Update parquet files (step 14 of 476)

spaces/1acneusushi/gradio-2dmoleculeeditor/10 Endrathukulla Full [UPD] Movie Download 720p.md

@@ -1,80 +0,0 @@
-## 10 endrathukulla full movie download 720p
-
-
-
- 
-
-  
-
- 
-
-**Download File ===> [https://eromdesre.blogspot.com/?d=2txKKP](https://eromdesre.blogspot.com/?d=2txKKP)**
-
-
-
- 
-
- 
-
- 
-
- 
-
- 
-
-# 10 Endrathukulla Full Movie Download 720p: A Thrilling Road Action Comedy
-
- 
-
-If you are looking for a movie that combines action, comedy, and adventure, then you might want to check out **10 Endrathukulla**, a 2015 Tamil-language film starring Vikram and Samantha Ruth Prabhu. The movie is written and directed by Vijay Milton and produced by A. R. Murugadoss under the banner A. R. Murugadoss Productions and Fox Star Studios.
-
- 
-
-The movie follows the story of an extreme driver (Vikram) who is on a mission to deliver his boss's goods to the rightful man. Along the way, he meets a mysterious woman (Samantha) who joins him on his journey. However, he soon finds himself being pulled into a track filled with twists and turns, as he faces various challenges and enemies. The movie is packed with thrilling car chases, stunts, and humor, as well as a surprising revelation at the end.
-
- 
-
-If you want to watch **10 Endrathukulla** full movie in 720p quality, you can download it from various online sources. However, be careful of illegal or pirated websites that may harm your device or violate the copyright laws. We recommend you to use legal and safe platforms that offer high-quality streaming or downloading options for **10 Endrathukulla** full movie.
-
- 
-
-Some of the legal and safe platforms that you can use to watch **10 Endrathukulla** full movie in 720p are:
-
- 
-
-- [Hotstar](https://www.hotstar.com/in/movies/10-endrathukulla/1000074620/watch): This is a popular streaming service that offers a variety of movies and shows in different languages. You can watch **10 Endrathukulla** full movie in 720p on Hotstar with a subscription plan or a VIP access.
-
-- [YouTube](https://www.youtube.com/watch?v=Q6kVU8uNdic): This is a free platform that allows you to watch videos of various genres and categories. You can watch **10 Endrathukulla** full movie in 720p on YouTube for free, but you may have to deal with some ads and interruptions.
-
-- [Amazon Prime Video](https://www.amazon.com/10-Endrathukulla-Vikram/dp/B01M7YJ4ZL): This is a premium streaming service that offers a wide range of movies and shows from different countries and languages. You can watch **10 Endrathukulla** full movie in 720p on Amazon Prime Video with a subscription plan or a rental fee.
-
-
-
-We hope you enjoy watching **10 Endrathukulla** full movie in 720p and have a great time with this entertaining road action comedy.
-
-
-
-If you want to know more about **10 Endrathukulla** and its cast and crew, here are some interesting facts and trivia that you might find useful.
-
-
-
-- **10 Endrathukulla** is the second collaboration between Vikram and A. R. Murugadoss, after the 2005 blockbuster **Ghajini**.
-
-- The movie was shot in various locations across India, including Chennai, Hyderabad, Rajasthan, Sikkim, and Nepal.
-
-- The movie features a cameo appearance by Bollywood actor Abhimanyu Singh, who plays the role of a corrupt cop.
-
-- The movie was originally titled **Paththu Enradhukulla**, which means "before I count to ten" in Tamil. However, the title was later changed to **10 Endrathukulla**, which is a shorter and catchier version.
-
-- The movie was released on October 21, 2015, coinciding with the festival of Dussehra. It received mixed reviews from critics and audiences, but was praised for its action sequences and performances.
-
-
-
-We hope you learned something new about **10 Endrathukulla** and its making. If you have any feedback or suggestions for us, please feel free to leave a comment below. We would love to hear from you.
-
- dfd1c89656
-
- 
-
- 
-

spaces/1gistliPinn/ChatGPT4/Examples/Ekb License Siemens Download.rar [UPDATED].md

@@ -1,30 +0,0 @@
-<br />
-<h1>How to Download and Install SIM EKB for Siemens Software</h1>
-<p>SIM EKB is a software that allows you to activate Siemens software products without buying a license. It is mainly used by students and hobbyists who want to learn and experiment with Siemens software. However, it is not recommended for professional use, as it may violate Siemens' terms and conditions. In this article, we will show you how to download and install SIM EKB for Siemens software.</p>
-<h2>Ekb License Siemens Download.rar</h2><br /><p><b><b>DOWNLOAD</b> ->>> <a href="https://imgfil.com/2uy0O7">https://imgfil.com/2uy0O7</a></b></p><br /><br />
-<h2>Step 1: Download SIM EKB</h2>
-<p>The latest version of SIM EKB as of April 2023 is SIM EKB Install 2022 11 27, which supports all the software in the TIA PORTAL V18 package along with many other upgrades. You can download it from the following link[^1^]. The password to extract the file is plc4me.com.</p>
-<h2>Step 2: Delete old keys</h2>
-<p>If you have previously installed any Siemens software products, you may need to delete the old keys before installing new ones. To do this, go to the hidden folder C:\AX NF ZZ and delete all the files inside it. You may need to enable the option to show hidden files and folders in Windows Explorer.</p>
-<h2>Step 3: Run SIM EKB Install</h2>
-<p>After extracting the file, run the SIM EKB Install.exe file as administrator. You will see a window like this:</p>
-<img src="https://plc4me.com/wp-content/uploads/2020/12/SIM-EKB-Install-2020-12-13.jpg" alt="SIM EKB Install window">
-<p>Select the software products that you want to activate from the list on the left. You can use the search box to find them quickly. The unlocked software will be highlighted in blue. Then click on Install button at the bottom right corner.</p>
-<h2>Step 4: Enjoy your Siemens software</h2>
-<p>After installing the keys, you can launch your Siemens software and use it without any limitations. However, remember that this is only for educational purposes and not for commercial use. If you need professional support or updates, you should contact Siemens and buy a license.</p>
-<p></p>
-<h3>References</h3>
-<ol>
-<li>[Download] SIM EKB Install 2022 11 27 for Siemens Software - plc4me.com</li>
-</ol><h2>Some examples of Siemens software products</h2>
-<p>Siemens offers a wide range of software products for various industrial applications. Some of the most popular ones are:</p>
-<ul>
-<li><strong>TIA Portal</strong>: This is an integrated engineering framework that allows you to program, configure, and commission Siemens automation devices such as PLCs, HMIs, drives, and networks. It supports various standards and protocols such as OPC UA, PROFINET, and EtherNet/IP. It also includes simulation and testing tools to help you optimize your system performance and reliability.</li>
-<li><strong>STEP 7</strong>: This is a programming software for Siemens PLCs that supports different languages such as Ladder Logic, Structured Text, Function Block Diagram, and Statement List. It allows you to create and edit programs, monitor and debug variables, and download and upload programs to PLCs. It can be used as a standalone software or as part of TIA Portal.</li>
-<li><strong>WinCC</strong>: This is a visualization software for Siemens HMIs that allows you to create and edit graphical user interfaces for your machines and processes. It supports various features such as animations, alarms, trends, recipes, and scripts. It can be used as a standalone software or as part of TIA Portal.</li>
-<li><strong>SINAMICS Startdrive</strong>: This is a commissioning software for Siemens drives that allows you to configure and optimize the parameters of your drive systems. It supports various types of drives such as frequency converters, servo drives, and motion controllers. It can be used as a standalone software or as part of TIA Portal.</li>
-<li><strong>SIMATIC PCS 7</strong>: This is a process control system software that allows you to design, implement, and operate complex process plants. It supports various functions such as distributed control, batch control, advanced process control, safety instrumented systems, and plant asset management. It also integrates with other Siemens software products such as SIMATIC NET, SIMATIC S7-400H/FH, and SIMATIC WinCC.</li>
-</ul>
-<p>These are just some of the Siemens software products that you can activate with SIM EKB. However, there are many more that you can explore on the Siemens website or on the SIM EKB Install window.</p> d5da3c52bf<br />
-<br />
-<br />

spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Brawl Stars 2017 APK The Best Way to Relive the First Edition of the Game on Android.md

@@ -1,143 +0,0 @@
-<br />
-<h1>2017 Brawl Stars APK: How to Download and Play the Epic Mobile Game</h1>
- <p>If you are a fan of mobile games, you might have heard of Brawl Stars, a fast-paced multiplayer game from Supercell, the makers of Clash of Clans and Clash Royale. Brawl Stars was released globally in 2018, but before that, it was available in a few countries as a beta version in 2017. If you want to experience the original version of the game, you can download and install the 2017 Brawl Stars APK on your Android device. In this article, we will show you how to do that and also give you some tips on how to play the game.</p>
-<h2>2017 brawl stars apk</h2><br /><p><b><b>DOWNLOAD</b> &#10031;&#10031;&#10031; <a href="https://urlin.us/2uSScE">https://urlin.us/2uSScE</a></b></p><br /><br />
- <h2>What is Brawl Stars?</h2>
- <h3>A fast-paced multiplayer game from Supercell</h3>
- <p>Brawl Stars is a game that combines elements of shooter, MOBA, and battle royale genres. You can team up with your friends or play solo in various game modes, each with a different objective. You can also unlock and upgrade dozens of characters, called Brawlers, each with a unique ability and style. You can collect skins, pins, and trophies to show off your achievements and personality.</p>
- <h3>Different game modes and characters to choose from</h3>
- <p>Brawl Stars has four main game modes: Smash & Grab, Heist, Showdown, and Bounty. Each mode has its own rules and strategies, so you need to adapt your gameplay accordingly. Here is a brief overview of each mode:</p>
- <ul>
-<li>Smash & Grab (3v3): Team up and out-strategize the opposing team. Collect and hold 10 gems to win, but get fragged and lose your gems.</li>
-<li>Showdown (Solo/Duo): A battle royale style fight for survival. Collect power ups for your Brawler. Grab a friend or play solo - be the last Brawler standing in the rowdiest battle royale yet. Winner take all!</li>
-<li>Brawl Ball (3v3): It's a whole new Brawl game! Show off your soccer/football skills and score two goals before the other team. There are no red cards here.</li>
-<li>Bounty (3v3): Take out opponents to earn stars, but don’t let them pick you off. The squad with the most stars wins the match!</li>
-<li>Heist (3v3): Protect your team’s safe and try to crack open your opponents’. Navigate the map to sneak, blast and blow your way clear to the enemies treasure.</li>
-<li>Special Events: Limited time special PvE and PvP game modes.</li>
-<li>Championship Challenge: Join Brawl Stars' esports scene with in-game qualifiers!</li>
-</ul>
- <p>Brawl Stars also has 22 different Brawlers that you can unlock and use in any game mode. Each Brawler has a basic attack, a super ability, a star power, and a gadget. You can level up your Brawlers by collecting power points and coins, and unlock new skins by earning gems or buying them with real money. Some of the Brawlers are:</p>
- <table>
-<tr><th>Name</th><th>Type</th><th>Ability</th></tr>
-<tr><td>Shelly</td><td>Common</td><td>A shotgunner who can blast enemies at close range and charge her super to unleash a powerful shot that can destroy obstacles.</td></tr>
-<tr><td>Nita</td><td>Common</td><td>A fighter who can summon a big bear to fight by her side.</td></tr>
-<tr><td>Colt</td><td>Common</td><td>A sharpshooter who can fire a burst of bullets with great accuracy.</td></tr>
-<tr><td>Bull </td><td>Common</td><td>A tank who can charge forward and deal massive damage with his double-barreled shotgun.</td></tr>
-<tr><td>Jessie</td><td>Common</td><td>An inventor who can build a turret that shoots at enemies.</td></tr>
-<tr><td>Brock</td><td>Rare</td><td>A rocket launcher who can fire long-range missiles that explode on impact.</td></tr>
-<tr><td>Dynamike</td><td>Rare</td><td>A miner who can throw sticks of dynamite and a big barrel bomb.</td></tr>
-<tr><td>Bo</td><td>Rare</td><td>A bowman who can shoot explosive arrows and plant hidden mines.</td></tr>
-<tr><td>Tick</td><td>Rare</td><td>A metal ball of mischief who can detach and toss his head, which explodes after a few seconds.</td></tr>
-<tr><td>8-Bit</td><td>Rare</td><td>A retro arcade machine who can shoot laser beams and boost his and his allies' damage with his booster.</td></tr>
-<tr><td>Emz</td><td>Rare</td><td>A social media star who can spray a cloud of hairspray that damages enemies over time.</td></tr>
-<tr><td>El Primo</td><td>Super Rare</td><td>A wrestler who can punch enemies with his fiery fists and leap into the fray with his super.</td></tr>
-<tr><td>Barley</td><lt>Super Rare</lt><lt>A bartender who can toss bottles of flaming liquid that leave a burning area on the ground.</lt></tr>
-<tr><lt>Poco</lt><lt>Super Rare</lt><lt>A musician who can heal himself and his allies with his soothing tunes.</lt></tr>
-<tr><lt>Rosa</lt><lt>Super Rare</lt><lt>A botanist who can punch enemies with her boxing gloves and shield herself with her plant barrier.</lt></tr>
-<tr><lt>Rico</lt><lt>Super Rare</lt><lt>A bouncy ball machine who can shoot bullets that bounce off walls and obstacles.</lt></tr>
-<tr><lt>Darryl</lt><lt>Super Rare</lt><lt>A barrel robot who can roll into enemies and blast them with his double shotguns.</lt></tr>
-<tr><lt>Penny</lt><lt>Epic</lt><lt>A pirate who can fire a bag of coins that splits into three on impact and build a cannon that shoots at enemies.</lt></tr>
-<tr><lt>Piper</lt><lt>Epic</lt><lt>A sniper who can deal more damage the farther her bullets travel and drop bombs when she uses her umbrella to fly away.</lt></tr>
-<tr><lt>Pam</lt><lt>Epic</lt><lt>A junker who can spray scrap metal at enemies and deploy a healing turret for her allies.</lt></tr>
-<tr><lt>Frank</lt><lt>Epic</t<td>A zombie who can smash enemies with his hammer and stun them with his super.</t></tr>
-<tr>t<Bea<t<Epic<t<A beekeeper who can fire a long-range shot that deals more damage if it hits consecutively and summon a swarm of angry bees to chase down enemies.</t></tr>
-<tr>t<Edgar<t<Epic<t<A moody teen who can dash forward and heal himself by attacking enemies with his scarf.</t></tr>
-<tr>t<Bibi<t<Epic<t<A baseball fan who can hit enemies with her bat and knock them back with her super.</t></tr>
-<tr>t<Mortis<t<Mythic<t<A vampire who can dash forward and steal the life of his enemies with his shovel.</t></tr>
-<tr>t<Tara<t<Mythic<t<A fortune teller who can throw tarot cards that pierce through enemies and pull them together with her super.</t></tr>
-<tr>t<Gene<t<Mythic<t<A genie who can shoot a magic hand that grabs and pulls enemies to him.</t></tr>
-<tr>t<Max<t<Mythic<t<A speedster who can run fast and boost her and her allies' speed with her super.</t></tr>
-<tr>t>Mr. P<t<Mythic<t<A hotel owner who can throw suitcases that bounce over obstacles and spawn robotic porters to attack enemies.</t></tr>
-<tr>t>Sprout<t<Mythic<t<A sentient plant who can throw seed bombs that bounce and explode, creating bushes, and create a protective wall with his super.</t></tr>
-<tr>t>Crow<t<Legendary<t<A toxic bird who can shoot daggers that poison enemies and jump high in the air, dropping poison bombs below him.</t></tr>
-<tr>t>Spike<t<Legendary<t<A cactus who can throw spikes that explode in a star shape, dealing damage to multiple enemies, and heal himself by standing in the bushes.</t></tr>
-<tr>t<Leon<t<Legendary<t<A stealthy assassin who can shoot blades that deal more damage the closer he is to his target and turn invisible with his super.</t></tr>
-<tr>t<Sandy<t<Legendary<t<A sleepy sandman who can throw sand pebbles that damage enemies and create a sandstorm that hides him and his allies from sight.</t></tr>
-<tr>t<Amber<t<Legendary<t<A fire dancer who can spray a continuous stream of fire and leave a trail of flames with her super.</t></tr>
-<tr>t>Gale<t<Legendary<t<A grumpy snowman who can shoot snowballs that push back enemies and create a jump pad with his super.</t></tr>
-<tr>t>Colette<t<Legendary<t<A cashier who can shoot a projectile that deals damage based on the enemy's health and charge forward with her super, hitting enemies along the way.</t></tr>
-</table>
- <h2>How to download and install the 2017 Brawl Stars APK</h2>
- <h3>The requirements and risks of using an APK file</h3>
- <p>An APK file is an Android application package that contains all the files and data needed to run an app on an Android device. You can download APK files from various sources online, but you need to be careful about the quality and security of the files. Some APK files may contain malware or viruses that can harm your device or steal your personal information. You also need to make sure that the APK file is compatible with your device and Android version.</p>
- <p>To download and install the 2017 Brawl Stars APK, you will need an Android device that runs on Android 4.1 or higher, has at least 1 GB of RAM, and has enough storage space. You will also need to enable the option to install apps from unknown sources in your device settings. This will allow you to install apps that are not from the Google Play Store. However, this also means that you are responsible for the safety and performance of your device. You should only download APK files from trusted sources and scan them for viruses before installing them.</p>
- <h3>The steps to download and install the APK file</h3>
- <p>Here are the steps to download and install the 2017 Brawl Stars APK on your Android device:</p>
- <ol>
-<li>Go to a reliable website that offers the 2017 Brawl Stars APK file, such as [APKPure] or [APKMirror].</li>
-<li>Find the 2017 Brawl Stars APK file and tap on the download button. The file size is about 100 MB, so make sure you have a stable internet connection and enough battery life.</li>
-<li>Once the download is complete, locate the APK file in your device's file manager and tap on it to start the installation process.</li>
-<li>Follow the instructions on the screen and grant the necessary permissions to the app.</li>
-<li>Wait for the installation to finish and then launch the app from your home screen or app drawer.</li>
-<li>Enjoy playing Brawl Stars!</li>
-</ol>
- <h2>How to play Brawl Stars on your Android device</h2>
- <h3>The basic controls and gameplay mechanics</h3>
- <p>Brawl Stars is easy to learn but hard to master. The game has simple controls that you can customize according to your preference. You can use either a joystick or tap mode to move your Brawler around the map. You can also use either auto-aim or manual aim to shoot at enemies. To use your super ability, you need to fill up your super meter by hitting enemies with your basic attack. You can also use a gadget once per match if you have unlocked it for your Brawler.</p>
-<p>2017 brawl stars apk download for android<br />
-2017 brawl stars apk mod unlimited gems<br />
-2017 brawl stars apk latest version<br />
-2017 brawl stars apk free download uptodown<br />
-2017 brawl stars apk old version<br />
-2017 brawl stars apk hack no root<br />
-2017 brawl stars apk offline installer<br />
-2017 brawl stars apk update new features<br />
-2017 brawl stars apk file size<br />
-2017 brawl stars apk compatible devices<br />
-2017 brawl stars apk gameplay tips<br />
-2017 brawl stars apk review and rating<br />
-2017 brawl stars apk best characters<br />
-2017 brawl stars apk how to install<br />
-2017 brawl stars apk error fix<br />
-2017 brawl stars apk online multiplayer mode<br />
-2017 brawl stars apk fun and addictive<br />
-2017 brawl stars apk unlock all skins<br />
-2017 brawl stars apk safe and secure<br />
-2017 brawl stars apk original from Supercell<br />
-2017 brawl stars apk cheats and tricks<br />
-2017 brawl stars apk requirements and specifications<br />
-2017 brawl stars apk alternative download links<br />
-2017 brawl stars apk beta version testing<br />
-2017 brawl stars apk support and feedback<br />
-2017 brawl stars apk new maps and modes<br />
-2017 brawl stars apk events and challenges<br />
-2017 brawl stars apk rewards and trophies<br />
-2017 brawl stars apk clans and friends<br />
-2017 brawl stars apk ranking and leaderboard<br />
-2017 brawl stars apk skins and customizations<br />
-2017 brawl stars apk coins and gems generator<br />
-2017 brawl stars apk patch notes and changelog<br />
-2017 brawl stars apk bugs and glitches report<br />
-2017 brawl stars apk videos and screenshots<br />
-2017 brawl stars apk guides and tutorials<br />
-2017 brawl stars apk forums and communities<br />
-2017 brawl stars apk news and updates<br />
-2017 brawl stars apk comparison with other games<br />
-2017 brawl stars apk pros and cons analysis</p>
- <p>The game has different gameplay mechanics depending on the game mode you choose. For example, in Smash & Grab, you need to collect gems from the center of the map and hold them until the countdown ends. If you die, you will drop all your gems, so you need to be careful and protect yourself and your teammates. In Showdown, you need to survive as long as possible by avoiding enemies, collecting power ups, and hiding in bushes or behind walls. The map will shrink over time, forcing you to confront other players. The last one standing wins.</p>
- <h3>Some tips and tricks to improve your skills</h3>
- <p>Brawl Stars is a game that requires strategy, teamwork, and skill. Here are some tips and tricks that can help you improve your skills:</p>
- <ul>
-<li>Choose a Brawler that suits your play style and the game mode. For example, if you like close-range combat, you can use Shelly or Bull. If you prefer long-range sniping, you can use Piper or Brock. If you like to heal and support your allies, you can use Poco or Pam.</li>
-<li>Learn the strengths and weaknesses of each Brawler and how to counter them. For example, if you are facing a tanky Brawler like El Primo or Rosa, you can use a Brawler that can deal high damage or pierce through their shield, like Colt or Spike. If you are facing a long-range Brawler like Piper or Brock, you can use a Brawler that can dodge their shots or close the gap, like Mortis or Leon.</li>
-<li>Communicate and cooperate with your teammates. You can use the in-game chat or voice chat to coordinate your moves and strategies. You can also use the quick chat buttons to send simple messages like "Attack", "Defend", or "Help". You can also use the ping system to mark enemies, gems, power ups, or locations on the map.</li>
-<li>Use the environment to your advantage. You can hide in bushes or behind walls to ambush enemies or escape from danger. You can also destroy obstacles with your attacks or super to create new paths or expose enemies. You can also use the jump pads, teleporters, or water to move around the map faster or surprise enemies.</li>
-<li>Practice and experiment with different Brawlers and game modes. You can play friendly matches with your friends or club members to test your skills and have fun. You can also play solo or duo Showdown to improve your survival skills and learn how to deal with different situations. You can also watch replays of your matches or other players' matches to learn from your mistakes or get inspired by their strategies.</li>
-</ul>
- <h2>Conclusion</h2>
- <p>Brawl Stars is a fun and addictive game that you can play on your Android device. If you want to experience the original version of the game from 2017, you can download and install the 2017 Brawl Stars APK file from a reliable source. However, you need to be careful about the quality and security of the APK file and enable the option to install apps from unknown sources on your device. You also need to learn how to play the game well and use the best Brawlers and strategies for each game mode. With some practice and teamwork, you can become a Brawl Star!</p>
- <h2>FAQs</h2>
- <p>Here are some frequently asked questions about Brawl Stars and the 2017 Brawl Stars APK:</p>
- <ol>
-<li>What is the difference between the 2017 Brawl Stars APK and the current version of the game?</li>
-<p>The 2017 Brawl Stars APK is the beta version of the game that was released in a few countries before the global launch in 2018. The 2017 version has some differences from the current version, such as fewer Brawlers, game modes, skins, maps, features, and updates. The 2017 version also has some bugs and glitches that may affect your gameplay experience.</p>
-<li>Is it safe to download and install the 2017 Brawl Stars APK?</li>
-<p>It depends on where you download the APK file from. Some websites may offer fake or malicious APK files that can harm your device or steal your personal information. You should only download APK files from trusted sources that have positive reviews and ratings from other users. You should also scan the APK file for viruses before installing it on your device.</p>
-<li>Will I get banned for using the 2017 Brawl Stars APK?</li>
-<p>No, you will not get banned for using the 2017 Brawl Stars APK as long as you do not use any cheats, hacks, mods, or third-party tools that give you an unfair advantage over other players. However, you may not be able to access some features or events that are exclusive to the current version of the game.</p>
-<li>Can I play with my friends who have the current version of the game?</li>
-<p>No, you cannot play with your friends who have the current version of the game because they are on different servers. You can only play with other players who have the same version of the game as you.</p>
-<li>Can I update the 2017 Brawl Stars APK to the current version of the game?</li>
-<p>No, you cannot update the 2017 Brawl Stars APK to the current version of the game. You will need to uninstall the 2017 Brawl Stars APK and download the current version of the game from the Google Play Store or another reliable source.</p> 197e85843d<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Apkfew Whatsapp Tracker Free APK Download - Track Online Activity and Chat History.md

@@ -1,149 +0,0 @@
-<br />
-<h1>How to Download Apkfew Whatsapp Tracker and Why You Need It</h1>
-<p>Do you want to track the online activity and chat history of any WhatsApp user? Do you want to know who viewed your profile and who deleted their account? If yes, then you need Apkfew Whatsapp Tracker, a powerful and reliable app that lets you monitor any WhatsApp account discreetly and remotely. In this article, we will show you how to download Apkfew Whatsapp Tracker for Android devices and how to use it effectively. We will also compare it with other similar apps and answer some frequently asked questions.</p>
-<h2>download apkfew whatsapp tracker</h2><br /><p><b><b>Download Zip</b> &mdash;&mdash;&mdash; <a href="https://jinyurl.com/2uNOSC">https://jinyurl.com/2uNOSC</a></b></p><br /><br />
- <h2>What is Apkfew Whatsapp Tracker?</h2>
-<p>Apkfew Whatsapp Tracker is a free app that allows you to track the online status, last seen, chat messages, media files, profile visits, and deleted accounts of any WhatsApp user. You can use it to spy on your spouse, children, friends, employees, or anyone else who uses WhatsApp. You can also use it to protect your privacy and security by knowing who is stalking you or trying to hack your account.</p>
- <h3>Features of Apkfew Whatsapp Tracker</h3>
-<ul>
-<li>Track online status and last seen of any WhatsApp user, even if they hide it or block you.</li>
-<li>Monitor chat messages and media files of any WhatsApp user, even if they delete them or use end-to-end encryption.</li>
-<li>View profile visits and deleted accounts of any WhatsApp user, even if they disable read receipts or change their number.</li>
-<li>Get instant notifications and reports on your phone or email whenever there is any activity on the target account.</li>
-<li>Access all the data remotely from a web-based dashboard that is easy to use and secure.</li>
-</ul>
- <h3>Benefits of Apkfew Whatsapp Tracker</h3>
-<ul>
-<li>Apkfew Whatsapp Tracker is free to download and use, unlike other apps that charge you monthly or yearly fees.</li>
-<li>Apkfew Whatsapp Tracker is compatible with all Android devices, regardless of the model or version.</li>
-<li>Apkfew Whatsapp Tracker is undetectable and untraceable, as it does not require rooting or jailbreaking the target device or installing any software on it.</li>
-<li>Apkfew Whatsapp Tracker is reliable and accurate, as it uses advanced algorithms and techniques to collect and analyze the data.</li>
-<li>Apkfew Whatsapp Tracker is ethical and legal, as it does not violate the privacy or security of the target user or anyone else involved.</li>
-</ul>
- <h2>How to Download Apkfew Whatsapp Tracker for Android</h2>
-<p>To download Apkfew Whatsapp Tracker for Android devices, you need to follow these simple steps:</p>
- <h3>Step 1: Enable Unknown Sources</h3>
-<p>Since Apkfew Whatsapp Tracker is not available on the Google Play Store, you need to enable unknown sources on your device to install it. To do this, go to Settings > Security > Unknown Sources and toggle it on. This will allow you to install apps from sources other than the Google Play Store.</p>
- <h3>Step 2: Visit the Apkfew Website</h3>
-<p>The next step is to visit the official website of Apkfew at [https://apkcombo.com/search/apkfew-whatsapp-tracker-free](^1^). Here you will find the latest version of the app along with its description and reviews. You can also check out other apps from Apkfew that offer similar features.</p>
- <h3>Step 3: Download and Install the Apk File</h3 <p>Once you are on the website, click on the download button and wait for the apk file to be downloaded on your device. The file size is about 10 MB and it should take a few minutes depending on your internet speed. After the download is complete, locate the file in your downloads folder and tap on it to start the installation process. Follow the instructions on the screen and agree to the terms and conditions to finish the installation.</p>
-<p>download apkfew whatsapp tracker free<br />
-download apkfew whatsapp tracker online<br />
-download apkfew whatsapp tracker app<br />
-download apkfew whatsapp tracker pro<br />
-download apkfew whatsapp tracker premium<br />
-download apkfew whatsapp tracker mod<br />
-download apkfew whatsapp tracker apk<br />
-download apkfew whatsapp tracker for android<br />
-download apkfew whatsapp tracker for ios<br />
-download apkfew whatsapp tracker for pc<br />
-download apkfew whatsapp tracker for windows<br />
-download apkfew whatsapp tracker for mac<br />
-download apkfew whatsapp tracker for linux<br />
-download apkfew whatsapp tracker latest version<br />
-download apkfew whatsapp tracker 2023<br />
-download apkfew whatsapp tracker update<br />
-download apkfew whatsapp tracker review<br />
-download apkfew whatsapp tracker tutorial<br />
-download apkfew whatsapp tracker guide<br />
-download apkfew whatsapp tracker tips<br />
-download apkfew whatsapp tracker tricks<br />
-download apkfew whatsapp tracker hacks<br />
-download apkfew whatsapp tracker cheats<br />
-download apkfew whatsapp tracker features<br />
-download apkfew whatsapp tracker benefits<br />
-download apkfew whatsapp tracker advantages<br />
-download apkfew whatsapp tracker disadvantages<br />
-download apkfew whatsapp tracker problems<br />
-download apkfew whatsapp tracker issues<br />
-download apkfew whatsapp tracker bugs<br />
-download apkfew whatsapp tracker fixes<br />
-download apkfew whatsapp tracker solutions<br />
-download apkfew whatsapp tracker alternatives<br />
-download apkfew whatsapp tracker competitors<br />
-download apkfew whatsapp tracker comparison<br />
-download apkfew whatsapp tracker best practices<br />
-download apkfew whatsapp tracker case studies<br />
-download apkfew whatsapp tracker testimonials<br />
-download apkfew whatsapp tracker feedbacks<br />
-download apkfew whatsapp tracker ratings<br />
-download apkfew whatsapp tracker rankings<br />
-download apkfew whatsapp tracker statistics<br />
-download apkfew whatsapp tracker analytics<br />
-download apkfew whatsapp tracker insights<br />
-download apkfew whatsapp tracker reports<br />
-download apkfew whatsapp tracker results<br />
-download apkfew whatsapp tracker performance<br />
-download apkfew whatsapp tracker quality<br />
-download apkfew whatsapp tracker reliability<br />
-download apkfew whatsapp tracker security</p>
- <h3>Step 4: Launch the App and Grant Permissions</h3>
-<p>The final step is to launch the app and grant it the necessary permissions to access your device's data and functions. To do this, open the app from your app drawer or home screen and sign up with your email and password. You will then be asked to enter the phone number of the WhatsApp user you want to track. You will also need to grant the app permissions to access your contacts, storage, location, camera, microphone, and notifications. These permissions are essential for the app to work properly and collect the data you need.</p>
- <h2>How to Use Apkfew Whatsapp Tracker</h2>
-<p>Now that you have downloaded and installed Apkfew Whatsapp Tracker, you can start using it to monitor any WhatsApp account you want. Here are some of the things you can do with the app:</p>
- <h3>Track Online Status and Last Seen</h3>
-<p>With Apkfew Whatsapp Tracker, you can track the online status and last seen of any WhatsApp user, even if they hide it or block you. You can see when they are online or offline, how long they stay online, and how often they change their status. You can also see their last seen time and date, even if they disable it in their settings. This way, you can know their activity patterns and habits, and find out if they are lying or cheating on you.</p>
- <h3>Monitor Chat Messages and Media Files</h3>
-<p>Another feature of Apkfew Whatsapp Tracker is that it allows you to monitor the chat messages and media files of any WhatsApp user, even if they delete them or use end-to-end encryption. You can read their text messages, voice messages, images, videos, documents, stickers, emojis, and more. You can also see who they are chatting with, what they are talking about, and when they are sending or receiving messages. This way, you can know their interests, preferences, opinions, and secrets.</p>
- <h3>View Profile Visits and Deleted Accounts</h3>
-<p>A third feature of Apkfew Whatsapp Tracker is that it enables you to view the profile visits and deleted accounts of any WhatsApp user, even if they disable read receipts or change their number. You can see who visited their profile, how many times they visited it, and when they visited it. You can also see who deleted their account, why they deleted it, and when they deleted it. This way, you can know who is stalking them or trying to hack their account.</p>
- <h2>Comparison Table of Apkfew Whatsapp Tracker and Other Apps</h2>
-<p>To give you a better idea of how Apkfew Whatsapp Tracker compares with other similar apps in the market, we have created a comparison table that shows some of the key features and differences between them. Here is the table:</p>
- <table>
-<tr>
-<th>App Name</th>
-<th>Price</th>
-<th>Compatibility</th>
-<th>Detectability</th>
-<th>Rooting/Jailbreaking Required</th>
-<th>Data Collected</th>
-</tr>
-<tr>
-<td>Apkfew Whatsapp Tracker</td>
-<td>Free</td>
-<td>All Android devices</td>
-<td>Undetectable</td>
-<td>No</td>
-<td>Online status, last seen, chat messages, media files, profile visits, deleted accounts</td>
-</tr>
-<tr>
-<td>mSpy</td>
-<td>$29.99/month</td>
-<td>All Android devices (rooted) All iOS devices (jailbroken)</td>
-<td>Detectable</td>
-<td>Yes</td>
-<td>Online status, last seen, chat messages, media files</td>
-</tr>
-<tr>
-<td>Spyzie</td>
-<td>$39.99/month</td>
-<td>All Android devices (rooted) All iOS devices (jailbroken)</td>
-<td>Detectable</td>
-<td>Yes</td>
-<td>Online status, last seen, chat messages, media files</td>
-</tr>
-<tr>
-<td>FoneMonitor</td>
-<td>$29.99/month</td <td>All Android devices (rooted) All iOS devices (jailbroken)</td <td>Detectable</td <td>Yes</td <td>Online status, last seen, chat messages, media files</td </tr <tr <td>Cocospy <td>$39.99/month <td>All Android devices <td>All Android devices (rooted) All iOS devices (jailbroken)</td>
-<td>Detectable</td>
-<td>Yes</td>
-<td>Online status, last seen, chat messages, media files</td>
-</tr>
-</table>
- <p>As you can see, Apkfew Whatsapp Tracker is the best app among the four, as it offers more features, better compatibility, higher security, and lower cost. It is the only app that does not require rooting or jailbreaking the target device, and it is the only app that can track profile visits and deleted accounts. It is also the only app that is free to download and use, while the others charge you hefty fees. Therefore, we recommend you to choose Apkfew Whatsapp Tracker over the other apps.</p>
- <h2>Conclusion</h2>
-<p>In conclusion, Apkfew Whatsapp Tracker is a free app that lets you track the online activity and chat history of any WhatsApp user. You can use it to spy on your spouse, children, friends, employees, or anyone else who uses WhatsApp. You can also use it to protect your privacy and security by knowing who is stalking you or trying to hack your account. To download Apkfew Whatsapp Tracker for Android devices, you need to enable unknown sources, visit the Apkfew website, download and install the apk file, and launch the app and grant permissions. To use Apkfew Whatsapp Tracker, you need to enter the phone number of the WhatsApp user you want to track, and then you can access all the data remotely from a web-based dashboard. Apkfew Whatsapp Tracker is better than other similar apps in terms of features, compatibility, security, and cost. It is the best app for WhatsApp tracking that you can find in the market.</p>
- <h2>FAQs</h2>
-<p>Here are some of the frequently asked questions about Apkfew Whatsapp Tracker:</p>
- <h3>Q: Is Apkfew Whatsapp Tracker safe to use?</h3>
-<p>A: Yes, Apkfew Whatsapp Tracker is safe to use, as it does not contain any viruses, malware, spyware, or adware. It also does not collect or store any personal or sensitive information from your device or the target device. It only accesses the data that is relevant for WhatsApp tracking and does not share it with anyone else.</p>
- <h3>Q: Is Apkfew Whatsapp Tracker legal to use?</h3>
-<p>A: Yes, Apkfew Whatsapp Tracker is legal to use, as long as you follow the laws and regulations of your country and respect the privacy and security of the target user. You should not use Apkfew Whatsapp Tracker for any illegal or unethical purposes, such as blackmailing, harassing, threatening, or harming anyone. You should also inform and obtain consent from the target user before using Apkfew Whatsapp Tracker on their device.</p>
- <h3>Q: Does Apkfew Whatsapp Tracker work on iOS devices?</h3>
-<p>A: No, Apkfew Whatsapp Tracker does not work on iOS devices, as it is designed for Android devices only. However, you can still use Apkfew Whatsapp Tracker to track an iOS device if you have access to its WhatsApp web login credentials. You can then scan the QR code from your Android device and access all the data from the web-based dashboard.</p>
- <h3>Q: How can I contact Apkfew Whatsapp Tracker support team?</h3>
-<p>A: If you have any questions, issues, feedbacks, or suggestions about Apkfew Whatsapp Tracker, you can contact their support team by sending an email to [[email protected]]. They will respond to you within 24 hours and help you resolve any problems.</p>
- <h3>Q: How can I update Apkfew Whatsapp Tracker to the latest version?</h3>
-<p>A: To update Apkfew Whatsapp Tracker to the latest version, you need to visit their website at [https://apkcombo.com/search/apkfew-whatsapp-tracker-free] and download and install the new apk file over the old one. You do not need to uninstall or reinstall the app. The update will automatically apply and improve the performance and functionality of the app.</p> 401be4b1e0<br />
-<br />
-<br />

spaces/7hao/bingo/src/lib/hooks/chat-history.ts

@@ -1,62 +0,0 @@
-import { zip } from 'lodash-es'
-import { ChatMessageModel, BotId } from '@/lib/bots/bing/types'
-import { Storage } from '../storage'
-
-/**
- * conversations:$botId => Conversation[]
- * conversation:$botId:$cid:messages => ChatMessageModel[]
- */
-
-interface Conversation {
-  id: string
-  createdAt: number
-}
-
-type ConversationWithMessages = Conversation & { messages: ChatMessageModel[] }
-
-async function loadHistoryConversations(botId: BotId): Promise<Conversation[]> {
-  const key = `conversations:${botId}`
-  const { [key]: value } = await Storage.get(key)
-  return value || []
-}
-
-async function deleteHistoryConversation(botId: BotId, cid: string) {
-  const conversations = await loadHistoryConversations(botId)
-  const newConversations = conversations.filter((c) => c.id !== cid)
-  await Storage.set({ [`conversations:${botId}`]: newConversations })
-}
-
-async function loadConversationMessages(botId: BotId, cid: string): Promise<ChatMessageModel[]> {
-  const key = `conversation:${botId}:${cid}:messages`
-  const { [key]: value } = await Storage.get(key)
-  return value || []
-}
-
-export async function setConversationMessages(botId: BotId, cid: string, messages: ChatMessageModel[]) {
-  const conversations = await loadHistoryConversations(botId)
-  if (!conversations.some((c) => c.id === cid)) {
-    conversations.unshift({ id: cid, createdAt: Date.now() })
-    await Storage.set({ [`conversations:${botId}`]: conversations })
-  }
-  const key = `conversation:${botId}:${cid}:messages`
-  await Storage.set({ [key]: messages })
-}
-
-export async function loadHistoryMessages(botId: BotId): Promise<ConversationWithMessages[]> {
-  const conversations = await loadHistoryConversations(botId)
-  const messagesList = await Promise.all(conversations.map((c) => loadConversationMessages(botId, c.id)))
-  return zip(conversations, messagesList).map(([c, messages]) => ({
-    id: c!.id,
-    createdAt: c!.createdAt,
-    messages: messages!,
-  }))
-}
-
-export async function deleteHistoryMessage(botId: BotId, conversationId: string, messageId: string) {
-  const messages = await loadConversationMessages(botId, conversationId)
-  const newMessages = messages.filter((m) => m.id !== messageId)
-  await setConversationMessages(botId, conversationId, newMessages)
-  if (!newMessages.length) {
-    await deleteHistoryConversation(botId, conversationId)
-  }
-}

spaces/A00001/bingothoo/src/lib/bots/bing/utils.ts

@@ -1,87 +0,0 @@
-import { ChatResponseMessage, BingChatResponse } from './types'
-
-export function convertMessageToMarkdown(message: ChatResponseMessage): string {
-  if (message.messageType === 'InternalSearchQuery') {
-    return message.text
-  }
-  for (const card of message.adaptiveCards??[]) {
-    for (const block of card.body) {
-      if (block.type === 'TextBlock') {
-        return block.text
-      }
-    }
-  }
-  return ''
-}
-
-const RecordSeparator = String.fromCharCode(30)
-
-export const websocketUtils = {
-  packMessage(data: any) {
-    return `${JSON.stringify(data)}${RecordSeparator}`
-  },
-  unpackMessage(data: string | ArrayBuffer | Blob) {
-    if (!data) return {}
-    return data
-      .toString()
-      .split(RecordSeparator)
-      .filter(Boolean)
-      .map((s) => {
-        try {
-          return JSON.parse(s)
-        } catch (e) {
-          return {}
-        }
-      })
-  },
-}
-
-export async function createImage(prompt: string, id: string, headers: HeadersInit): Promise<string | undefined> {
-  const { headers: responseHeaders } = await fetch(`https://www.bing.com/images/create?partner=sydney&re=1&showselective=1&sude=1&kseed=7000&SFX=&q=${encodeURIComponent(prompt)}&iframeid=${id}`,
-    {
-      method: 'HEAD',
-      headers,
-      redirect: 'manual'
-    },
-  );
-
-  if (!/&id=([^&]+)$/.test(responseHeaders.get('location') || '')) {
-    throw new Error('请求异常，请检查 cookie 是否有效')
-  }
-
-  const resultId = RegExp.$1;
-  let count = 0
-  const imageThumbUrl = `https://www.bing.com/images/create/async/results/${resultId}?q=${encodeURIComponent(prompt)}&partner=sydney&showselective=1&IID=images.as`;
-
-  do {
-    await sleep(3000);
-    const content = await fetch(imageThumbUrl, { headers, method: 'GET' })
-
-    // @ts-ignore
-    if (content.headers.get('content-length') > 1) {
-      const text = await content.text()
-        return (text?.match(/<img class="mimg"((?!src).)+src="[^"]+/mg)??[])
-          .map(target => target?.split('src="').pop()?.replace(/&amp;/g, '&'))
-          .map(img => `![${prompt}](${img})`).join(' ')
-    }
-  } while(count ++ < 10);
-}
-
-
-export async function* streamAsyncIterable(stream: ReadableStream) {
-  const reader = stream.getReader()
-  try {
-    while (true) {
-      const { done, value } = await reader.read()
-      if (done) {
-        return
-      }
-      yield value
-    }
-  } finally {
-    reader.releaseLock()
-  }
-}
-
-export const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))
-

spaces/ATang0729/Forecast4Muses/Model/Model6/Model6_2_ProfileRecogition/mmpretrain/configs/resnet/resnet50_32xb64-warmup-lbs_in1k.py

@@ -1,12 +0,0 @@
-_base_ = ['./resnet50_32xb64-warmup_in1k.py']
-model = dict(
-    head=dict(
-        type='LinearClsHead',
-        num_classes=1000,
-        in_channels=2048,
-        loss=dict(
-            type='LabelSmoothLoss',
-            loss_weight=1.0,
-            label_smooth_val=0.1,
-            num_classes=1000),
-    ))

spaces/Abhaykoul/BardCookies-AI_Query/README.md

@@ -1,13 +0,0 @@
----
-title: AI With Realtime Data
-emoji: 🐠
-colorFrom: pink
-colorTo: yellow
-sdk: gradio
-sdk_version: 3.50.2
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/AchyuthGamer/OpenGPT/g4f/Provider/Providers/Aibn.py

@@ -1,52 +0,0 @@
-from __future__ import annotations
-
-import time
-import hashlib
-
-from ..typing import AsyncGenerator
-from ..requests import StreamSession
-from .base_provider import AsyncGeneratorProvider
-
-
-class Aibn(AsyncGeneratorProvider):
-    url                   = "https://aibn.cc"
-    supports_gpt_35_turbo = True
-    working               = True
-
-    @classmethod
-    async def create_async_generator(
-        cls,
-        model: str,
-        messages: list[dict[str, str]],
-        timeout: int = 30,
-        **kwargs
-    ) -> AsyncGenerator:
-        async with StreamSession(impersonate="chrome107", timeout=timeout) as session:
-            timestamp = int(time.time())
-            data = {
-                "messages": messages,
-                "pass": None,
-                "sign": generate_signature(timestamp, messages[-1]["content"]),
-                "time": timestamp
-            }
-            async with session.post(f"{cls.url}/api/generate", json=data) as response:
-                response.raise_for_status()
-                async for chunk in response.iter_content():
-                    yield chunk.decode()
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-            ("temperature", "float"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
-    
-
-def generate_signature(timestamp: int, message: str, secret: str = "undefined"):
-    data = f"{timestamp}:{message}:{secret}"
-    return hashlib.sha256(data.encode()).hexdigest()

spaces/AchyuthGamer/OpenGPT/g4f/Provider/Providers/ChatgptLogin.py

@@ -1,74 +0,0 @@
-from __future__ import annotations
-
-import os, re
-from aiohttp import ClientSession
-
-from .base_provider import AsyncProvider, format_prompt
-
-
-class ChatgptLogin(AsyncProvider):
-    url                   = "https://opchatgpts.net"
-    supports_gpt_35_turbo = True
-    working               = True
-    _nonce                = None
-
-    @classmethod
-    async def create_async(
-        cls,
-        model: str,
-        messages: list[dict[str, str]],
-        **kwargs
-    ) -> str:
-        headers = {
-            "User-Agent"         : "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36",
-            "Accept"             : "*/*",
-            "Accept-language"    : "en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3",
-            "Origin"             : "https://opchatgpts.net",
-            "Alt-Used"           : "opchatgpts.net",
-            "Referer"            : "https://opchatgpts.net/chatgpt-free-use/",
-            "Sec-Fetch-Dest"     : "empty",
-            "Sec-Fetch-Mode"     : "cors",
-            "Sec-Fetch-Site"     : "same-origin",
-        }
-        async with ClientSession(
-            headers=headers
-        ) as session:
-            if not cls._nonce:
-                async with session.get(
-                    "https://opchatgpts.net/chatgpt-free-use/",
-                    params={"id": os.urandom(6).hex()},
-                ) as response:
-                    result = re.search(r'data-nonce="(.*?)"', await response.text())
-                if not result:
-                    raise RuntimeError("No nonce value")
-                cls._nonce = result.group(1)
-            data = {
-                "_wpnonce": cls._nonce,
-                "post_id": 28,
-                "url": "https://opchatgpts.net/chatgpt-free-use",
-                "action": "wpaicg_chat_shortcode_message",
-                "message": format_prompt(messages),
-                "bot_id": 0
-            }
-            async with session.post("https://opchatgpts.net/wp-admin/admin-ajax.php", data=data) as response:
-                response.raise_for_status()
-                data = await response.json()
-                if "data" in data:
-                    return data["data"]
-                elif "msg" in data:
-                    raise RuntimeError(data["msg"])
-                else:
-                    raise RuntimeError(f"Response: {data}")
-
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-            ("temperature", "float"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"

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

@@ -1,19 +0,0 @@
-import Flip from './flip.js';
-
-class FlipPlugin extends Phaser.Plugins.BasePlugin {
-
-    constructor(pluginManager) {
-        super(pluginManager);
-    }
-
-    start() {
-        var eventEmitter = this.game.events;
-        eventEmitter.on('destroy', this.destroy, this);
-    }
-
-    add(gameObject, config) {
-        return new Flip(gameObject, config);
-    }
-}
-
-export default FlipPlugin;

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

@@ -1,11 +0,0 @@
-import Shake from './Shake.js';
-import ObjectFactory from '../ObjectFactory.js';
-import SetValue from '../../../plugins/utils/object/SetValue.js';
-
-ObjectFactory.register('shake', function (gameObject, config) {
-    return new Shake(gameObject, config);
-});
-
-SetValue(window, 'RexPlugins.UI.Shake', Shake);
-
-export default Shake;

spaces/Ailexcoder/GPT4ALL1/README.md

@@ -1,13 +0,0 @@
----
-title: Gpt4all
-emoji: 🦀
-colorFrom: gray
-colorTo: pink
-sdk: gradio
-sdk_version: 3.24.1
-app_file: app.py
-pinned: false
-duplicated_from: Ailexcoder/GPT4ALL
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/AlekseyKorshuk/instagram-filter-removal/modeling/base.py

@@ -1,60 +0,0 @@
-from torch import nn
-
-
-class BaseNetwork(nn.Module):
-    def __init__(self):
-        super(BaseNetwork, self).__init__()
-
-    def forward(self, x, y):
-        pass
-
-    def print_network(self):
-        if isinstance(self, list):
-            self = self[0]
-        num_params = 0
-        for param in self.parameters():
-            num_params += param.numel()
-        print('Network [%s] was created. Total number of parameters: %.1f million. '
-              'To see the architecture, do print(network).'
-              % (type(self).__name__, num_params / 1000000))
-
-    def set_requires_grad(self, requires_grad=False):
-        """Set requies_grad=Fasle for all the networks to avoid unnecessary computations
-        Parameters:
-        requires_grad (bool) -- whether the networks require gradients or not
-        """
-        for param in self.parameters():
-            param.requires_grad = requires_grad
-
-    def init_weights(self, init_type='xavier', gain=0.02):
-        def init_func(m):
-            classname = m.__class__.__name__
-            if classname.find('BatchNorm2d') != -1:
-                if hasattr(m, 'weight') and m.weight is not None:
-                    nn.init.normal_(m.weight.data, 1.0, gain)
-                if hasattr(m, 'bias') and m.bias is not None:
-                    nn.init.constant_(m.bias.data, 0.0)
-            elif hasattr(m, 'weight') and (classname.find('Conv') != -1 or classname.find('Linear') != -1):
-                if init_type == 'normal':
-                    nn.init.normal_(m.weight.data, 0.0, gain)
-                elif init_type == 'xavier':
-                    nn.init.xavier_normal_(m.weight.data, gain=gain)
-                elif init_type == 'xavier_uniform':
-                    nn.init.xavier_uniform_(m.weight.data, gain=1.0)
-                elif init_type == 'kaiming':
-                    nn.init.kaiming_normal_(m.weight.data, a=0, mode='fan_in')
-                elif init_type == 'orthogonal':
-                    nn.init.orthogonal_(m.weight.data, gain=gain)
-                elif init_type == 'none':  # uses pytorch's default init method
-                    m.reset_parameters()
-                else:
-                    raise NotImplementedError('initialization method [%s] is not implemented' % init_type)
-                if hasattr(m, 'bias') and m.bias is not None:
-                    nn.init.constant_(m.bias.data, 0.0)
-
-        self.apply(init_func)
-
-        # propagate to children
-        for m in self.children():
-            if hasattr(m, 'init_weights'):
-                m.init_weights(init_type, gain)

spaces/Ame42/rwms/main.py

@@ -1,401 +0,0 @@
-# 'dataset' holds the input data for this script
-import os.path
-
-import gradio as gr
-import numpy
-import pandas
-from sklearn.ensemble import RandomForestRegressor
-from sklearn.linear_model import LinearRegression
-from sklearn.metrics import explained_variance_score, max_error, mean_absolute_error, mean_squared_error, \
-    mean_squared_log_error, median_absolute_error, mean_absolute_percentage_error, r2_score, mean_poisson_deviance, \
-    mean_gamma_deviance, mean_tweedie_deviance, d2_tweedie_score, mean_pinball_loss, d2_pinball_score, \
-    d2_absolute_error_score
-from sklearn.model_selection import train_test_split
-from sklearn.preprocessing import StandardScaler
-
-import datastore
-from local_utils import *
-
-MAX_DEPTH = 20
-N_EST = 10
-
-mode = {"app": test_mode, "data": all_mode, "regen": False}
-
-
-def clean_prepare_train(data_i, train_size=0.015, test_size=0.005):
-    # drop sparse column THP BLIND then drop empty rows for all remaining columns
-    data_i.drop(axis=1, columns=[blind_col], inplace=True)
-    data_i.dropna(axis=0, inplace=True, how="any")
-    data_i.reset_index(inplace=True)
-
-    # change well_id to dummies
-    dummies = pandas.get_dummies(data_i[well_col])
-    data_i = pandas.concat([data_i, dummies], axis=1).reindex(data_i.index)
-    data_i.drop(columns=[well_col], axis=1, inplace=True)
-
-    # remove useless columns
-    data_i = keep_useful_cols(data_i, [ro_col, dur_col, man_col, blind_col, temp_col] + dummies.columns.tolist())
-
-    # get x and y
-    y = data_i[ro_col]
-    x_i = data_i.drop(axis=1, columns=[ro_col])
-
-    # verify data row count
-    print(f"\n{x_i.shape[0]} rows")
-
-    # fit scaler
-    scaler_i = StandardScaler(copy=False)
-    scaler_i.fit(x_i)
-    x_fit = pandas.DataFrame(scaler_i.transform(x_i), columns=x_i.columns)
-
-    # data split
-    x_train, x_test, y_train, y_test = \
-        train_test_split(x_fit, y, random_state=30, train_size=train_size, test_size=test_size)
-
-    # model
-    model_i = RandomForestRegressor(n_estimators=N_EST, random_state=30, max_depth=MAX_DEPTH)
-    model_i.fit(x_train, y_train)
-    # print([est.get_depth() for est in model_i.estimators_])
-
-    # testing
-    y_pred = model_i.predict(x_test)
-    score_i = r2_score(y_test, y_pred)
-    # print("explained_variance_score:", explained_variance_score(y_test, y_pred))
-    # print("max_error:", max_error(y_test, y_pred))
-    # print("mean_absolute_error:", mean_absolute_error(y_test, y_pred))
-    # print("mean_squared_error:", mean_squared_error(y_test, y_pred))
-    # print("mean_squared_log_error:", mean_squared_log_error(y_test, y_pred))
-    # print("median_absolute_error:", median_absolute_error(y_test, y_pred))
-    # print("mean_absolute_percentage_error:", mean_absolute_percentage_error(y_test, y_pred))
-    # print("r2_score:", r2_score(y_test, y_pred))
-    # print("mean_poisson_deviance:", mean_poisson_deviance(y_test, y_pred))
-    # print("mean_gamma_deviance:", mean_gamma_deviance(y_test, y_pred))
-    # print("mean_tweedie_deviance:", mean_tweedie_deviance(y_test, y_pred))
-    # print("d2_tweedie_score:", d2_tweedie_score(y_test, y_pred))
-    # print("mean_pinball_loss:", mean_pinball_loss(y_test, y_pred))
-    # print("d2_pinball_score:", d2_pinball_score(y_test, y_pred))
-    # print("d2_absolute_error_score:", d2_absolute_error_score(y_test, y_pred))
-
-    # create power_bi data payload
-    x_test, y_test, y_pred = (pandas.DataFrame(x_test).reset_index(),
-                              pandas.DataFrame(y_test).reset_index(),
-                              pandas.DataFrame(y_pred, columns=[sim_col]).reset_index())
-    data_run = pandas.concat([x_test, y_test, y_pred], axis=1).drop("index", axis=1)
-
-    return model_i, scaler_i, score_i, x_i, data_run
-
-
-def report_on(model_i, scaler_i, score_i, x_i):
-    print(f"""
-        \033[1;31mAI generalization stats\033[0m
-        Model performance (rms score): \033[0;35m{score_i * 100:.2f}%\033[0m
-        """)
-
-    tests = [WellDataPoint(thp=661.84, day_sec=54100, man_pres=143.93, temp=93.9, _l1=0, _s1=1, _l2=0, _s2=0),
-             WellDataPoint(thp=1118.456, day_sec=86050, man_pres=166.063, temp=79.706, _l1=1, _s1=0, _l2=0, _s2=0),
-             WellDataPoint(thp=609.08, day_sec=42600, man_pres=137.2, temp=95.477, _l1=0, _s1=0, _l2=0, _s2=1),
-             WellDataPoint(thp=1118.07, day_sec=49400, man_pres=146.44, temp=98.5, _l1=0, _s1=0, _l2=1, _s2=0)]
-
-    for test in tests:
-        print(f"\n{test}")
-        try:
-            test_x = pandas.DataFrame(scaler_i.transform(pandas.DataFrame([test.get_x()], columns=x_i.columns)),
-                                      columns=x_i.columns)
-            y_vis_pred = model_i.predict(test_x)
-            print(f"Real: \033[0;35m{test.get_y():.2f} psi\033[0m vs. "
-                  f"Prediction: \033[0;35m{y_vis_pred[0]:.2f} psi\033[0m", flush=True)
-        except ValueError:
-            print(x_i.columns, flush=True)
-
-
-def train(mode, best=(25, 10, 54, 0, 0)):
-    if mode == day_mode:
-        data = datastore.get_22_data()
-        model, scaler, score, x, results = clean_prepare_train(data, train_size=0.75, test_size=0.25)
-        write_state_files(model, scaler)
-        results.to_csv(f"{out_folder}POWER_BI_DATA_DAY.csv", index_label=id_col)
-        report_on(model, scaler, score, x)
-    else:
-        # get data payload
-        if not os.path.exists(f"{out_folder}data_opt_balanced.csv"):
-            data_dict = datastore.get_all_data()
-
-            # search for the best offset combination model
-            # best = find_best(data_dict, model_search, best)
-            print(f"\033[1;31mFinal offsets\033[0m\n{s1}: {best[0]}, {l1}: {best[1]}, {s2}: {best[2]}, {l2}: {best[3]}")
-            data = datastore.offset_wells(data_dict, [x for x in best[:4]])
-
-            # remove unnecessary id columns
-            data = keep_useful_cols(data)
-
-            # balance it by oversampling
-            data = oversample_balance(data)
-
-            # dump it
-            data.to_csv(f"{out_folder}data_opt_balanced.csv", index_label=id_col)
-        else:
-            data = pandas.read_csv(f"{out_folder}data_opt_balanced.csv")
-
-        # create model
-        model, scaler, score, x, results = clean_prepare_train(keep_useful_cols(data), train_size=0.75, test_size=0.25)
-        write_state_files(model, scaler)
-        results.to_csv(f"{out_folder}POWER_BI_DATA.csv", index_label=id_col)
-        report_on(model, scaler, score, x)
-
-        return model
-
-
-def model_search(dt_dict, s_1, l_1, s_2, l_2, current_best):
-    dt = datastore.offset_wells(dt_dict, [s_1, l_1, s_2, l_2])
-    _, _, scr, _, _ = clean_prepare_train(dt, train_size=0.75, test_size=0.25)
-    scores_i = (s_1, l_1, s_2, l_2, scr)
-    print(f"s1: {s_1}, l1: {l_1}, s2: {s_2}, l2: {l_2}, \033[0;35mscore: {scr * 100}\033[0m vs. "
-          f"\033[1;31mbest: {current_best[4] * 100}\033[0m")
-    return scores_i if scr > current_best[4] else current_best
-
-
-def find_best(data_dict, model_search, best):
-    for i in range(60):
-        best = model_search(data_dict, i, best[1], best[2], best[3], best)
-    for j in range(60):
-        best = model_search(data_dict, best[0], j, best[2], best[3], best)
-    for k in range(60):
-        best = model_search(data_dict, best[0], best[1], k, best[3], best)
-    for n in range(180):
-        best = model_search(data_dict, best[0], best[1], best[2], n, best)
-    return best
-
-
-def app(hours, mins, secs, man_pres, temp, well, thp=None, regen=False, full_text_reply=True):
-    global test_x, y_vis_pred
-
-    dur_sec = to_sec(hours, mins, secs)
-
-    if regen or not (os.path.exists(f"{model_file}.mdl") and os.path.exists(f"{scaler_file}.sts")):
-        train(mode['data'])
-
-    mdl, scl = read_state_files(model_file, scaler_file)
-
-    thp = 0 if thp is None else thp
-
-    _l1, _l2, _s1, _s2 = change_well_to_dummy(well)
-
-    test = WellDataPoint(thp=thp, day_sec=dur_sec, man_pres=man_pres, temp=temp, _l1=_l1, _s1=_s1, _l2=_l2, _s2=_s2)
-    columns = ['Daylight duration (SEC)', 'Manifold Pressure (PSI)', 'TEMP (°F)', '1L', '1S', '2L', '2S']
-    try:
-        test_x = pandas.DataFrame(scl.transform(pandas.DataFrame([test.get_x()], columns=columns)), columns=columns)
-        y_vis_pred = mdl.predict(test_x)
-        print(f"Real: \033[0;35m{test.get_y():.2f} psi\033[0m vs. "
-              f"Prediction: \033[0;35m{y_vis_pred[0]:.2f} psi\033[0m")
-    except ValueError:
-        print(test, flush=True)
-        raise
-
-    return f"{test.__plain__()}\nReal: {test.get_y():.2f} psi vs. Prediction: {y_vis_pred[0]:.2f} psi" if \
-        full_text_reply else y_vis_pred
-
-
-def i_app(wl, pres):
-    # match well to factors
-    factor = factors.loc[factors["Well"] == wl[6:]]
-
-    # retrieve conversion and flow factor
-    c_factor = factor["Conversion Factor"]
-    f_factor = factor["Flow Factor"]
-
-    # return math result
-    return f"""\
-Testing data
-    Manifold pressure: {pres} psi
-    Well: {wl}
-    
-Flowing tubing head pressure: {pres + [f for f in c_factor][0]:.2f} psi
-Q-liquid: {pres * [f for f in f_factor][0]:.2f} bbl/day"""
-
-
-scroll_data = pandas.read_csv(f"{out_folder}data_opt_balanced.csv")  # pandas.DataFrame()
-n_real = 0
-n_sim = 0
-mn = 0
-mx = 0
-_, _, _, _, results = clean_prepare_train(scroll_data, train_size=0.50, test_size=0.50)
-state_var = False
-results.insert(0, id_col, numpy.array(range(results.shape[0])), False)
-
-# randomize data rows and reset index
-scroll_data = scroll_data.sample(frac=1)
-scroll_data.drop([id_col, "index"], axis=1, inplace=True, errors="ignore")
-scroll_data.insert(0, id_col, numpy.array(range(scroll_data.shape[0])), False)
-y_range = min(scroll_data[ro_col]), max(scroll_data[ro_col])
-
-
-# async def load_data():
-#     global state_var
-#     if not state_var:
-#         state_var = True
-#         global scroll_data
-#         data = pandas.read_csv(f"{out_folder}data_opt_balanced.csv")
-#         model, scaler, score, x, results = clean_prepare_train(keep_useful_cols(data), train_size=0.50, test_size=0.50)
-#         i = 0
-#
-#         while i < results.shape[0]:
-#             await asyncio.sleep(1)
-#             i += 1
-#             new_row = results.iloc[[i]]
-#             print(new_row)
-#             scroll_data = pandas.concat([scroll_data, new_row], ignore_index=True)
-#             if scroll_data.shape[0] > 100:
-#                 scroll_data.drop(0, axis=0, inplace=True)
-#                 print(scroll_data.shape)
-
-
-# URL = "https://docs.google.com/spreadsheets/d/1ZQbeOeCaiLMidenqmwq7wC-ni7rdtUYQXH1XER6XyyQ/edit#gid=0"
-# csv_url = URL.replace('/edit#gid=', '/export?format=csv&gid=')
-#
-#
-# def get_data():
-#     return pandas.read_csv(csv_url)
-
-
-def get_real_data() -> pandas.DataFrame:
-    global results
-    global mn
-    global mx
-    mx += 1
-    mn = 0 if mx - 50 < 0 else mx - 50
-    sl = results.iloc[mn:mx]
-    sl.insert(0, time_col, numpy.array([from_sec(int(r)) for r in sl[id_col].tolist()]), False)
-    return gr.LinePlot.update(value=sl)  # scroll_data
-
-
-def get_sim_data() -> pandas.DataFrame:
-    global results
-    sl = results.iloc[mn:mx]
-    sl.insert(0, time_col, numpy.array([from_sec(r) for r in sl[id_col].tolist()]), False)
-    return gr.LinePlot.update(value=sl)  # scroll_data
-
-
-x_real = 0
-x_pres = 0
-x_ql = 0
-
-
-def get_x_real_data() -> pandas.DataFrame:
-    global results
-    sl = scroll_data.iloc[mn:mx]
-    sl = sl.drop(time_col, axis=1, errors="ignore")
-    sl.insert(0, time_col, numpy.array([from_sec(int(r)) for r in sl[id_col].tolist()]), False)
-    return gr.LinePlot.update(value=sl)  # scroll_data
-
-
-def get_x_sim_pres_data() -> pandas.DataFrame:
-    global results
-    sl = scroll_data.iloc[mn:mx]
-    sl = sl.drop(sim_col, axis=1, errors="ignore")
-    sl = sl.drop(time_col, axis=1, errors="ignore")
-    sl.insert(0, time_col, numpy.array([from_sec(int(r)) for r in sl[id_col].tolist()]), False)
-    sl.insert(0, sim_col, numpy.array([calc_excel(r)[0] for r in sl[man_col].tolist()]), False)
-    return gr.LinePlot.update(value=sl)  # scroll_data
-
-
-def get_x_sim_ql_data() -> pandas.DataFrame:
-    global results
-    sl = scroll_data.iloc[mn:mx]
-    sl = sl.drop(time_col, axis=1, errors="ignore")
-    sl.insert(0, time_col, numpy.array([from_sec(int(r)) for r in sl[id_col].tolist()]), False)
-    sl.insert(0, ql_col, numpy.array([calc_excel(r)[1] for r in sl[man_col].tolist()]), False)
-    return gr.LinePlot.update(value=sl)  # scroll_data
-
-
-# get conversion factors
-factors = datastore.get_conversion_factors()
-
-if mode['app'] == train_mode:
-    app(23, 59, 40, 143.96, 79.523, parse_well_id(s2))
-    app(17, 2, 0, 144.41, 97.278, parse_well_id(l1), regen=mode['regen'])
-else:
-    with gr.Blocks() as demo:
-        gr.Markdown("#")
-        with gr.Tab("Dashboard"):
-            mx = 50
-            # pull data into line plot
-            with gr.Row():
-                with gr.Column():
-                    gr.Markdown("# Our AI-powered calculator (Accuracy: 99.61%)")
-                    # Real Tubing Head Pressure
-                    real_ai = gr.LinePlot(y=ro_col, x=time_col, label="Awoba Well X", title="Real Tubing Head Pressure",
-                                          y_title=ro_col, x_title=time_col, every=1, height=150, width=600)
-                    demo.load(fn=get_real_data, inputs=None, outputs=real_ai)
-
-                    # Calculated Tubing Head Pressure
-                    sim_ai = gr.LinePlot(y=sim_col, x=time_col, label="Awoba Well X",
-                                         title="Calculated Tubing Head Pressure",
-                                         y_title=sim_col, x_title=time_col, every=1, height=150, width=600)
-                    demo.load(fn=get_sim_data, inputs=None, outputs=sim_ai)
-
-
-                with gr.Column():
-                    gr.Markdown("###")
-                    gr.Markdown("### Excel formulae (Accuracy: 27.53%)")
-                    # Real Tubing Head Pressure
-                    real_x = gr.LinePlot(y=ro_col, x=time_col, label="Abura Well X", title="Real Tubing Head Pressure",
-                                         y_title=ro_col, x_title=time_col, every=1, height=150, width=600, y_lim=y_range
-                                         )
-                    demo.load(fn=get_x_real_data, inputs=None, outputs=real_x)
-
-                    # Calculated Tubing Head Pressure
-                    sim_x = gr.LinePlot(y=sim_col, x=time_col, label="Abura Well X", title="Calculated Tubing Head Pressure"
-                                        , y_title=sim_col, x_title=time_col, every=1, height=150, width=600,
-                                        y_lim=y_range)
-                    demo.load(fn=get_x_sim_pres_data, inputs=None, outputs=sim_x)
-
-                    # Calculated Production
-                    sim_ql_x = gr.LinePlot(y=ql_col, x=time_col, label="Abura Well X", title="Calculated Production",
-                                           y_title=ql_col, x_title=time_col, every=1, height=150, width=600)
-                    demo.load(fn=get_x_sim_ql_data, inputs=None, outputs=sim_ql_x)
-        with gr.Tab("AI approach"):
-            hours = gr.Number(label="Hours (24-hour format)", value=23)
-            mins = gr.Number(label="Minutes", value=59)
-            secs = gr.Number(label="Seconds", value=40)
-            man_pres = gr.Number(label=man_col, value=143.96)
-            temp = gr.Number(label=temp_col, value=79.523)
-            well = gr.Radio(
-                [parse_well_id(w) for w in [l1, s1, l2, s2]],
-                value=parse_well_id(s2),
-                label="Select a well"
-            )
-            thp = gr.Number(label=ro_col, value=641.98)
-            greet_btn = gr.Button("Simulate")
-            greet_btn.style(full_width=True)
-            output = gr.Textbox(label="Results")
-            greet_btn.click(fn=app, inputs=[hours, mins, secs, man_pres, temp, well, thp], outputs=output)
-
-        with gr.Tab("Excel approach"):
-            # build interface to take in well selection and manifold pressure
-            i_man_pres = gr.Number(label=man_col, value=143.96)
-            i_well = gr.Radio(
-                [parse_well_id_2(w) for w in factors["Well"]],
-                label="Select a well"
-            )
-            i_greet_btn = gr.Button("Simulate")
-            i_greet_btn.style(full_width=True)
-            i_output = gr.Textbox(label="Results")
-
-            # call i_app function with params on button click
-            i_greet_btn.click(fn=i_app, inputs=[i_well, i_man_pres], outputs=i_output)
-
-
-        # demo.load(fn=get_real_data, inputs=None, outputs=real_ai)
-            # with gr.Column():
-            #     with gr.Row():
-            #         gr.LinePlot(value=get_real_data, y=ro_col, x=id_col, label="Real Tubing Head Pressure",
-            #                     y_title=ro_col, x_title=time_col, every=1, height=80, width=600)
-            #         gr.LinePlot(value=get_sim_data, y=sim_col, x=id_col, label="Calculated Tubing Head Pressure",
-            #                     y_title=sim_col, x_title=time_col, every=1, height=80, width=600)
-            #     with gr.Row():
-            #         gr.LinePlot(value=get_real_data, y=ro_col, x=id_col, label="Real Tubing Head Pressure",
-            #                     y_title=ro_col, x_title=time_col, every=1, height=80, width=600)
-            #         gr.LinePlot(value=get_sim_data, y=sim_col, x=id_col, label="Calculated Tubing Head Pressure",
-            #                     y_title=sim_col, x_title=time_col, every=1, height=80, width=600)
-
-    demo.launch(enable_queue=True, share=False)

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

@@ -1,720 +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
-from typing import Any, Callable, Dict, List, Optional, Union
-
-import numpy as np
-import PIL
-import torch
-from transformers import CLIPTextModel, CLIPTokenizer
-
-from ...loaders import LoraLoaderMixin, TextualInversionLoaderMixin
-from ...models import AutoencoderKL, UNet3DConditionModel
-from ...schedulers import KarrasDiffusionSchedulers
-from ...utils import (
-    is_accelerate_available,
-    is_accelerate_version,
-    logging,
-    randn_tensor,
-    replace_example_docstring,
-)
-from ..pipeline_utils import DiffusionPipeline
-from . import TextToVideoSDPipelineOutput
-
-
-logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
-
-EXAMPLE_DOC_STRING = """
-    Examples:
-        ```py
-        >>> import torch
-        >>> from diffusers import DiffusionPipeline, DPMSolverMultistepScheduler
-        >>> from diffusers.utils import export_to_video
-
-        >>> pipe = DiffusionPipeline.from_pretrained("cerspense/zeroscope_v2_576w", torch_dtype=torch.float16)
-        >>> pipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
-        >>> pipe.to("cuda")
-
-        >>> prompt = "spiderman running in the desert"
-        >>> video_frames = pipe(prompt, num_inference_steps=40, height=320, width=576, num_frames=24).frames
-        >>> # safe low-res video
-        >>> video_path = export_to_video(video_frames, output_video_path="./video_576_spiderman.mp4")
-
-        >>> # let's offload the text-to-image model
-        >>> pipe.to("cpu")
-
-        >>> # and load the image-to-image model
-        >>> pipe = DiffusionPipeline.from_pretrained(
-        ...     "cerspense/zeroscope_v2_XL", torch_dtype=torch.float16, revision="refs/pr/15"
-        ... )
-        >>> pipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
-        >>> pipe.enable_model_cpu_offload()
-
-        >>> # The VAE consumes A LOT of memory, let's make sure we run it in sliced mode
-        >>> pipe.vae.enable_slicing()
-
-        >>> # now let's upscale it
-        >>> video = [Image.fromarray(frame).resize((1024, 576)) for frame in video_frames]
-
-        >>> # and denoise it
-        >>> video_frames = pipe(prompt, video=video, strength=0.6).frames
-        >>> video_path = export_to_video(video_frames, output_video_path="./video_1024_spiderman.mp4")
-        >>> video_path
-        ```
-"""
-
-
-def tensor2vid(video: torch.Tensor, mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) -> List[np.ndarray]:
-    # This code is copied from https://github.com/modelscope/modelscope/blob/1509fdb973e5871f37148a4b5e5964cafd43e64d/modelscope/pipelines/multi_modal/text_to_video_synthesis_pipeline.py#L78
-    # reshape to ncfhw
-    mean = torch.tensor(mean, device=video.device).reshape(1, -1, 1, 1, 1)
-    std = torch.tensor(std, device=video.device).reshape(1, -1, 1, 1, 1)
-    # unnormalize back to [0,1]
-    video = video.mul_(std).add_(mean)
-    video.clamp_(0, 1)
-    # prepare the final outputs
-    i, c, f, h, w = video.shape
-    images = video.permute(2, 3, 0, 4, 1).reshape(
-        f, h, i * w, c
-    )  # 1st (frames, h, batch_size, w, c) 2nd (frames, h, batch_size * w, c)
-    images = images.unbind(dim=0)  # prepare a list of indvidual (consecutive frames)
-    images = [(image.cpu().numpy() * 255).astype("uint8") for image in images]  # f h w c
-    return images
-
-
-def preprocess_video(video):
-    supported_formats = (np.ndarray, torch.Tensor, PIL.Image.Image)
-
-    if isinstance(video, supported_formats):
-        video = [video]
-    elif not (isinstance(video, list) and all(isinstance(i, supported_formats) for i in video)):
-        raise ValueError(
-            f"Input is in incorrect format: {[type(i) for i in video]}. Currently, we only support {', '.join(supported_formats)}"
-        )
-
-    if isinstance(video[0], PIL.Image.Image):
-        video = [np.array(frame) for frame in video]
-
-    if isinstance(video[0], np.ndarray):
-        video = np.concatenate(video, axis=0) if video[0].ndim == 5 else np.stack(video, axis=0)
-
-        if video.dtype == np.uint8:
-            video = np.array(video).astype(np.float32) / 255.0
-
-        if video.ndim == 4:
-            video = video[None, ...]
-
-        video = torch.from_numpy(video.transpose(0, 4, 1, 2, 3))
-
-    elif isinstance(video[0], torch.Tensor):
-        video = torch.cat(video, axis=0) if video[0].ndim == 5 else torch.stack(video, axis=0)
-
-        # don't need any preprocess if the video is latents
-        channel = video.shape[1]
-        if channel == 4:
-            return video
-
-        # move channels before num_frames
-        video = video.permute(0, 2, 1, 3, 4)
-
-    # normalize video
-    video = 2.0 * video - 1.0
-
-    return video
-
-
-class VideoToVideoSDPipeline(DiffusionPipeline, TextualInversionLoaderMixin, LoraLoaderMixin):
-    r"""
-    Pipeline for text-guided video-to-video generation.
-
-    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 videos to and from latent representations.
-        text_encoder ([`CLIPTextModel`]):
-            Frozen text-encoder ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)).
-        tokenizer (`CLIPTokenizer`):
-            A [`~transformers.CLIPTokenizer`] to tokenize text.
-        unet ([`UNet3DConditionModel`]):
-            A [`UNet3DConditionModel`] to denoise the encoded video 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`].
-    """
-
-    def __init__(
-        self,
-        vae: AutoencoderKL,
-        text_encoder: CLIPTextModel,
-        tokenizer: CLIPTokenizer,
-        unet: UNet3DConditionModel,
-        scheduler: KarrasDiffusionSchedulers,
-    ):
-        super().__init__()
-
-        self.register_modules(
-            vae=vae,
-            text_encoder=text_encoder,
-            tokenizer=tokenizer,
-            unet=unet,
-            scheduler=scheduler,
-        )
-        self.vae_scale_factor = 2 ** (len(self.vae.config.block_out_channels) - 1)
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.enable_vae_slicing
-    def enable_vae_slicing(self):
-        r"""
-        Enable sliced VAE decoding. When this option is enabled, the VAE will split the input tensor in slices to
-        compute decoding in several steps. This is useful to save some memory and allow larger batch sizes.
-        """
-        self.vae.enable_slicing()
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.disable_vae_slicing
-    def disable_vae_slicing(self):
-        r"""
-        Disable sliced VAE decoding. If `enable_vae_slicing` was previously enabled, this method will go back to
-        computing decoding in one step.
-        """
-        self.vae.disable_slicing()
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.enable_vae_tiling
-    def enable_vae_tiling(self):
-        r"""
-        Enable tiled VAE decoding. When this option is enabled, the VAE will split the input tensor into tiles to
-        compute decoding and encoding in several steps. This is useful for saving a large amount of memory and to allow
-        processing larger images.
-        """
-        self.vae.enable_tiling()
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.disable_vae_tiling
-    def disable_vae_tiling(self):
-        r"""
-        Disable tiled VAE decoding. If `enable_vae_tiling` was previously enabled, this method will go back to
-        computing decoding in one step.
-        """
-        self.vae.disable_tiling()
-
-    def enable_model_cpu_offload(self, gpu_id=0):
-        r"""
-        Offload all models to CPU to reduce memory usage with a low impact on performance. Moves one whole model at a
-        time to the GPU when its `forward` method is called, and the model remains in GPU until the next model runs.
-        Memory savings are lower than using `enable_sequential_cpu_offload`, but performance is much better due to the
-        iterative execution of the `unet`.
-        """
-        if is_accelerate_available() and is_accelerate_version(">=", "0.17.0.dev0"):
-            from accelerate import cpu_offload_with_hook
-        else:
-            raise ImportError("`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher.")
-
-        device = torch.device(f"cuda:{gpu_id}")
-
-        if self.device.type != "cpu":
-            self.to("cpu", silence_dtype_warnings=True)
-            torch.cuda.empty_cache()  # otherwise we don't see the memory savings (but they probably exist)
-
-        hook = None
-        for cpu_offloaded_model in [self.text_encoder, self.vae, self.unet]:
-            _, hook = cpu_offload_with_hook(cpu_offloaded_model, device, prev_module_hook=hook)
-
-        # We'll offload the last model manually.
-        self.final_offload_hook = hook
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._encode_prompt
-    def _encode_prompt(
-        self,
-        prompt,
-        device,
-        num_images_per_prompt,
-        do_classifier_free_guidance,
-        negative_prompt=None,
-        prompt_embeds: Optional[torch.FloatTensor] = None,
-        negative_prompt_embeds: Optional[torch.FloatTensor] = None,
-        lora_scale: Optional[float] = None,
-    ):
-        r"""
-        Encodes the prompt into text encoder hidden states.
-
-        Args:
-             prompt (`str` or `List[str]`, *optional*):
-                prompt to be encoded
-            device: (`torch.device`):
-                torch device
-            num_images_per_prompt (`int`):
-                number of images that should be generated per prompt
-            do_classifier_free_guidance (`bool`):
-                whether to use classifier free guidance or not
-            negative_prompt (`str` or `List[str]`, *optional*):
-                The prompt or prompts not to guide the image generation. If not defined, one has to pass
-                `negative_prompt_embeds` instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is
-                less than `1`).
-            prompt_embeds (`torch.FloatTensor`, *optional*):
-                Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not
-                provided, text embeddings will be generated from `prompt` input argument.
-            negative_prompt_embeds (`torch.FloatTensor`, *optional*):
-                Pre-generated negative text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt
-                weighting. If not provided, negative_prompt_embeds will be generated from `negative_prompt` input
-                argument.
-            lora_scale (`float`, *optional*):
-                A lora scale that will be applied to all LoRA layers of the text encoder if LoRA layers are loaded.
-        """
-        # set lora scale so that monkey patched LoRA
-        # function of text encoder can correctly access it
-        if lora_scale is not None and isinstance(self, LoraLoaderMixin):
-            self._lora_scale = lora_scale
-
-        if prompt is not None and isinstance(prompt, str):
-            batch_size = 1
-        elif prompt is not None and isinstance(prompt, list):
-            batch_size = len(prompt)
-        else:
-            batch_size = prompt_embeds.shape[0]
-
-        if prompt_embeds is None:
-            # textual inversion: procecss multi-vector tokens if necessary
-            if isinstance(self, TextualInversionLoaderMixin):
-                prompt = self.maybe_convert_prompt(prompt, self.tokenizer)
-
-            text_inputs = self.tokenizer(
-                prompt,
-                padding="max_length",
-                max_length=self.tokenizer.model_max_length,
-                truncation=True,
-                return_tensors="pt",
-            )
-            text_input_ids = text_inputs.input_ids
-            untruncated_ids = self.tokenizer(prompt, padding="longest", return_tensors="pt").input_ids
-
-            if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(
-                text_input_ids, untruncated_ids
-            ):
-                removed_text = self.tokenizer.batch_decode(
-                    untruncated_ids[:, self.tokenizer.model_max_length - 1 : -1]
-                )
-                logger.warning(
-                    "The following part of your input was truncated because CLIP can only handle sequences up to"
-                    f" {self.tokenizer.model_max_length} tokens: {removed_text}"
-                )
-
-            if hasattr(self.text_encoder.config, "use_attention_mask") and self.text_encoder.config.use_attention_mask:
-                attention_mask = text_inputs.attention_mask.to(device)
-            else:
-                attention_mask = None
-
-            prompt_embeds = self.text_encoder(
-                text_input_ids.to(device),
-                attention_mask=attention_mask,
-            )
-            prompt_embeds = prompt_embeds[0]
-
-        prompt_embeds = prompt_embeds.to(dtype=self.text_encoder.dtype, device=device)
-
-        bs_embed, seq_len, _ = prompt_embeds.shape
-        # duplicate text embeddings for each generation per prompt, using mps friendly method
-        prompt_embeds = prompt_embeds.repeat(1, num_images_per_prompt, 1)
-        prompt_embeds = prompt_embeds.view(bs_embed * num_images_per_prompt, seq_len, -1)
-
-        # get unconditional embeddings for classifier free guidance
-        if do_classifier_free_guidance and negative_prompt_embeds is None:
-            uncond_tokens: List[str]
-            if negative_prompt is None:
-                uncond_tokens = [""] * batch_size
-            elif prompt is not None and type(prompt) is not type(negative_prompt):
-                raise TypeError(
-                    f"`negative_prompt` should be the same type to `prompt`, but got {type(negative_prompt)} !="
-                    f" {type(prompt)}."
-                )
-            elif isinstance(negative_prompt, str):
-                uncond_tokens = [negative_prompt]
-            elif batch_size != len(negative_prompt):
-                raise ValueError(
-                    f"`negative_prompt`: {negative_prompt} has batch size {len(negative_prompt)}, but `prompt`:"
-                    f" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches"
-                    " the batch size of `prompt`."
-                )
-            else:
-                uncond_tokens = negative_prompt
-
-            # textual inversion: procecss multi-vector tokens if necessary
-            if isinstance(self, TextualInversionLoaderMixin):
-                uncond_tokens = self.maybe_convert_prompt(uncond_tokens, self.tokenizer)
-
-            max_length = prompt_embeds.shape[1]
-            uncond_input = self.tokenizer(
-                uncond_tokens,
-                padding="max_length",
-                max_length=max_length,
-                truncation=True,
-                return_tensors="pt",
-            )
-
-            if hasattr(self.text_encoder.config, "use_attention_mask") and self.text_encoder.config.use_attention_mask:
-                attention_mask = uncond_input.attention_mask.to(device)
-            else:
-                attention_mask = None
-
-            negative_prompt_embeds = self.text_encoder(
-                uncond_input.input_ids.to(device),
-                attention_mask=attention_mask,
-            )
-            negative_prompt_embeds = negative_prompt_embeds[0]
-
-        if do_classifier_free_guidance:
-            # duplicate unconditional embeddings for each generation per prompt, using mps friendly method
-            seq_len = negative_prompt_embeds.shape[1]
-
-            negative_prompt_embeds = negative_prompt_embeds.to(dtype=self.text_encoder.dtype, device=device)
-
-            negative_prompt_embeds = negative_prompt_embeds.repeat(1, num_images_per_prompt, 1)
-            negative_prompt_embeds = negative_prompt_embeds.view(batch_size * num_images_per_prompt, seq_len, -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
-            prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds])
-
-        return prompt_embeds
-
-    # Copied from diffusers.pipelines.text_to_video_synthesis.pipeline_text_to_video_synth.TextToVideoSDPipeline.decode_latents
-    def decode_latents(self, latents):
-        latents = 1 / self.vae.config.scaling_factor * latents
-
-        batch_size, channels, num_frames, height, width = latents.shape
-        latents = latents.permute(0, 2, 1, 3, 4).reshape(batch_size * num_frames, channels, height, width)
-
-        image = self.vae.decode(latents).sample
-        video = (
-            image[None, :]
-            .reshape(
-                (
-                    batch_size,
-                    num_frames,
-                    -1,
-                )
-                + image.shape[2:]
-            )
-            .permute(0, 2, 1, 3, 4)
-        )
-        # we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16
-        video = video.float()
-        return video
-
-    # 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_img2img.StableDiffusionImg2ImgPipeline.check_inputs
-    def check_inputs(
-        self, prompt, strength, callback_steps, negative_prompt=None, prompt_embeds=None, negative_prompt_embeds=None
-    ):
-        if strength < 0 or strength > 1:
-            raise ValueError(f"The value of strength should in [0.0, 1.0] but is {strength}")
-
-        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)}."
-            )
-
-        if prompt is not None and prompt_embeds is not None:
-            raise ValueError(
-                f"Cannot forward both `prompt`: {prompt} and `prompt_embeds`: {prompt_embeds}. Please make sure to"
-                " only forward one of the two."
-            )
-        elif prompt is None and prompt_embeds is None:
-            raise ValueError(
-                "Provide either `prompt` or `prompt_embeds`. Cannot leave both `prompt` and `prompt_embeds` undefined."
-            )
-        elif prompt is not None and (not isinstance(prompt, str) and not isinstance(prompt, list)):
-            raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}")
-
-        if negative_prompt is not None and negative_prompt_embeds is not None:
-            raise ValueError(
-                f"Cannot forward both `negative_prompt`: {negative_prompt} and `negative_prompt_embeds`:"
-                f" {negative_prompt_embeds}. Please make sure to only forward one of the two."
-            )
-
-        if prompt_embeds is not None and negative_prompt_embeds is not None:
-            if prompt_embeds.shape != negative_prompt_embeds.shape:
-                raise ValueError(
-                    "`prompt_embeds` and `negative_prompt_embeds` must have the same shape when passed directly, but"
-                    f" got: `prompt_embeds` {prompt_embeds.shape} != `negative_prompt_embeds`"
-                    f" {negative_prompt_embeds.shape}."
-                )
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_img2img.StableDiffusionImg2ImgPipeline.get_timesteps
-    def get_timesteps(self, num_inference_steps, strength, device):
-        # get the original timestep using init_timestep
-        init_timestep = min(int(num_inference_steps * strength), num_inference_steps)
-
-        t_start = max(num_inference_steps - init_timestep, 0)
-        timesteps = self.scheduler.timesteps[t_start * self.scheduler.order :]
-
-        return timesteps, num_inference_steps - t_start
-
-    def prepare_latents(self, video, timestep, batch_size, dtype, device, generator=None):
-        video = video.to(device=device, dtype=dtype)
-
-        # change from (b, c, f, h, w) -> (b * f, c, w, h)
-        bsz, channel, frames, width, height = video.shape
-        video = video.permute(0, 2, 1, 3, 4).reshape(bsz * frames, channel, width, height)
-
-        if video.shape[1] == 4:
-            init_latents = video
-        else:
-            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."
-                )
-
-            elif isinstance(generator, list):
-                init_latents = [
-                    self.vae.encode(video[i : i + 1]).latent_dist.sample(generator[i]) for i in range(batch_size)
-                ]
-                init_latents = torch.cat(init_latents, dim=0)
-            else:
-                init_latents = self.vae.encode(video).latent_dist.sample(generator)
-
-            init_latents = self.vae.config.scaling_factor * init_latents
-
-        if batch_size > init_latents.shape[0] and batch_size % init_latents.shape[0] != 0:
-            raise ValueError(
-                f"Cannot duplicate `video` of batch size {init_latents.shape[0]} to {batch_size} text prompts."
-            )
-        else:
-            init_latents = torch.cat([init_latents], dim=0)
-
-        shape = init_latents.shape
-        noise = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
-
-        # get latents
-        init_latents = self.scheduler.add_noise(init_latents, noise, timestep)
-        latents = init_latents
-
-        latents = latents[None, :].reshape((bsz, frames, latents.shape[1]) + latents.shape[2:]).permute(0, 2, 1, 3, 4)
-
-        return latents
-
-    @torch.no_grad()
-    @replace_example_docstring(EXAMPLE_DOC_STRING)
-    def __call__(
-        self,
-        prompt: Union[str, List[str]] = None,
-        video: Union[List[np.ndarray], torch.FloatTensor] = None,
-        strength: float = 0.6,
-        num_inference_steps: int = 50,
-        guidance_scale: float = 15.0,
-        negative_prompt: Optional[Union[str, List[str]]] = None,
-        eta: float = 0.0,
-        generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
-        latents: Optional[torch.FloatTensor] = None,
-        prompt_embeds: Optional[torch.FloatTensor] = None,
-        negative_prompt_embeds: Optional[torch.FloatTensor] = None,
-        output_type: Optional[str] = "np",
-        return_dict: bool = True,
-        callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None,
-        callback_steps: int = 1,
-        cross_attention_kwargs: Optional[Dict[str, Any]] = None,
-    ):
-        r"""
-        The call function to the pipeline for generation.
-
-        Args:
-            prompt (`str` or `List[str]`, *optional*):
-                The prompt or prompts to guide image generation. If not defined, you need to pass `prompt_embeds`.
-            video (`List[np.ndarray]` or `torch.FloatTensor`):
-                `video` frames or tensor representing a video batch to be used as the starting point for the process.
-                Can also accpet video latents as `image`, if passing latents directly, it will not be encoded again.
-            strength (`float`, *optional*, defaults to 0.8):
-                Indicates extent to transform the reference `video`. Must be between 0 and 1. `video` is used as a
-                starting point, adding more noise to it the larger the `strength`. The number of denoising steps
-                depends on the amount of noise initially added. When `strength` is 1, added noise is maximum and the
-                denoising process runs for the full number of iterations specified in `num_inference_steps`. A value of
-                1 essentially ignores `video`.
-            num_inference_steps (`int`, *optional*, defaults to 50):
-                The number of denoising steps. More denoising steps usually lead to a higher quality videos 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 video generation. If not defined, you need to
-                pass `negative_prompt_embeds` instead. Ignored when not using guidance (`guidance_scale < 1`).
-            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 video
-                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`. Latents should be of shape
-                `(batch_size, num_channel, num_frames, height, width)`.
-            prompt_embeds (`torch.FloatTensor`, *optional*):
-                Pre-generated text embeddings. Can be used to easily tweak text inputs (prompt weighting). If not
-                provided, text embeddings are generated from the `prompt` input argument.
-            negative_prompt_embeds (`torch.FloatTensor`, *optional*):
-                Pre-generated negative text embeddings. Can be used to easily tweak text inputs (prompt weighting). If
-                not provided, `negative_prompt_embeds` are generated from the `negative_prompt` input argument.
-            output_type (`str`, *optional*, defaults to `"np"`):
-                The output format of the generated video. Choose between `torch.FloatTensor` or `np.array`.
-            return_dict (`bool`, *optional*, defaults to `True`):
-                Whether or not to return a [`~pipelines.text_to_video_synthesis.TextToVideoSDPipelineOutput`] 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.
-            cross_attention_kwargs (`dict`, *optional*):
-                A kwargs dictionary that if specified is passed along to the [`AttentionProcessor`] as defined in
-                [`self.processor`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/cross_attention.py).
-
-        Examples:
-
-        Returns:
-            [`~pipelines.text_to_video_synthesis.TextToVideoSDPipelineOutput`] or `tuple`:
-                If `return_dict` is `True`, [`~pipelines.text_to_video_synthesis.TextToVideoSDPipelineOutput`] is
-                returned, otherwise a `tuple` is returned where the first element is a list with the generated frames.
-        """
-        # 0. Default height and width to unet
-        num_images_per_prompt = 1
-
-        # 1. Check inputs. Raise error if not correct
-        self.check_inputs(prompt, strength, callback_steps, negative_prompt, prompt_embeds, negative_prompt_embeds)
-
-        # 2. Define call parameters
-        if prompt is not None and isinstance(prompt, str):
-            batch_size = 1
-        elif prompt is not None and isinstance(prompt, list):
-            batch_size = len(prompt)
-        else:
-            batch_size = prompt_embeds.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
-
-        # 3. Encode input prompt
-        text_encoder_lora_scale = (
-            cross_attention_kwargs.get("scale", None) if cross_attention_kwargs is not None else None
-        )
-        prompt_embeds = self._encode_prompt(
-            prompt,
-            device,
-            num_images_per_prompt,
-            do_classifier_free_guidance,
-            negative_prompt,
-            prompt_embeds=prompt_embeds,
-            negative_prompt_embeds=negative_prompt_embeds,
-            lora_scale=text_encoder_lora_scale,
-        )
-
-        # 4. Preprocess video
-        video = preprocess_video(video)
-
-        # 5. Prepare timesteps
-        self.scheduler.set_timesteps(num_inference_steps, device=device)
-        timesteps, num_inference_steps = self.get_timesteps(num_inference_steps, strength, device)
-        latent_timestep = timesteps[:1].repeat(batch_size * num_images_per_prompt)
-
-        # 5. Prepare latent variables
-        latents = self.prepare_latents(video, latent_timestep, batch_size, prompt_embeds.dtype, device, generator)
-
-        # 6. 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)
-
-        # 7. 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
-                latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)
-
-                # predict the noise residual
-                noise_pred = self.unet(
-                    latent_model_input,
-                    t,
-                    encoder_hidden_states=prompt_embeds,
-                    cross_attention_kwargs=cross_attention_kwargs,
-                    return_dict=False,
-                )[0]
-
-                # 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)
-
-                # reshape latents
-                bsz, channel, frames, width, height = latents.shape
-                latents = latents.permute(0, 2, 1, 3, 4).reshape(bsz * frames, channel, width, height)
-                noise_pred = noise_pred.permute(0, 2, 1, 3, 4).reshape(bsz * frames, channel, width, height)
-
-                # compute the previous noisy sample x_t -> x_t-1
-                latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs).prev_sample
-
-                # reshape latents back
-                latents = latents[None, :].reshape(bsz, frames, channel, width, height).permute(0, 2, 1, 3, 4)
-
-                # 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 output_type == "latent":
-            return TextToVideoSDPipelineOutput(frames=latents)
-
-        if hasattr(self, "final_offload_hook") and self.final_offload_hook is not None:
-            self.unet.to("cpu")
-
-        video_tensor = self.decode_latents(latents)
-
-        if output_type == "pt":
-            video = video_tensor
-        else:
-            video = tensor2vid(video_tensor)
-
-        # Offload last model to CPU
-        if hasattr(self, "final_offload_hook") and self.final_offload_hook is not None:
-            self.final_offload_hook.offload()
-
-        if not return_dict:
-            return (video,)
-
-        return TextToVideoSDPipelineOutput(frames=video)

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

@@ -1,143 +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 unittest
-
-import numpy as np
-import torch
-
-from diffusers import DDIMPipeline, DDIMScheduler, UNet2DModel
-from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, slow, torch_device
-
-from ..pipeline_params import UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS, UNCONDITIONAL_IMAGE_GENERATION_PARAMS
-from ..test_pipelines_common import PipelineTesterMixin
-
-
-enable_full_determinism()
-
-
-class DDIMPipelineFastTests(PipelineTesterMixin, unittest.TestCase):
-    pipeline_class = DDIMPipeline
-    params = UNCONDITIONAL_IMAGE_GENERATION_PARAMS
-    required_optional_params = PipelineTesterMixin.required_optional_params - {
-        "num_images_per_prompt",
-        "latents",
-        "callback",
-        "callback_steps",
-    }
-    batch_params = UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS
-
-    def get_dummy_components(self):
-        torch.manual_seed(0)
-        unet = UNet2DModel(
-            block_out_channels=(32, 64),
-            layers_per_block=2,
-            sample_size=32,
-            in_channels=3,
-            out_channels=3,
-            down_block_types=("DownBlock2D", "AttnDownBlock2D"),
-            up_block_types=("AttnUpBlock2D", "UpBlock2D"),
-        )
-        scheduler = DDIMScheduler()
-        components = {"unet": unet, "scheduler": scheduler}
-        return components
-
-    def get_dummy_inputs(self, device, seed=0):
-        if str(device).startswith("mps"):
-            generator = torch.manual_seed(seed)
-        else:
-            generator = torch.Generator(device=device).manual_seed(seed)
-        inputs = {
-            "batch_size": 1,
-            "generator": generator,
-            "num_inference_steps": 2,
-            "output_type": "numpy",
-        }
-        return inputs
-
-    def test_inference(self):
-        device = "cpu"
-
-        components = self.get_dummy_components()
-        pipe = self.pipeline_class(**components)
-        pipe.to(device)
-        pipe.set_progress_bar_config(disable=None)
-
-        inputs = self.get_dummy_inputs(device)
-        image = pipe(**inputs).images
-        image_slice = image[0, -3:, -3:, -1]
-
-        self.assertEqual(image.shape, (1, 32, 32, 3))
-        expected_slice = np.array(
-            [1.000e00, 5.717e-01, 4.717e-01, 1.000e00, 0.000e00, 1.000e00, 3.000e-04, 0.000e00, 9.000e-04]
-        )
-        max_diff = np.abs(image_slice.flatten() - expected_slice).max()
-        self.assertLessEqual(max_diff, 1e-3)
-
-    def test_dict_tuple_outputs_equivalent(self):
-        super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3)
-
-    def test_save_load_local(self):
-        super().test_save_load_local(expected_max_difference=3e-3)
-
-    def test_save_load_optional_components(self):
-        super().test_save_load_optional_components(expected_max_difference=3e-3)
-
-    def test_inference_batch_single_identical(self):
-        super().test_inference_batch_single_identical(expected_max_diff=3e-3)
-
-
-@slow
-@require_torch_gpu
-class DDIMPipelineIntegrationTests(unittest.TestCase):
-    def test_inference_cifar10(self):
-        model_id = "google/ddpm-cifar10-32"
-
-        unet = UNet2DModel.from_pretrained(model_id)
-        scheduler = DDIMScheduler()
-
-        ddim = DDIMPipeline(unet=unet, scheduler=scheduler)
-        ddim.to(torch_device)
-        ddim.set_progress_bar_config(disable=None)
-
-        generator = torch.manual_seed(0)
-        image = ddim(generator=generator, eta=0.0, output_type="numpy").images
-
-        image_slice = image[0, -3:, -3:, -1]
-
-        assert image.shape == (1, 32, 32, 3)
-        expected_slice = np.array([0.1723, 0.1617, 0.1600, 0.1626, 0.1497, 0.1513, 0.1505, 0.1442, 0.1453])
-
-        assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-2
-
-    def test_inference_ema_bedroom(self):
-        model_id = "google/ddpm-ema-bedroom-256"
-
-        unet = UNet2DModel.from_pretrained(model_id)
-        scheduler = DDIMScheduler.from_pretrained(model_id)
-
-        ddpm = DDIMPipeline(unet=unet, scheduler=scheduler)
-        ddpm.to(torch_device)
-        ddpm.set_progress_bar_config(disable=None)
-
-        generator = torch.manual_seed(0)
-        image = ddpm(generator=generator, output_type="numpy").images
-
-        image_slice = image[0, -3:, -3:, -1]
-
-        assert image.shape == (1, 256, 256, 3)
-        expected_slice = np.array([0.0060, 0.0201, 0.0344, 0.0024, 0.0018, 0.0002, 0.0022, 0.0000, 0.0069])
-
-        assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-2

spaces/Andy1621/uniformer_image_detection/mmdet/core/mask/utils.py

@@ -1,63 +0,0 @@
-import mmcv
-import numpy as np
-import pycocotools.mask as mask_util
-
-
-def split_combined_polys(polys, poly_lens, polys_per_mask):
-    """Split the combined 1-D polys into masks.
-
-    A mask is represented as a list of polys, and a poly is represented as
-    a 1-D array. In dataset, all masks are concatenated into a single 1-D
-    tensor. Here we need to split the tensor into original representations.
-
-    Args:
-        polys (list): a list (length = image num) of 1-D tensors
-        poly_lens (list): a list (length = image num) of poly length
-        polys_per_mask (list): a list (length = image num) of poly number
-            of each mask
-
-    Returns:
-        list: a list (length = image num) of list (length = mask num) of \
-            list (length = poly num) of numpy array.
-    """
-    mask_polys_list = []
-    for img_id in range(len(polys)):
-        polys_single = polys[img_id]
-        polys_lens_single = poly_lens[img_id].tolist()
-        polys_per_mask_single = polys_per_mask[img_id].tolist()
-
-        split_polys = mmcv.slice_list(polys_single, polys_lens_single)
-        mask_polys = mmcv.slice_list(split_polys, polys_per_mask_single)
-        mask_polys_list.append(mask_polys)
-    return mask_polys_list
-
-
-# TODO: move this function to more proper place
-def encode_mask_results(mask_results):
-    """Encode bitmap mask to RLE code.
-
-    Args:
-        mask_results (list | tuple[list]): bitmap mask results.
-            In mask scoring rcnn, mask_results is a tuple of (segm_results,
-            segm_cls_score).
-
-    Returns:
-        list | tuple: RLE encoded mask.
-    """
-    if isinstance(mask_results, tuple):  # mask scoring
-        cls_segms, cls_mask_scores = mask_results
-    else:
-        cls_segms = mask_results
-    num_classes = len(cls_segms)
-    encoded_mask_results = [[] for _ in range(num_classes)]
-    for i in range(len(cls_segms)):
-        for cls_segm in cls_segms[i]:
-            encoded_mask_results[i].append(
-                mask_util.encode(
-                    np.array(
-                        cls_segm[:, :, np.newaxis], order='F',
-                        dtype='uint8'))[0])  # encoded with RLE
-    if isinstance(mask_results, tuple):
-        return encoded_mask_results, cls_mask_scores
-    else:
-        return encoded_mask_results

spaces/Anonymous-sub/Rerender/ControlNet/annotator/uniformer/mmcv/runner/hooks/logger/text.py

@@ -1,256 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import datetime
-import os
-import os.path as osp
-from collections import OrderedDict
-
-import torch
-import torch.distributed as dist
-
-import annotator.uniformer.mmcv as mmcv
-from annotator.uniformer.mmcv.fileio.file_client import FileClient
-from annotator.uniformer.mmcv.utils import is_tuple_of, scandir
-from ..hook import HOOKS
-from .base import LoggerHook
-
-
-@HOOKS.register_module()
-class TextLoggerHook(LoggerHook):
-    """Logger hook in text.
-
-    In this logger hook, the information will be printed on terminal and
-    saved in json file.
-
-    Args:
-        by_epoch (bool, optional): Whether EpochBasedRunner is used.
-            Default: True.
-        interval (int, optional): Logging interval (every k iterations).
-            Default: 10.
-        ignore_last (bool, optional): Ignore the log of last iterations in each
-            epoch if less than :attr:`interval`. Default: True.
-        reset_flag (bool, optional): Whether to clear the output buffer after
-            logging. Default: False.
-        interval_exp_name (int, optional): Logging interval for experiment
-            name. This feature is to help users conveniently get the experiment
-            information from screen or log file. Default: 1000.
-        out_dir (str, optional): Logs are saved in ``runner.work_dir`` default.
-            If ``out_dir`` is specified, logs will be copied to a new directory
-            which is the concatenation of ``out_dir`` and the last level
-            directory of ``runner.work_dir``. Default: None.
-            `New in version 1.3.16.`
-        out_suffix (str or tuple[str], optional): Those filenames ending with
-            ``out_suffix`` will be copied to ``out_dir``.
-            Default: ('.log.json', '.log', '.py').
-            `New in version 1.3.16.`
-        keep_local (bool, optional): Whether to keep local log when
-            :attr:`out_dir` is specified. If False, the local log will be
-            removed. Default: True.
-            `New in version 1.3.16.`
-        file_client_args (dict, optional): Arguments to instantiate a
-            FileClient. See :class:`mmcv.fileio.FileClient` for details.
-            Default: None.
-            `New in version 1.3.16.`
-    """
-
-    def __init__(self,
-                 by_epoch=True,
-                 interval=10,
-                 ignore_last=True,
-                 reset_flag=False,
-                 interval_exp_name=1000,
-                 out_dir=None,
-                 out_suffix=('.log.json', '.log', '.py'),
-                 keep_local=True,
-                 file_client_args=None):
-        super(TextLoggerHook, self).__init__(interval, ignore_last, reset_flag,
-                                             by_epoch)
-        self.by_epoch = by_epoch
-        self.time_sec_tot = 0
-        self.interval_exp_name = interval_exp_name
-
-        if out_dir is None and file_client_args is not None:
-            raise ValueError(
-                'file_client_args should be "None" when `out_dir` is not'
-                'specified.')
-        self.out_dir = out_dir
-
-        if not (out_dir is None or isinstance(out_dir, str)
-                or is_tuple_of(out_dir, str)):
-            raise TypeError('out_dir should be  "None" or string or tuple of '
-                            'string, but got {out_dir}')
-        self.out_suffix = out_suffix
-
-        self.keep_local = keep_local
-        self.file_client_args = file_client_args
-        if self.out_dir is not None:
-            self.file_client = FileClient.infer_client(file_client_args,
-                                                       self.out_dir)
-
-    def before_run(self, runner):
-        super(TextLoggerHook, self).before_run(runner)
-
-        if self.out_dir is not None:
-            self.file_client = FileClient.infer_client(self.file_client_args,
-                                                       self.out_dir)
-            # The final `self.out_dir` is the concatenation of `self.out_dir`
-            # and the last level directory of `runner.work_dir`
-            basename = osp.basename(runner.work_dir.rstrip(osp.sep))
-            self.out_dir = self.file_client.join_path(self.out_dir, basename)
-            runner.logger.info(
-                (f'Text logs will be saved to {self.out_dir} by '
-                 f'{self.file_client.name} after the training process.'))
-
-        self.start_iter = runner.iter
-        self.json_log_path = osp.join(runner.work_dir,
-                                      f'{runner.timestamp}.log.json')
-        if runner.meta is not None:
-            self._dump_log(runner.meta, runner)
-
-    def _get_max_memory(self, runner):
-        device = getattr(runner.model, 'output_device', None)
-        mem = torch.cuda.max_memory_allocated(device=device)
-        mem_mb = torch.tensor([mem / (1024 * 1024)],
-                              dtype=torch.int,
-                              device=device)
-        if runner.world_size > 1:
-            dist.reduce(mem_mb, 0, op=dist.ReduceOp.MAX)
-        return mem_mb.item()
-
-    def _log_info(self, log_dict, runner):
-        # print exp name for users to distinguish experiments
-        # at every ``interval_exp_name`` iterations and the end of each epoch
-        if runner.meta is not None and 'exp_name' in runner.meta:
-            if (self.every_n_iters(runner, self.interval_exp_name)) or (
-                    self.by_epoch and self.end_of_epoch(runner)):
-                exp_info = f'Exp name: {runner.meta["exp_name"]}'
-                runner.logger.info(exp_info)
-
-        if log_dict['mode'] == 'train':
-            if isinstance(log_dict['lr'], dict):
-                lr_str = []
-                for k, val in log_dict['lr'].items():
-                    lr_str.append(f'lr_{k}: {val:.3e}')
-                lr_str = ' '.join(lr_str)
-            else:
-                lr_str = f'lr: {log_dict["lr"]:.3e}'
-
-            # by epoch: Epoch [4][100/1000]
-            # by iter:  Iter [100/100000]
-            if self.by_epoch:
-                log_str = f'Epoch [{log_dict["epoch"]}]' \
-                          f'[{log_dict["iter"]}/{len(runner.data_loader)}]\t'
-            else:
-                log_str = f'Iter [{log_dict["iter"]}/{runner.max_iters}]\t'
-            log_str += f'{lr_str}, '
-
-            if 'time' in log_dict.keys():
-                self.time_sec_tot += (log_dict['time'] * self.interval)
-                time_sec_avg = self.time_sec_tot / (
-                    runner.iter - self.start_iter + 1)
-                eta_sec = time_sec_avg * (runner.max_iters - runner.iter - 1)
-                eta_str = str(datetime.timedelta(seconds=int(eta_sec)))
-                log_str += f'eta: {eta_str}, '
-                log_str += f'time: {log_dict["time"]:.3f}, ' \
-                           f'data_time: {log_dict["data_time"]:.3f}, '
-                # statistic memory
-                if torch.cuda.is_available():
-                    log_str += f'memory: {log_dict["memory"]}, '
-        else:
-            # val/test time
-            # here 1000 is the length of the val dataloader
-            # by epoch: Epoch[val] [4][1000]
-            # by iter: Iter[val] [1000]
-            if self.by_epoch:
-                log_str = f'Epoch({log_dict["mode"]}) ' \
-                    f'[{log_dict["epoch"]}][{log_dict["iter"]}]\t'
-            else:
-                log_str = f'Iter({log_dict["mode"]}) [{log_dict["iter"]}]\t'
-
-        log_items = []
-        for name, val in log_dict.items():
-            # TODO: resolve this hack
-            # these items have been in log_str
-            if name in [
-                    'mode', 'Epoch', 'iter', 'lr', 'time', 'data_time',
-                    'memory', 'epoch'
-            ]:
-                continue
-            if isinstance(val, float):
-                val = f'{val:.4f}'
-            log_items.append(f'{name}: {val}')
-        log_str += ', '.join(log_items)
-
-        runner.logger.info(log_str)
-
-    def _dump_log(self, log_dict, runner):
-        # dump log in json format
-        json_log = OrderedDict()
-        for k, v in log_dict.items():
-            json_log[k] = self._round_float(v)
-        # only append log at last line
-        if runner.rank == 0:
-            with open(self.json_log_path, 'a+') as f:
-                mmcv.dump(json_log, f, file_format='json')
-                f.write('\n')
-
-    def _round_float(self, items):
-        if isinstance(items, list):
-            return [self._round_float(item) for item in items]
-        elif isinstance(items, float):
-            return round(items, 5)
-        else:
-            return items
-
-    def log(self, runner):
-        if 'eval_iter_num' in runner.log_buffer.output:
-            # this doesn't modify runner.iter and is regardless of by_epoch
-            cur_iter = runner.log_buffer.output.pop('eval_iter_num')
-        else:
-            cur_iter = self.get_iter(runner, inner_iter=True)
-
-        log_dict = OrderedDict(
-            mode=self.get_mode(runner),
-            epoch=self.get_epoch(runner),
-            iter=cur_iter)
-
-        # only record lr of the first param group
-        cur_lr = runner.current_lr()
-        if isinstance(cur_lr, list):
-            log_dict['lr'] = cur_lr[0]
-        else:
-            assert isinstance(cur_lr, dict)
-            log_dict['lr'] = {}
-            for k, lr_ in cur_lr.items():
-                assert isinstance(lr_, list)
-                log_dict['lr'].update({k: lr_[0]})
-
-        if 'time' in runner.log_buffer.output:
-            # statistic memory
-            if torch.cuda.is_available():
-                log_dict['memory'] = self._get_max_memory(runner)
-
-        log_dict = dict(log_dict, **runner.log_buffer.output)
-
-        self._log_info(log_dict, runner)
-        self._dump_log(log_dict, runner)
-        return log_dict
-
-    def after_run(self, runner):
-        # copy or upload logs to self.out_dir
-        if self.out_dir is not None:
-            for filename in scandir(runner.work_dir, self.out_suffix, True):
-                local_filepath = osp.join(runner.work_dir, filename)
-                out_filepath = self.file_client.join_path(
-                    self.out_dir, filename)
-                with open(local_filepath, 'r') as f:
-                    self.file_client.put_text(f.read(), out_filepath)
-
-                runner.logger.info(
-                    (f'The file {local_filepath} has been uploaded to '
-                     f'{out_filepath}.'))
-
-                if not self.keep_local:
-                    os.remove(local_filepath)
-                    runner.logger.info(
-                        (f'{local_filepath} was removed due to the '
-                         '`self.keep_local=False`'))

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

@@ -1,52 +0,0 @@
-import logging
-from optparse import Values
-from typing import List
-
-from pip._internal.cli.base_command import Command
-from pip._internal.cli.status_codes import ERROR, SUCCESS
-from pip._internal.operations.check import (
-    check_package_set,
-    create_package_set_from_installed,
-)
-from pip._internal.utils.misc import write_output
-
-logger = logging.getLogger(__name__)
-
-
-class CheckCommand(Command):
-    """Verify installed packages have compatible dependencies."""
-
-    usage = """
-      %prog [options]"""
-
-    def run(self, options: Values, args: List[str]) -> int:
-        package_set, parsing_probs = create_package_set_from_installed()
-        missing, conflicting = check_package_set(package_set)
-
-        for project_name in missing:
-            version = package_set[project_name].version
-            for dependency in missing[project_name]:
-                write_output(
-                    "%s %s requires %s, which is not installed.",
-                    project_name,
-                    version,
-                    dependency[0],
-                )
-
-        for project_name in conflicting:
-            version = package_set[project_name].version
-            for dep_name, dep_version, req in conflicting[project_name]:
-                write_output(
-                    "%s %s has requirement %s, but you have %s %s.",
-                    project_name,
-                    version,
-                    req,
-                    dep_name,
-                    dep_version,
-                )
-
-        if missing or conflicting or parsing_probs:
-            return ERROR
-        else:
-            write_output("No broken requirements found.")
-            return SUCCESS

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

@@ -1,9 +0,0 @@
-"""
-This module exists only to simplify retrieving the version number of chardet
-from within setuptools and from chardet subpackages.
-
-:author: Dan Blanchard ([email protected])
-"""
-
-__version__ = "5.1.0"
-VERSION = __version__.split(".")

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

@@ -1,99 +0,0 @@
-"""
-requests.structures
-~~~~~~~~~~~~~~~~~~~
-
-Data structures that power Requests.
-"""
-
-from collections import OrderedDict
-
-from .compat import Mapping, MutableMapping
-
-
-class CaseInsensitiveDict(MutableMapping):
-    """A case-insensitive ``dict``-like object.
-
-    Implements all methods and operations of
-    ``MutableMapping`` as well as dict's ``copy``. Also
-    provides ``lower_items``.
-
-    All keys are expected to be strings. The structure remembers the
-    case of the last key to be set, and ``iter(instance)``,
-    ``keys()``, ``items()``, ``iterkeys()``, and ``iteritems()``
-    will contain case-sensitive keys. However, querying and contains
-    testing is case insensitive::
-
-        cid = CaseInsensitiveDict()
-        cid['Accept'] = 'application/json'
-        cid['aCCEPT'] == 'application/json'  # True
-        list(cid) == ['Accept']  # True
-
-    For example, ``headers['content-encoding']`` will return the
-    value of a ``'Content-Encoding'`` response header, regardless
-    of how the header name was originally stored.
-
-    If the constructor, ``.update``, or equality comparison
-    operations are given keys that have equal ``.lower()``s, the
-    behavior is undefined.
-    """
-
-    def __init__(self, data=None, **kwargs):
-        self._store = OrderedDict()
-        if data is None:
-            data = {}
-        self.update(data, **kwargs)
-
-    def __setitem__(self, key, value):
-        # Use the lowercased key for lookups, but store the actual
-        # key alongside the value.
-        self._store[key.lower()] = (key, value)
-
-    def __getitem__(self, key):
-        return self._store[key.lower()][1]
-
-    def __delitem__(self, key):
-        del self._store[key.lower()]
-
-    def __iter__(self):
-        return (casedkey for casedkey, mappedvalue in self._store.values())
-
-    def __len__(self):
-        return len(self._store)
-
-    def lower_items(self):
-        """Like iteritems(), but with all lowercase keys."""
-        return ((lowerkey, keyval[1]) for (lowerkey, keyval) in self._store.items())
-
-    def __eq__(self, other):
-        if isinstance(other, Mapping):
-            other = CaseInsensitiveDict(other)
-        else:
-            return NotImplemented
-        # Compare insensitively
-        return dict(self.lower_items()) == dict(other.lower_items())
-
-    # Copy is required
-    def copy(self):
-        return CaseInsensitiveDict(self._store.values())
-
-    def __repr__(self):
-        return str(dict(self.items()))
-
-
-class LookupDict(dict):
-    """Dictionary lookup object."""
-
-    def __init__(self, name=None):
-        self.name = name
-        super().__init__()
-
-    def __repr__(self):
-        return f"<lookup '{self.name}'>"
-
-    def __getitem__(self, key):
-        # We allow fall-through here, so values default to None
-
-        return self.__dict__.get(key, None)
-
-    def get(self, key, default=None):
-        return self.__dict__.get(key, default)

spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/tests/modeling/test_box2box_transform.py

@@ -1,94 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import logging
-import unittest
-import torch
-
-from detectron2.modeling.box_regression import (
-    Box2BoxTransform,
-    Box2BoxTransformLinear,
-    Box2BoxTransformRotated,
-)
-from detectron2.utils.testing import random_boxes
-
-logger = logging.getLogger(__name__)
-
-
-class TestBox2BoxTransform(unittest.TestCase):
-    def test_reconstruction(self):
-        weights = (5, 5, 10, 10)
-        b2b_tfm = Box2BoxTransform(weights=weights)
-        src_boxes = random_boxes(10)
-        dst_boxes = random_boxes(10)
-
-        devices = [torch.device("cpu")]
-        if torch.cuda.is_available():
-            devices.append(torch.device("cuda"))
-        for device in devices:
-            src_boxes = src_boxes.to(device=device)
-            dst_boxes = dst_boxes.to(device=device)
-            deltas = b2b_tfm.get_deltas(src_boxes, dst_boxes)
-            dst_boxes_reconstructed = b2b_tfm.apply_deltas(deltas, src_boxes)
-            self.assertTrue(torch.allclose(dst_boxes, dst_boxes_reconstructed))
-
-    def test_apply_deltas_tracing(self):
-        weights = (5, 5, 10, 10)
-        b2b_tfm = Box2BoxTransform(weights=weights)
-
-        with torch.no_grad():
-            func = torch.jit.trace(b2b_tfm.apply_deltas, (torch.randn(10, 20), torch.randn(10, 4)))
-
-            o = func(torch.randn(10, 20), torch.randn(10, 4))
-            self.assertEqual(o.shape, (10, 20))
-            o = func(torch.randn(5, 20), torch.randn(5, 4))
-            self.assertEqual(o.shape, (5, 20))
-
-
-def random_rotated_boxes(mean_box, std_length, std_angle, N):
-    return torch.cat(
-        [torch.rand(N, 4) * std_length, torch.rand(N, 1) * std_angle], dim=1
-    ) + torch.tensor(mean_box, dtype=torch.float)
-
-
-class TestBox2BoxTransformRotated(unittest.TestCase):
-    def test_reconstruction(self):
-        weights = (5, 5, 10, 10, 1)
-        b2b_transform = Box2BoxTransformRotated(weights=weights)
-        src_boxes = random_rotated_boxes([10, 10, 20, 20, -30], 5, 60.0, 10)
-        dst_boxes = random_rotated_boxes([10, 10, 20, 20, -30], 5, 60.0, 10)
-
-        devices = [torch.device("cpu")]
-        if torch.cuda.is_available():
-            devices.append(torch.device("cuda"))
-        for device in devices:
-            src_boxes = src_boxes.to(device=device)
-            dst_boxes = dst_boxes.to(device=device)
-            deltas = b2b_transform.get_deltas(src_boxes, dst_boxes)
-            dst_boxes_reconstructed = b2b_transform.apply_deltas(deltas, src_boxes)
-            assert torch.allclose(dst_boxes[:, :4], dst_boxes_reconstructed[:, :4], atol=1e-5)
-            # angle difference has to be normalized
-            assert torch.allclose(
-                (dst_boxes[:, 4] - dst_boxes_reconstructed[:, 4] + 180.0) % 360.0 - 180.0,
-                torch.zeros_like(dst_boxes[:, 4]),
-                atol=1e-4,
-            )
-
-
-class TestBox2BoxTransformLinear(unittest.TestCase):
-    def test_reconstruction(self):
-        b2b_tfm = Box2BoxTransformLinear()
-        src_boxes = random_boxes(10)
-        dst_boxes = torch.tensor([0, 0, 101, 101] * 10).reshape(10, 4).float()
-
-        devices = [torch.device("cpu")]
-        if torch.cuda.is_available():
-            devices.append(torch.device("cuda"))
-        for device in devices:
-            src_boxes = src_boxes.to(device=device)
-            dst_boxes = dst_boxes.to(device=device)
-            deltas = b2b_tfm.get_deltas(src_boxes, dst_boxes)
-            dst_boxes_reconstructed = b2b_tfm.apply_deltas(deltas, src_boxes)
-            self.assertTrue(torch.allclose(dst_boxes, dst_boxes_reconstructed, atol=1e-3))
-
-
-if __name__ == "__main__":
-    unittest.main()

spaces/Benson/text-generation/Examples/Bus Simulator Indonesia Nuevo Mapa Descargar.md

@@ -1,69 +0,0 @@
-<br />
-<h1>Simulador de autobús Indonesia: Cómo descargar y disfrutar de nuevos mapas</h1>
-<p>Bus Simulator Indonesia (alias BUSSID) es un popular juego de simulación que te permite experimentar lo que le gusta ser un conductor de autobús en Indonesia de una manera divertida y auténtica. BUSSID puede no ser el primero, pero es probablemente uno de los únicos juegos de simulador de bus con más características y el entorno indonesio más auténtico. </p>
-<p>Algunas de las características principales de BUSSID son:</p>
-<h2>bus simulator indonesia nuevo mapa descargar</h2><br /><p><b><b>DOWNLOAD</b> >>>>> <a href="https://bltlly.com/2v6MdH">https://bltlly.com/2v6MdH</a></b></p><br /><br />
-<ul>
-<li>Diseña tu propia librea</li>
-<li> Control muy fácil e intuitivo</li>
-<li>Ciudades y lugares indonesios auténticos</li>
-<li>Autobuses de Indonesia</li>
-<li>Fresco y divertido bocinazos, incluyendo el icónico "Om Telolet Om!" bocina</li>
-<li> Alta calidad y gráficos 3D detallados</li>
-<li>No hay anuncios obstructivos durante la conducción</li>
-<li>Tabla de clasificación y ahorro de datos en línea</li>
-<li>Utilice su propio modelo 3D utilizando el sistema de vehículo mod</li>
-<li>Convoy multijugador en línea</li>
-</ul>
-<p>Para jugar BUSSID, es necesario elegir un autobús, una librea, y una ruta. Luego, debe conducir su autobús a lo largo de la ruta, recoger y dejar pasajeros, ganar dinero y evitar accidentes. También puede personalizar su autobús, actualizar su garaje y unirse a convoyes en línea con otros jugadores. </p>
-<p>Uno de los beneficios de jugar BUSSID es que puedes descargar nuevos mapas para el juego, lo que puede agregar más variedad, desafío y diversión a tu experiencia de conducción. Los nuevos mapas pueden tener diferentes temas, como extremos, off-road o escénicos. También pueden tener diferentes características, como curvas afiladas, colinas empinadas o hitos realistas. Los nuevos mapas pueden hacerte sentir que conduces en diferentes regiones de Indonesia o incluso en otros países. </p>
-<p>Pero, ¿cómo descargar nuevos mapas para BUSSID? ¿Y cómo los disfruta? En este artículo, le mostraremos cómo hacer ambos en pasos fáciles. ¡Vamos a empezar! </p>
- <h2>Cómo descargar nuevos mapas para Bus Simulator Indonesia</h2>
-
-<p>Una de las mejores fuentes de mapas mod para BUSSID es [MediaRale]( 1 ), un sitio web que proporciona varios mods para juegos, incluyendo BUSSID. MediaRale tiene una sección dedicada a los mapas mod para BUSSID, donde puede encontrar muchas opciones para elegir. Puedes navegar por categorías, como extrema, todoterreno o escénica. También puede ver capturas de pantalla, descripciones, calificaciones y enlaces de descarga para cada mapa de mods. </p>
-<p>Una vez que hayas encontrado un mapa mod que te guste, necesitas descargarlo en tu dispositivo. El archivo de mapa mod generalmente estará en formato ZIP o RAR, lo que significa que necesita extraerlo usando una aplicación de administrador de archivos o una aplicación extractora ZIP. Puedes encontrar muchas aplicaciones gratuitas para este propósito en la Google Play Store o en la App Store.</p>
-<p>Después de haber extraído el archivo de mapa mod, debe copiarlo en la carpeta mod de BUSSID. La carpeta mod se encuentra en el almacenamiento interno de su dispositivo, bajo la carpeta Android/data/com.maleo.bussimulatorid/files/mod. Puede usar una aplicación de administrador de archivos para navegar a esta carpeta y pegar el archivo de mapa mod allí. </p>
-<p></p>
-<p>El último paso es iniciar el juego y seleccionar el mapa mod desde el menú del mapa. Puede hacer esto pulsando en el icono del mapa en la esquina superior derecha de la pantalla, y luego desplazándose hacia abajo para encontrar el mapa mod que ha descargado. Toque en él para seleccionarlo, y luego toque en el botón de inicio para comenzar su viaje. </p>
- <h2>Cómo disfrutar de nuevos mapas para Bus Simulator Indonesia</h2>
-<p>Ahora que ha descargado e instalado un nuevo mapa para BUSSID, puede disfrutarlo conduciendo su autobús en él. Sin embargo, hay algunos consejos que pueden ayudarte a aprovechar al máximo tu experiencia. Estos son algunos de ellos:</p>
-<ul>
-
-<li><strong>Consejo 2: Siga las reglas de tráfico y respete otros controladores</strong>. A pesar de que usted está jugando en un mapa mod, todavía tiene que seguir las reglas de tráfico y respetar a otros conductores en la carretera. Esto significa que debe obedecer el límite de velocidad, detenerse en las luces rojas, hacer una señal antes de girar y evitar colisiones. Esto no solo hará que su conducción sea más realista y segura, sino también más agradable y gratificante. </li>
-<li><strong>Consejo 3: Utilice el bocinazo y otras características para interactuar con el entorno</strong>. Uno de los aspectos más divertidos de BUSSID es que puedes utilizar la bocina y otras funciones para interactuar con el entorno. Por ejemplo, puedes usar la bocina para saludar a otros conductores, peatones o animales. También puede usar los limpiaparabrisas, los faros, los indicadores y las puertas para comunicarse con otros o expresarse. Incluso puede usar el "Om Telolet Om!" tocar el claxon para hacer que la gente te vitoree. </li>
-<li><strong>Consejo 4: Explora diferentes rutas y puntos de referencia en el mapa</strong>. Otra forma de disfrutar de nuevos mapas para BUSSID es explorar diferentes rutas y puntos de referencia en ellos. Puede hacer esto siguiendo la navegación GPS o eligiendo su propio camino. Puede descubrir nuevos lugares, paisajes o desafíos que no haya visto antes. También puede encontrar secretos ocultos o huevos de Pascua que el creador del mapa ha dejado para usted. </li>
-<li><strong>Consejo 5: Únete a convoyes multijugador en línea con otros jugadores</strong>. La mejor manera de disfrutar de nuevos mapas para BUSSID es unirse a convoyes multijugador en línea con otros jugadores. Puede hacer esto tocando el icono del convoy en la esquina superior izquierda de la pantalla, y luego elegir un convoy que está jugando en el mismo mapa que usted. También puede crear su propio convoy e invitar a sus amigos u otros jugadores a unirse a usted. Al unirte a un convoy, puedes chatear con otros jugadores, compartir tus experiencias y divertirte juntos. </li>
-</ul>
- <h2>Conclusión</h2>
-
-<ol>
-<li>Encuentra un mapa mod que te guste en MediaRale</li>
-<li>Descargar el archivo de mapa mod y extraerlo si es necesario</li>
-<li>Copiar el archivo de mapa mod a la carpeta mod de BUSSID</li>
-<li>Iniciar el juego y seleccionar el mapa de mod desde el menú del mapa</li>
-</ol>
-<p>Para disfrutar de nuevos mapas para BUSSID, puedes seguir estos consejos:</p>
-<ul>
-<li> Elegir un autobús adecuado y librea para el mapa</li>
-<li>Siga las reglas de tráfico y respete otros controladores</li>
-<li>Utilice el bocinazo y otras características para interactuar con el entorno</li>
-<li>Explora diferentes rutas y puntos de referencia en el mapa</li>
-<li>Únete a convoyes multijugador en línea con otros jugadores</li>
-</ul>
-<p>Siguiendo estos pasos y consejos, puede descargar y disfrutar de nuevos mapas para BUSSID y divertirse conduciendo su autobús en ellos. Si aún no has probado BUSSID, puedes descargarlo gratis desde la Google Play Store o la App Store. También puedes visitar el sitio web oficial de BUSSID para aprender más sobre el juego y sus características. ¡Feliz conducción! </p>
- <h2>Preguntas frecuentes</h2>
-<p>Aquí hay algunas preguntas frecuentes sobre nuevos mapas para BUSSID:</p>
-<ol>
-<li><strong>Q: ¿Cuántos mapas nuevos están disponibles para BUSSID? </strong></li>
-<li>A: No hay un número exacto de nuevos mapas para BUSSID, ya que los nuevos mapas mod son constantemente creados y subidos por los usuarios. Sin embargo, puede encontrar cientos de mapas mod para BUSSID en MediaRale, que van desde mapas extremos, off-road, escénicos, a mapas realistas. </li>
-<li><strong>Q: ¿Cómo sé si un mapa mod es compatible con mi versión de BUSSID? </strong></li>
-<li>A: Puede comprobar la compatibilidad de un mapa mod mirando su descripción, calificación y comentarios en MediaRale. También puede comprobar la fecha de subida del mapa mod y compararlo con la fecha de la última actualización de BUSSID. Generalmente, los mapas mod que se cargan después de la última actualización de BUSSID tienen más probabilidades de ser compatibles. </li>
-<li><strong>Q: ¿Cómo puedo desinstalar un mapa mod de BUSSID? </strong></li>
-
-<li><strong>Q: ¿Cómo puedo reportar un problema o un error con un mapa mod? </strong></li>
-<li>A: Si encuentras un problema o un error con un mapa mod, puedes reportarlo al creador de mapas mod o a MediaRale. Puede encontrar la información de contacto del creador de mapas mod en su página de perfil en MediaRale. También puede dejar un comentario o una valoración en la página del mapa de mods en MediaRale para compartir sus comentarios. </li>
-<li><strong>Q: ¿Cómo puedo crear mi propio mapa mod para BUSSID? </strong></li>
-<li>A: Si quieres crear tu propio mapa mod para BUSSID, necesitas usar un software de modelado 3D, como Blender, SketchUp o Maya. También debe seguir las directrices y especificaciones de BUSSID para crear mapas mod. Puede encontrar más información y tutoriales sobre cómo crear mapas mod para BUSSID en el sitio web oficial de BUSSID o en YouTube.</li>
-</ol></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/.github/CODE_OF_CONDUCT.md

@@ -1,5 +0,0 @@
-# Code of Conduct
-
-Facebook has adopted a Code of Conduct that we expect project participants to adhere to.
-Please read the [full text](https://code.fb.com/codeofconduct/)
-so that you can understand what actions will and will not be tolerated.

spaces/CVPR/LIVE/thrust/cmake/ThrustMultiConfig.cmake

@@ -1,127 +0,0 @@
-# This file defines thrust_configure_multiconfig(), which sets up and handles
-# the MultiConfig options that allow multiple host/device/dialect configurations
-# to be generated from a single thrust build.
-
-function(thrust_configure_multiconfig)
-  option(THRUST_ENABLE_MULTICONFIG "Enable multiconfig options for coverage testing." OFF)
-
-  # Dialects:
-  set(THRUST_CPP_DIALECT_OPTIONS
-    11 14 17
-    CACHE INTERNAL "C++ dialects supported by Thrust." FORCE
-  )
-
-  if (THRUST_ENABLE_MULTICONFIG)
-    # Handle dialect options:
-    foreach (dialect IN LISTS THRUST_CPP_DIALECT_OPTIONS)
-      set(default_value OFF)
-      if (dialect EQUAL 14) # Default to just 14 on:
-        set(default_value ON)
-      endif()
-      option(THRUST_MULTICONFIG_ENABLE_DIALECT_CPP${dialect}
-        "Generate C++${dialect} build configurations."
-        ${default_value}
-      )
-    endforeach()
-
-    # Supported versions of MSVC do not distinguish between C++11 and C++14.
-    # Warn the user that they may be generating a ton of redundant targets.
-    if ("MSVC" STREQUAL "${CMAKE_CXX_COMPILER_ID}" AND
-        THRUST_MULTICONFIG_ENABLE_DIALECT_CPP11)
-      message(WARNING
-        "Supported versions of MSVC (2017+) do not distinguish between C++11 "
-        "and C++14. The requested C++11 targets will be built with C++14."
-      )
-    endif()
-
-    # Systems:
-    option(THRUST_MULTICONFIG_ENABLE_SYSTEM_CPP "Generate build configurations that use CPP." ON)
-    option(THRUST_MULTICONFIG_ENABLE_SYSTEM_CUDA "Generate build configurations that use CUDA." ON)
-    option(THRUST_MULTICONFIG_ENABLE_SYSTEM_OMP "Generate build configurations that use OpenMP." OFF)
-    option(THRUST_MULTICONFIG_ENABLE_SYSTEM_TBB "Generate build configurations that use TBB." OFF)
-
-    # CMake added C++17 support for CUDA targets in 3.18:
-    if (THRUST_MULTICONFIG_ENABLE_DIALECT_CPP17 AND
-        THRUST_MULTICONFIG_ENABLE_SYSTEM_CUDA)
-      cmake_minimum_required(VERSION 3.18)
-    endif()
-
-    # Workload:
-    # - `SMALL`: [3 configs] Minimal coverage and validation of each device system against the `CPP` host.
-    # - `MEDIUM`: [6 configs] Cheap extended coverage.
-    # - `LARGE`: [8 configs] Expensive extended coverage. Include all useful build configurations.
-    # - `FULL`: [12 configs] The complete cross product of all possible build configurations.
-    #
-    # Config   | Workloads | Value      | Expense   | Note
-    # ---------|-----------|------------|-----------|-----------------------------
-    # CPP/CUDA | F L M S   | Essential  | Expensive | Validates CUDA against CPP
-    # CPP/OMP  | F L M S   | Essential  | Cheap     | Validates OMP against CPP
-    # CPP/TBB  | F L M S   | Essential  | Cheap     | Validates TBB against CPP
-    # CPP/CPP  | F L M     | Important  | Cheap     | Tests CPP as device
-    # OMP/OMP  | F L M     | Important  | Cheap     | Tests OMP as host
-    # TBB/TBB  | F L M     | Important  | Cheap     | Tests TBB as host
-    # TBB/CUDA | F L       | Important  | Expensive | Validates TBB/CUDA interop
-    # OMP/CUDA | F L       | Important  | Expensive | Validates OMP/CUDA interop
-    # TBB/OMP  | F         | Not useful | Cheap     | Mixes CPU-parallel systems
-    # OMP/TBB  | F         | Not useful | Cheap     | Mixes CPU-parallel systems
-    # TBB/CPP  | F         | Not Useful | Cheap     | Parallel host, serial device
-    # OMP/CPP  | F         | Not Useful | Cheap     | Parallel host, serial device
-
-    set(THRUST_MULTICONFIG_WORKLOAD SMALL CACHE STRING
-      "Limit host/device configs: SMALL (up to 3 h/d combos per dialect), MEDIUM(6), LARGE(8), FULL(12)"
-    )
-    set_property(CACHE THRUST_MULTICONFIG_WORKLOAD PROPERTY STRINGS
-      SMALL MEDIUM LARGE FULL
-    )
-    set(THRUST_MULTICONFIG_WORKLOAD_SMALL_CONFIGS
-      CPP_OMP CPP_TBB CPP_CUDA
-      CACHE INTERNAL "Host/device combos enabled for SMALL workloads." FORCE
-    )
-    set(THRUST_MULTICONFIG_WORKLOAD_MEDIUM_CONFIGS
-      ${THRUST_MULTICONFIG_WORKLOAD_SMALL_CONFIGS}
-      CPP_CPP TBB_TBB OMP_OMP
-      CACHE INTERNAL "Host/device combos enabled for MEDIUM workloads." FORCE
-    )
-    set(THRUST_MULTICONFIG_WORKLOAD_LARGE_CONFIGS
-      ${THRUST_MULTICONFIG_WORKLOAD_MEDIUM_CONFIGS}
-      OMP_CUDA TBB_CUDA
-      CACHE INTERNAL "Host/device combos enabled for LARGE workloads." FORCE
-    )
-    set(THRUST_MULTICONFIG_WORKLOAD_FULL_CONFIGS
-      ${THRUST_MULTICONFIG_WORKLOAD_LARGE_CONFIGS}
-      OMP_CPP TBB_CPP OMP_TBB  TBB_OMP
-      CACHE INTERNAL "Host/device combos enabled for FULL workloads." FORCE
-    )
-
-    # Hide the single config options if they exist from a previous run:
-    if (DEFINED THRUST_HOST_SYSTEM)
-      set_property(CACHE THRUST_HOST_SYSTEM PROPERTY TYPE INTERNAL)
-      set_property(CACHE THRUST_DEVICE_SYSTEM PROPERTY TYPE INTERNAL)
-    endif()
-    if (DEFINED THRUST_CPP_DIALECT)
-      set_property(CACHE THRUST_CPP_DIALECT PROPERTY TYPE INTERNAL)
-    endif()
-
-  else() # Single config:
-    # Restore system option visibility if these cache options already exist
-    # from a previous run.
-    if (DEFINED THRUST_HOST_SYSTEM)
-      set_property(CACHE THRUST_HOST_SYSTEM PROPERTY TYPE STRING)
-      set_property(CACHE THRUST_DEVICE_SYSTEM PROPERTY TYPE STRING)
-    endif()
-
-    set(THRUST_CPP_DIALECT 14
-      CACHE STRING "The C++ standard to target: ${THRUST_CPP_DIALECT_OPTIONS}"
-    )
-    set_property(CACHE THRUST_CPP_DIALECT
-      PROPERTY STRINGS
-      ${THRUST_CPP_DIALECT_OPTIONS}
-    )
-
-    # CMake added C++17 support for CUDA targets in 3.18:
-    if (THRUST_CPP_DIALECT EQUAL 17 AND
-        THRUST_DEVICE_SYSTEM STREQUAL "CUDA")
-      cmake_minimum_required(VERSION 3.18)
-    endif()
-  endif()
-endfunction()

spaces/DAMO-NLP-SG/CLEX-Chat/modeling_llama.py

@@ -1,985 +0,0 @@
-# coding=utf-8
-# Copyright 2022 EleutherAI and the HuggingFace Inc. team. All rights reserved.
-#
-# This code is based on EleutherAI's GPT-NeoX library and the GPT-NeoX
-# and OPT implementations in this library. It has been modified from its
-# original forms to accommodate minor architectural differences compared
-# to GPT-NeoX and OPT used by the Meta AI team that trained the model.
-#
-# 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.
-""" PyTorch LLaMA model."""
-import math
-from typing import List, Optional, Tuple, Union
-
-import torch
-import torch.utils.checkpoint
-from torch import nn
-from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss
-
-from transformers.activations import ACT2FN
-from transformers.modeling_outputs import BaseModelOutputWithPast, CausalLMOutputWithPast, SequenceClassifierOutputWithPast
-from transformers.modeling_utils import PreTrainedModel
-from transformers.utils import add_start_docstrings, add_start_docstrings_to_model_forward, logging, replace_return_docstrings
-from configuration_clex import CLEXLlamaConfig
-from clex_layer import LlamaCLEXScalingRotaryEmbedding
-from einops import rearrange
-import importlib.metadata
-import importlib.util
-
-
-logger = logging.get_logger(__name__)
-
-def _is_package_available(pkg_name: str, return_version: bool = False) -> Union[Tuple[bool, str], bool]:
-    # Check we're not importing a "pkg_name" directory somewhere but the actual library by trying to grab the version
-    package_exists = importlib.util.find_spec(pkg_name) is not None
-    package_version = "N/A"
-    if package_exists:
-        try:
-            package_version = importlib.metadata.version(pkg_name)
-            package_exists = True
-        except importlib.metadata.PackageNotFoundError:
-            package_exists = False
-        logger.info(f"Detected {pkg_name} version {package_version}")
-    if return_version:
-        return package_exists, package_version
-    else:
-        return package_exists
-
-def is_flash_attn_available():
-    if not _is_package_available("torch", return_version=True):
-        return False
-
-    # Let's add an extra check to see if cuda is available
-
-    return _is_package_available("flash_attn") and torch.cuda.is_available()
-
-
-
-
-
-
-_CONFIG_FOR_DOC = "CLEXLlamaConfig"
-
-
-
-
-
-# Copied from transformers.models.bart.modeling_bart._make_causal_mask
-def _make_causal_mask(
-    input_ids_shape: torch.Size, dtype: torch.dtype, device: torch.device, past_key_values_length: int = 0
-):
-    """
-    Make causal mask used for bi-directional self-attention.
-    """
-    bsz, tgt_len = input_ids_shape
-    mask = torch.full((tgt_len, tgt_len), torch.tensor(torch.finfo(dtype).min, device=device), device=device)
-    mask_cond = torch.arange(mask.size(-1), device=device)
-    mask.masked_fill_(mask_cond < (mask_cond + 1).view(mask.size(-1), 1), 0)
-    mask = mask.to(dtype)
-
-    if past_key_values_length > 0:
-        mask = torch.cat([torch.zeros(tgt_len, past_key_values_length, dtype=dtype, device=device), mask], dim=-1)
-    return mask[None, None, :, :].expand(bsz, 1, tgt_len, tgt_len + past_key_values_length)
-
-
-# Copied from transformers.models.bart.modeling_bart._expand_mask
-def _expand_mask(mask: torch.Tensor, dtype: torch.dtype, tgt_len: Optional[int] = None):
-    """
-    Expands attention_mask from `[bsz, seq_len]` to `[bsz, 1, tgt_seq_len, src_seq_len]`.
-    """
-    bsz, src_len = mask.size()
-    tgt_len = tgt_len if tgt_len is not None else src_len
-
-    expanded_mask = mask[:, None, None, :].expand(bsz, 1, tgt_len, src_len).to(dtype)
-
-    inverted_mask = 1.0 - expanded_mask
-
-    return inverted_mask.masked_fill(inverted_mask.to(torch.bool), torch.finfo(dtype).min)
-
-
-class LlamaRMSNorm(nn.Module):
-    def __init__(self, hidden_size, eps=1e-6):
-        """
-        LlamaRMSNorm is equivalent to T5LayerNorm
-        """
-        super().__init__()
-        self.weight = nn.Parameter(torch.ones(hidden_size))
-        self.variance_epsilon = eps
-
-    def forward(self, hidden_states):
-        variance = hidden_states.to(torch.float32).pow(2).mean(-1, keepdim=True)
-        hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)
-
-        # convert into half-precision if necessary
-        if self.weight.dtype in [torch.float16, torch.bfloat16]:
-            hidden_states = hidden_states.to(self.weight.dtype)
-
-        return self.weight * hidden_states
-
-
-class LlamaRotaryEmbedding(torch.nn.Module):
-    def __init__(self, dim, max_position_embeddings=2048, base=10000, device=None):
-        super().__init__()
-        inv_freq = 1.0 / (base ** (torch.arange(0, dim, 2).float().to(device) / dim))
-        self.register_buffer("inv_freq", inv_freq)
-
-        # Build here to make `torch.jit.trace` work.
-        self.max_seq_len_cached = max_position_embeddings
-        t = torch.arange(self.max_seq_len_cached, device=self.inv_freq.device, dtype=self.inv_freq.dtype)
-        freqs = torch.einsum("i,j->ij", t, self.inv_freq)
-        # Different from paper, but it uses a different permutation in order to obtain the same calculation
-        emb = torch.cat((freqs, freqs), dim=-1)
-        self.register_buffer("cos_cached", emb.cos()[None, None, :, :], persistent=False)
-        self.register_buffer("sin_cached", emb.sin()[None, None, :, :], persistent=False)
-
-    def forward(self, x, seq_len=None):
-        # x: [bs, num_attention_heads, seq_len, head_size]
-        # This `if` block is unlikely to be run after we build sin/cos in `__init__`. Keep the logic here just in case.
-        if seq_len > self.max_seq_len_cached:
-            self.max_seq_len_cached = seq_len
-            t = torch.arange(self.max_seq_len_cached, device=x.device, dtype=self.inv_freq.dtype)
-            freqs = torch.einsum("i,j->ij", t, self.inv_freq)
-            # Different from paper, but it uses a different permutation in order to obtain the same calculation
-            emb = torch.cat((freqs, freqs), dim=-1).to(x.device)
-            self.register_buffer("cos_cached", emb.cos()[None, None, :, :], persistent=False)
-            self.register_buffer("sin_cached", emb.sin()[None, None, :, :], persistent=False)
-        return (
-            self.cos_cached[:, :, :seq_len, ...].to(dtype=x.dtype),
-            self.sin_cached[:, :, :seq_len, ...].to(dtype=x.dtype),
-        )
-
-
-def rotate_half(x):
-    """Rotates half the hidden dims of the input."""
-    x1 = x[..., : x.shape[-1] // 2]
-    x2 = x[..., x.shape[-1] // 2 :]
-    return torch.cat((-x2, x1), dim=-1)
-
-
-def apply_rotary_pos_emb(q, k, cos, sin,  position_ids):
-    # The first two dimensions of cos and sin are always 1, so we can `squeeze` them.
-    cos = cos.squeeze(1).squeeze(0)  # [seq_len, dim]
-    sin = sin.squeeze(1).squeeze(0)  # [seq_len, dim]
-    cos = cos[position_ids].unsqueeze(1)  # [bs, 1, seq_len, dim]
-    sin = sin[position_ids].unsqueeze(1)  # [bs, 1, seq_len, dim]
-    q_embed = (q * cos) + (rotate_half(q) * sin)
-    k_embed = (k * cos) + (rotate_half(k) * sin)
-    return q_embed, k_embed
-
-
-class LlamaMLP(nn.Module):
-    def __init__(
-        self,
-        hidden_size: int,
-        intermediate_size: int,
-        hidden_act: str,
-    ):
-        super().__init__()
-        self.gate_proj = nn.Linear(hidden_size, intermediate_size, bias=False)
-        self.down_proj = nn.Linear(intermediate_size, hidden_size, bias=False)
-        self.up_proj = nn.Linear(hidden_size, intermediate_size, bias=False)
-        self.act_fn = ACT2FN[hidden_act]
-
-    def forward(self, x):
-        return self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))
-
-
-class LlamaAttention(nn.Module):
-    """Multi-headed attention from 'Attention Is All You Need' paper"""
-
-    def __init__(self, config: CLEXLlamaConfig):
-        super().__init__()
-        self.config = config
-        self.hidden_size = config.hidden_size
-        self.num_heads = config.num_attention_heads
-        self.head_dim = self.hidden_size // self.num_heads
-        self.max_position_embeddings = config.max_position_embeddings
-        self.log_scale = config.log_scale
-        if (self.head_dim * self.num_heads) != self.hidden_size:
-            raise ValueError(
-                f"hidden_size must be divisible by num_heads (got `hidden_size`: {self.hidden_size}"
-                f" and `num_heads`: {self.num_heads})."
-            )
-        self.q_proj = nn.Linear(self.hidden_size, self.num_heads * self.head_dim, bias=False)
-        self.k_proj = nn.Linear(self.hidden_size, self.num_heads * self.head_dim, bias=False)
-        self.v_proj = nn.Linear(self.hidden_size, self.num_heads * self.head_dim, bias=False)
-        self.o_proj = nn.Linear(self.num_heads * self.head_dim, self.hidden_size, bias=False)
-        self.rotary_emb = LlamaRotaryEmbedding(self.head_dim, max_position_embeddings=self.max_position_embeddings)
-
-    def _shape(self, tensor: torch.Tensor, seq_len: int, bsz: int):
-        return tensor.view(bsz, seq_len, self.num_heads, self.head_dim).transpose(1, 2).contiguous()
-    
-    def flash_attn_forward(
-        self,
-        qkv: torch.Tensor,
-        key_padding_mask: Optional[torch.Tensor] = None,
-    ) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[Tuple[torch.Tensor]]]:
-        """Input shape: Batch x Time x Channel
-
-        attention_mask: [bsz, q_len]
-        """
-        if is_flash_attn_available():
-            from flash_attn.flash_attn_interface import flash_attn_varlen_qkvpacked_func, flash_attn_qkvpacked_func, flash_attn_with_kvcache
-            # from flash_attn.flash_attn_interface import flash_attn_unpadded_qkvpacked_func
-            from flash_attn.bert_padding import unpad_input, pad_input
-        bsz, q_len, *_ = qkv.size()
-
-        if key_padding_mask is None:
-            # qkv = rearrange(qkv, "b s ... -> (b s) ...")
-            max_s = q_len
-            cu_q_lens = torch.arange(
-                0, (bsz + 1) * q_len, step=q_len, dtype=torch.int32, device=qkv.device
-            )
-            output = flash_attn_qkvpacked_func(
-                qkv, 0.0, softmax_scale=None, causal=True
-            )
-        else:
-            nheads = qkv.shape[-2]
-            x = rearrange(qkv, "b s three h d -> b s (three h d)")
-            x_unpad, indices, cu_q_lens, max_s = unpad_input(x, key_padding_mask)
-            x_unpad = rearrange(
-                x_unpad, "nnz (three h d) -> nnz three h d", three=3, h=nheads
-            )
-            output_unpad = flash_attn_varlen_qkvpacked_func(
-                x_unpad, cu_q_lens, max_s, 0.0, softmax_scale=None, causal=True
-            )
-            output = rearrange(
-                pad_input(
-                    rearrange(output_unpad, "nnz h d -> nnz (h d)"), indices, bsz, q_len
-                ),
-                "b s (h d) -> b s h d",
-                h=nheads,
-            )
-        return self.o_proj(rearrange(output, "b s h d -> b s (h d)"))
-    
-    def forward(
-        self,
-        hidden_states: torch.Tensor,
-        attention_mask: Optional[torch.Tensor] = None,
-        position_ids: Optional[torch.LongTensor] = None,
-        pack_cos_sin = None,
-        past_key_value: Optional[Tuple[torch.Tensor]] = None,
-        output_attentions: bool = False,
-        use_cache: bool = False,
-    ) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[Tuple[torch.Tensor]]]:
-        bsz, q_len, _ = hidden_states.size()
-
-        query_states = self.q_proj(hidden_states).view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2)
-        key_states = self.k_proj(hidden_states).view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2)
-        value_states = self.v_proj(hidden_states).view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2)
-
-        kv_seq_len = key_states.shape[-2]
-
-        if past_key_value is not None:
-            kv_seq_len += past_key_value[0].shape[-2]
-        
-        if pack_cos_sin is not None:
-            cos, sin = pack_cos_sin.to(query_states.device)
-        else:
-            cos, sin = self.rotary_emb(value_states, seq_len=kv_seq_len)
-        query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin, position_ids)
-
-        if past_key_value is not None:
-            # reuse k, v, self_attention
-            key_states = torch.cat([past_key_value[0], key_states], dim=2)
-            value_states = torch.cat([past_key_value[1], value_states], dim=2)
-
-        past_key_value = (key_states, value_states) if use_cache else None
-
-        use_flashattn =  self.config.use_flashattn and is_flash_attn_available()
-
-        
-
-        attn_weights = torch.matmul(query_states, key_states.transpose(2, 3)) / math.sqrt(self.head_dim)
-
-        if attn_weights.size() != (bsz, self.num_heads, q_len, kv_seq_len):
-            raise ValueError(
-                f"Attention weights should be of size {(bsz, self.num_heads, q_len, kv_seq_len)}, but is"
-                f" {attn_weights.size()}"
-            )
-
-        if attention_mask is not None:
-            if attention_mask.size() != (bsz, 1, q_len, kv_seq_len):
-                raise ValueError(
-                    f"Attention mask should be of size {(bsz, 1, q_len, kv_seq_len)}, but is {attention_mask.size()}"
-                )
-            attn_weights = attn_weights + attention_mask
-            attn_weights = torch.max(attn_weights, torch.tensor(torch.finfo(attn_weights.dtype).min))
-
-        # upcast attention to fp32
-        attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query_states.dtype)
-        attn_output = torch.matmul(attn_weights, value_states)
-
-        if attn_output.size() != (bsz, self.num_heads, q_len, self.head_dim):
-            raise ValueError(
-                f"`attn_output` should be of size {(bsz, self.num_heads, q_len, self.head_dim)}, but is"
-                f" {attn_output.size()}"
-            )
-
-        attn_output = attn_output.transpose(1, 2)
-        attn_output = attn_output.reshape(bsz, q_len, self.hidden_size)
-
-        attn_output = self.o_proj(attn_output)
-
-        if not output_attentions:
-            attn_weights = None
-
-        return attn_output, attn_weights, past_key_value
-
-
-class LlamaDecoderLayer(nn.Module):
-    def __init__(self, config: CLEXLlamaConfig):
-        super().__init__()
-        self.hidden_size = config.hidden_size
-        self.self_attn = LlamaAttention(config=config)
-        self.mlp = LlamaMLP(
-            hidden_size=self.hidden_size,
-            intermediate_size=config.intermediate_size,
-            hidden_act=config.hidden_act,
-        )
-        self.input_layernorm = LlamaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
-        self.post_attention_layernorm = LlamaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
-
-    def forward(
-        self,
-        hidden_states: torch.Tensor,
-        attention_mask: Optional[torch.Tensor] = None,
-        position_ids: Optional[torch.LongTensor] = None,
-        pack_cos_sin=None,
-        past_key_value: Optional[Tuple[torch.Tensor]] = None,
-        output_attentions: Optional[bool] = False,
-        use_cache: Optional[bool] = False,
-    ) -> Tuple[torch.FloatTensor, Optional[Tuple[torch.FloatTensor, torch.FloatTensor]]]:
-        """
-        Args:
-            hidden_states (`torch.FloatTensor`): input to the layer of shape `(batch, seq_len, embed_dim)`
-            attention_mask (`torch.FloatTensor`, *optional*): attention mask of size
-                `(batch, 1, tgt_len, src_len)` where padding elements are indicated by very large negative values.
-            output_attentions (`bool`, *optional*):
-                Whether or not to return the attentions tensors of all attention layers. See `attentions` under
-                returned tensors for more detail.
-            use_cache (`bool`, *optional*):
-                If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding
-                (see `past_key_values`).
-            past_key_value (`Tuple(torch.FloatTensor)`, *optional*): cached past key and value projection states
-        """
-
-        residual = hidden_states
-
-        hidden_states = self.input_layernorm(hidden_states)
-
-        # Self Attention
-        hidden_states, self_attn_weights, present_key_value = self.self_attn(
-            hidden_states=hidden_states,
-            attention_mask=attention_mask,
-            position_ids=position_ids,
-            pack_cos_sin=pack_cos_sin,
-            past_key_value=past_key_value,
-            output_attentions=output_attentions,
-            use_cache=use_cache,
-        )
-        hidden_states = residual + hidden_states
-
-        # Fully Connected
-        residual = hidden_states
-        hidden_states = self.post_attention_layernorm(hidden_states)
-        hidden_states = self.mlp(hidden_states)
-        hidden_states = residual + hidden_states
-
-        outputs = (hidden_states,)
-
-        if output_attentions:
-            outputs += (self_attn_weights,)
-
-        if use_cache:
-            outputs += (present_key_value,)
-
-        return outputs
-
-
-LLAMA_START_DOCSTRING = r"""
-    This model inherits from [`PreTrainedModel`]. Check the superclass documentation for the generic methods the
-    library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads
-    etc.)
-
-    This model is also a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass.
-    Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
-    and behavior.
-
-    Parameters:
-        config ([`CLEXLlamaConfig`]):
-            Model configuration class with all the parameters of the model. Initializing with a config file does not
-            load the weights associated with the model, only the configuration. Check out the
-            [`~PreTrainedModel.from_pretrained`] method to load the model weights.
-"""
-
-
-@add_start_docstrings(
-    "The bare LLaMA Model outputting raw hidden-states without any specific head on top.",
-    LLAMA_START_DOCSTRING,
-)
-class LlamaPreTrainedModel(PreTrainedModel):
-    config_class = CLEXLlamaConfig
-    base_model_prefix = "model"
-    supports_gradient_checkpointing = True
-    _no_split_modules = ["LlamaDecoderLayer"]
-    _keys_to_ignore_on_load_unexpected = [r"decoder\.version"]
-    _keep_in_fp32_modules = ["model.clex_layer.proj_func.ode_up_proj", "model.clex_layer.proj_func.ode_down_proj", "model.clex_layer.inv_freq"]
-
-    def _init_weights(self, module):
-        std = self.config.initializer_range
-        if isinstance(module, nn.Linear):
-            module.weight.data.normal_(mean=0.0, std=std)
-            if module.bias is not None:
-                module.bias.data.zero_()
-        elif isinstance(module, nn.Embedding):
-            module.weight.data.normal_(mean=0.0, std=std)
-            if module.padding_idx is not None:
-                module.weight.data[module.padding_idx].zero_()
-
-    def _set_gradient_checkpointing(self, module, value=False):
-        if isinstance(module, LlamaModel):
-            module.gradient_checkpointing = value
-
-
-LLAMA_INPUTS_DOCSTRING = r"""
-    Args:
-        input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
-            Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you provide
-            it.
-
-            Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
-            [`PreTrainedTokenizer.__call__`] for details.
-
-            [What are input IDs?](../glossary#input-ids)
-        attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
-            Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:
-
-            - 1 for tokens that are **not masked**,
-            - 0 for tokens that are **masked**.
-
-            [What are attention masks?](../glossary#attention-mask)
-
-            Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
-            [`PreTrainedTokenizer.__call__`] for details.
-
-            If `past_key_values` is used, optionally only the last `decoder_input_ids` have to be input (see
-            `past_key_values`).
-
-            If you want to change padding behavior, you should read [`modeling_opt._prepare_decoder_attention_mask`]
-            and modify to your needs. See diagram 1 in [the paper](https://arxiv.org/abs/1910.13461) for more
-            information on the default strategy.
-
-            - 1 indicates the head is **not masked**,
-            - 0 indicates the head is **masked**.
-        position_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
-            Indices of positions of each input sequence tokens in the position embeddings. Selected in the range `[0,
-            config.n_positions - 1]`.
-
-            [What are position IDs?](../glossary#position-ids)
-        past_key_values (`tuple(tuple(torch.FloatTensor))`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`):
-            Tuple of `tuple(torch.FloatTensor)` of length `config.n_layers`, with each tuple having 2 tensors of shape
-            `(batch_size, num_heads, sequence_length, embed_size_per_head)`) and 2 additional tensors of shape
-            `(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)`.
-
-            Contains pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention
-            blocks) that can be used (see `past_key_values` input) to speed up sequential decoding.
-
-            If `past_key_values` are used, the user can optionally input only the last `decoder_input_ids` (those that
-            don't have their past key value states given to this model) of shape `(batch_size, 1)` instead of all
-            `decoder_input_ids` of shape `(batch_size, sequence_length)`.
-        inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
-            Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation. This
-            is useful if you want more control over how to convert `input_ids` indices into associated vectors than the
-            model's internal embedding lookup matrix.
-        use_cache (`bool`, *optional*):
-            If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see
-            `past_key_values`).
-        output_attentions (`bool`, *optional*):
-            Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned
-            tensors for more detail.
-        output_hidden_states (`bool`, *optional*):
-            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
-            more detail.
-        return_dict (`bool`, *optional*):
-            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
-"""
-
-
-@add_start_docstrings(
-    "The bare LLaMA Model outputting raw hidden-states without any specific head on top.",
-    LLAMA_START_DOCSTRING,
-)
-class LlamaModel(LlamaPreTrainedModel):
-    """
-    Transformer decoder consisting of *config.num_hidden_layers* layers. Each layer is a [`LlamaDecoderLayer`]
-
-    Args:
-        config: CLEXLlamaConfig
-    """
-
-    def __init__(self, config: CLEXLlamaConfig):
-        super().__init__(config)
-        self.padding_idx = config.pad_token_id
-        self.vocab_size = config.vocab_size
-
-        self.embed_tokens = nn.Embedding(config.vocab_size, config.hidden_size, self.padding_idx)
-        self.layers = nn.ModuleList([LlamaDecoderLayer(config) for _ in range(config.num_hidden_layers)])
-        self.norm = LlamaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
-        head_dim = config.hidden_size // config.num_attention_heads
-        if config.rope_scaling["type"] == "clex":
-            self.clex_layer = LlamaCLEXScalingRotaryEmbedding(head_dim, config.max_position_embeddings, config.rope_scaling)
-        self.gradient_checkpointing = False
-        # Initialize weights and apply final processing
-        self.post_init()
-    
-
-    def get_input_embeddings(self):
-        return self.embed_tokens
-
-    def set_input_embeddings(self, value):
-        self.embed_tokens = value
-
-    # Copied from transformers.models.bart.modeling_bart.BartDecoder._prepare_decoder_attention_mask
-    def _prepare_decoder_attention_mask(self, attention_mask, input_shape, inputs_embeds, past_key_values_length):
-        # create causal mask
-        # [bsz, seq_len] -> [bsz, 1, tgt_seq_len, src_seq_len]
-        combined_attention_mask = None
-        if input_shape[-1] > 1:
-            combined_attention_mask = _make_causal_mask(
-                input_shape,
-                inputs_embeds.dtype,
-                device=inputs_embeds.device,
-                past_key_values_length=past_key_values_length,
-            )
-
-        if attention_mask is not None:
-            # [bsz, seq_len] -> [bsz, 1, tgt_seq_len, src_seq_len]
-            expanded_attn_mask = _expand_mask(attention_mask, inputs_embeds.dtype, tgt_len=input_shape[-1]).to(
-                inputs_embeds.device
-            )
-            combined_attention_mask = (
-                expanded_attn_mask if combined_attention_mask is None else expanded_attn_mask + combined_attention_mask
-            )
-
-        return combined_attention_mask
-
-    @add_start_docstrings_to_model_forward(LLAMA_INPUTS_DOCSTRING)
-    def forward(
-        self,
-        input_ids: torch.LongTensor = None,
-        attention_mask: Optional[torch.Tensor] = None,
-        position_ids: Optional[torch.LongTensor] = None,
-        past_key_values: Optional[List[torch.FloatTensor]] = None,
-        inputs_embeds: Optional[torch.FloatTensor] = None,
-        use_cache: Optional[bool] = None,
-        output_attentions: Optional[bool] = None,
-        output_hidden_states: Optional[bool] = None,
-        return_dict: Optional[bool] = None,
-    ) -> Union[Tuple, BaseModelOutputWithPast]:
-        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
-        output_hidden_states = (
-            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
-        )
-        use_cache = use_cache if use_cache is not None else self.config.use_cache
-
-        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
-
-        # retrieve input_ids and inputs_embeds
-        if input_ids is not None and inputs_embeds is not None:
-            raise ValueError("You cannot specify both decoder_input_ids and decoder_inputs_embeds at the same time")
-        elif input_ids is not None:
-            batch_size, seq_length = input_ids.shape
-        elif inputs_embeds is not None:
-            batch_size, seq_length, _ = inputs_embeds.shape
-        else:
-            raise ValueError("You have to specify either decoder_input_ids or decoder_inputs_embeds")
-
-        seq_length_with_past = seq_length
-        past_key_values_length = 0
-
-        if past_key_values is not None:
-            past_key_values_length = past_key_values[0][0].shape[2]
-            seq_length_with_past = seq_length_with_past + past_key_values_length
-
-        if position_ids is None:
-            device = input_ids.device if input_ids is not None else inputs_embeds.device
-            position_ids = torch.arange(
-                past_key_values_length, seq_length + past_key_values_length, dtype=torch.long, device=device
-            )
-            position_ids = position_ids.unsqueeze(0).view(-1, seq_length)
-        else:
-            position_ids = position_ids.view(-1, seq_length).long()
-
-        if inputs_embeds is None:
-            inputs_embeds = self.embed_tokens(input_ids)
-        # embed positions
-        if attention_mask is None:
-            attention_mask = torch.ones(
-                (batch_size, seq_length_with_past), dtype=torch.bool, device=inputs_embeds.device
-            )
-        attention_mask = self._prepare_decoder_attention_mask(
-            attention_mask, (batch_size, seq_length), inputs_embeds, past_key_values_length
-        )
-        # attention_mask = None
-
-
-        hidden_states = inputs_embeds
-
-        if self.gradient_checkpointing and self.training:
-            if use_cache:
-                logger.warning_once(
-                    "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..."
-                )
-                use_cache = False
-
-        # decoder layers
-        all_hidden_states = () if output_hidden_states else None
-        all_self_attns = () if output_attentions else None
-        next_decoder_cache = () if use_cache else None
-
-        pack_cos_sin = None
-        if self.config.rope_scaling["type"] == "clex":
-            pack_cos_sin = self.clex_layer(inputs_embeds.device, inputs_embeds.dtype, seq_length_with_past, self.training)
-
-        for idx, decoder_layer in enumerate(self.layers):
-            if output_hidden_states:
-                all_hidden_states += (hidden_states,)
-
-            past_key_value = past_key_values[idx] if past_key_values is not None else None
-
-            if self.gradient_checkpointing and self.training:
-
-                def create_custom_forward(module):
-                    def custom_forward(*inputs):
-                        # None for past_key_value
-                        return module(*inputs, output_attentions, None)
-
-                    return custom_forward
-
-                layer_outputs = torch.utils.checkpoint.checkpoint(
-                    create_custom_forward(decoder_layer),
-                    hidden_states,
-                    attention_mask,
-                    position_ids,
-                    pack_cos_sin,
-                    None,
-                )
-            else:
-                layer_outputs = decoder_layer(
-                    hidden_states,
-                    attention_mask=attention_mask,
-                    position_ids=position_ids,
-                    pack_cos_sin=pack_cos_sin,
-                    past_key_value=past_key_value,
-                    output_attentions=output_attentions,
-                    use_cache=use_cache,
-                )
-
-            hidden_states = layer_outputs[0]
-
-            if use_cache:
-                next_decoder_cache += (layer_outputs[2 if output_attentions else 1],)
-
-            if output_attentions:
-                all_self_attns += (layer_outputs[1],)
-
-        hidden_states = self.norm(hidden_states)
-
-        # add hidden states from the last decoder layer
-        if output_hidden_states:
-            all_hidden_states += (hidden_states,)
-
-        next_cache = next_decoder_cache if use_cache else None
-        if not return_dict:
-            return tuple(v for v in [hidden_states, next_cache, all_hidden_states, all_self_attns] if v is not None)
-        return BaseModelOutputWithPast(
-            last_hidden_state=hidden_states,
-            past_key_values=next_cache,
-            hidden_states=all_hidden_states,
-            attentions=all_self_attns,
-        )
-
-
-class LlamaForCausalLM(LlamaPreTrainedModel):
-    def __init__(self, config):
-        super().__init__(config)
-        self.model = LlamaModel(config)
-
-        self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
-
-        # Initialize weights and apply final processing
-        self.post_init()
-
-    def get_input_embeddings(self):
-        return self.model.embed_tokens
-
-    def set_input_embeddings(self, value):
-        self.model.embed_tokens = value
-
-    def get_output_embeddings(self):
-        return self.lm_head
-
-    def set_output_embeddings(self, new_embeddings):
-        self.lm_head = new_embeddings
-
-    def set_decoder(self, decoder):
-        self.model = decoder
-
-    def get_decoder(self):
-        return self.model
-
-    @add_start_docstrings_to_model_forward(LLAMA_INPUTS_DOCSTRING)
-    @replace_return_docstrings(output_type=CausalLMOutputWithPast, config_class=_CONFIG_FOR_DOC)
-    def forward(
-        self,
-        input_ids: torch.LongTensor = None,
-        attention_mask: Optional[torch.Tensor] = None,
-        position_ids: Optional[torch.LongTensor] = None,
-        past_key_values: Optional[List[torch.FloatTensor]] = None,
-        inputs_embeds: Optional[torch.FloatTensor] = None,
-        labels: Optional[torch.LongTensor] = None,
-        use_cache: Optional[bool] = None,
-        output_attentions: Optional[bool] = None,
-        output_hidden_states: Optional[bool] = None,
-        return_dict: Optional[bool] = None,
-    ) -> Union[Tuple, CausalLMOutputWithPast]:
-        r"""
-        Args:
-            labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
-                Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,
-                config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored
-                (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`.
-
-        Returns:
-
-        Example:
-
-        ```python
-        >>> from transformers import AutoTokenizer, LlamaForCausalLM
-
-        >>> model = LlamaForCausalLM.from_pretrained(PATH_TO_CONVERTED_WEIGHTS)
-        >>> tokenizer = AutoTokenizer.from_pretrained(PATH_TO_CONVERTED_TOKENIZER)
-
-        >>> prompt = "Hey, are you consciours? Can you talk to me?"
-        >>> inputs = tokenizer(prompt, return_tensors="pt")
-
-        >>> # Generate
-        >>> generate_ids = model.generate(inputs.input_ids, max_length=30)
-        >>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
-        "Hey, are you consciours? Can you talk to me?\nI'm not consciours, but I can talk to you."
-        ```"""
-
-        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
-        output_hidden_states = (
-            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
-        )
-        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
-
-        # decoder outputs consists of (dec_features, layer_state, dec_hidden, dec_attn)
-        outputs = self.model(
-            input_ids=input_ids,
-            attention_mask=attention_mask,
-            position_ids=position_ids,
-            past_key_values=past_key_values,
-            inputs_embeds=inputs_embeds,
-            use_cache=use_cache,
-            output_attentions=output_attentions,
-            output_hidden_states=output_hidden_states,
-            return_dict=return_dict,
-        )
-
-        hidden_states = outputs[0]
-        logits = self.lm_head(hidden_states)
-
-        loss = None
-        if labels is not None:
-            # Shift so that tokens < n predict n
-            shift_logits = logits[..., :-1, :].contiguous()
-            shift_labels = labels[..., 1:].contiguous()
-            # Flatten the tokens
-            loss_fct = CrossEntropyLoss()
-            shift_logits = shift_logits.view(-1, self.config.vocab_size)
-            shift_labels = shift_labels.view(-1)
-            # Enable model parallelism
-            shift_labels = shift_labels.to(shift_logits.device)
-            loss = loss_fct(shift_logits, shift_labels)
-        if not return_dict:
-            output = (logits,) + outputs[1:]
-            return (loss,) + output if loss is not None else output
-        return CausalLMOutputWithPast(
-            loss=loss,
-            logits=logits,
-            past_key_values=outputs.past_key_values,
-            hidden_states=outputs.hidden_states,
-            attentions=outputs.attentions,
-        )
-
-    def prepare_inputs_for_generation(
-        self, input_ids, past_key_values=None, attention_mask=None, inputs_embeds=None, **kwargs
-    ):
-        if past_key_values:
-            input_ids = input_ids[:, -1:]
-
-        position_ids = kwargs.get("position_ids", None)
-        if attention_mask is not None and position_ids is None:
-            # create position_ids on the fly for batch generation
-            position_ids = attention_mask.long().cumsum(-1) - 1
-            position_ids.masked_fill_(attention_mask == 0, 1)
-            if past_key_values:
-                position_ids = position_ids[:, -1].unsqueeze(-1)
-
-        # if `inputs_embeds` are passed, we only want to use them in the 1st generation step
-        if inputs_embeds is not None and past_key_values is None:
-            model_inputs = {"inputs_embeds": inputs_embeds}
-        else:
-            model_inputs = {"input_ids": input_ids}
-
-        model_inputs.update(
-            {
-                "position_ids": position_ids,
-                "past_key_values": past_key_values,
-                "use_cache": kwargs.get("use_cache"),
-                "attention_mask": attention_mask,
-            }
-        )
-        return model_inputs
-
-    @staticmethod
-    def _reorder_cache(past_key_values, beam_idx):
-        reordered_past = ()
-        for layer_past in past_key_values:
-            reordered_past += (tuple(past_state.index_select(0, beam_idx) for past_state in layer_past),)
-        return reordered_past
-
-
-@add_start_docstrings(
-    """
-    The LLaMa Model transformer with a sequence classification head on top (linear layer).
-
-    [`LlamaForSequenceClassification`] uses the last token in order to do the classification, as other causal models
-    (e.g. GPT-2) do.
-
-    Since it does classification on the last token, it requires to know the position of the last token. If a
-    `pad_token_id` is defined in the configuration, it finds the last token that is not a padding token in each row. If
-    no `pad_token_id` is defined, it simply takes the last value in each row of the batch. Since it cannot guess the
-    padding tokens when `inputs_embeds` are passed instead of `input_ids`, it does the same (take the last value in
-    each row of the batch).
-    """,
-    LLAMA_START_DOCSTRING,
-)
-class LlamaForSequenceClassification(LlamaPreTrainedModel):
-    _keys_to_ignore_on_load_missing = [r"lm_head.weight"]
-
-    def __init__(self, config):
-        super().__init__(config)
-        self.num_labels = config.num_labels
-        self.model = LlamaModel(config)
-        self.score = nn.Linear(config.hidden_size, self.num_labels, bias=False)
-
-        # Initialize weights and apply final processing
-        self.post_init()
-
-    def get_input_embeddings(self):
-        return self.model.embed_tokens
-
-    def set_input_embeddings(self, value):
-        self.model.embed_tokens = value
-
-    @add_start_docstrings_to_model_forward(LLAMA_INPUTS_DOCSTRING)
-    def forward(
-        self,
-        input_ids: torch.LongTensor = None,
-        attention_mask: Optional[torch.Tensor] = None,
-        position_ids: Optional[torch.LongTensor] = None,
-        past_key_values: Optional[List[torch.FloatTensor]] = None,
-        inputs_embeds: Optional[torch.FloatTensor] = None,
-        labels: Optional[torch.LongTensor] = None,
-        use_cache: Optional[bool] = None,
-        output_attentions: Optional[bool] = None,
-        output_hidden_states: Optional[bool] = None,
-        return_dict: Optional[bool] = None,
-    ) -> Union[Tuple, SequenceClassifierOutputWithPast]:
-        r"""
-        labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
-            Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
-            config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
-            `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
-        """
-        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
-
-        transformer_outputs = self.model(
-            input_ids,
-            attention_mask=attention_mask,
-            position_ids=position_ids,
-            past_key_values=past_key_values,
-            inputs_embeds=inputs_embeds,
-            use_cache=use_cache,
-            output_attentions=output_attentions,
-            output_hidden_states=output_hidden_states,
-            return_dict=return_dict,
-        )
-        hidden_states = transformer_outputs[0]
-        logits = self.score(hidden_states)
-
-        if input_ids is not None:
-            batch_size = input_ids.shape[0]
-        else:
-            batch_size = inputs_embeds.shape[0]
-
-        if self.config.pad_token_id is None and batch_size != 1:
-            raise ValueError("Cannot handle batch sizes > 1 if no padding token is defined.")
-        if self.config.pad_token_id is None:
-            sequence_lengths = -1
-        else:
-            if input_ids is not None:
-                sequence_lengths = (torch.ne(input_ids, self.config.pad_token_id).sum(-1) - 1).to(logits.device)
-            else:
-                sequence_lengths = -1
-
-        pooled_logits = logits[torch.arange(batch_size, device=logits.device), sequence_lengths]
-
-        loss = None
-        if labels is not None:
-            labels = labels.to(logits.device)
-            if self.config.problem_type is None:
-                if self.num_labels == 1:
-                    self.config.problem_type = "regression"
-                elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
-                    self.config.problem_type = "single_label_classification"
-                else:
-                    self.config.problem_type = "multi_label_classification"
-
-            if self.config.problem_type == "regression":
-                loss_fct = MSELoss()
-                if self.num_labels == 1:
-                    loss = loss_fct(pooled_logits.squeeze(), labels.squeeze())
-                else:
-                    loss = loss_fct(pooled_logits, labels)
-            elif self.config.problem_type == "single_label_classification":
-                loss_fct = CrossEntropyLoss()
-                loss = loss_fct(pooled_logits.view(-1, self.num_labels), labels.view(-1))
-            elif self.config.problem_type == "multi_label_classification":
-                loss_fct = BCEWithLogitsLoss()
-                loss = loss_fct(pooled_logits, labels)
-        if not return_dict:
-            output = (pooled_logits,) + transformer_outputs[1:]
-            return ((loss,) + output) if loss is not None else output
-
-        return SequenceClassifierOutputWithPast(
-            loss=loss,
-            logits=pooled_logits,
-            past_key_values=transformer_outputs.past_key_values,
-            hidden_states=transformer_outputs.hidden_states,
-            attentions=transformer_outputs.attentions,
-        )

spaces/DAMO-NLP-SG/Video-LLaMA/video_llama/datasets/datasets/dataloader_utils.py

@@ -1,162 +0,0 @@
-"""
- Copyright (c) 2022, salesforce.com, inc.
- All rights reserved.
- SPDX-License-Identifier: BSD-3-Clause
- For full license text, see the LICENSE_Lavis file in the repo root or https://opensource.org/licenses/BSD-3-Clause
-"""
-
-import time
-import random
-import torch
-from video_llama.datasets.data_utils import move_to_cuda
-from torch.utils.data import DataLoader
-
-
-class MultiIterLoader:
-    """
-    A simple wrapper for iterating over multiple iterators.
-
-    Args:
-        loaders (List[Loader]): List of Iterator loaders.
-        ratios (List[float]): List of ratios to sample from each loader. If None, all loaders are sampled uniformly.
-    """
-
-    def __init__(self, loaders, ratios=None):
-        # assert all loaders has __next__ method
-        for loader in loaders:
-            assert hasattr(
-                loader, "__next__"
-            ), "Loader {} has no __next__ method.".format(loader)
-
-        if ratios is None:
-            ratios = [1.0] * len(loaders)
-        else:
-            assert len(ratios) == len(loaders)
-            ratios = [float(ratio) / sum(ratios) for ratio in ratios]
-
-        self.loaders = loaders
-        self.ratios = ratios
-
-    def __next__(self):
-        # random sample from each loader by ratio
-        loader_idx = random.choices(range(len(self.loaders)), self.ratios, k=1)[0]
-        return next(self.loaders[loader_idx])
-
-
-class PrefetchLoader(object):
-    """
-    Modified from https://github.com/ChenRocks/UNITER.
-
-    overlap compute and cuda data transfer
-    (copied and then modified from nvidia apex)
-    """
-
-    def __init__(self, loader):
-        self.loader = loader
-        self.stream = torch.cuda.Stream()
-
-    def __iter__(self):
-        loader_it = iter(self.loader)
-        self.preload(loader_it)
-        batch = self.next(loader_it)
-        while batch is not None:
-            is_tuple = isinstance(batch, tuple)
-            if is_tuple:
-                task, batch = batch
-
-            if is_tuple:
-                yield task, batch
-            else:
-                yield batch
-            batch = self.next(loader_it)
-
-    def __len__(self):
-        return len(self.loader)
-
-    def preload(self, it):
-        try:
-            self.batch = next(it)
-        except StopIteration:
-            self.batch = None
-            return
-        # if record_stream() doesn't work, another option is to make sure
-        # device inputs are created on the main stream.
-        # self.next_input_gpu = torch.empty_like(self.next_input,
-        #                                        device='cuda')
-        # self.next_target_gpu = torch.empty_like(self.next_target,
-        #                                         device='cuda')
-        # Need to make sure the memory allocated for next_* is not still in use
-        # by the main stream at the time we start copying to next_*:
-        # self.stream.wait_stream(torch.cuda.current_stream())
-        with torch.cuda.stream(self.stream):
-            self.batch = move_to_cuda(self.batch)
-            # more code for the alternative if record_stream() doesn't work:
-            # copy_ will record the use of the pinned source tensor in this
-            # side stream.
-            # self.next_input_gpu.copy_(self.next_input, non_blocking=True)
-            # self.next_target_gpu.copy_(self.next_target, non_blocking=True)
-            # self.next_input = self.next_input_gpu
-            # self.next_target = self.next_target_gpu
-
-    def next(self, it):
-        torch.cuda.current_stream().wait_stream(self.stream)
-        batch = self.batch
-        if batch is not None:
-            record_cuda_stream(batch)
-        self.preload(it)
-        return batch
-
-    def __getattr__(self, name):
-        method = self.loader.__getattribute__(name)
-        return method
-
-
-def record_cuda_stream(batch):
-    if isinstance(batch, torch.Tensor):
-        batch.record_stream(torch.cuda.current_stream())
-    elif isinstance(batch, list) or isinstance(batch, tuple):
-        for t in batch:
-            record_cuda_stream(t)
-    elif isinstance(batch, dict):
-        for t in batch.values():
-            record_cuda_stream(t)
-    else:
-        pass
-
-
-class IterLoader:
-    """
-    A wrapper to convert DataLoader as an infinite iterator.
-
-    Modified from:
-        https://github.com/open-mmlab/mmcv/blob/master/mmcv/runner/iter_based_runner.py
-    """
-
-    def __init__(self, dataloader: DataLoader, use_distributed: bool = False):
-        self._dataloader = dataloader
-        self.iter_loader = iter(self._dataloader)
-        self._use_distributed = use_distributed
-        self._epoch = 0
-
-    @property
-    def epoch(self) -> int:
-        return self._epoch
-
-    def __next__(self):
-        try:
-            data = next(self.iter_loader)
-        except StopIteration:
-            self._epoch += 1
-            if hasattr(self._dataloader.sampler, "set_epoch") and self._use_distributed:
-                self._dataloader.sampler.set_epoch(self._epoch)
-            time.sleep(2)  # Prevent possible deadlock during epoch transition
-            self.iter_loader = iter(self._dataloader)
-            data = next(self.iter_loader)
-
-        return data
-
-    def __iter__(self):
-        return self
-
-    def __len__(self):
-        return len(self._dataloader)

spaces/Dao3/OpenArt/README.md

@@ -1,19 +0,0 @@
----
-title: OpenArt
-emoji: 🧘🏻‍♂️
-colorFrom: blue
-colorTo: yellow
-sdk: gradio
-sdk_version: 3.16.1
-app_file: app.py
-pinned: false
-duplicated_from: Dao3/DreamlikeArt-Diffusion-1.0
----
----
-title: DreamlikeArt-Diffusion .0
-emoji: 🧘🏻‍♂️
-colorFrom: blue
-colorTo: yellow
-sdk: gradio
-sdk_version: 3.16.1
-app_file: app.py

spaces/Dao3/openai-translator/app.py

@@ -1,255 +0,0 @@
-import os
-import openai
-import gradio as gr
-
-openai.api_key = os.environ['OPENAI_KEY']
-
-supportLanguages = [
-    ["auto", "自动识别"],
-    ["粤语", "粤语"],
-    ["古文", "文言文"],
-    ["af","Afrikaans"],
-    ["ak","Akan"],
-    ["sq","Albanian"],
-    ["am","Amharic"],
-    ["ar","Arabic"],
-    ["hy","Armenian"],
-    ["az","Azerbaijani"],
-    ["eu","Basque"],
-    ["be","Belarusian"],
-    ["bem","Bemba"],
-    ["bn","Bengali"],
-    ["bh","Bihari"],
-    ["xx-bork","Bork, bork, bork!"],
-    ["bs","Bosnian"],
-    ["br","Breton"],
-    ["bg","Bulgarian"],
-    ["km","Cambodian"],
-    ["ca","Catalan"],
-    ["chr","Cherokee"],
-    ["ny","Chichewa"],
-    ["zh-CN","中文（简体）"],
-    ["zh-TW","中文 (繁体)"],
-    ["co","Corsican"],
-    ["hr","Croatian"],
-    ["cs","Czech"],
-    ["da","Danish"],
-    ["nl","Dutch"],
-    ["xx-elmer","Elmer Fudd"],
-    ["en","English"],
-    ["eo","Esperanto"],
-    ["et","Estonian"],
-    ["ee","Ewe"],
-    ["fo","Faroese"],
-    ["tl","Filipino"],
-    ["fi","Finnish"],
-    ["fr","French"],
-    ["fy","Frisian"],
-    ["gaa","Ga"],
-    ["gl","Galician"],
-    ["ka","Georgian"],
-    ["de","German"],
-    ["el","Greek"],
-    ["gn","Guarani"],
-    ["gu","Gujarati"],
-    ["xx-hacker","Hacker"],
-    ["ht","Haitian Creole"],
-    ["ha","Hausa"],
-    ["haw","Hawaiian"],
-    ["iw","Hebrew"],
-    ["hi","Hindi"],
-    ["hu","Hungarian"],
-    ["is","Icelandic"],
-    ["ig","Igbo"],
-    ["id","Indonesian"],
-    ["ia","Interlingua"],
-    ["ga","Irish"],
-    ["it","Italian"],
-    ["ja","Japanese"],
-    ["jw","Javanese"],
-    ["kn","Kannada"],
-    ["kk","Kazakh"],
-    ["rw","Kinyarwanda"],
-    ["rn","Kirundi"],
-    ["xx-klingon","Klingon"],
-    ["kg","Kongo"],
-    ["ko","Korean"],
-    ["kri","Krio (Sierra Leone)"],
-    ["ku","Kurdish"],
-    ["ckb","Kurdish (Soranî)"],
-    ["ky","Kyrgyz"],
-    ["lo","Laothian"],
-    ["la","Latin"],
-    ["lv","Latvian"],
-    ["ln","Lingala"],
-    ["lt","Lithuanian"],
-    ["loz","Lozi"],
-    ["lg","Luganda"],
-    ["ach","Luo"],
-    ["mk","Macedonian"],
-    ["mg","Malagasy"],
-    ["ms","Malay"],
-    ["ml","Malayalam"],
-    ["mt","Maltese"],
-    ["mi","Maori"],
-    ["mr","Marathi"],
-    ["mfe","Mauritian Creole"],
-    ["mo","Moldavian"],
-    ["mn","Mongolian"],
-    ["sr-ME","Montenegrin"],
-    ["ne","Nepali"],
-    ["pcm","Nigerian Pidgin"],
-    ["nso","Northern Sotho"],
-    ["no","Norwegian"],
-    ["nn","Norwegian (Nynorsk)"],
-    ["oc","Occitan"],
-    ["or","Oriya"],
-    ["om","Oromo"],
-    ["ps","Pashto"],
-    ["fa","Persian"],
-    ["xx-pirate","Pirate"],
-    ["pl","Polish"],
-    ["pt-BR","Portuguese (Brazil)"],
-    ["pt-PT","Portuguese (Portugal)"],
-    ["pa","Punjabi"],
-    ["qu","Quechua"],
-    ["ro","Romanian"],
-    ["rm","Romansh"],
-    ["nyn","Runyakitara"],
-    ["ru","Russian"],
-    ["gd","Scots Gaelic"],
-    ["sr","Serbian"],
-    ["sh","Serbo-Croatian"],
-    ["st","Sesotho"],
-    ["tn","Setswana"],
-    ["crs","Seychellois Creole"],
-    ["sn","Shona"],
-    ["sd","Sindhi"],
-    ["si","Sinhalese"],
-    ["sk","Slovak"],
-    ["sl","Slovenian"],
-    ["so","Somali"],
-    ["es","Spanish"],
-    ["es-419","Spanish (Latin American)"],
-    ["su","Sundanese"],
-    ["sw","Swahili"],
-    ["sv","Swedish"],
-    ["tg","Tajik"],
-    ["ta","Tamil"],
-    ["tt","Tatar"],
-    ["te","Telugu"],
-    ["th","Thai"],
-    ["ti","Tigrinya"],
-    ["to","Tonga"],
-    ["lua","Tshiluba"],
-    ["tum","Tumbuka"],
-    ["tr","Turkish"],
-    ["tk","Turkmen"],
-    ["tw","Twi"],
-    ["ug","Uighur"],
-    ["uk","Ukrainian"],
-    ["ur","Urdu"],
-    ["uz","Uzbek"],
-    ["vi","Vietnamese"],
-    ["cy","Welsh"],
-    ["wo","Wolof"],
-    ["xh","Xhosa"],
-    ["yi","Yiddish"],
-    ["yo","Yoruba"],
-    ["zu","Zulu"],
-]
-prompt_template = "You are a translation engine that can only translate text and cannot interpret it. Keep the indent of the original text, only modify when you need."
-
-def submit_message(detectFrom, detectTo, user_token, prompt):
-    if user_token != "":
-        openai.api_key = user_token
-
-    if not prompt:
-        return gr.update(value="")
-    
-    for lc, lang in supportLanguages:
-        if detectFrom == lang:
-            detectFrom = lc
-        if detectTo == lang:
-            detectTo = lc
-
-    systemInstruct = prompt_template
-    translateInstruct = f"translate from {detectFrom} to {detectTo}"
-    if detectFrom == "auto":
-        translateInstruct = f"translate to {detectTo}"
-    if detectFrom in ["古文", "zh-CN", "zh-TW"]:
-        if detectTo == "zh-TW":
-            translateInstruct = "翻译成繁体白话文"
-        if detectTo == "zh-CN":
-            translateInstruct = "翻译成简体白话文"
-        if detectTo == "粤语":
-            translateInstruct = "翻译成粤语白话文"
-
-    if detectFrom == detectTo:
-        systemInstruct = "You are a text embellisher, you can only embellish the text, don't interpret it."
-        if detectTo in ["zh-CN", "zh-TW"]:
-            translateInstruct = "润色此句"
-        else:
-            translateInstruct = "polish this sentence"
-
-    prompt_msg = [
-        {"role": "system", "content": systemInstruct},
-        {"role": "user", "content": translateInstruct},
-        {"role": "user", "content": prompt},
-    ]
-
-    try:
-        openai_response = openai.ChatCompletion.create(
-            model="gpt-3.5-turbo",
-            messages=prompt_msg,
-            temperature=0,
-            max_tokens=1000,
-            top_p=1,
-            stream=True,
-            frequency_penalty=1,
-            presence_penalty=1,
-        )
-
-        combined = ""
-        for resp in openai_response:
-            delta = resp["choices"][0]["delta"]
-            if "content" in delta:
-                combined += delta["content"]
-            yield combined
-
-    except Exception as e:
-        return f"Error: {e}"
-
-css = """
-      #col-container {max-width: 80%; margin-left: auto; margin-right: auto;}
-      #chatbox {min-height: 400px;}
-      #header {text-align: center;}
-      #label {font-size: 0.8em; padding: 0.5em; margin: 0;}
-      .message { font-size: 1.2em; }
-      """
-
-with gr.Blocks(css=css) as demo:
-    
-    state = gr.State([])
-
-    with gr.Column(elem_id="col-container"):
-        gr.Markdown("""## 多语言翻译
-                    使用OpenAI官方 API (gpt-3.5-turbo model).""", elem_id="header")
-
-        with gr.Row():
-            with gr.Column():
-                translateFrom = gr.Dropdown(label="原文", elem_id="translate-from", multiselect=False, value="自动识别", choices=[l[1] for l in supportLanguages]).style(container=False)
-                input_message = gr.Textbox(max_lines=100, show_label=False, lines=10, placeholder="Enter text and press enter", visible=True).style(container=False)
-            with gr.Column():
-                translateTo = gr.Dropdown(label="译文", elem_id="translate-to", multiselect=False, value="中文 (简体)", choices=[l[1] for l in supportLanguages[1:]]).style(container=False)
-                output = gr.Textbox(max_lines=100, show_label=False, lines=10, label="Output", visible=True).style(container=False)
-            
-        btn_submit = gr.Button("急急如律令")
-
-        with gr.Row():
-            user_token = gr.Textbox(value='', placeholder="OpenAI API Key", type="password", label="输入你自己的OpenAI API Key翻译过程会更准确哦~.")
-
-    btn_submit.click(submit_message, [translateFrom, translateTo, user_token, input_message], [output])
-
-demo.queue(concurrency_count=10)
-demo.launch(height='800px')

spaces/DeclK/pose/tools/dtw.py

@@ -1,116 +0,0 @@
-import numpy as np
-from .utils import get_keypoint_weight
-
-
-class DTWForKeypoints:
-    def __init__(self, keypoints1, keypoints2):
-        self.keypoints1 = keypoints1
-        self.keypoints2 = keypoints2
-    
-    def get_dtw_path(self):
-
-        norm_kp1 = self.normalize_keypoints(self.keypoints1)
-        norm_kp2 = self.normalize_keypoints(self.keypoints2)
-
-        kp_weight = get_keypoint_weight()
-        oks, oks_unnorm = self.object_keypoint_similarity(norm_kp1,
-                               norm_kp2, keypoint_weights=kp_weight)
-        print(f"OKS max {oks.max():.2f} min {oks.min():.2f}")
-
-        # do the DTW, and return the path
-        cost_matrix = 1 - oks
-        dtw_dist, dtw_path = self.dynamic_time_warp(cost_matrix)
-
-        return dtw_path, oks, oks_unnorm
-        
-    def normalize_keypoints(self, keypoints):
-        centroid = keypoints.mean(axis=1)[:, None]
-        max_distance = np.max(np.sqrt(np.sum((keypoints - centroid) ** 2, axis=2)),
-                              axis=1) + 1e-6
-
-        normalized_keypoints = (keypoints - centroid) / max_distance[:, None, None]
-        return normalized_keypoints
-
-    def keypoints_areas(self, keypoints):
-        min_coords = np.min(keypoints, axis=1)
-        max_coords = np.max(keypoints, axis=1)
-        areas = np.prod(max_coords - min_coords, axis=1)
-        return areas
-
-    def object_keypoint_similarity(self, keypoints1,
-                                keypoints2,
-                                scale_constant=0.2,
-                                keypoint_weights=None):
-        """ Calculate the Object Keypoint Similarity (OKS) for multiple objects,
-        and add weight to each keypoint. Here we choose to normalize the points
-        using centroid and max distance instead of bounding box area.
-        """
-        # Compute squared distances between all pairs of keypoints
-        sq_diff = np.sum((keypoints1[:, None] - keypoints2) ** 2, axis=-1)
-        
-        oks = np.exp(-sq_diff / (2 * scale_constant ** 2))
-        oks_unnorm = oks.copy()
-        
-        if keypoint_weights is not None:
-            oks = oks * keypoint_weights
-            oks = np.sum(oks, axis=-1)
-        else:
-            oks = np.mean(oks, axis=-1)
-        
-        return oks, oks_unnorm
-
-    def dynamic_time_warp(self, cost_matrix, R=1000):
-        """Compute the Dynamic Time Warping distance and path between two time series.
-        If the time series is too long, it will use the Sakoe-Chiba Band constraint,
-        so time complexity is bounded at O(MR).
-        """
-        
-        M = len(self.keypoints1)
-        N = len(self.keypoints2)
-
-        # Initialize the distance matrix with infinity
-        D = np.full((M, N), np.inf)
-
-        # Initialize the first row and column of the matrix
-        D[0, 0] = cost_matrix[0, 0]
-        for i in range(1, M):
-            D[i, 0] = D[i - 1, 0] + cost_matrix[i, 0]
-
-        for j in range(1, N):
-            D[0, j] = D[0, j - 1] + cost_matrix[0, j]
-
-        # Fill the remaining elements of the matrix within the
-        # Sakoe-Chiba Band using dynamic programming
-        for i in range(1, M):
-            for j in range(max(1, i - R), min(N, i + R + 1)):
-                cost = cost_matrix[i, j]
-                D[i, j] = cost + min(D[i - 1, j], D[i, j - 1], D[i - 1, j - 1])
-
-        # Backtrack to find the optimal path
-        path = [(M - 1, N - 1)]
-        i, j = M - 1, N - 1
-        while i > 0 or j > 0:
-            min_idx = np.argmin([D[i - 1, j], D[i, j - 1], D[i - 1, j - 1]])
-            if min_idx == 0:
-                i -= 1
-            elif min_idx == 1:
-                j -= 1
-            else:
-                i -= 1
-                j -= 1
-            path.append((i, j))
-        path.reverse()
-
-        return D[-1, -1], path
-
-if __name__ == '__main__':
-
-    from mmengine.fileio import load
-
-    keypoints1, kp1_scores = load('tennis1.pkl')
-    keypoints2, kp2_scores = load('tennis3.pkl')
-
-    # Normalize the keypoints
-    dtw = DTWForKeypoints(keypoints1, keypoints2)
-    path = dtw.get_dtw_path()
-    print(path)

spaces/Demi2809/rvc-models/infer_pack/models_onnx.py

@@ -1,849 +0,0 @@
-import math, pdb, os
-from time import time as ttime
-import torch
-from torch import nn
-from torch.nn import functional as F
-from infer_pack import modules
-from infer_pack import attentions
-from infer_pack import commons
-from infer_pack.commons import init_weights, get_padding
-from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
-from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
-from infer_pack.commons import init_weights
-import numpy as np
-from infer_pack import commons
-
-
-class TextEncoder256(nn.Module):
-    def __init__(
-        self,
-        out_channels,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout,
-        f0=True,
-    ):
-        super().__init__()
-        self.out_channels = out_channels
-        self.hidden_channels = hidden_channels
-        self.filter_channels = filter_channels
-        self.n_heads = n_heads
-        self.n_layers = n_layers
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.emb_phone = nn.Linear(256, hidden_channels)
-        self.lrelu = nn.LeakyReLU(0.1, inplace=True)
-        if f0 == True:
-            self.emb_pitch = nn.Embedding(256, hidden_channels)  # pitch 256
-        self.encoder = attentions.Encoder(
-            hidden_channels, filter_channels, n_heads, n_layers, kernel_size, p_dropout
-        )
-        self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
-    def forward(self, phone, pitch, lengths):
-        if pitch == None:
-            x = self.emb_phone(phone)
-        else:
-            x = self.emb_phone(phone) + self.emb_pitch(pitch)
-        x = x * math.sqrt(self.hidden_channels)  # [b, t, h]
-        x = self.lrelu(x)
-        x = torch.transpose(x, 1, -1)  # [b, h, t]
-        x_mask = torch.unsqueeze(commons.sequence_mask(lengths, x.size(2)), 1).to(
-            x.dtype
-        )
-        x = self.encoder(x * x_mask, x_mask)
-        stats = self.proj(x) * x_mask
-
-        m, logs = torch.split(stats, self.out_channels, dim=1)
-        return m, logs, x_mask
-
-
-class TextEncoder256Sim(nn.Module):
-    def __init__(
-        self,
-        out_channels,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout,
-        f0=True,
-    ):
-        super().__init__()
-        self.out_channels = out_channels
-        self.hidden_channels = hidden_channels
-        self.filter_channels = filter_channels
-        self.n_heads = n_heads
-        self.n_layers = n_layers
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.emb_phone = nn.Linear(256, hidden_channels)
-        self.lrelu = nn.LeakyReLU(0.1, inplace=True)
-        if f0 == True:
-            self.emb_pitch = nn.Embedding(256, hidden_channels)  # pitch 256
-        self.encoder = attentions.Encoder(
-            hidden_channels, filter_channels, n_heads, n_layers, kernel_size, p_dropout
-        )
-        self.proj = nn.Conv1d(hidden_channels, out_channels, 1)
-
-    def forward(self, phone, pitch, lengths):
-        if pitch == None:
-            x = self.emb_phone(phone)
-        else:
-            x = self.emb_phone(phone) + self.emb_pitch(pitch)
-        x = x * math.sqrt(self.hidden_channels)  # [b, t, h]
-        x = self.lrelu(x)
-        x = torch.transpose(x, 1, -1)  # [b, h, t]
-        x_mask = torch.unsqueeze(commons.sequence_mask(lengths, x.size(2)), 1).to(
-            x.dtype
-        )
-        x = self.encoder(x * x_mask, x_mask)
-        x = self.proj(x) * x_mask
-        return x, x_mask
-
-
-class ResidualCouplingBlock(nn.Module):
-    def __init__(
-        self,
-        channels,
-        hidden_channels,
-        kernel_size,
-        dilation_rate,
-        n_layers,
-        n_flows=4,
-        gin_channels=0,
-    ):
-        super().__init__()
-        self.channels = channels
-        self.hidden_channels = hidden_channels
-        self.kernel_size = kernel_size
-        self.dilation_rate = dilation_rate
-        self.n_layers = n_layers
-        self.n_flows = n_flows
-        self.gin_channels = gin_channels
-
-        self.flows = nn.ModuleList()
-        for i in range(n_flows):
-            self.flows.append(
-                modules.ResidualCouplingLayer(
-                    channels,
-                    hidden_channels,
-                    kernel_size,
-                    dilation_rate,
-                    n_layers,
-                    gin_channels=gin_channels,
-                    mean_only=True,
-                )
-            )
-            self.flows.append(modules.Flip())
-
-    def forward(self, x, x_mask, g=None, reverse=False):
-        if not reverse:
-            for flow in self.flows:
-                x, _ = flow(x, x_mask, g=g, reverse=reverse)
-        else:
-            for flow in reversed(self.flows):
-                x = flow(x, x_mask, g=g, reverse=reverse)
-        return x
-
-    def remove_weight_norm(self):
-        for i in range(self.n_flows):
-            self.flows[i * 2].remove_weight_norm()
-
-
-class PosteriorEncoder(nn.Module):
-    def __init__(
-        self,
-        in_channels,
-        out_channels,
-        hidden_channels,
-        kernel_size,
-        dilation_rate,
-        n_layers,
-        gin_channels=0,
-    ):
-        super().__init__()
-        self.in_channels = in_channels
-        self.out_channels = out_channels
-        self.hidden_channels = hidden_channels
-        self.kernel_size = kernel_size
-        self.dilation_rate = dilation_rate
-        self.n_layers = n_layers
-        self.gin_channels = gin_channels
-
-        self.pre = nn.Conv1d(in_channels, hidden_channels, 1)
-        self.enc = modules.WN(
-            hidden_channels,
-            kernel_size,
-            dilation_rate,
-            n_layers,
-            gin_channels=gin_channels,
-        )
-        self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
-    def forward(self, x, x_lengths, g=None):
-        x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(
-            x.dtype
-        )
-        x = self.pre(x) * x_mask
-        x = self.enc(x, x_mask, g=g)
-        stats = self.proj(x) * x_mask
-        m, logs = torch.split(stats, self.out_channels, dim=1)
-        z = (m + torch.randn_like(m) * torch.exp(logs)) * x_mask
-        return z, m, logs, x_mask
-
-    def remove_weight_norm(self):
-        self.enc.remove_weight_norm()
-
-
-class Generator(torch.nn.Module):
-    def __init__(
-        self,
-        initial_channel,
-        resblock,
-        resblock_kernel_sizes,
-        resblock_dilation_sizes,
-        upsample_rates,
-        upsample_initial_channel,
-        upsample_kernel_sizes,
-        gin_channels=0,
-    ):
-        super(Generator, self).__init__()
-        self.num_kernels = len(resblock_kernel_sizes)
-        self.num_upsamples = len(upsample_rates)
-        self.conv_pre = Conv1d(
-            initial_channel, upsample_initial_channel, 7, 1, padding=3
-        )
-        resblock = modules.ResBlock1 if resblock == "1" else modules.ResBlock2
-
-        self.ups = nn.ModuleList()
-        for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
-            self.ups.append(
-                weight_norm(
-                    ConvTranspose1d(
-                        upsample_initial_channel // (2**i),
-                        upsample_initial_channel // (2 ** (i + 1)),
-                        k,
-                        u,
-                        padding=(k - u) // 2,
-                    )
-                )
-            )
-
-        self.resblocks = nn.ModuleList()
-        for i in range(len(self.ups)):
-            ch = upsample_initial_channel // (2 ** (i + 1))
-            for j, (k, d) in enumerate(
-                zip(resblock_kernel_sizes, resblock_dilation_sizes)
-            ):
-                self.resblocks.append(resblock(ch, k, d))
-
-        self.conv_post = Conv1d(ch, 1, 7, 1, padding=3, bias=False)
-        self.ups.apply(init_weights)
-
-        if gin_channels != 0:
-            self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1)
-
-    def forward(self, x, g=None):
-        x = self.conv_pre(x)
-        if g is not None:
-            x = x + self.cond(g)
-
-        for i in range(self.num_upsamples):
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            x = self.ups[i](x)
-            xs = None
-            for j in range(self.num_kernels):
-                if xs is None:
-                    xs = self.resblocks[i * self.num_kernels + j](x)
-                else:
-                    xs += self.resblocks[i * self.num_kernels + j](x)
-            x = xs / self.num_kernels
-        x = F.leaky_relu(x)
-        x = self.conv_post(x)
-        x = torch.tanh(x)
-
-        return x
-
-    def remove_weight_norm(self):
-        for l in self.ups:
-            remove_weight_norm(l)
-        for l in self.resblocks:
-            l.remove_weight_norm()
-
-
-class SineGen(torch.nn.Module):
-    """Definition of sine generator
-    SineGen(samp_rate, harmonic_num = 0,
-            sine_amp = 0.1, noise_std = 0.003,
-            voiced_threshold = 0,
-            flag_for_pulse=False)
-    samp_rate: sampling rate in Hz
-    harmonic_num: number of harmonic overtones (default 0)
-    sine_amp: amplitude of sine-wavefrom (default 0.1)
-    noise_std: std of Gaussian noise (default 0.003)
-    voiced_thoreshold: F0 threshold for U/V classification (default 0)
-    flag_for_pulse: this SinGen is used inside PulseGen (default False)
-    Note: when flag_for_pulse is True, the first time step of a voiced
-        segment is always sin(np.pi) or cos(0)
-    """
-
-    def __init__(
-        self,
-        samp_rate,
-        harmonic_num=0,
-        sine_amp=0.1,
-        noise_std=0.003,
-        voiced_threshold=0,
-        flag_for_pulse=False,
-    ):
-        super(SineGen, self).__init__()
-        self.sine_amp = sine_amp
-        self.noise_std = noise_std
-        self.harmonic_num = harmonic_num
-        self.dim = self.harmonic_num + 1
-        self.sampling_rate = samp_rate
-        self.voiced_threshold = voiced_threshold
-
-    def _f02uv(self, f0):
-        # generate uv signal
-        uv = torch.ones_like(f0)
-        uv = uv * (f0 > self.voiced_threshold)
-        return uv
-
-    def forward(self, f0, upp):
-        """sine_tensor, uv = forward(f0)
-        input F0: tensor(batchsize=1, length, dim=1)
-                  f0 for unvoiced steps should be 0
-        output sine_tensor: tensor(batchsize=1, length, dim)
-        output uv: tensor(batchsize=1, length, 1)
-        """
-        with torch.no_grad():
-            f0 = f0[:, None].transpose(1, 2)
-            f0_buf = torch.zeros(f0.shape[0], f0.shape[1], self.dim, device=f0.device)
-            # fundamental component
-            f0_buf[:, :, 0] = f0[:, :, 0]
-            for idx in np.arange(self.harmonic_num):
-                f0_buf[:, :, idx + 1] = f0_buf[:, :, 0] * (
-                    idx + 2
-                )  # idx + 2: the (idx+1)-th overtone, (idx+2)-th harmonic
-            rad_values = (f0_buf / self.sampling_rate) % 1  ###%1意味着n_har的乘积无法后处理优化
-            rand_ini = torch.rand(
-                f0_buf.shape[0], f0_buf.shape[2], device=f0_buf.device
-            )
-            rand_ini[:, 0] = 0
-            rad_values[:, 0, :] = rad_values[:, 0, :] + rand_ini
-            tmp_over_one = torch.cumsum(rad_values, 1)  # % 1  #####%1意味着后面的cumsum无法再优化
-            tmp_over_one *= upp
-            tmp_over_one = F.interpolate(
-                tmp_over_one.transpose(2, 1),
-                scale_factor=upp,
-                mode="linear",
-                align_corners=True,
-            ).transpose(2, 1)
-            rad_values = F.interpolate(
-                rad_values.transpose(2, 1), scale_factor=upp, mode="nearest"
-            ).transpose(
-                2, 1
-            )  #######
-            tmp_over_one %= 1
-            tmp_over_one_idx = (tmp_over_one[:, 1:, :] - tmp_over_one[:, :-1, :]) < 0
-            cumsum_shift = torch.zeros_like(rad_values)
-            cumsum_shift[:, 1:, :] = tmp_over_one_idx * -1.0
-            sine_waves = torch.sin(
-                torch.cumsum(rad_values + cumsum_shift, dim=1) * 2 * np.pi
-            )
-            sine_waves = sine_waves * self.sine_amp
-            uv = self._f02uv(f0)
-            uv = F.interpolate(
-                uv.transpose(2, 1), scale_factor=upp, mode="nearest"
-            ).transpose(2, 1)
-            noise_amp = uv * self.noise_std + (1 - uv) * self.sine_amp / 3
-            noise = noise_amp * torch.randn_like(sine_waves)
-            sine_waves = sine_waves * uv + noise
-        return sine_waves, uv, noise
-
-
-class SourceModuleHnNSF(torch.nn.Module):
-    """SourceModule for hn-nsf
-    SourceModule(sampling_rate, harmonic_num=0, sine_amp=0.1,
-                 add_noise_std=0.003, voiced_threshod=0)
-    sampling_rate: sampling_rate in Hz
-    harmonic_num: number of harmonic above F0 (default: 0)
-    sine_amp: amplitude of sine source signal (default: 0.1)
-    add_noise_std: std of additive Gaussian noise (default: 0.003)
-        note that amplitude of noise in unvoiced is decided
-        by sine_amp
-    voiced_threshold: threhold to set U/V given F0 (default: 0)
-    Sine_source, noise_source = SourceModuleHnNSF(F0_sampled)
-    F0_sampled (batchsize, length, 1)
-    Sine_source (batchsize, length, 1)
-    noise_source (batchsize, length 1)
-    uv (batchsize, length, 1)
-    """
-
-    def __init__(
-        self,
-        sampling_rate,
-        harmonic_num=0,
-        sine_amp=0.1,
-        add_noise_std=0.003,
-        voiced_threshod=0,
-        is_half=True,
-    ):
-        super(SourceModuleHnNSF, self).__init__()
-
-        self.sine_amp = sine_amp
-        self.noise_std = add_noise_std
-        self.is_half = is_half
-        # to produce sine waveforms
-        self.l_sin_gen = SineGen(
-            sampling_rate, harmonic_num, sine_amp, add_noise_std, voiced_threshod
-        )
-
-        # to merge source harmonics into a single excitation
-        self.l_linear = torch.nn.Linear(harmonic_num + 1, 1)
-        self.l_tanh = torch.nn.Tanh()
-
-    def forward(self, x, upp=None):
-        sine_wavs, uv, _ = self.l_sin_gen(x, upp)
-        if self.is_half:
-            sine_wavs = sine_wavs.half()
-        sine_merge = self.l_tanh(self.l_linear(sine_wavs))
-        return sine_merge, None, None  # noise, uv
-
-
-class GeneratorNSF(torch.nn.Module):
-    def __init__(
-        self,
-        initial_channel,
-        resblock,
-        resblock_kernel_sizes,
-        resblock_dilation_sizes,
-        upsample_rates,
-        upsample_initial_channel,
-        upsample_kernel_sizes,
-        gin_channels,
-        sr,
-        is_half=False,
-    ):
-        super(GeneratorNSF, self).__init__()
-        self.num_kernels = len(resblock_kernel_sizes)
-        self.num_upsamples = len(upsample_rates)
-
-        self.f0_upsamp = torch.nn.Upsample(scale_factor=np.prod(upsample_rates))
-        self.m_source = SourceModuleHnNSF(
-            sampling_rate=sr, harmonic_num=0, is_half=is_half
-        )
-        self.noise_convs = nn.ModuleList()
-        self.conv_pre = Conv1d(
-            initial_channel, upsample_initial_channel, 7, 1, padding=3
-        )
-        resblock = modules.ResBlock1 if resblock == "1" else modules.ResBlock2
-
-        self.ups = nn.ModuleList()
-        for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
-            c_cur = upsample_initial_channel // (2 ** (i + 1))
-            self.ups.append(
-                weight_norm(
-                    ConvTranspose1d(
-                        upsample_initial_channel // (2**i),
-                        upsample_initial_channel // (2 ** (i + 1)),
-                        k,
-                        u,
-                        padding=(k - u) // 2,
-                    )
-                )
-            )
-            if i + 1 < len(upsample_rates):
-                stride_f0 = np.prod(upsample_rates[i + 1 :])
-                self.noise_convs.append(
-                    Conv1d(
-                        1,
-                        c_cur,
-                        kernel_size=stride_f0 * 2,
-                        stride=stride_f0,
-                        padding=stride_f0 // 2,
-                    )
-                )
-            else:
-                self.noise_convs.append(Conv1d(1, c_cur, kernel_size=1))
-
-        self.resblocks = nn.ModuleList()
-        for i in range(len(self.ups)):
-            ch = upsample_initial_channel // (2 ** (i + 1))
-            for j, (k, d) in enumerate(
-                zip(resblock_kernel_sizes, resblock_dilation_sizes)
-            ):
-                self.resblocks.append(resblock(ch, k, d))
-
-        self.conv_post = Conv1d(ch, 1, 7, 1, padding=3, bias=False)
-        self.ups.apply(init_weights)
-
-        if gin_channels != 0:
-            self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1)
-
-        self.upp = np.prod(upsample_rates)
-
-    def forward(self, x, f0, g=None):
-        har_source, noi_source, uv = self.m_source(f0, self.upp)
-        har_source = har_source.transpose(1, 2)
-        x = self.conv_pre(x)
-        if g is not None:
-            x = x + self.cond(g)
-
-        for i in range(self.num_upsamples):
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            x = self.ups[i](x)
-            x_source = self.noise_convs[i](har_source)
-            x = x + x_source
-            xs = None
-            for j in range(self.num_kernels):
-                if xs is None:
-                    xs = self.resblocks[i * self.num_kernels + j](x)
-                else:
-                    xs += self.resblocks[i * self.num_kernels + j](x)
-            x = xs / self.num_kernels
-        x = F.leaky_relu(x)
-        x = self.conv_post(x)
-        x = torch.tanh(x)
-        return x
-
-    def remove_weight_norm(self):
-        for l in self.ups:
-            remove_weight_norm(l)
-        for l in self.resblocks:
-            l.remove_weight_norm()
-
-
-sr2sr = {
-    "32k": 32000,
-    "40k": 40000,
-    "48k": 48000,
-}
-
-
-class SynthesizerTrnMs256NSFsid(nn.Module):
-    def __init__(
-        self,
-        spec_channels,
-        segment_size,
-        inter_channels,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout,
-        resblock,
-        resblock_kernel_sizes,
-        resblock_dilation_sizes,
-        upsample_rates,
-        upsample_initial_channel,
-        upsample_kernel_sizes,
-        spk_embed_dim,
-        gin_channels,
-        sr,
-        **kwargs
-    ):
-        super().__init__()
-        if type(sr) == type("strr"):
-            sr = sr2sr[sr]
-        self.spec_channels = spec_channels
-        self.inter_channels = inter_channels
-        self.hidden_channels = hidden_channels
-        self.filter_channels = filter_channels
-        self.n_heads = n_heads
-        self.n_layers = n_layers
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.resblock = resblock
-        self.resblock_kernel_sizes = resblock_kernel_sizes
-        self.resblock_dilation_sizes = resblock_dilation_sizes
-        self.upsample_rates = upsample_rates
-        self.upsample_initial_channel = upsample_initial_channel
-        self.upsample_kernel_sizes = upsample_kernel_sizes
-        self.segment_size = segment_size
-        self.gin_channels = gin_channels
-        # self.hop_length = hop_length#
-        self.spk_embed_dim = spk_embed_dim
-        self.enc_p = TextEncoder256(
-            inter_channels,
-            hidden_channels,
-            filter_channels,
-            n_heads,
-            n_layers,
-            kernel_size,
-            p_dropout,
-        )
-        self.dec = GeneratorNSF(
-            inter_channels,
-            resblock,
-            resblock_kernel_sizes,
-            resblock_dilation_sizes,
-            upsample_rates,
-            upsample_initial_channel,
-            upsample_kernel_sizes,
-            gin_channels=gin_channels,
-            sr=sr,
-            is_half=kwargs["is_half"],
-        )
-        self.enc_q = PosteriorEncoder(
-            spec_channels,
-            inter_channels,
-            hidden_channels,
-            5,
-            1,
-            16,
-            gin_channels=gin_channels,
-        )
-        self.flow = ResidualCouplingBlock(
-            inter_channels, hidden_channels, 5, 1, 3, gin_channels=gin_channels
-        )
-        self.emb_g = nn.Embedding(self.spk_embed_dim, gin_channels)
-        print("gin_channels:", gin_channels, "self.spk_embed_dim:", self.spk_embed_dim)
-
-    def remove_weight_norm(self):
-        self.dec.remove_weight_norm()
-        self.flow.remove_weight_norm()
-        self.enc_q.remove_weight_norm()
-
-    def forward(self, phone, phone_lengths, pitch, nsff0, sid, rnd, max_len=None):
-        g = self.emb_g(sid).unsqueeze(-1)
-        m_p, logs_p, x_mask = self.enc_p(phone, pitch, phone_lengths)
-        z_p = (m_p + torch.exp(logs_p) * rnd) * x_mask
-        z = self.flow(z_p, x_mask, g=g, reverse=True)
-        o = self.dec((z * x_mask)[:, :, :max_len], nsff0, g=g)
-        return o
-
-
-class SynthesizerTrnMs256NSFsid_sim(nn.Module):
-    """
-    Synthesizer for Training
-    """
-
-    def __init__(
-        self,
-        spec_channels,
-        segment_size,
-        inter_channels,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout,
-        resblock,
-        resblock_kernel_sizes,
-        resblock_dilation_sizes,
-        upsample_rates,
-        upsample_initial_channel,
-        upsample_kernel_sizes,
-        spk_embed_dim,
-        # hop_length,
-        gin_channels=0,
-        use_sdp=True,
-        **kwargs
-    ):
-        super().__init__()
-        self.spec_channels = spec_channels
-        self.inter_channels = inter_channels
-        self.hidden_channels = hidden_channels
-        self.filter_channels = filter_channels
-        self.n_heads = n_heads
-        self.n_layers = n_layers
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.resblock = resblock
-        self.resblock_kernel_sizes = resblock_kernel_sizes
-        self.resblock_dilation_sizes = resblock_dilation_sizes
-        self.upsample_rates = upsample_rates
-        self.upsample_initial_channel = upsample_initial_channel
-        self.upsample_kernel_sizes = upsample_kernel_sizes
-        self.segment_size = segment_size
-        self.gin_channels = gin_channels
-        # self.hop_length = hop_length#
-        self.spk_embed_dim = spk_embed_dim
-        self.enc_p = TextEncoder256Sim(
-            inter_channels,
-            hidden_channels,
-            filter_channels,
-            n_heads,
-            n_layers,
-            kernel_size,
-            p_dropout,
-        )
-        self.dec = GeneratorNSF(
-            inter_channels,
-            resblock,
-            resblock_kernel_sizes,
-            resblock_dilation_sizes,
-            upsample_rates,
-            upsample_initial_channel,
-            upsample_kernel_sizes,
-            gin_channels=gin_channels,
-            is_half=kwargs["is_half"],
-        )
-
-        self.flow = ResidualCouplingBlock(
-            inter_channels, hidden_channels, 5, 1, 3, gin_channels=gin_channels
-        )
-        self.emb_g = nn.Embedding(self.spk_embed_dim, gin_channels)
-        print("gin_channels:", gin_channels, "self.spk_embed_dim:", self.spk_embed_dim)
-
-    def remove_weight_norm(self):
-        self.dec.remove_weight_norm()
-        self.flow.remove_weight_norm()
-        self.enc_q.remove_weight_norm()
-
-    def forward(
-        self, phone, phone_lengths, pitch, pitchf, ds, max_len=None
-    ):  # y是spec不需要了现在
-        g = self.emb_g(ds.unsqueeze(0)).unsqueeze(-1)  # [b, 256, 1]##1是t，广播的
-        x, x_mask = self.enc_p(phone, pitch, phone_lengths)
-        x = self.flow(x, x_mask, g=g, reverse=True)
-        o = self.dec((x * x_mask)[:, :, :max_len], pitchf, g=g)
-        return o
-
-
-class MultiPeriodDiscriminator(torch.nn.Module):
-    def __init__(self, use_spectral_norm=False):
-        super(MultiPeriodDiscriminator, self).__init__()
-        periods = [2, 3, 5, 7, 11, 17]
-        # periods = [3, 5, 7, 11, 17, 23, 37]
-
-        discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
-        discs = discs + [
-            DiscriminatorP(i, use_spectral_norm=use_spectral_norm) for i in periods
-        ]
-        self.discriminators = nn.ModuleList(discs)
-
-    def forward(self, y, y_hat):
-        y_d_rs = []  #
-        y_d_gs = []
-        fmap_rs = []
-        fmap_gs = []
-        for i, d in enumerate(self.discriminators):
-            y_d_r, fmap_r = d(y)
-            y_d_g, fmap_g = d(y_hat)
-            # for j in range(len(fmap_r)):
-            #     print(i,j,y.shape,y_hat.shape,fmap_r[j].shape,fmap_g[j].shape)
-            y_d_rs.append(y_d_r)
-            y_d_gs.append(y_d_g)
-            fmap_rs.append(fmap_r)
-            fmap_gs.append(fmap_g)
-
-        return y_d_rs, y_d_gs, fmap_rs, fmap_gs
-
-
-class DiscriminatorS(torch.nn.Module):
-    def __init__(self, use_spectral_norm=False):
-        super(DiscriminatorS, self).__init__()
-        norm_f = weight_norm if use_spectral_norm == False else spectral_norm
-        self.convs = nn.ModuleList(
-            [
-                norm_f(Conv1d(1, 16, 15, 1, padding=7)),
-                norm_f(Conv1d(16, 64, 41, 4, groups=4, padding=20)),
-                norm_f(Conv1d(64, 256, 41, 4, groups=16, padding=20)),
-                norm_f(Conv1d(256, 1024, 41, 4, groups=64, padding=20)),
-                norm_f(Conv1d(1024, 1024, 41, 4, groups=256, padding=20)),
-                norm_f(Conv1d(1024, 1024, 5, 1, padding=2)),
-            ]
-        )
-        self.conv_post = norm_f(Conv1d(1024, 1, 3, 1, padding=1))
-
-    def forward(self, x):
-        fmap = []
-
-        for l in self.convs:
-            x = l(x)
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            fmap.append(x)
-        x = self.conv_post(x)
-        fmap.append(x)
-        x = torch.flatten(x, 1, -1)
-
-        return x, fmap
-
-
-class DiscriminatorP(torch.nn.Module):
-    def __init__(self, period, kernel_size=5, stride=3, use_spectral_norm=False):
-        super(DiscriminatorP, self).__init__()
-        self.period = period
-        self.use_spectral_norm = use_spectral_norm
-        norm_f = weight_norm if use_spectral_norm == False else spectral_norm
-        self.convs = nn.ModuleList(
-            [
-                norm_f(
-                    Conv2d(
-                        1,
-                        32,
-                        (kernel_size, 1),
-                        (stride, 1),
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-                norm_f(
-                    Conv2d(
-                        32,
-                        128,
-                        (kernel_size, 1),
-                        (stride, 1),
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-                norm_f(
-                    Conv2d(
-                        128,
-                        512,
-                        (kernel_size, 1),
-                        (stride, 1),
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-                norm_f(
-                    Conv2d(
-                        512,
-                        1024,
-                        (kernel_size, 1),
-                        (stride, 1),
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-                norm_f(
-                    Conv2d(
-                        1024,
-                        1024,
-                        (kernel_size, 1),
-                        1,
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-            ]
-        )
-        self.conv_post = norm_f(Conv2d(1024, 1, (3, 1), 1, padding=(1, 0)))
-
-    def forward(self, x):
-        fmap = []
-
-        # 1d to 2d
-        b, c, t = x.shape
-        if t % self.period != 0:  # pad first
-            n_pad = self.period - (t % self.period)
-            x = F.pad(x, (0, n_pad), "reflect")
-            t = t + n_pad
-        x = x.view(b, c, t // self.period, self.period)
-
-        for l in self.convs:
-            x = l(x)
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            fmap.append(x)
-        x = self.conv_post(x)
-        fmap.append(x)
-        x = torch.flatten(x, 1, -1)
-
-        return x, fmap

spaces/Detomo/ai-comic-generation/src/lib/computeSha256.ts

@@ -1,14 +0,0 @@
-import { createHash } from 'node:crypto'
-
-/**
- * Returns a SHA256 hash using SHA-3 for the given `content`.
- *
- * @see https://en.wikipedia.org/wiki/SHA-3
- *
- * @param {String} content
- *
- * @returns {String}
- */
-export function computeSha256(strContent: string) {
-  return createHash('sha3-256').update(strContent).digest('hex')
-}

spaces/DonaSmix/anime-remove-background/README.md

@@ -1,14 +0,0 @@
----
-title: Anime Remove Background
-emoji: 🪄🖼️
-colorFrom: indigo
-colorTo: pink
-sdk: gradio
-sdk_version: 3.1.4
-app_file: app.py
-pinned: false
-license: apache-2.0
-duplicated_from: skytnt/anime-remove-background
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/EDGAhab/Aatrox-Talking/app.py

@@ -1,98 +0,0 @@
-import gradio as gr
-import os
-os.system('cd monotonic_align && python setup.py build_ext --inplace && cd ..')
-import torch
-
-import commons
-import utils
-from models import SynthesizerTrn
-from text.symbols import symbols
-from text import text_to_sequence
-
-import IPython.display as ipd
-
-import json
-import math
-
-#new imports
-import matplotlib.pyplot as plt
-import re
-
-from torch import nn
-from torch.nn import functional as F
-from torch.utils.data import DataLoader
-
-from models import SynthesizerTrn
-import unicodedata
-import openai
-
-def get_text(text, hps):
-    text_norm = text_to_sequence(text, hps.data.text_cleaners)
-    if hps.data.add_blank:
-        text_norm = commons.intersperse(text_norm, 0)
-    text_norm = torch.LongTensor(text_norm)
-    return text_norm
-
-hps = utils.get_hparams_from_file("configs/biaobei_base.json")
-
-net_g = SynthesizerTrn(
-    len(symbols),
-    hps.data.filter_length // 2 + 1,
-    hps.train.segment_size // hps.data.hop_length,
-    **hps.model)
-_ = net_g.eval()
-
-_ = utils.load_checkpoint("G_aatrox.pth", net_g, None) 
-
-def friend_chat(text, tts_input3):
-  call_name = "亚托克斯"
-  openai.api_key = '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'
-  identity = tts_input3
-  start_sequence = '\n'+str(call_name)+':'
-  restart_sequence = "\nYou: "
-  all_text = identity + restart_sequence
-  if 1 == 1:
-     prompt0 = text #当期prompt
-  if text == 'quit':
-     return prompt0
-  prompt = identity + prompt0 + start_sequence
-
-  response = openai.Completion.create(
-    model="text-davinci-003",
-    prompt=prompt,
-    temperature=0.5,
-    max_tokens=1000,
-    top_p=1.0,
-    frequency_penalty=0.5,
-    presence_penalty=0.0,
-    stop=["\nYou:"]
-  )
-  print(response)
-  return response['choices'][0]['text'].strip()
-
-def sle(text, tts_input3):
-    text = friend_chat(text, tts_input3).replace('\n','。').replace(' ',',')
-    return text
-
-def infer(text,tts_input3):
-    stn_tst = get_text(sle(text,tts_input3), hps)
-    with torch.no_grad():
-        x_tst = stn_tst.unsqueeze(0)
-        x_tst_lengths = torch.LongTensor([stn_tst.size(0)])
-        audio = net_g.infer(x_tst, x_tst_lengths, noise_scale=.667, noise_scale_w=0.8, length_scale=1)[0][0,0].data.cpu().float().numpy()
-    sampling_rate = 22050
-    return (sampling_rate, audio)
-        
-app = gr.Blocks()
-
-with app:
-    with gr.Tabs():
-
-        with gr.TabItem("Basic"):
-
-            tts_input1 = gr.TextArea(label="输入你想跟剑魔说的话", value="我是暮光星灵佐伊，我要三天之内杀了你")
-            tts_input3 = gr.TextArea(label="写上你给他的设定", value="你叫亚托克斯，俗称剑魔，世界的终结者。")
-            tts_submit = gr.Button("Generate", variant="primary")
-            tts_output2 = gr.Audio(label="Output")
-            tts_submit.click(infer, [tts_input1,tts_input3], [tts_output2])
-    app.launch()

spaces/Eddycrack864/Applio-Inference/Applio-RVC-Fork/utils/clonerepo_experimental.py

@@ -1,253 +0,0 @@
-import os
-import subprocess
-import shutil
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from tqdm.notebook import tqdm
-from pathlib import Path
-import requests
-
-def run_script():
-    def run_cmd(cmd):
-        process = subprocess.run(cmd, shell=True, check=True, text=True)
-        return process.stdout
-
-    # Change the current directory to /content/
-    os.chdir('/content/')
-    print("Changing dir to /content/")
-
-    # Your function to edit the file
-    def edit_file(file_path):
-        temp_file_path = "/tmp/temp_file.py"
-        changes_made = False
-        with open(file_path, "r") as file, open(temp_file_path, "w") as temp_file:
-            previous_line = ""
-            second_previous_line = ""
-            for line in file:
-                new_line = line.replace("value=160", "value=128")
-                if new_line != line:
-                    print("Replaced 'value=160' with 'value=128'")
-                    changes_made = True
-                line = new_line
-
-                new_line = line.replace("crepe hop length: 160", "crepe hop length: 128")
-                if new_line != line:
-                    print("Replaced 'crepe hop length: 160' with 'crepe hop length: 128'")
-                    changes_made = True
-                line = new_line
-
-                new_line = line.replace("value=0.88", "value=0.75")
-                if new_line != line:
-                    print("Replaced 'value=0.88' with 'value=0.75'")
-                    changes_made = True
-                line = new_line
-
-                if "label=i18n(\"输入源音量包络替换输出音量包络融合比例，越靠近1越使用输出包络\")" in previous_line and "value=1," in line:
-                    new_line = line.replace("value=1,", "value=0.25,")
-                    if new_line != line:
-                        print("Replaced 'value=1,' with 'value=0.25,' based on the condition")
-                        changes_made = True
-                    line = new_line
-
-                if "label=i18n(\"总训练轮数total_epoch\")" in previous_line and "value=20," in line:
-                    new_line = line.replace("value=20,", "value=500,")
-                    if new_line != line:
-                        print("Replaced 'value=20,' with 'value=500,' based on the condition for DEFAULT EPOCH")
-                        changes_made = True
-                    line = new_line
-
-                if 'choices=["pm", "harvest", "dio", "crepe", "crepe-tiny", "mangio-crepe", "mangio-crepe-tiny"], # Fork Feature. Add Crepe-Tiny' in previous_line:
-                    if 'value="pm",' in line:
-                        new_line = line.replace('value="pm",', 'value="mangio-crepe",')
-                        if new_line != line:
-                            print("Replaced 'value=\"pm\",' with 'value=\"mangio-crepe\",' based on the condition")
-                            changes_made = True
-                        line = new_line
-
-                new_line = line.replace('label=i18n("输入训练文件夹路径"), value="E:\\\\语音音频+标注\\\\米津玄师\\\\src"', 'label=i18n("输入训练文件夹路径"), value="/content/dataset/"')
-                if new_line != line:
-                    print("Replaced 'label=i18n(\"输入训练文件夹路径\"), value=\"E:\\\\语音音频+标注\\\\米津玄师\\\\src\"' with 'label=i18n(\"输入训练文件夹路径\"), value=\"/content/dataset/\"'")
-                    changes_made = True
-                line = new_line
-
-                if 'label=i18n("是否仅保存最新的ckpt文件以节省硬盘空间"),' in second_previous_line:
-                    if 'value=i18n("否"),' in line:
-                        new_line = line.replace('value=i18n("否"),', 'value=i18n("是"),')
-                        if new_line != line:
-                            print("Replaced 'value=i18n(\"否\"),' with 'value=i18n(\"是\"),' based on the condition for SAVE ONLY LATEST")
-                            changes_made = True
-                        line = new_line
-
-                if 'label=i18n("是否在每次保存时间点将最终小模型保存至weights文件夹"),' in second_previous_line:
-                    if 'value=i18n("否"),' in line:
-                        new_line = line.replace('value=i18n("否"),', 'value=i18n("是"),')
-                        if new_line != line:
-                            print("Replaced 'value=i18n(\"否\"),' with 'value=i18n(\"是\"),' based on the condition for SAVE SMALL WEIGHTS")
-                            changes_made = True
-                        line = new_line
-
-                temp_file.write(line)
-                second_previous_line = previous_line
-                previous_line = line
-
-        # After finished, we replace the original file with the temp one
-        import shutil
-        shutil.move(temp_file_path, file_path)
-
-        if changes_made:
-            print("Changes made and file saved successfully.")
-        else:
-            print("No changes were needed.")
-
-    # Define the repo path
-    repo_path = '/content/Applio-RVC-Fork'
-
-    def copy_all_files_in_directory(src_dir, dest_dir):
-        # Iterate over all files in source directory
-        for item in Path(src_dir).glob('*'):
-            if item.is_file():
-                # Copy each file to destination directory
-                shutil.copy(item, dest_dir)
-            else:
-                # If it's a directory, make a new directory in the destination and copy the files recursively
-                new_dest = Path(dest_dir) / item.name
-                new_dest.mkdir(exist_ok=True)
-                copy_all_files_in_directory(str(item), str(new_dest))
-
-    def clone_and_copy_repo(repo_path):
-        # New repository link
-        new_repo_link = "https://github.com/IAHispano/Applio-RVC-Fork/"
-        # Temporary path to clone the repository
-        temp_repo_path = "/content/temp_Applio-RVC-Fork"
-        # New folder name
-        new_folder_name = "Applio-RVC-Fork"
-
-        # Clone the latest code from the new repository to a temporary location
-        run_cmd(f"git clone {new_repo_link} {temp_repo_path}")
-        os.chdir(temp_repo_path)
-
-        run_cmd(f"git checkout 3fa4dad3d8961e5ca2522e9e12c0b4ddb71ad402")
-        run_cmd(f"git checkout f9e606c279cb49420597519b0a83b92be81e42e4")
-        run_cmd(f"git checkout 9e305588844c5442d58add1061b29beeca89d679")
-        run_cmd(f"git checkout bf92dc1eb54b4f28d6396a4d1820a25896cc9af8")
-        run_cmd(f"git checkout c3810e197d3cb98039973b2f723edf967ecd9e61")
-        run_cmd(f"git checkout a33159efd134c2413b0afe26a76b7dc87926d2de")
-        run_cmd(f"git checkout 24e251fb62c662e39ac5cf9253cc65deb9be94ec")
-        run_cmd(f"git checkout ad5667d3017e93232dba85969cddac1322ba2902")
-        run_cmd(f"git checkout ce9715392cf52dd5a0e18e00d1b5e408f08dbf27")
-        run_cmd(f"git checkout 7c7da3f2ac68f3bd8f3ad5ca5c700f18ab9f90eb")
-        run_cmd(f"git checkout 4ac395eab101955e8960b50d772c26f592161764")
-        run_cmd(f"git checkout b15b358702294c7375761584e5276c811ffab5e8")
-        run_cmd(f"git checkout 1501793dc490982db9aca84a50647764caa66e51")
-        run_cmd(f"git checkout 21f7faf57219c75e6ba837062350391a803e9ae2")
-        run_cmd(f"git checkout b5eb689fbc409b49f065a431817f822f554cebe7")
-        run_cmd(f"git checkout 7e02fae1ebf24cb151bf6cbe787d06734aa65862")
-        run_cmd(f"git checkout 6aea5ea18ed0b9a1e03fa5d268d6bc3c616672a9")
-        run_cmd(f"git checkout f0f9b25717e59116473fb42bd7f9252cfc32b398")
-        run_cmd(f"git checkout b394de424088a81fc081224bc27338a8651ad3b2")
-        run_cmd(f"git checkout f1999406a88b80c965d2082340f5ea2bfa9ab67a")
-        run_cmd(f"git checkout d98a0fa8dc715308dfc73eac5c553b69c6ee072b")
-        run_cmd(f"git checkout d73267a415fb0eba98477afa43ef71ffd82a7157")
-        run_cmd(f"git checkout 1a03d01356ae79179e1fb8d8915dc9cc79925742")
-        run_cmd(f"git checkout 81497bb3115e92c754300c9b3992df428886a3e9")
-        run_cmd(f"git checkout c5af1f8edcf79cb70f065c0110e279e78e48caf9")
-        run_cmd(f"git checkout cdb3c90109387fa4dfa92f53c3864c71170ffc77")
-
-        # Edit the file here, before copying
-        #edit_file(f"{temp_repo_path}/infer-web.py")
-
-        # Copy all files from the cloned repository to the existing path
-        copy_all_files_in_directory(temp_repo_path, repo_path)
-        print(f"Copying all {new_folder_name} files from GitHub.")
-
-        # Change working directory back to /content/
-        os.chdir('/content/')
-        print("Changed path back to /content/")
-        
-        # Remove the temporary cloned repository
-        shutil.rmtree(temp_repo_path)
-
-    # Call the function
-    clone_and_copy_repo(repo_path)
-
-    # Download the credentials file for RVC archive sheet
-    os.makedirs('/content/Applio-RVC-Fork/stats/', exist_ok=True)
-    run_cmd("wget -q https://cdn.discordapp.com/attachments/945486970883285045/1114717554481569802/peppy-generator-388800-07722f17a188.json -O /content/Applio-RVC-Fork/stats/peppy-generator-388800-07722f17a188.json")
-
-    # Forcefully delete any existing torchcrepe dependencies downloaded from an earlier run just in case
-    shutil.rmtree('/content/Applio-RVC-Fork/torchcrepe', ignore_errors=True)
-    shutil.rmtree('/content/torchcrepe', ignore_errors=True)
-
-    # Download the torchcrepe folder from the maxrmorrison/torchcrepe repository
-    run_cmd("git clone https://github.com/maxrmorrison/torchcrepe.git")
-    shutil.move('/content/torchcrepe/torchcrepe', '/content/Applio-RVC-Fork/')
-    shutil.rmtree('/content/torchcrepe', ignore_errors=True)  # Delete the torchcrepe repository folder
-
-    # Change the current directory to /content/Applio-RVC-Fork
-    os.chdir('/content/Applio-RVC-Fork')
-    os.makedirs('pretrained', exist_ok=True)
-    os.makedirs('uvr5_weights', exist_ok=True)
-
-def download_file(url, filepath):
-    response = requests.get(url, stream=True)
-    response.raise_for_status()
-
-    with open(filepath, "wb") as file:
-        for chunk in response.iter_content(chunk_size=8192):
-            if chunk:
-                file.write(chunk)
-
-def download_pretrained_models():
-    pretrained_models = {
-        "pretrained": [
-            "D40k.pth",
-            "G40k.pth",
-            "f0D40k.pth",
-            "f0G40k.pth"
-        ],
-        "pretrained_v2": [
-            "D40k.pth",
-            "G40k.pth",
-            "f0D40k.pth",
-            "f0G40k.pth",
-            "f0G48k.pth",
-            "f0D48k.pth"
-        ],
-        "uvr5_weights": [
-            "HP2-人声vocals+非人声instrumentals.pth",
-            "HP5-主旋律人声vocals+其他instrumentals.pth",
-            "VR-DeEchoNormal.pth",
-            "VR-DeEchoDeReverb.pth",
-            "VR-DeEchoAggressive.pth",
-            "HP5_only_main_vocal.pth",
-            "HP3_all_vocals.pth",
-            "HP2_all_vocals.pth"
-        ]
-    }
-    part2 = "I"
-    base_url = "https://huggingface.co/lj1995/VoiceConversionWebU" + part2 + "/resolve/main/"
-    base_path = "/content/Applio-RVC-Fork/"
-    base_pathm = base_path
-
-    # Calculate total number of files to download
-    total_files = sum(len(files) for files in pretrained_models.values()) + 1  # +1 for hubert_base.pt
-
-    with tqdm(total=total_files, desc="Downloading files") as pbar:
-        for folder, models in pretrained_models.items():
-            folder_path = os.path.join(base_path, folder)
-            os.makedirs(folder_path, exist_ok=True)
-            for model in models:
-                url = base_url + folder + "/" + model
-                filepath = os.path.join(folder_path, model)
-                download_file(url, filepath)
-                pbar.update()
-
-        # Download hubert_base.pt to the base path
-        hubert_url = base_url + "hubert_base.pt"
-        hubert_filepath = os.path.join(base_pathm, "hubert_base.pt")
-        download_file(hubert_url, hubert_filepath)
-        pbar.update()
-def clone_repository(run_download):
-    with ThreadPoolExecutor(max_workers=2) as executor:
-        executor.submit(run_script)
-        if run_download:
-            executor.submit(download_pretrained_models)

spaces/Ekohai/bingAI/README.md

@@ -1,11 +0,0 @@
----
-title: BingAI
-emoji: 🐢
-colorFrom: indigo
-colorTo: indigo
-sdk: docker
-pinned: false
-license: mit
-app_port: 8080
----
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/FlippFuzz/whisper-webui/src/whisper/abstractWhisperContainer.py

@@ -1,108 +0,0 @@
-import abc
-from typing import List
-from src.config import ModelConfig
-
-from src.hooks.progressListener import ProgressListener
-from src.modelCache import GLOBAL_MODEL_CACHE, ModelCache
-
-class AbstractWhisperCallback:
-    @abc.abstractmethod
-    def invoke(self, audio, segment_index: int, prompt: str, detected_language: str, progress_listener: ProgressListener = None):
-        """
-        Peform the transcription of the given audio file or data.
-
-        Parameters
-        ----------
-        audio: Union[str, np.ndarray, torch.Tensor]
-            The audio file to transcribe, or the audio data as a numpy array or torch tensor.
-        segment_index: int
-            The target language of the transcription. If not specified, the language will be inferred from the audio content.
-        task: str
-            The task - either translate or transcribe.
-        progress_listener: ProgressListener
-            A callback to receive progress updates.
-        """
-        raise NotImplementedError()
-
-    def _concat_prompt(self, prompt1, prompt2):
-        if (prompt1 is None):
-            return prompt2
-        elif (prompt2 is None):
-            return prompt1
-        else:
-            return prompt1 + " " + prompt2
-
-class AbstractWhisperContainer:
-    def __init__(self, model_name: str, device: str = None, compute_type: str = "float16",
-                 download_root: str = None,
-                 cache: ModelCache = None, models: List[ModelConfig] = []):
-        self.model_name = model_name
-        self.device = device
-        self.compute_type = compute_type
-        self.download_root = download_root
-        self.cache = cache
-
-        # Will be created on demand
-        self.model = None
-
-        # List of known models
-        self.models = models
-    
-    def get_model(self):
-        if self.model is None:
-
-            if (self.cache is None):
-                self.model = self._create_model()
-            else:
-                model_key = "WhisperContainer." + self.model_name + ":" + (self.device if self.device else '')
-                self.model = self.cache.get(model_key, self._create_model)
-        return self.model
-    
-    @abc.abstractmethod
-    def _create_model(self):
-        raise NotImplementedError()
-
-    def ensure_downloaded(self):
-        pass
-
-    @abc.abstractmethod
-    def create_callback(self, language: str = None, task: str = None, initial_prompt: str = None, **decodeOptions: dict) -> AbstractWhisperCallback:
-        """
-        Create a WhisperCallback object that can be used to transcript audio files.
-
-        Parameters
-        ----------
-        language: str
-            The target language of the transcription. If not specified, the language will be inferred from the audio content.
-        task: str
-            The task - either translate or transcribe.
-        initial_prompt: str
-            The initial prompt to use for the transcription.
-        decodeOptions: dict
-            Additional options to pass to the decoder. Must be pickleable.
-
-        Returns
-        -------
-        A WhisperCallback object.
-        """
-        raise NotImplementedError()
-
-    # This is required for multiprocessing
-    def __getstate__(self):
-        return { 
-            "model_name": self.model_name, 
-            "device": self.device, 
-            "download_root": self.download_root, 
-            "models": self.models, 
-            "compute_type": self.compute_type 
-        }
-
-    def __setstate__(self, state):
-        self.model_name = state["model_name"]
-        self.device = state["device"]
-        self.download_root = state["download_root"]
-        self.models = state["models"]
-        self.compute_type = state["compute_type"]
-        self.model = None
-        # Depickled objects must use the global cache
-        self.cache = GLOBAL_MODEL_CACHE

spaces/GV05/text-emotion-detector/app.py

@@ -1,34 +0,0 @@
-import gradio as gr
-from transformers import pipeline
-
-model_id = "GV05/distilbert-base-uncased-finetuned-emotion"
-classifier = pipeline("text-classification", model=model_id)
-
-label_to_emotion = {
-    'LABEL_0': 'sadness',
-    'LABEL_1': 'joy',
-    'LABEL_2': 'love',
-    'LABEL_3': 'anger',
-    'LABEL_4': 'fear',
-    'LABEL_5': 'surprise',
-}
-
-def classify_emotion(text):
-    preds = classifier(text, return_all_scores=True)
-    res = {}
-    for x in preds[0]:
-        res[label_to_emotion[x['label']]] = x['score']
-    return res
-
-image = gr.Textbox()
-label = gr.Label()
-examples = ["you are not too sensitive. you are not overreacting",
-            "Thinking of you keeps me awake. Dreaming of you keeps me asleep. Being with you keeps me alive."]
-
-title = "Emotion Detector"
-description = "This model is a fine-tuned version of distilbert-base-uncased on the emotion dataset"
-
-intf = gr.Interface(fn=classify_emotion, inputs=image, outputs=label, examples=examples, title=title,
-                    description=description)
-
-intf.launch(inline=False)

spaces/Gen-Sim/Gen-Sim/cliport/generated_tasks/color_coordinated_insertion.py

@@ -1,62 +0,0 @@
-import numpy as np
-import os
-import pybullet as p
-import random
-from cliport.tasks import primitives
-from cliport.tasks.grippers import Spatula
-from cliport.tasks.task import Task
-from cliport.utils import utils
-import numpy as np
-from cliport.tasks.task import Task
-from cliport.utils import utils
-import pybullet as p
-
-class ColorCoordinatedInsertion(Task):
-    """Insert each block into the fixture of the same color"""
-
-    def __init__(self):
-        super().__init__()
-        self.max_steps = 20
-        self.lang_template = "insert each block into the fixture of the same color"
-        self.task_completed_desc = "done with color-coordinated-insertion."
-        self.additional_reset()
-
-    def reset(self, env):
-        super().reset(env)
-
-        # Add pallet.
-        pallet_size = (0.35, 0.35, 0.01)
-        pallet_pose = self.get_random_pose(env, pallet_size)
-        pallet_urdf = 'pallet/pallet.urdf'
-        env.add_object(pallet_urdf, pallet_pose, 'fixed')
-
-        # Add fixtures and blocks.
-        colors = ['red', 'blue', 'green', 'yellow']
-        fixtures = []
-        blocks = []
-        fixture_size = (0.05, 0.05, 0.05)
-        block_size = (0.04, 0.04, 0.04)
-        fixture_urdf = 'insertion/fixture.urdf'
-        block_urdf = 'block/block.urdf'
-        for color in colors:
-            # Add fixture.
-            fixture_pose = self.get_random_pose(env, fixture_size)
-            fixture_id = env.add_object(fixture_urdf, fixture_pose, color=utils.COLORS[color])
-            fixtures.append(fixture_id)
-
-            # Add block.
-            block_pose = self.get_random_pose(env, block_size)
-            block_id = env.add_object(block_urdf, block_pose, color=utils.COLORS[color])
-            blocks.append(block_id)
-
-        # Goal: each block is in the fixture of the same color.
-        for i in range(len(blocks)):
-            self.add_goal(objs=[blocks[i]], matches=np.ones((1, 1)), targ_poses=[p.getBasePositionAndOrientation(fixtures[i])], replace=False,
-                          rotations=True, metric='pose', params=None, step_max_reward=1 / len(blocks),
-                          language_goal=self.lang_template)
-
-        # Goal: each fixture is on the pallet.
-        for i in range(len(fixtures)):
-            self.add_goal(objs=[fixtures[i]], matches=np.ones((1, 1)), targ_poses=[pallet_pose], replace=False,
-                          rotations=True, metric='zone', params=[(pallet_pose, pallet_size)], step_max_reward=1 / len(fixtures),
-                          language_goal=self.lang_template)

spaces/Gradio-Blocks/protGPT2_gradioFold/alphafold/alphafold/model/tf/shape_helpers_test.py

@@ -1,39 +0,0 @@
-# Copyright 2021 DeepMind Technologies Limited
-#
-# 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.
-
-"""Tests for shape_helpers."""
-
-from alphafold.model.tf import shape_helpers
-import numpy as np
-import tensorflow.compat.v1 as tf
-
-
-class ShapeTest(tf.test.TestCase):
-
-  def test_shape_list(self):
-    """Test that shape_list can allow for reshaping to dynamic shapes."""
-    a = tf.zeros([10, 4, 4, 2])
-    p = tf.placeholder(tf.float32, shape=[None, None, 1, 4, 4])
-    shape_dyn = shape_helpers.shape_list(p)[:2] + [4, 4]
-
-    b = tf.reshape(a, shape_dyn)
-    with self.session() as sess:
-      out = sess.run(b, feed_dict={p: np.ones((20, 1, 1, 4, 4))})
-
-    self.assertAllEqual(out.shape, (20, 1, 4, 4))
-
-
-if __name__ == '__main__':
-  tf.disable_v2_behavior()
-  tf.test.main()

spaces/Gradio-Blocks/uniformer_image_detection/configs/_base_/models/cascade_mask_rcnn_r50_fpn.py

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

spaces/Gradio-Blocks/uniformer_image_detection/configs/ms_rcnn/ms_rcnn_x101_64x4d_fpn_2x_coco.py

@@ -1,4 +0,0 @@
-_base_ = './ms_rcnn_x101_64x4d_fpn_1x_coco.py'
-# learning policy
-lr_config = dict(step=[16, 22])
-runner = dict(type='EpochBasedRunner', max_epochs=24)

spaces/Gradio-Blocks/uniformer_image_detection/configs/regnet/mask_rcnn_regnetx-3.2GF_fpn_mstrain_3x_coco.py

@@ -1,65 +0,0 @@
-_base_ = [
-    '../_base_/models/mask_rcnn_r50_fpn.py',
-    '../_base_/datasets/coco_instance.py',
-    '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py'
-]
-model = dict(
-    pretrained='open-mmlab://regnetx_3.2gf',
-    backbone=dict(
-        _delete_=True,
-        type='RegNet',
-        arch='regnetx_3.2gf',
-        out_indices=(0, 1, 2, 3),
-        frozen_stages=1,
-        norm_cfg=dict(type='BN', requires_grad=True),
-        norm_eval=True,
-        style='pytorch'),
-    neck=dict(
-        type='FPN',
-        in_channels=[96, 192, 432, 1008],
-        out_channels=256,
-        num_outs=5))
-img_norm_cfg = dict(
-    # The mean and std are used in PyCls when training RegNets
-    mean=[103.53, 116.28, 123.675],
-    std=[57.375, 57.12, 58.395],
-    to_rgb=False)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
-    dict(
-        type='Resize',
-        img_scale=[(1333, 640), (1333, 672), (1333, 704), (1333, 736),
-                   (1333, 768), (1333, 800)],
-        multiscale_mode='value',
-        keep_ratio=True),
-    dict(type='RandomFlip', flip_ratio=0.5),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size_divisor=32),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels', 'gt_masks']),
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(1333, 800),
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='Pad', size_divisor=32),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img']),
-        ])
-]
-data = dict(
-    train=dict(pipeline=train_pipeline),
-    val=dict(pipeline=test_pipeline),
-    test=dict(pipeline=test_pipeline))
-optimizer = dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.00005)
-lr_config = dict(step=[28, 34])
-runner = dict(type='EpochBasedRunner', max_epochs=36)
-optimizer_config = dict(
-    _delete_=True, grad_clip=dict(max_norm=35, norm_type=2))

spaces/HCMUT-GraduateThesis-HNTThinh/rgbdsod-multimae-demo/dpt/models.py

@@ -1,126 +0,0 @@
-import torch
-import torch.nn as nn
-from torch import Tensor
-
-from .base_model import BaseModel
-from .blocks import (
-    FeatureFusionBlock_custom,
-    Interpolate,
-    _make_encoder,
-    forward_vit,
-)
-
-
-def _make_fusion_block(features, use_bn):
-    return FeatureFusionBlock_custom(
-        features,
-        nn.ReLU(False),
-        deconv=False,
-        bn=use_bn,
-        expand=False,
-        align_corners=True,
-    )
-
-
-class DPT(BaseModel):
-    def __init__(
-        self,
-        head,
-        features=256,
-        backbone="vitb_rn50_384",
-        readout="project",
-        channels_last=False,
-        use_bn=False,
-        enable_attention_hooks=False,
-    ):
-
-        super(DPT, self).__init__()
-
-        self.channels_last = channels_last
-
-        hooks = {
-            "vitb_rn50_384": [0, 1, 8, 11],
-            "vitb16_384": [2, 5, 8, 11],
-            "vitl16_384": [5, 11, 17, 23],
-        }
-
-        # Instantiate backbone and reassemble blocks
-        self.pretrained, self.scratch = _make_encoder(
-            backbone,
-            features,
-            False,  # Set to true of you want to train from scratch, uses ImageNet weights
-            groups=1,
-            expand=False,
-            exportable=False,
-            hooks=hooks[backbone],
-            use_readout=readout,
-            enable_attention_hooks=enable_attention_hooks,
-        )
-
-        self.scratch.refinenet1 = _make_fusion_block(features, use_bn)
-        self.scratch.refinenet2 = _make_fusion_block(features, use_bn)
-        self.scratch.refinenet3 = _make_fusion_block(features, use_bn)
-        self.scratch.refinenet4 = _make_fusion_block(features, use_bn)
-
-        self.scratch.output_conv = head
-
-    def forward(self, x: Tensor) -> Tensor:
-        if self.channels_last == True:
-            x.contiguous(memory_format=torch.channels_last)
-
-        layer_1, layer_2, layer_3, layer_4 = forward_vit(self.pretrained, x)
-
-        layer_1_rn = self.scratch.layer1_rn(layer_1)
-        layer_2_rn = self.scratch.layer2_rn(layer_2)
-        layer_3_rn = self.scratch.layer3_rn(layer_3)
-        layer_4_rn = self.scratch.layer4_rn(layer_4)
-
-        path_4 = self.scratch.refinenet4(layer_4_rn)
-        path_3 = self.scratch.refinenet3(path_4, layer_3_rn)
-        path_2 = self.scratch.refinenet2(path_3, layer_2_rn)
-        path_1 = self.scratch.refinenet1(path_2, layer_1_rn)
-
-        out = self.scratch.output_conv(path_1)
-
-        return out
-
-
-class DPTDepthModel(DPT):
-    def __init__(
-        self, path=None, non_negative=True, scale=1.0, shift=0.0, invert=False, **kwargs
-    ):
-        features = kwargs["features"] if "features" in kwargs else 256
-
-        self.scale = scale
-        self.shift = shift
-        self.invert = invert
-
-        head = nn.Sequential(
-            nn.Conv2d(features, features // 2, kernel_size=3, stride=1, padding=1),
-            Interpolate(scale_factor=2, mode="bilinear", align_corners=True),
-            nn.Conv2d(features // 2, 32, kernel_size=3, stride=1, padding=1),
-            nn.ReLU(True),
-            nn.Conv2d(32, 1, kernel_size=1, stride=1, padding=0),
-            nn.ReLU(True) if non_negative else nn.Identity(),
-            nn.Identity(),
-        )
-
-        super().__init__(head, **kwargs)
-
-        if path is not None:
-            self.load(path)
-
-    def forward(self, x: Tensor) -> Tensor:
-        """Input x of shape [b, c, h, w]
-        Return tensor of shape [b, c, h, w]
-        """
-        inv_depth = super().forward(x)
-
-        if self.invert:
-            depth = self.scale * inv_depth + self.shift
-            depth[depth < 1e-8] = 1e-8
-            depth = 1.0 / depth
-            return depth
-        else:
-            return inv_depth
-

spaces/HaloMaster/chinesesummary/fengshen/models/megatron_t5/__init__.py

@@ -1,49 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The IDEA Authors. All rights reserved.
-
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-
-#     http://www.apache.org/licenses/LICENSE-2.0
-
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from typing import TYPE_CHECKING
-
-from transformers.file_utils import _LazyModule, is_torch_available
-
-
-_import_structure = {
-    "configuration_megatron_t5": ["T5Config"],
-    "tokenization_megatron_t5": ["T5Tokenizer"],
-}
-
-if is_torch_available():
-    _import_structure["modeling_megatron_t5"] = [
-        "T5Model",
-        "T5EncoderModel",
-        "T5ForConditionalGeneration"
-    ]
-
-
-if TYPE_CHECKING:
-    from .configuration_megatron_t5 import T5Config
-    from .tokenization_megatron_t5 import T5Tokenizer
-
-    if is_torch_available():
-        from .modeling_megatron_t5 import (
-            T5Model,
-            T5EncoderModel,
-            T5ForConditionalGeneration
-        )
-
-else:
-    import sys
-
-    sys.modules[__name__] = _LazyModule(
-        __name__, globals()["__file__"], _import_structure)

spaces/Happys/chatbot/Dockerfile

@@ -1,8 +0,0 @@
-# Pull the base image
-FROM happyclo/libre:latest
-
-# Install dependencies
-RUN cd /app/api && npm install
-
-# Command to run on container start
-CMD ["npm", "run", "backend"]

spaces/HarryLee/eCommerceImageCaptioning/fairseq/fairseq/tasks/sentence_ranking.py

@@ -1,219 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import logging
-import os
-
-import numpy as np
-from fairseq import utils
-from fairseq.data import (
-    ConcatSentencesDataset,
-    Dictionary,
-    IdDataset,
-    NestedDictionaryDataset,
-    NumelDataset,
-    NumSamplesDataset,
-    PrependTokenDataset,
-    RawLabelDataset,
-    RightPadDataset,
-    SortDataset,
-    TruncateDataset,
-    data_utils,
-)
-from fairseq.data.shorten_dataset import maybe_shorten_dataset
-from fairseq.tasks import LegacyFairseqTask, register_task
-
-
-logger = logging.getLogger(__name__)
-
-
-@register_task("sentence_ranking")
-class SentenceRankingTask(LegacyFairseqTask):
-    """
-    Ranking task on multiple sentences.
-
-    Args:
-        dictionary (Dictionary): the dictionary for the input of the task
-    """
-
-    @staticmethod
-    def add_args(parser):
-        """Add task-specific arguments to the parser."""
-        parser.add_argument("data", metavar="FILE", help="file prefix for data")
-        parser.add_argument(
-            "--num-classes", type=int, help="number of sentences to be ranked"
-        )
-        parser.add_argument(
-            "--init-token",
-            type=int,
-            help="add token at the beginning of each batch item",
-        )
-        parser.add_argument(
-            "--separator-token", type=int, help="add separator token between inputs"
-        )
-        parser.add_argument("--no-shuffle", action="store_true")
-        parser.add_argument(
-            "--shorten-method",
-            default="none",
-            choices=["none", "truncate", "random_crop"],
-            help="if not none, shorten sequences that exceed --tokens-per-sample",
-        )
-        parser.add_argument(
-            "--shorten-data-split-list",
-            default="",
-            help="comma-separated list of dataset splits to apply shortening to, "
-            'e.g., "train,valid" (default: all dataset splits)',
-        )
-        parser.add_argument(
-            "--max-option-length", type=int, help="max length for each option"
-        )
-
-    def __init__(self, args, dictionary):
-        super().__init__(args)
-        self.dictionary = dictionary
-
-    @classmethod
-    def load_dictionary(cls, args, filename, source=True):
-        """Load the dictionary from the filename
-
-        Args:
-            filename (str): the filename
-        """
-        dictionary = Dictionary.load(filename)
-        dictionary.add_symbol("<mask>")
-        return dictionary
-
-    @classmethod
-    def setup_task(cls, args, **kwargs):
-        assert (
-            args.criterion == "sentence_ranking"
-        ), "Must set --criterion=sentence_ranking"
-
-        # load data dictionary
-        data_dict = cls.load_dictionary(
-            args,
-            os.path.join(args.data, "input0", "dict.txt"),
-            source=True,
-        )
-        logger.info("[input] dictionary: {} types".format(len(data_dict)))
-        return SentenceRankingTask(args, data_dict)
-
-    def load_dataset(self, split, combine=False, **kwargs):
-        """Load a given dataset split (e.g., train, valid, test)."""
-
-        def get_path(type, split):
-            return os.path.join(self.args.data, type, split)
-
-        def make_dataset(type, dictionary):
-            split_path = get_path(type, split)
-
-            dataset = data_utils.load_indexed_dataset(
-                split_path,
-                self.source_dictionary,
-                self.args.dataset_impl,
-                combine=combine,
-            )
-            return dataset
-
-        input0 = make_dataset("input0", self.source_dictionary)
-        input_options = [
-            make_dataset("input{idx}".format(idx=idx + 1), self.source_dictionary)
-            for idx in range(self.args.num_classes)
-        ]
-
-        if self.args.separator_token is not None:
-            input0 = PrependTokenDataset(input0, self.args.separator_token)
-
-        src_tokens = []
-        for input_option in input_options:
-            if self.args.init_token is not None:
-                input_option = PrependTokenDataset(input_option, self.args.init_token)
-            if self.args.max_option_length is not None:
-                input_option = TruncateDataset(
-                    input_option, self.args.max_option_length
-                )
-            src_token = ConcatSentencesDataset(input_option, input0)
-            src_token = maybe_shorten_dataset(
-                src_token,
-                split,
-                self.args.shorten_data_split_list,
-                self.args.shorten_method,
-                self.args.max_positions,
-                self.args.seed,
-            )
-            src_tokens.append(src_token)
-
-        with data_utils.numpy_seed(self.args.seed):
-            shuffle = np.random.permutation(len(src_tokens[0]))
-
-        dataset = {
-            "id": IdDataset(),
-            "nsentences": NumSamplesDataset(),
-            "ntokens": NumelDataset(src_tokens[0], reduce=True),
-        }
-
-        for src_token_idx in range(len(src_tokens)):
-            dataset.update(
-                {
-                    "net_input{idx}".format(idx=src_token_idx + 1): {
-                        "src_tokens": RightPadDataset(
-                            src_tokens[src_token_idx],
-                            pad_idx=self.source_dictionary.pad(),
-                        ),
-                        "src_lengths": NumelDataset(
-                            src_tokens[src_token_idx], reduce=False
-                        ),
-                    }
-                }
-            )
-
-        label_path = "{}.label".format(get_path("label", split))
-        if os.path.exists(label_path):
-            with open(label_path) as h:
-                dataset.update(
-                    target=RawLabelDataset([int(x.strip()) for x in h.readlines()])
-                )
-
-        nested_dataset = NestedDictionaryDataset(
-            dataset,
-            sizes=[np.maximum.reduce([src_token.sizes for src_token in src_tokens])],
-        )
-
-        if self.args.no_shuffle:
-            dataset = nested_dataset
-        else:
-            dataset = SortDataset(
-                nested_dataset,
-                # shuffle
-                sort_order=[shuffle],
-            )
-
-        logger.info("Loaded {0} with #samples: {1}".format(split, len(dataset)))
-
-        self.datasets[split] = dataset
-        return self.datasets[split]
-
-    def build_model(self, args):
-        from fairseq import models
-
-        model = models.build_model(args, self)
-
-        model.register_classification_head(
-            getattr(args, "ranking_head_name", "sentence_classification_head"),
-            num_classes=1,
-        )
-
-        return model
-
-    def max_positions(self):
-        return self.args.max_positions
-
-    @property
-    def source_dictionary(self):
-        return self.dictionary
-
-    @property
-    def target_dictionary(self):
-        return self.dictionary