Datasets:

Weyaxi
/

huggingface-spaces-codes

@@ -1,114 +0,0 @@
-<br />
-<h1>Bum Simulator Download For Pc: A Guide to Living on the Streets</h1>
-<p>Have you ever wondered what it's like to be a bum? To live on the streets, beg for money, fight for survival, and deal with the harsh realities of urban life? If you have, then you might be interested in <strong>Bum Simulator</strong>, a sandbox game that lets you experience the life of a homeless person in a humorous and absurd way. In this article, we will tell you everything you need to know about Bum Simulator, how to download it for PC, and why you should play it.</p>
-<h2>What is Bum Simulator?</h2>
-<p>Bum Simulator is a sandbox game developed by Ragged Games that was released in 2023. It is a game that combines elements of adventure, survival, simulation, and comedy. You play as a bum who lives on the streets of Bumsville, a fictional city inspired by New York. You can explore the city, interact with other characters, complete quests, collect items, craft weapons, build your own cardboard house, tame pigeons, and more. You can also choose how to shape your fate: you can either accept your situation and live like a bum, find a job and try to get back on your feet, or seek revenge on those who ruined your life. The game offers endless possibilities and outcomes for your bum's story.</p>
-<h2>Bum Simulator Download For Pcl</h2><br /><p><b><b>Download</b> &middot; <a href="https://byltly.com/2uKx6D">https://byltly.com/2uKx6D</a></b></p><br /><br />
-<h3>A sandbox game with inappropriate humor and memorable characters</h3>
-<p>One of the main features of Bum Simulator is its open-world sandbox gameplay. You can go wherever you want and do whatever you like in the city. You can explore dirty alleys, busy streets, pawnshops, central park, underground passages, and more. You can also interact with many unusual characters with their own storylines and quests. Some of them are friendly and helpful, while others are hostile and dangerous. You can also encounter various events and situations that will test your skills and luck. For example, you can get chased by the police, attacked by gangs, kidnapped by mole people, or invited to a party by aliens. The game is full of inappropriate humor and jokes that will make you laugh or cringe.</p>
-<h3>A survival game with freedom and choices</h3>
-<p>Another feature of Bum Simulator is its survival aspect. You have to manage your basic needs such as hunger, thirst, health, hygiene, energy, and happiness. You have to find food and water sources, scavenge for useful items, craft tools and weapons, build shelters and traps, fight enemies and predators, avoid dangers and diseases, and more. You also have to deal with the consequences of your actions. For example, if you steal from someone or cause trouble in public, you will attract attention from the authorities or other bums. If you help someone or do a good deed, you will earn respect or gratitude from them. You also have to make choices that will affect your bum's personality and reputation. For example, you can be kind or cruel, honest or deceitful, generous or greedy, etc. Your choices will also affect the endings of the game.</p>
-<h3>A game with achievements, secrets and pigeons</h3>
-<p>The last feature of Bum Simulator is its variety of content and challenges. The game has many achievements to unlock and secrets to discover. You can find hidden items, easter eggs, references to pop culture or other games, and more. You can also complete mini-games, challenges, and quests that will reward you with money, items, or skills. One of the most unique aspects of the game is its pigeon system. You can tame pigeons, train them, and use them as your allies or weapons. You can also learn the secrets of alcohol alchemy, a mysterious art that allows you to create powerful potions from booze.</p>
-<p>How to download Bum Simulator for free on PC<br />
-Bum Simulator PC game full version download<br />
-Bum Simulator crack download for Windows 10<br />
-Bum Simulator torrent download link for PC<br />
-Bum Simulator gameplay and review for PC<br />
-Bum Simulator system requirements and compatibility for PC<br />
-Bum Simulator mods and cheats for PC<br />
-Bum Simulator update and patch download for PC<br />
-Bum Simulator steam key giveaway for PC<br />
-Bum Simulator best settings and tips for PC<br />
-Bum Simulator download size and installation guide for PC<br />
-Bum Simulator free demo download for PC<br />
-Bum Simulator online multiplayer mode for PC<br />
-Bum Simulator DLC and expansion pack download for PC<br />
-Bum Simulator controller support and configuration for PC<br />
-Bum Simulator alternatives and similar games for PC<br />
-Bum Simulator release date and price for PC<br />
-Bum Simulator official trailer and screenshots for PC<br />
-Bum Simulator developer and publisher information for PC<br />
-Bum Simulator minimum and recommended specs for PC<br />
-Bum Simulator error fix and troubleshooting guide for PC<br />
-Bum Simulator steam charts and achievements for PC<br />
-Bum Simulator save file location and backup for PC<br />
-Bum Simulator keyboard and mouse controls for PC<br />
-Bum Simulator VR support and compatibility for PC<br />
-Bum Simulator soundtrack and music download for PC<br />
-Bum Simulator custom maps and levels for PC<br />
-Bum Simulator steam workshop and community hub for PC<br />
-Bum Simulator rating and reviews for PC<br />
-Bum Simulator co-op and split-screen mode for PC<br />
-Bum Simulator direct download link for PC<br />
-Bum Simulator skidrow reloaded download for PC<br />
-Bum Simulator fitgirl repack download for PC<br />
-Bum Simulator ocean of games download for PC<br />
-Bum Simulator igg games download for PC<br />
-Bum Simulator apunkagames download for PC<br />
-Bum Simulator cpy games download for PC<br />
-Bum Simulator codex games download for PC<br />
-Bum Simulator plaza games download for PC<br />
-Bum Simulator rg mechanics download for PC<br />
-Bum Simulator pcgames88 download for PC<br />
-Bum Simulator gametrex download for PC<br />
-Bum Simulator worldofpcgames download for PC<br />
-Bum Simulator pcgamestorrents download for PC<br />
-Bum Simulator thepcgames download for PC<br />
-Bum Simulator fullypcgames download for PC<br />
-Bum Simulator oldgamesdownload download for PC<br />
-Bum Simulator freegogpcgames download for PC<br />
-Bum Simulator gog-games.com download for PC</p>
-<h2>How to download Bum Simulator for PC?</h2>
-<p>If you are interested in playing Bum Simulator on your PC, you will need to meet some requirements and follow some steps. Here are the details:</p>
-<h3>Requirements and specifications</h3>
-<p>To run Bum Simulator on your PC, you will need to have a Windows 8.1 or higher operating system, a 64-bit processor, at least 8 GB of RAM, and at least 20 GB of available space on your hard drive. You will also need a graphics card that supports DirectX 11 and has at least 2 GB of VRAM. The recommended graphics card is NVIDIA GeForce GTX 1060 or AMD Radeon RX 580.</p>
-<h3>Steps to download and install Bum Simulator</h3>
-<ol>
-<li>The first step is to buy Bum Simulator from an online platform such as Steam or GOG.com. You can also find other websites that offer the game for download, but make sure they are trustworthy and virus-free.</li>
-<li>The second step is to download the game installer from the platform you chose. You will need an internet connection and enough space on your hard drive to download the game files.</li>
-<li>The third step is to run the installer and follow the instructions on the screen. You will need to agree to the terms and conditions and choose a destination folder for the game.</li>
-<li>The fourth step is to wait for the installation process to finish. It may take some time depending on your internet speed and computer performance.</li>
-<li>The fifth step is to launch the game from your desktop shortcut or from the platform you bought it from. You may need to create an account or log in with an existing one to access the game.</li>
-<li>The sixth step is to enjoy playing Bum Simulator on your PC!</li>
-</ol>
-<h3>Tips and tricks for playing Bum Simulator</h3>
-<ul>
-<li>Explore every corner of the city and look for useful items, hidden secrets, and interesting characters.</li>
-<li>Manage your needs carefully and don't let them drop too low. You can find food and water in trash cans, shops, or vending machines. You can also hunt animals or fish in ponds.</li>
-<li>Craft weapons and tools from items you find or buy. You can make knives, hammers, bombs, bows, etc. You can also upgrade them with better materials or skills.</li>
-<li>Build your own cardboard house and decorate it with furniture, paintings, or posters. You can also invite other bums or pigeons to live with you.</li>
-<li>Tame pigeons and use them as your companions or weapons. You can feed them, pet them, name them, and teach them tricks. You can also weaponize them with bombs, lasers, or hats.</li>
-<li>Learn alcohol alchemy and create potions from booze. You can make potions that heal you, boost your stats, give you special abilities, or cause hilarious effects.</li>
-<li>Complete quests and challenges for other characters or yourself. You can earn money, items, skills, or reputation from them.</li>
-<li>Choose your path and shape your fate. You can either accept your situation and live like a bum, find a job and try to get back on your feet, or seek revenge on those who ruined your life. Your choices will affect the endings of the game.</li>
-<li>Have fun and don't take the game too seriously. It's a silly game full of absurd humor and jokes.</li>
-</ul>
- <h2>Why should you play Bum Simulator?</h2>
- <p>Bum Simulator is a game that offers a lot of fun and entertainment for anyone who likes sandbox games, survival games, simulation games, or comedy games. It's a game that lets you experience the life of a homeless person in a humorous and absurd way. It's a game that gives you freedom and choices to shape your fate. It's a game that has achievements, secrets, and pigeons to keep you engaged. Here are some reasons why you should play Bum Simulator:</p>
- ```html <h3>It's fun and absurd</h3>
-<p>Bum Simulator is a game that doesn't take itself too seriously. It's a game that makes fun of the stereotypes and clichés of being a bum. It's a game that has ridiculous situations and events that will make you laugh or cringe. For example, you can get chased by the police, attacked by gangs, kidnapped by mole people, or invited to a party by aliens. You can also interact with many funny characters with their own quirks and personalities. You can also create your own fun and absurd scenarios with the sandbox gameplay. You can do whatever you want and see what happens.</p>
-<h3>It's challenging and rewarding</h3>
-<p>Bum Simulator is also a game that tests your skills and luck. It's a game that has survival elements that require you to manage your basic needs and resources. It's a game that has enemies and dangers that threaten your life and well-being. It's a game that has quests and challenges that demand your attention and effort. It's a game that has consequences and outcomes that depend on your actions and choices. But it's also a game that rewards you for your achievements and discoveries. It's a game that gives you money, items, skills, or reputation for completing tasks or finding secrets. It's a game that gives you satisfaction and pride for overcoming obstacles or reaching goals.</p>
-<h3>It's immersive and interactive</h3>
-<p>Bum Simulator is also a game that immerses you in its world and story. It's a game that has a detailed and realistic city environment that you can explore and interact with. It's a game that has a dynamic day-night cycle and weather system that affect the gameplay and atmosphere. It's a game that has a rich and diverse soundtrack that matches the mood and tone of the game. It's also a game that has a compelling and branching story that you can influence with your choices. It's a game that has multiple endings that reflect your personality and reputation.</p>
-<h2>Conclusion</h2>
-<p>Bum Simulator is a sandbox game that lets you experience the life of a homeless person in a humorous and absurd way. You can explore the city, interact with other characters, complete quests, collect items, craft weapons, build your own cardboard house, tame pigeons, and more. You can also choose how to shape your fate: you can either accept your situation and live like a bum, find a job and try to get back on your feet, or seek revenge on those who ruined your life. The game offers endless possibilities and outcomes for your bum's story.</p>
-<p>If you are looking for a fun and entertaining game that combines elements of adventure, survival, simulation, and comedy, then you should try Bum Simulator. You can download it for PC from various online platforms such as Steam or GOG.com. You will need to meet some requirements and follow some steps to install it on your PC. You will also need some tips and tricks to play it well.</p>
-<p>Bum Simulator is a game that will make you laugh, cry, cringe, or cheer. It's a game that will challenge you, reward you, immerse you, or surprise you. It's a game that will give you freedom, choices, achievements, secrets, or pigeons. It's a game that will let you live on the streets as a bum.</p>
-<h2>FAQs</h2>
-<ul>
-<li><strong>Q: Is Bum Simulator based on real life?</strong></li>
-<li>A: No, Bum Simulator is not based on real life. It is a fictional game that exaggerates and parodies the stereotypes and clichés of being a bum. It is not meant to offend or mock anyone who is homeless or struggling in life.</li>
-<li><strong>Q: Is Bum Simulator multiplayer?</strong></li>
-<li>A: No, Bum Simulator is not multiplayer. It is a single-player game that focuses on your bum's story and choices.</li>
-<li><strong>Q: Is Bum Simulator suitable for children?</strong></li>
-<li>A: No, Bum Simulator is not suitable for children. It is a mature game that contains violence, blood, gore, nudity, sexual content, drugs, alcohol, profanity, and crude humor.</li>
-<li><strong>Q: How long is Bum Simulator?</strong></li>
-<li>A: The length of Bum Simulator depends on how you play it. You can finish the main story in about 10 hours if you focus on the main quests. You can also spend more time exploring the city, doing side quests, collecting items, crafting weapons, building your house, taming pigeons, etc.</li>
-<li><strong>Q: How many endings does Bum Simulator have?</strong></li>
-<li>A: Bum Simulator has multiple endings that depend on your choices throughout the game. Your choices will affect your bum's personality, reputation, and fate. You can either become a happy bum, a successful bum, a vengeful bum, or something else.</li>
-</ul>
- </p> 0a6ba089eb<br />
-<br />
-<br />

spaces/1gistliPinn/ChatGPT4/Examples/3d Sex Villa 2 Full For Android Apk.rar.md DELETED Viewed

@@ -1,40 +0,0 @@
-<h2>3d Sex Villa 2 Full for android apk.rar</h2><br /><p><b><b>Download</b> &#9734;&#9734;&#9734; <a href="https://imgfil.com/2uy0Za">https://imgfil.com/2uy0Za</a></b></p><br /><br />
-Sexvilla2 3D Sexvilla 2 part 1, 3D SexVilla 2 Everlust 1 torrent.Some people have been trying to get people to play Pokémon Go at a recent visit by the local police.
-The police found many people playing the game while they were patrolling on the streets.
-At the moment, people who find themselves playing the game while on the street can be reported to the police, and warned they are doing a criminal act.
-Playing Pokémon Go on the streets of Loch Lomond has been banned by police in Scotland.
-This comes after new rules were introduced to police forces across the UK banning the use of smartphones while out on patrol.
-People have been warned that playing the game while out on the street could put their lives at risk.
-Currently, police forces across the UK are trying to create more visible patrols, and more officers on the streets to look for trouble.
-Glasgow police already patrol in pairs, while a new rule has been introduced across Scotland banning playing Pokémon Go on the street while out on patrol.
-Detective Inspector Stuart Reid said: “Our aim is to make sure people are safe when out on the streets.
-“We would like to remind everyone that Pokémon Go has not been endorsed by the police, and we would encourage all those who find themselves playing to ensure they remain safe.
-“We encourage people to play Pokémon Go in public areas, but remind them that it is still a criminal offence to play in public.”
-This story was originally published in the Daily Record. Read the original here.Religion
-Antonio di Pietro is an artist who draws a lot with the art of lettering. His latest project is, “The sea which has no beginning, no end”. He received thousands of messages from people who didn’t understand why he had to use the word Sea for such a concept. Here is a new artwork which answers the question:
-About us
-Hearst Mantis is an art and design platform for the latest trends in music, fashion, art, food, travel and more. We provide cutting-edge content from a variety of industry leading creators.Q:
-Unexpected nil when setting a global variable
-I have a Python class that I'm using to transfer data between the server and the client.
-When the client disconnects, I want to set a 4fefd39f24<br />
-<br />
-<br />
-<p></p>

spaces/1gistliPinn/ChatGPT4/Examples/Experience The Trench Warfare Of Verdun 1914-1918 On Your Mac!.md DELETED Viewed

@@ -1,11 +0,0 @@
-<br />
-<p>On the afternoon of the 4th, the last pigeon was released. On themorning of the 5th, thanks to two signalmen who volunteered to changea signal post which the Commandant had difficulty in observing,communications were maintained.</p>
-<h2>Verdun 1914-1918 Released For Mac!</h2><br /><p><b><b>Download File</b> &ndash;&ndash;&ndash; <a href="https://imgfil.com/2uxZXY">https://imgfil.com/2uxZXY</a></b></p><br /><br />
-<p>Verdun is a squad-based multiplayer first-person shooter set during World War I. It was released on 28 April 2015 on Steam after more than a year in Early Access. The game features realistic trench warfare and offers players an immersive experience as they battle it out against other squads. Verdun also has a unique system where players can choose to fight for one of four different armies, each with its own strengths and weaknesses. If you're looking for an intense and strategic WWI FPS, then Verdun is definitely worth checking out.</p>
-<p><i><b>Tannenberg</b></i> is a squad-based multiplayer first-person shooter video game set during World War I. It is a standalone expansion to <i>Verdun</i>, and entered Steam Early Access on November 17, 2017.[1][2][3][4] <i>Tannenberg</i> left Steam Early Access on February 13, 2019.[5][6] It was released on PlayStation 4 and Xbox One on July 24, 2020.[7][8][9][10]</p>
-<p><strong>1914-1918 series</strong><br />Starting out on the Western Front with the release of the first realistic WW1 FPS Verdun back in April 2015, and expanding to the Eastern Front with the upcoming Tannenberg, the 1914-1918 series throws players into intense warfare inspired by the chaos and fury of iconic battles from the First World War. With over 900,000 copies of Verdun sold, this novel and underserved setting has proven popular with the gaming community!<br />Players choose from a variety of historically accurate squads and weapons, with more available to unlock through playing the game, before diving into the mud and blood splattered battlefields of dynamic multiplayer trench warfare.<br />Every game is built on a base of thorough research and receives extensive post-release support bringing new content and challenges for our players. The games in the series are linked, but each one is standalone and provides a different experience, reflecting the nature of the fighting in the many-sided theaters of the war.</p>
-<p><b>Verdun</b> is een computerspel van het genre first-person shooter dat zich afspeelt tijdens de Eerste Wereldoorlog (1914-1918). Het werd ontwikkeld door de Nederlandse studio's M2H en Blackmill Games. Verdun verscheen als bètaversie op 9 juni 2013 en werd officieel gelanceerd op 28 april 2015 op het Steam softwareplatform.[1] Het spel is beschikbaar voor Windows, Mac en Linux.</p>
-<p></p>
-<p><strong>Less than a year ago, Verdun was released as a Steam Early Access game. The successful collaboration of M2H and BlackMill Games has finally reached a point where the developers are happy to release the game in all its glory. Many features and content has been added only shortly after our preview, which you can read here, but even more has been added since.</strong></p> aaccfb2cb3<br />
-<br />
-<br />

spaces/1gistliPinn/ChatGPT4/Examples/FULL DanDans (Easy) Audio Editor V9.0 The Ultimate Guide to Visual Music Editing.md DELETED Viewed

@@ -1,6 +0,0 @@
-<p>Still struggling with your shooting 4K video won't play on other devices or playing with audio and video out of sync? Wondershare UniConverter helps you out! Find your issues and get the full answer now.</p>
-<h2>FULL DanDans (Easy) Audio Editor V9.0</h2><br /><p><b><b>DOWNLOAD</b> &#10040;&#10040;&#10040; <a href="https://imgfil.com/2uy06L">https://imgfil.com/2uy06L</a></b></p><br /><br />
-<p>Easy Audio Editor is a visual multifunctional audio files editor which allow you to perform various operations with audio data such as visual editing, creating, recording, converting and playing audio files. It supports all audio and video formats.</p> aaccfb2cb3<br />
-<br />
-<br />

spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Download APK Magic COC S1 Versi Terbaru and Enjoy the Best Private Server for Clash of Clans.md DELETED Viewed

@@ -1,95 +0,0 @@
-<br />
-<h1>Download APK Magic COC S1 Versi Terbaru: A Private Server for Clash of Clans</h1>
-<p>If you are a fan of Clash of Clans, you might have heard of APK Magic COC S1, a private server that lets you play the game with unlimited resources and custom mods. In this article, we will tell you everything you need to know about this app, including its features, how to download and install it, and its pros and cons. Read on to find out why you should download APK Magic COC S1 versi terbaru and enjoy the game like never before.</p>
-<h2>download apk magic coc s1 versi terbaru</h2><br /><p><b><b>Download Zip</b> &#10084;&#10084;&#10084; <a href="https://urlin.us/2uT1uY">https://urlin.us/2uT1uY</a></b></p><br /><br />
- <h2>Features of APK Magic COC S1</h2>
-<p>APK Magic COC S1 is a modified version of Clash of Clans that runs on a private server. This means that you can play the game with some extra features that are not available in the official version. Here are some of the main features of APK Magic COC S1:</p>
-<ul>
-<li><b>Unlimited resources:</b> You can get unlimited gems, gold, elixir, and dark elixir to build your base, train your troops, upgrade your buildings, and research new technologies. You don't have to worry about running out of resources or spending real money to buy them.</li>
-<li><b>Custom mods:</b> You can customize your game with various mods that allow you to create your own buildings, troops, heroes, and spells. You can also change the appearance and behavior of the existing ones. For example, you can make your archers shoot fireballs, your barbarians fly, or your pekkas invisible.</li>
-<li><b>Fast and stable servers:</b> You can play the game smoothly without any lag or crash. The servers of APK Magic COC S1 are fast and reliable, and they can handle thousands of players at the same time. You also don't have to worry about getting banned by Supercell, as they cannot detect or access your private server.</li>
-<li><b>Real-time PvP battles:</b> You can challenge other players online in real-time battles. You can test your skills and strategies against other players who are using the same private server as you. You can also join clans and participate in clan wars with your friends.</li>
-</ul>
- <h2>How to Download and Install APK Magic COC S1</h2>
-<p>If you want to download and install APK Magic COC S1 on your Android device, you need to follow these simple steps:</p>
-<ol>
-<li><b>Enable unknown sources on your device:</b> To install apps from sources other than Google Play Store, you need to enable unknown sources on your device. To do this, go to Settings > Security > Unknown Sources and toggle it on.</li>
-<li><b>Download the APK file from a trusted source:</b> You need to download the APK file of APK Magic COC S1 from a trusted source. You can use the link  to download the latest version of the app. Make sure you have enough storage space on your device before downloading.</li>
-<li><b>Install the APK file and launch the app :</b> After downloading the APK file, you need to install it on your device. To do this, locate the file in your file manager and tap on it. You will see a pop-up window asking you to confirm the installation. Tap on Install and wait for the process to finish. Once the app is installed, you can launch it by tapping on its icon on your home screen or app drawer.</li>
-</ol>
- <h2>Pros and Cons of APK Magic COC S1</h2>
-<p>APK Magic COC S1 is a great app for Clash of Clans lovers who want to have more fun and freedom in the game. However, it also has some drawbacks that you should be aware of before downloading it. Here are some of the pros and cons of APK Magic COC S1:</p>
-<table>
-<tr>
-<th>Pros</th>
-<th>Cons</th>
-</tr>
-<tr>
-<td>- More fun: You can enjoy the game without any limitations or restrictions. You can build your base, train your troops, and attack other players as much as you want.</td>
-<td>- Not official: APK Magic COC S1 is not an official app from Supercell, the developer of Clash of Clans. It is a third-party app that is not endorsed or supported by Supercell.</td>
-</tr>
-<tr>
-<td>- More freedom: You can customize your game with various mods that allow you to create your own buildings, troops, heroes, and spells. You can also change the appearance and behavior of the existing ones.</td>
-<td>- Not compatible: APK Magic COC S1 is not compatible with the official version of Clash of Clans. You cannot play with or against players who are using the official version. You also cannot sync your progress or data with your Google Play account.</td>
-</tr>
-<tr>
-<td>- More options: You can choose from different servers that offer different features and settings. You can also switch between servers easily without losing your data.</td>
-<td>- Not updated: APK Magic COC S1 is not updated regularly with the latest features and updates from Clash of Clans. You may miss out on some new content or events that are available in the official version.</td>
-</tr>
-</table>
- <h2>Conclusion and FAQs</h2>
-<p>APK Magic COC S1 is a private server for Clash of Clans that offers unlimited resources and custom mods. It is a great alternative for Clash of Clans fans who want to enjoy the game without any limitations. However, it also has some disadvantages that you should consider before downloading it, such as being not official, not compatible, and not updated. If you are interested in trying out APK Magic COC S1, you can download it from the link  and follow the steps we have provided in this article.</p>
- <p>If you have any questions about APK Magic COC S1, you may find the answers in the following FAQs:</p>
- <h3>Q: Is APK Magic COC S1 safe to use?</h3>
-<p>A: APK Magic COC S1 is safe to use as long as you download it from a trusted source and enable unknown sources on your device. However, you should always be careful when installing apps from unknown sources, as they may contain malware or viruses that can harm your device or steal your data.</p>
-<p>Download clash of magic apk private server game coc terbaru[^3^]<br />
-Clash of magic apk android game free download latest version[^1^]<br />
-Magic coc s1 10.322 r1 apk android app free download updated version[^2^]<br />
-How to install clash of magic apk on android device without root<br />
-Clash of magic apk mod unlimited resources and gems for coc<br />
-Magic coc s1 10.322 r1 app private server with custom mods and commands<br />
-Clash of magic apk download for ios iphone ipad ipod touch<br />
-Clash of clans with unlimited resources using clash of magic apk<br />
-Magic coc s1 10.322 r1 apk features and benefits for coc players<br />
-Clash of magic apk review and rating by users and experts<br />
-How to update clash of magic apk to the latest version easily<br />
-Clash of magic apk vs clash of lights apk which one is better<br />
-Magic coc s1 10.322 r1 apk download link and installation guide<br />
-Clash of magic apk troubleshooting and support for common issues<br />
-Magic coc s1 10.322 r1 app download size and compatibility with android devices<br />
-Clash of magic apk alternatives and similar apps for coc private server<br />
-Magic coc s1 10.322 r1 app pros and cons for coc fans<br />
-Clash of magic apk security and safety tips for downloading and playing<br />
-Magic coc s1 10.322 r1 app feedback and suggestions from users and developers<br />
-Clash of magic apk faq and answers to frequently asked questions<br />
-Magic coc s1 10.322 r1 app screenshots and videos for preview and demonstration<br />
-Clash of magic apk history and development by tatem games inc.<br />
-Magic coc s1 10.322 r1 app news and updates from official sources<br />
-Clash of magic apk comparison and difference with original coc game<br />
-Magic coc s1 10.322 r1 app requirements and specifications for optimal performance<br />
-Clash of magic apk advantages and disadvantages for coc lovers<br />
-Magic coc s1 10.322 r1 app testimonials and reviews from satisfied users<br />
-Clash of magic apk tips and tricks for mastering the game<br />
-Magic coc s1 10.322 r1 app hacks and cheats for getting more resources and gems<br />
-Clash of magic apk best practices and recommendations for playing the game<br />
-Magic coc s1 10.322 r1 app rankings and ratings on google play store and other platforms<br />
-Clash of magic apk fun facts and trivia about the game and its developers<br />
-Magic coc s1 10.322 r1 app challenges and achievements for completing the game<br />
-Clash of magic apk community and social media for connecting with other players<br />
-Magic coc s1 10.322 r1 app tutorials and guides for learning the game<br />
-Clash of magic apk statistics and data for analyzing the game performance<br />
-Magic coc s1 10.322 r1 app rewards and incentives for playing the game regularly<br />
-Clash of magic apk myths and misconceptions about the game and its features<br />
-Magic coc s1 10.322 r1 app terms and conditions for using the game legally</p>
- <h3>Q: Can I play APK Magic COC S1 on PC?</h3>
-<p>A: Yes, you can play APK Magic COC S1 on PC using an Android emulator. An Android emulator is a software that allows you to run Android apps on your PC. Some of the popular Android emulators are BlueStacks, NoxPlayer, and LDPlayer. You can download any of these emulators from their official websites and install them on your PC. Then, you can download APK Magic COC S1 from the link  and install it on your emulator. After that, you can launch the app and play it on your PC.</p>
- <h3>Q: How can I update APK Magic COC S1?</h3>
-<p>A: APK Magic COC S1 is not updated regularly with the latest features and updates from Clash of Clans. However, if there is a new version available, you can update it by downloading the latest APK file from the link  and installing it over the existing app. You don't have to uninstall the previous version or lose your data.</p>
- <h3>Q: How can I contact the developer of APK Magic COC S1?</h3>
-<p>A: The developer of APK Magic COC S1 is unknown and does not have an official website or social media account. Therefore, it is difficult to contact them or get support from them. However, you can try to contact them through their email address  or their Telegram group [^ <h3>Q: What is the difference between APK Magic COC S1 and Clash of Clans?</h3>
-<p>A: APK Magic COC S1 and Clash of Clans are both strategy games that involve building bases, training troops, and attacking other players. However, APK Magic COC S1 is a modified version of Clash of Clans that runs on a private server and has unlimited resources and custom mods. Clash of Clans is the official version of the game that runs on Supercell's servers and has limited resources and standard features.</p>
- <h3>Q: Can I play APK Magic COC S1 with my friends?</h3>
-<p>A: Yes, you can play APK Magic COC S1 with your friends if they are also using the same private server as you. You can join clans and chat with your friends in the game. You can also invite your friends to join your server by sharing the link  or the QR code . However, you cannot play APK Magic COC S1 with your friends who are using the official version of Clash of Clans or a different private server.</p>
- <p>We hope this article has helped you learn more about APK Magic COC S1 versi terbaru and how to download and install it on your device. If you have any feedback or suggestions, please feel free to contact us at  or join our Telegram group . Thank you for reading and happy gaming!</p> 197e85843d<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/FIFA Mobile Hile - The Best Tricks and Tips for Winning Every Match.md DELETED Viewed

@@ -1,114 +0,0 @@
-<br />
-<h1>FIFA APK Hile: How to Play FIFA Mobile with Unlimited Coins and Gems</h1>
-<p>If you are a fan of football games, you probably know about FIFA Mobile, the popular mobile game from EA Sports that lets you play with your favorite teams and players from around the world. But did you know that there is a way to play FIFA Mobile with unlimited coins and gems? Yes, you heard that right. With FIFA APK Hile, you can enjoy the game without spending any money or waiting for hours to earn coins and gems. In this article, we will tell you everything you need to know about FIFA APK Hile, including what it is, why you should use it, how to download and install it, how to use it, what are its features, what are some tips and tricks for it, and what are the risks of using it.</p>
-<h2>What is FIFA APK Hile?</h2>
-<p>FIFA APK Hile is a modified version of FIFA Mobile that gives you unlimited coins and gems to buy players, packs, and upgrades in the game. Coins and gems are the main currencies in FIFA Mobile that allow you to improve your team and compete with other players online. However, earning coins and gems in the game can be very slow and tedious, especially if you want to get the best players and items. That's why some people use FIFA APK Hile to get unlimited coins and gems for free.</p>
-<h2>fifa apk hile</h2><br /><p><b><b>Download Zip</b> &#10038; <a href="https://jinyurl.com/2uNQSz">https://jinyurl.com/2uNQSz</a></b></p><br /><br />
-<h2>Why Use FIFA APK Hile?</h2>
-<p>There are many reasons why you might want to use FIFA APK Hile. Here are some of them:</p>
-<ul>
-<li>You can have more fun playing the game without worrying about running out of coins or gems.</li>
-<li>You can save money that you would otherwise spend on buying coins or gems with real money.</li>
-<li>You can build your dream team with any players you want, regardless of their price or availability.</li>
-<li>You can unlock all the modes, features, and events in the game that require coins or gems.</li>
-<li>You can experiment with different strategies and tactics without risking your coins or gems.</li>
-</ul>
-<h2>How to Download and Install FIFA APK Hile?</h2>
-<p>Downloading and installing FIFA APK Hile is very easy. Just follow these steps:</p>
-<ol>
-<li>Go to this link: [FIFA Mobile APK Para Hilesi (2022) Sınırsız Para - Websesi](^2^) and click on the download button.</li>
-<li>Wait for the download to finish and locate the FIFA APK Hile file on your device.</li>
-<li>Tap on the file and allow the installation from unknown sources if prompted.</li>
-<li>Wait for the installation to complete and launch the game.</li>
-<li>Enjoy playing FIFA Mobile with unlimited coins and gems.</li>
-</ol>
-<h2>How to Use FIFA APK Hile?</h2>
-<p>Using FIFA APK Hile is very simple. Once you launch the game, you will see that you have unlimited coins and gems in your account. You can use them to buy anything you want in the game, such as players, packs, and upgrades. Here are some examples of how to use FIFA APK Hile:</p>
-<ul>
-<li>To buy players, go to the market and search for the player you want. You can filter by name, rating, position, league, nation, or team. Then, tap on the player and buy him with coins or gems.</li>
-<li>To buy packs, go to the store and choose the pack you want. You can buy premium packs, special packs, or event packs with coins or gems. Then, open the pack and see what players and items you get.</li>
-<li>To upgrade your team, go to the team management and select the player you want to upgrade. You can upgrade his skills, chemistry, or rank with coins or gems. You can also train him with other players or items.</li>
-</ul>
-<h2>What are the Features of FIFA APK Hile?</h2>
-<p>FIFA APK Hile has many features that make it better than the original FIFA Mobile. Some of these features are:</p>
-<ul>
-<li>New gameplay technology that makes the game more realistic, responsive, and fluid.</li>
-<li>New modes such as Volta Football, Career Mode, Ultimate Team, and Champions League.</li>
-<li>New players such as Messi, Ronaldo, Neymar, Mbappe, and Haaland.</li>
-<li>New graphics that enhance the visual quality of the game.</li>
-</ul>
-<h2>What are the Tips and Tricks for FIFA APK Hile?</h2>
-<p>FIFA APK Hile is a fun and easy game to play, but there are some tips and tricks that can help you improve your skills and performance. Here are some of them:</p>
-<p>fifa mobile apk hile indir<br />
-fifa soccer apk hile nasıl yapılır<br />
-fifa 2023 apk hile mod<br />
-fifa ultimate team apk hile<br />
-fifa 21 apk hile android oyun club<br />
-fifa mobile apk hileli sınırsız para<br />
-fifa 20 apk hile güncel<br />
-fifa mobile apk hile yapma<br />
-fifa 19 apk hile full<br />
-fifa mobile apk hileli paket açılımı<br />
-fifa soccer apk hileli versiyon<br />
-fifa 22 apk hile mega<br />
-fifa mobile apk hileli indirme linki<br />
-fifa 18 apk hile kurulumu<br />
-fifa mobile apk hileli oyun indir club<br />
-fifa soccer apk hile nasıl indirilir<br />
-fifa 17 apk hile no root<br />
-fifa mobile apk hileli son sürüm<br />
-fifa soccer apk hileli oyna<br />
-fifa 16 apk hile mediafire<br />
-fifa mobile apk hileli nasıl yüklenir<br />
-fifa soccer apk hileli güncelleme<br />
-fifa 15 apk hile offline<br />
-fifa mobile apk hileli online<br />
-fifa soccer apk hileli mod menu<br />
-fifa 14 apk hile data<br />
-fifa mobile apk hileli para kasma<br />
-fifa soccer apk hileli hack<br />
-fifa 13 apk hile android 1<br />
-fifa mobile apk hileli yeni sezon<br />
-fifa soccer apk hileli coins<br />
-fifa 12 apk hile obb<br />
-fifa mobile apk hileli transfer marketi açma<br />
-fifa soccer apk hileli vip<br />
-fifa 11 apk hile revdl<br />
-fifa mobile apk hileli oyuncu yükseltme<br />
-fifa soccer apk hileli unlimited money<br />
-fifa 10 apk hile rexdl<br />
-fifa mobile apk hileli draft modu<br />
-fifa soccer apk hileli points</p>
-<ul>
-<li>Use explosive sprint to accelerate past defenders and create space for yourself or your teammates.</li>
-<li>Use finesse shots to curl the ball around the goalkeeper and score from tight angles.</li>
-<li>Use creative runs to control where your teammates run and create more options for passing or shooting.</li>
-<li>Use adaptive right stick switching to switch between defenders quickly and easily.</li>
-</ul>
-<h2>What are the Risks of FIFA APK Hile?</h2>
-<p>FIFA APK Hile may sound like a great way to play FIFA Mobile, but it also comes with some risks that you should be aware of. Some of these risks are:</p>
-<ul>
-<li>You may violate the terms of service of EA Sports and get banned from playing FIFA Mobile or other EA games.</li>
-<li>You may lose your progress and data if you uninstall FIFA APK Hile or update it to a newer version.</li>
-<li>You may expose your device to malware or viruses that may harm your device or steal your personal information.</li>
-</ul>
-<h2>Conclusion</h2>
-<p>FIFA APK Hile is a modified version of FIFA Mobile that gives you unlimited coins and gems to play the game without any limitations. It has many features, benefits, and tips that make it more enjoyable and exciting than the original game. However, it also has some risks that you should consider before using it. If you want to try FIFA APK Hile, you can download it from this link: [FIFA Mobile APK Para Hilesi (2022) Sınırsız Para - Websesi] and follow the instructions in this article. Have fun playing FIFA Mobile with unlimited coins and gems!</p>
- <h2>FAQs</h2>
- <p>Here are some frequently asked questions about FIFA APK Hile:</p>
- <ol>
- <li>What is FIFA APK Hile?</li>
- <p>FIFA APK Hile is a modified version of FIFA Mobile that gives you unlimited coins and gems to buy players, packs, and upgrades in the game.</p>
- <li>How to download and install FIFA APK Hile?</li>
- <p>You can download FIFA APK Hile from this link: [FIFA Mobile APK Para Hilesi (2022) Sınırsız Para - Websesi] and install it on your Android device by following these steps: - Go to this link: [FIFA Mobile APK Para Hilesi (2022) Sınırsız Para - Websesi] and click on the download button. - Wait for the download to finish and locate the FIFA APK Hile file on your device. - Tap on the file and allow the installation from unknown sources if prompted. - Wait for the installation to complete and launch the game. - Enjoy playing FIFA Mobile with unlimited coins and gems.</p>
- <li>How to use FIFA APK Hile?</li>
- <p>You can use FIFA APK Hile to buy anything you want in the game, such as players, packs, and upgrades. You can also unlock all the modes, features, and events in the game. Here are some examples of how to use FIFA APK Hile: - To buy players, go to the market and search for the player you want. You can filter by name, rating, position, league, nation, or team. Then, tap on the player and buy him with coins or gems. - To buy packs, go to the store and choose the pack you want. You can buy premium packs, special packs, or event packs with coins or gems. Then, open the pack and see what players and items you get. - To upgrade your team, go to the team management and select the player you want to upgrade. You can upgrade his skills, chemistry, or rank with coins or gems. You can also train him with other players or items.</p>
- <li>What are the features of FIFA APK Hile?</li>
- <p>FIFA APK Hile has many features that make it better than the original FIFA Mobile. Some of these features are: - New gameplay technology that makes the game more realistic, responsive, and fluid. - New modes such as Volta Football, Career Mode, Ultimate Team, and Champions League. - New players such as Messi, Ronaldo, Neymar, Mbappe, and Haaland. - New graphics that enhance the visual quality of the game.</p>
- <li>What are the tips and tricks for FIFA APK Hile?</li>
- <p>FIFA APK Hile is a fun and easy game to play, but there are some tips and tricks that can help you improve your skills and performance. Here are some of them: - Use explosive sprint to accelerate past defenders and create space for yourself or your teammates. - Use finesse shots to curl the ball around the goalkeeper and score from tight angles. - Use creative runs to control where your teammates run and create more options for passing or shooting. - Use adaptive right stick switching to switch between defenders quickly and easily.</p>
- <li>What are the risks of FIFA APK Hile?</li>
- <p>FIFA APK Hile may sound like a great way to play FIFA Mobile, but it also comes with some risks that you should be aware of. Some of these risks are: - You may violate the terms of service of EA Sports and get banned from playing FIFA Mobile or other EA games. - You may lose your progress and data if you uninstall FIFA APK Hile or update it to a newer version. - You may expose your device to malware or viruses that may harm your device or steal your personal information.</p>
-</ol></p> 401be4b1e0<br />
-<br />
-<br />

spaces/44ov41za8i/FreeVC/utils.py DELETED Viewed

@@ -1,305 +0,0 @@
-import os
-import sys
-import argparse
-import logging
-import json
-import subprocess
-import numpy as np
-from scipy.io.wavfile import read
-import torch
-from torch.nn import functional as F
-from commons import sequence_mask
-MATPLOTLIB_FLAG = False
-logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
-logger = logging
-def get_cmodel(rank):
-    checkpoint = torch.load('wavlm/WavLM-Large.pt')
-    cfg = WavLMConfig(checkpoint['cfg'])
-    cmodel = WavLM(cfg).cuda(rank)
-    cmodel.load_state_dict(checkpoint['model'])
-    cmodel.eval()
-    return cmodel
-def get_content(cmodel, y):
-    with torch.no_grad():
-        c = cmodel.extract_features(y.squeeze(1))[0]
-    c = c.transpose(1, 2)
-    return c
-def get_vocoder(rank):
-    with open("hifigan/config.json", "r") as f:
-        config = json.load(f)
-    config = hifigan.AttrDict(config)
-    vocoder = hifigan.Generator(config)
-    ckpt = torch.load("hifigan/generator_v1")
-    vocoder.load_state_dict(ckpt["generator"])
-    vocoder.eval()
-    vocoder.remove_weight_norm()
-    vocoder.cuda(rank)
-    return vocoder
-def transform(mel, height): # 68-92
-    #r = np.random.random()
-    #rate = r * 0.3 + 0.85 # 0.85-1.15
-    #height = int(mel.size(-2) * rate)
-    tgt = torchvision.transforms.functional.resize(mel, (height, mel.size(-1)))
-    if height >= mel.size(-2):
-        return tgt[:, :mel.size(-2), :]
-    else:
-        silence = tgt[:,-1:,:].repeat(1,mel.size(-2)-height,1)
-        silence += torch.randn_like(silence) / 10
-        return torch.cat((tgt, silence), 1)
-def stretch(mel, width): # 0.5-2
-    return torchvision.transforms.functional.resize(mel, (mel.size(-2), width))
-def load_checkpoint(checkpoint_path, model, optimizer=None):
-  assert os.path.isfile(checkpoint_path)
-  checkpoint_dict = torch.load(checkpoint_path, map_location='cpu')
-  iteration = checkpoint_dict['iteration']
-  learning_rate = checkpoint_dict['learning_rate']
-  if optimizer is not None:
-    optimizer.load_state_dict(checkpoint_dict['optimizer'])
-  saved_state_dict = checkpoint_dict['model']
-  if hasattr(model, 'module'):
-    state_dict = model.module.state_dict()
-  else:
-    state_dict = model.state_dict()
-  new_state_dict= {}
-  for k, v in state_dict.items():
-    try:
-      new_state_dict[k] = saved_state_dict[k]
-    except:
-      logger.info("%s is not in the checkpoint" % k)
-      new_state_dict[k] = v
-  if hasattr(model, 'module'):
-    model.module.load_state_dict(new_state_dict)
-  else:
-    model.load_state_dict(new_state_dict)
-  logger.info("Loaded checkpoint '{}' (iteration {})" .format(
-    checkpoint_path, iteration))
-  return model, optimizer, learning_rate, iteration
-def save_checkpoint(model, optimizer, learning_rate, iteration, checkpoint_path):
-  logger.info("Saving model and optimizer state at iteration {} to {}".format(
-    iteration, checkpoint_path))
-  if hasattr(model, 'module'):
-    state_dict = model.module.state_dict()
-  else:
-    state_dict = model.state_dict()
-  torch.save({'model': state_dict,
-              'iteration': iteration,
-              'optimizer': optimizer.state_dict(),
-              'learning_rate': learning_rate}, checkpoint_path)
-def summarize(writer, global_step, scalars={}, histograms={}, images={}, audios={}, audio_sampling_rate=22050):
-  for k, v in scalars.items():
-    writer.add_scalar(k, v, global_step)
-  for k, v in histograms.items():
-    writer.add_histogram(k, v, global_step)
-  for k, v in images.items():
-    writer.add_image(k, v, global_step, dataformats='HWC')
-  for k, v in audios.items():
-    writer.add_audio(k, v, global_step, audio_sampling_rate)
-def latest_checkpoint_path(dir_path, regex="G_*.pth"):
-  f_list = glob.glob(os.path.join(dir_path, regex))
-  f_list.sort(key=lambda f: int("".join(filter(str.isdigit, f))))
-  x = f_list[-1]
-  print(x)
-  return x
-def plot_spectrogram_to_numpy(spectrogram):
-  global MATPLOTLIB_FLAG
-  if not MATPLOTLIB_FLAG:
-    import matplotlib
-    matplotlib.use("Agg")
-    MATPLOTLIB_FLAG = True
-    mpl_logger = logging.getLogger('matplotlib')
-    mpl_logger.setLevel(logging.WARNING)
-  import matplotlib.pylab as plt
-  import numpy as np
-  fig, ax = plt.subplots(figsize=(10,2))
-  im = ax.imshow(spectrogram, aspect="auto", origin="lower",
-                  interpolation='none')
-  plt.colorbar(im, ax=ax)
-  plt.xlabel("Frames")
-  plt.ylabel("Channels")
-  plt.tight_layout()
-  fig.canvas.draw()
-  data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='')
-  data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))
-  plt.close()
-  return data
-def plot_alignment_to_numpy(alignment, info=None):
-  global MATPLOTLIB_FLAG
-  if not MATPLOTLIB_FLAG:
-    import matplotlib
-    matplotlib.use("Agg")
-    MATPLOTLIB_FLAG = True
-    mpl_logger = logging.getLogger('matplotlib')
-    mpl_logger.setLevel(logging.WARNING)
-  import matplotlib.pylab as plt
-  import numpy as np
-  fig, ax = plt.subplots(figsize=(6, 4))
-  im = ax.imshow(alignment.transpose(), aspect='auto', origin='lower',
-                  interpolation='none')
-  fig.colorbar(im, ax=ax)
-  xlabel = 'Decoder timestep'
-  if info is not None:
-      xlabel += '\n\n' + info
-  plt.xlabel(xlabel)
-  plt.ylabel('Encoder timestep')
-  plt.tight_layout()
-  fig.canvas.draw()
-  data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='')
-  data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))
-  plt.close()
-  return data
-def load_wav_to_torch(full_path):
-  sampling_rate, data = read(full_path)
-  return torch.FloatTensor(data.astype(np.float32)), sampling_rate
-def load_filepaths_and_text(filename, split="|"):
-  with open(filename, encoding='utf-8') as f:
-    filepaths_and_text = [line.strip().split(split) for line in f]
-  return filepaths_and_text
-def get_hparams(init=True):
-  parser = argparse.ArgumentParser()
-  parser.add_argument('-c', '--config', type=str, default="./configs/base.json",
-                      help='JSON file for configuration')
-  parser.add_argument('-m', '--model', type=str, required=True,
-                      help='Model name')
-  args = parser.parse_args()
-  model_dir = os.path.join("./logs", args.model)
-  if not os.path.exists(model_dir):
-    os.makedirs(model_dir)
-  config_path = args.config
-  config_save_path = os.path.join(model_dir, "config.json")
-  if init:
-    with open(config_path, "r") as f:
-      data = f.read()
-    with open(config_save_path, "w") as f:
-      f.write(data)
-  else:
-    with open(config_save_path, "r") as f:
-      data = f.read()
-  config = json.loads(data)
-  hparams = HParams(**config)
-  hparams.model_dir = model_dir
-  return hparams
-def get_hparams_from_dir(model_dir):
-  config_save_path = os.path.join(model_dir, "config.json")
-  with open(config_save_path, "r") as f:
-    data = f.read()
-  config = json.loads(data)
-  hparams =HParams(**config)
-  hparams.model_dir = model_dir
-  return hparams
-def get_hparams_from_file(config_path):
-  with open(config_path, "r") as f:
-    data = f.read()
-  config = json.loads(data)
-  hparams =HParams(**config)
-  return hparams
-def check_git_hash(model_dir):
-  source_dir = os.path.dirname(os.path.realpath(__file__))
-  if not os.path.exists(os.path.join(source_dir, ".git")):
-    logger.warn("{} is not a git repository, therefore hash value comparison will be ignored.".format(
-      source_dir
-    ))
-    return
-  cur_hash = subprocess.getoutput("git rev-parse HEAD")
-  path = os.path.join(model_dir, "githash")
-  if os.path.exists(path):
-    saved_hash = open(path).read()
-    if saved_hash != cur_hash:
-      logger.warn("git hash values are different. {}(saved) != {}(current)".format(
-        saved_hash[:8], cur_hash[:8]))
-  else:
-    open(path, "w").write(cur_hash)
-def get_logger(model_dir, filename="train.log"):
-  global logger
-  logger = logging.getLogger(os.path.basename(model_dir))
-  logger.setLevel(logging.DEBUG)
-  formatter = logging.Formatter("%(asctime)s\t%(name)s\t%(levelname)s\t%(message)s")
-  if not os.path.exists(model_dir):
-    os.makedirs(model_dir)
-  h = logging.FileHandler(os.path.join(model_dir, filename))
-  h.setLevel(logging.DEBUG)
-  h.setFormatter(formatter)
-  logger.addHandler(h)
-  return logger
-class HParams():
-  def __init__(self, **kwargs):
-    for k, v in kwargs.items():
-      if type(v) == dict:
-        v = HParams(**v)
-      self[k] = v
-  def keys(self):
-    return self.__dict__.keys()
-  def items(self):
-    return self.__dict__.items()
-  def values(self):
-    return self.__dict__.values()
-  def __len__(self):
-    return len(self.__dict__)
-  def __getitem__(self, key):
-    return getattr(self, key)
-  def __setitem__(self, key, value):
-    return setattr(self, key, value)
-  def __contains__(self, key):
-    return key in self.__dict__
-  def __repr__(self):
-    return self.__dict__.__repr__()

spaces/4Taps/SadTalker/src/face3d/models/arcface_torch/configs/3millions_pfc.py DELETED Viewed

@@ -1,23 +0,0 @@
-from easydict import EasyDict as edict
-# configs for test speed
-config = edict()
-config.loss = "arcface"
-config.network = "r50"
-config.resume = False
-config.output = None
-config.embedding_size = 512
-config.sample_rate = 0.1
-config.fp16 = True
-config.momentum = 0.9
-config.weight_decay = 5e-4
-config.batch_size = 128
-config.lr = 0.1  # batch size is 512
-config.rec = "synthetic"
-config.num_classes = 300 * 10000
-config.num_epoch = 30
-config.warmup_epoch = -1
-config.decay_epoch = [10, 16, 22]
-config.val_targets = []

spaces/4Taps/SadTalker/src/face3d/models/arcface_torch/utils/utils_os.py DELETED Viewed

File without changes

spaces/AIGC-Audio/AudioGPT/NeuralSeq/data_gen/tts/emotion/inference.py DELETED Viewed

@@ -1,177 +0,0 @@
-from data_gen.tts.emotion.params_data import *
-from data_gen.tts.emotion.model import EmotionEncoder
-from data_gen.tts.emotion.audio import preprocess_wav   # We want to expose this function from here
-from matplotlib import cm
-from data_gen.tts.emotion import audio
-from pathlib import Path
-import matplotlib.pyplot as plt
-import numpy as np
-import torch
-_model = None # type: EmotionEncoder
-_device = None # type: torch.device
-def load_model(weights_fpath: Path, device=None):
-    """
-    Loads the model in memory. If this function is not explicitely called, it will be run on the
-    first call to embed_frames() with the default weights file.
-    :param weights_fpath: the path to saved model weights.
-    :param device: either a torch device or the name of a torch device (e.g. "cpu", "cuda"). The
-    model will be loaded and will run on this device. Outputs will however always be on the cpu.
-    If None, will default to your GPU if it"s available, otherwise your CPU.
-    """
-    # TODO: I think the slow loading of the encoder might have something to do with the device it
-    #   was saved on. Worth investigating.
-    global _model, _device
-    if device is None:
-        _device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    elif isinstance(device, str):
-        _device = torch.device(device)
-    _model = EmotionEncoder(_device, torch.device("cpu"))
-    checkpoint = torch.load(weights_fpath)
-    _model.load_state_dict(checkpoint["model_state"])
-    _model.eval()
-    print("Loaded encoder trained to step %d" % (checkpoint["step"]))
-def is_loaded():
-    return _model is not None
-def embed_frames_batch(frames_batch):
-    """
-    Computes embeddings for a batch of mel spectrogram.
-    :param frames_batch: a batch mel of spectrogram as a numpy array of float32 of shape
-    (batch_size, n_frames, n_channels)
-    :return: the embeddings as a numpy array of float32 of shape (batch_size, model_embedding_size)
-    """
-    if _model is None:
-        raise Exception("Model was not loaded. Call load_model() before inference.")
-    frames = torch.from_numpy(frames_batch).to(_device)
-    embed = _model.inference(frames).detach().cpu().numpy()
-    return embed
-def compute_partial_slices(n_samples, partial_utterance_n_frames=partials_n_frames,
-                           min_pad_coverage=0.75, overlap=0.5):
-    """
-    Computes where to split an utterance waveform and its corresponding mel spectrogram to obtain
-    partial utterances of <partial_utterance_n_frames> each. Both the waveform and the mel
-    spectrogram slices are returned, so as to make each partial utterance waveform correspond to
-    its spectrogram. This function assumes that the mel spectrogram parameters used are those
-    defined in params_data.py.
-    The returned ranges may be indexing further than the length of the waveform. It is
-    recommended that you pad the waveform with zeros up to wave_slices[-1].stop.
-    :param n_samples: the number of samples in the waveform
-    :param partial_utterance_n_frames: the number of mel spectrogram frames in each partial
-    utterance
-    :param min_pad_coverage: when reaching the last partial utterance, it may or may not have
-    enough frames. If at least <min_pad_coverage> of <partial_utterance_n_frames> are present,
-    then the last partial utterance will be considered, as if we padded the audio. Otherwise,
-    it will be discarded, as if we trimmed the audio. If there aren't enough frames for 1 partial
-    utterance, this parameter is ignored so that the function always returns at least 1 slice.
-    :param overlap: by how much the partial utterance should overlap. If set to 0, the partial
-    utterances are entirely disjoint.
-    :return: the waveform slices and mel spectrogram slices as lists of array slices. Index
-    respectively the waveform and the mel spectrogram with these slices to obtain the partial
-    utterances.
-    """
-    assert 0 <= overlap < 1
-    assert 0 < min_pad_coverage <= 1
-    samples_per_frame = int((sampling_rate * mel_window_step / 1000))
-    n_frames = int(np.ceil((n_samples + 1) / samples_per_frame))
-    frame_step = max(int(np.round(partial_utterance_n_frames * (1 - overlap))), 1)
-    # Compute the slices
-    wav_slices, mel_slices = [], []
-    steps = max(1, n_frames - partial_utterance_n_frames + frame_step + 1)
-    for i in range(0, steps, frame_step):
-        mel_range = np.array([i, i + partial_utterance_n_frames])
-        wav_range = mel_range * samples_per_frame
-        mel_slices.append(slice(*mel_range))
-        wav_slices.append(slice(*wav_range))
-    # Evaluate whether extra padding is warranted or not
-    last_wav_range = wav_slices[-1]
-    coverage = (n_samples - last_wav_range.start) / (last_wav_range.stop - last_wav_range.start)
-    if coverage < min_pad_coverage and len(mel_slices) > 1:
-        mel_slices = mel_slices[:-1]
-        wav_slices = wav_slices[:-1]
-    return wav_slices, mel_slices
-def embed_utterance(wav, using_partials=True, return_partials=False, **kwargs):
-    """
-    Computes an embedding for a single utterance.
-    # TODO: handle multiple wavs to benefit from batching on GPU
-    :param wav: a preprocessed (see audio.py) utterance waveform as a numpy array of float32
-    :param using_partials: if True, then the utterance is split in partial utterances of
-    <partial_utterance_n_frames> frames and the utterance embedding is computed from their
-    normalized average. If False, the utterance is instead computed from feeding the entire
-    spectogram to the network.
-    :param return_partials: if True, the partial embeddings will also be returned along with the
-    wav slices that correspond to the partial embeddings.
-    :param kwargs: additional arguments to compute_partial_splits()
-    :return: the embedding as a numpy array of float32 of shape (model_embedding_size,). If
-    <return_partials> is True, the partial utterances as a numpy array of float32 of shape
-    (n_partials, model_embedding_size) and the wav partials as a list of slices will also be
-    returned. If <using_partials> is simultaneously set to False, both these values will be None
-    instead.
-    """
-    # Process the entire utterance if not using partials
-    if not using_partials:
-        frames = audio.wav_to_mel_spectrogram(wav)
-        embed = embed_frames_batch(frames[None, ...])[0]
-        if return_partials:
-            return embed, None, None
-        return embed
-    # Compute where to split the utterance into partials and pad if necessary
-    wave_slices, mel_slices = compute_partial_slices(len(wav), **kwargs)
-    max_wave_length = wave_slices[-1].stop
-    if max_wave_length >= len(wav):
-        wav = np.pad(wav, (0, max_wave_length - len(wav)), "constant")
-    # Split the utterance into partials
-    frames = audio.wav_to_mel_spectrogram(wav)
-    frames_batch = np.array([frames[s] for s in mel_slices])
-    partial_embeds = embed_frames_batch(frames_batch)
-    # Compute the utterance embedding from the partial embeddings
-    raw_embed = np.mean(partial_embeds, axis=0)
-    embed = raw_embed / np.linalg.norm(raw_embed, 2)
-    if return_partials:
-        return embed, partial_embeds, wave_slices
-    return embed
-def embed_speaker(wavs, **kwargs):
-    raise NotImplemented()
-def plot_embedding_as_heatmap(embed, ax=None, title="", shape=None, color_range=(0, 0.30)):
-    if ax is None:
-        ax = plt.gca()
-    if shape is None:
-        height = int(np.sqrt(len(embed)))
-        shape = (height, -1)
-    embed = embed.reshape(shape)
-    cmap = cm.get_cmap()
-    mappable = ax.imshow(embed, cmap=cmap)
-    cbar = plt.colorbar(mappable, ax=ax, fraction=0.046, pad=0.04)
-    cbar.set_clim(*color_range)
-    ax.set_xticks([]), ax.set_yticks([])
-    ax.set_title(title)

spaces/AIGC-Audio/Make_An_Audio_inpaint/ldm/modules/diffusionmodules/openaimodel.py DELETED Viewed

@@ -1,963 +0,0 @@
-from abc import abstractmethod
-from functools import partial
-import math
-from typing import Iterable
-import numpy as np
-import torch as th
-import torch.nn as nn
-import torch.nn.functional as F
-from ldm.modules.diffusionmodules.util import (
-    checkpoint,
-    conv_nd,
-    linear,
-    avg_pool_nd,
-    zero_module,
-    normalization,
-    timestep_embedding,
-)
-from ldm.modules.attention import SpatialTransformer
-# dummy replace
-def convert_module_to_f16(x):
-    pass
-def convert_module_to_f32(x):
-    pass
-## go
-class AttentionPool2d(nn.Module):
-    """
-    Adapted from CLIP: https://github.com/openai/CLIP/blob/main/clip/model.py
-    """
-    def __init__(
-        self,
-        spacial_dim: int,
-        embed_dim: int,
-        num_heads_channels: int,
-        output_dim: int = None,
-    ):
-        super().__init__()
-        self.positional_embedding = nn.Parameter(th.randn(embed_dim, spacial_dim ** 2 + 1) / embed_dim ** 0.5)
-        self.qkv_proj = conv_nd(1, embed_dim, 3 * embed_dim, 1)
-        self.c_proj = conv_nd(1, embed_dim, output_dim or embed_dim, 1)
-        self.num_heads = embed_dim // num_heads_channels
-        self.attention = QKVAttention(self.num_heads)
-    def forward(self, x):
-        b, c, *_spatial = x.shape
-        x = x.reshape(b, c, -1)  # NC(HW)
-        x = th.cat([x.mean(dim=-1, keepdim=True), x], dim=-1)  # NC(HW+1)
-        x = x + self.positional_embedding[None, :, :].to(x.dtype)  # NC(HW+1)
-        x = self.qkv_proj(x)
-        x = self.attention(x)
-        x = self.c_proj(x)
-        return x[:, :, 0]
-class TimestepBlock(nn.Module):
-    """
-    Any module where forward() takes timestep embeddings as a second argument.
-    """
-    @abstractmethod
-    def forward(self, x, emb):
-        """
-        Apply the module to `x` given `emb` timestep embeddings.
-        """
-class TimestepEmbedSequential(nn.Sequential, TimestepBlock):
-    """
-    A sequential module that passes timestep embeddings to the children that
-    support it as an extra input.
-    """
-    def forward(self, x, emb, context=None):
-        for layer in self:
-            if isinstance(layer, TimestepBlock):
-                x = layer(x, emb)
-            elif isinstance(layer, SpatialTransformer):
-                x = layer(x, context)
-            else:
-                x = layer(x)
-        return x
-class Upsample(nn.Module):
-    """
-    An upsampling layer with an optional convolution.
-    :param channels: channels in the inputs and outputs.
-    :param use_conv: a bool determining if a convolution is applied.
-    :param dims: determines if the signal is 1D, 2D, or 3D. If 3D, then
-                 upsampling occurs in the inner-two dimensions.
-    """
-    def __init__(self, channels, use_conv, dims=2, out_channels=None, padding=1):
-        super().__init__()
-        self.channels = channels
-        self.out_channels = out_channels or channels
-        self.use_conv = use_conv
-        self.dims = dims
-        if use_conv:
-            self.conv = conv_nd(dims, self.channels, self.out_channels, 3, padding=padding)
-    def forward(self, x):
-        assert x.shape[1] == self.channels
-        if self.dims == 3:
-            x = F.interpolate(
-                x, (x.shape[2], x.shape[3] * 2, x.shape[4] * 2), mode="nearest"
-            )
-        else:
-            x = F.interpolate(x, scale_factor=2, mode="nearest")
-        if self.use_conv:
-            x = self.conv(x)
-        return x
-class TransposedUpsample(nn.Module):
-    'Learned 2x upsampling without padding'
-    def __init__(self, channels, out_channels=None, ks=5):
-        super().__init__()
-        self.channels = channels
-        self.out_channels = out_channels or channels
-        self.up = nn.ConvTranspose2d(self.channels,self.out_channels,kernel_size=ks,stride=2)
-    def forward(self,x):
-        return self.up(x)
-class Downsample(nn.Module):
-    """
-    A downsampling layer with an optional convolution.
-    :param channels: channels in the inputs and outputs.
-    :param use_conv: a bool determining if a convolution is applied.
-    :param dims: determines if the signal is 1D, 2D, or 3D. If 3D, then
-                 downsampling occurs in the inner-two dimensions.
-    """
-    def __init__(self, channels, use_conv, dims=2, out_channels=None,padding=1):
-        super().__init__()
-        self.channels = channels
-        self.out_channels = out_channels or channels
-        self.use_conv = use_conv
-        self.dims = dims
-        stride = 2 if dims != 3 else (1, 2, 2)
-        if use_conv:
-            self.op = conv_nd(
-                dims, self.channels, self.out_channels, 3, stride=stride, padding=padding
-            )
-        else:
-            assert self.channels == self.out_channels
-            self.op = avg_pool_nd(dims, kernel_size=stride, stride=stride)
-    def forward(self, x):
-        assert x.shape[1] == self.channels
-        return self.op(x)
-class ResBlock(TimestepBlock):
-    """
-    A residual block that can optionally change the number of channels.
-    :param channels: the number of input channels.
-    :param emb_channels: the number of timestep embedding channels.
-    :param dropout: the rate of dropout.
-    :param out_channels: if specified, the number of out channels.
-    :param use_conv: if True and out_channels is specified, use a spatial
-        convolution instead of a smaller 1x1 convolution to change the
-        channels in the skip connection.
-    :param dims: determines if the signal is 1D, 2D, or 3D.
-    :param use_checkpoint: if True, use gradient checkpointing on this module.
-    :param up: if True, use this block for upsampling.
-    :param down: if True, use this block for downsampling.
-    """
-    def __init__(
-        self,
-        channels,
-        emb_channels,
-        dropout,
-        out_channels=None,
-        use_conv=False,
-        use_scale_shift_norm=False,
-        dims=2,
-        use_checkpoint=False,
-        up=False,
-        down=False,
-    ):
-        super().__init__()
-        self.channels = channels
-        self.emb_channels = emb_channels
-        self.dropout = dropout
-        self.out_channels = out_channels or channels
-        self.use_conv = use_conv
-        self.use_checkpoint = use_checkpoint
-        self.use_scale_shift_norm = use_scale_shift_norm
-        self.in_layers = nn.Sequential(
-            normalization(channels),
-            nn.SiLU(),
-            conv_nd(dims, channels, self.out_channels, 3, padding=1),
-        )
-        self.updown = up or down
-        if up:
-            self.h_upd = Upsample(channels, False, dims)
-            self.x_upd = Upsample(channels, False, dims)
-        elif down:
-            self.h_upd = Downsample(channels, False, dims)
-            self.x_upd = Downsample(channels, False, dims)
-        else:
-            self.h_upd = self.x_upd = nn.Identity()
-        self.emb_layers = nn.Sequential(
-            nn.SiLU(),
-            linear(
-                emb_channels,
-                2 * self.out_channels if use_scale_shift_norm else self.out_channels,
-            ),
-        )
-        self.out_layers = nn.Sequential(
-            normalization(self.out_channels),
-            nn.SiLU(),
-            nn.Dropout(p=dropout),
-            zero_module(
-                conv_nd(dims, self.out_channels, self.out_channels, 3, padding=1)
-            ),
-        )
-        if self.out_channels == channels:
-            self.skip_connection = nn.Identity()
-        elif use_conv:
-            self.skip_connection = conv_nd(
-                dims, channels, self.out_channels, 3, padding=1
-            )
-        else:
-            self.skip_connection = conv_nd(dims, channels, self.out_channels, 1)
-    def forward(self, x, emb):
-        """
-        Apply the block to a Tensor, conditioned on a timestep embedding.
-        :param x: an [N x C x ...] Tensor of features.
-        :param emb: an [N x emb_channels] Tensor of timestep embeddings.
-        :return: an [N x C x ...] Tensor of outputs.
-        """
-        return checkpoint(
-            self._forward, (x, emb), self.parameters(), self.use_checkpoint
-        )
-    def _forward(self, x, emb):
-        if self.updown:
-            in_rest, in_conv = self.in_layers[:-1], self.in_layers[-1]
-            h = in_rest(x)
-            h = self.h_upd(h)
-            x = self.x_upd(x)
-            h = in_conv(h)
-        else:
-            h = self.in_layers(x)
-        emb_out = self.emb_layers(emb).type(h.dtype)
-        while len(emb_out.shape) < len(h.shape):
-            emb_out = emb_out[..., None]
-        if self.use_scale_shift_norm:
-            out_norm, out_rest = self.out_layers[0], self.out_layers[1:]
-            scale, shift = th.chunk(emb_out, 2, dim=1)
-            h = out_norm(h) * (1 + scale) + shift
-            h = out_rest(h)
-        else:
-            h = h + emb_out
-            h = self.out_layers(h)
-        return self.skip_connection(x) + h
-class AttentionBlock(nn.Module):
-    """
-    An attention block that allows spatial positions to attend to each other.
-    Originally ported from here, but adapted to the N-d case.
-    https://github.com/hojonathanho/diffusion/blob/1e0dceb3b3495bbe19116a5e1b3596cd0706c543/diffusion_tf/models/unet.py#L66.
-    """
-    def __init__(
-        self,
-        channels,
-        num_heads=1,
-        num_head_channels=-1,
-        use_checkpoint=False,
-        use_new_attention_order=False,
-    ):
-        super().__init__()
-        self.channels = channels
-        if num_head_channels == -1:
-            self.num_heads = num_heads
-        else:
-            assert (
-                channels % num_head_channels == 0
-            ), f"q,k,v channels {channels} is not divisible by num_head_channels {num_head_channels}"
-            self.num_heads = channels // num_head_channels
-        self.use_checkpoint = use_checkpoint
-        self.norm = normalization(channels)
-        self.qkv = conv_nd(1, channels, channels * 3, 1)
-        if use_new_attention_order:
-            # split qkv before split heads
-            self.attention = QKVAttention(self.num_heads)
-        else:
-            # split heads before split qkv
-            self.attention = QKVAttentionLegacy(self.num_heads)
-        self.proj_out = zero_module(conv_nd(1, channels, channels, 1))
-    def forward(self, x):
-        return checkpoint(self._forward, (x,), self.parameters(), True)   # TODO: check checkpoint usage, is True # TODO: fix the .half call!!!
-        #return pt_checkpoint(self._forward, x)  # pytorch
-    def _forward(self, x):
-        b, c, *spatial = x.shape
-        x = x.reshape(b, c, -1)
-        qkv = self.qkv(self.norm(x))
-        h = self.attention(qkv)
-        h = self.proj_out(h)
-        return (x + h).reshape(b, c, *spatial)
-def count_flops_attn(model, _x, y):
-    """
-    A counter for the `thop` package to count the operations in an
-    attention operation.
-    Meant to be used like:
-        macs, params = thop.profile(
-            model,
-            inputs=(inputs, timestamps),
-            custom_ops={QKVAttention: QKVAttention.count_flops},
-        )
-    """
-    b, c, *spatial = y[0].shape
-    num_spatial = int(np.prod(spatial))
-    # We perform two matmuls with the same number of ops.
-    # The first computes the weight matrix, the second computes
-    # the combination of the value vectors.
-    matmul_ops = 2 * b * (num_spatial ** 2) * c
-    model.total_ops += th.DoubleTensor([matmul_ops])
-class QKVAttentionLegacy(nn.Module):
-    """
-    A module which performs QKV attention. Matches legacy QKVAttention + input/ouput heads shaping
-    """
-    def __init__(self, n_heads):
-        super().__init__()
-        self.n_heads = n_heads
-    def forward(self, qkv):
-        """
-        Apply QKV attention.
-        :param qkv: an [N x (H * 3 * C) x T] tensor of Qs, Ks, and Vs.
-        :return: an [N x (H * C) x T] tensor after attention.
-        """
-        bs, width, length = qkv.shape
-        assert width % (3 * self.n_heads) == 0
-        ch = width // (3 * self.n_heads)
-        q, k, v = qkv.reshape(bs * self.n_heads, ch * 3, length).split(ch, dim=1)
-        scale = 1 / math.sqrt(math.sqrt(ch))
-        weight = th.einsum(
-            "bct,bcs->bts", q * scale, k * scale
-        )  # More stable with f16 than dividing afterwards
-        weight = th.softmax(weight.float(), dim=-1).type(weight.dtype)
-        a = th.einsum("bts,bcs->bct", weight, v)
-        return a.reshape(bs, -1, length)
-    @staticmethod
-    def count_flops(model, _x, y):
-        return count_flops_attn(model, _x, y)
-class QKVAttention(nn.Module):
-    """
-    A module which performs QKV attention and splits in a different order.
-    """
-    def __init__(self, n_heads):
-        super().__init__()
-        self.n_heads = n_heads
-    def forward(self, qkv):
-        """
-        Apply QKV attention.
-        :param qkv: an [N x (3 * H * C) x T] tensor of Qs, Ks, and Vs.
-        :return: an [N x (H * C) x T] tensor after attention.
-        """
-        bs, width, length = qkv.shape
-        assert width % (3 * self.n_heads) == 0
-        ch = width // (3 * self.n_heads)
-        q, k, v = qkv.chunk(3, dim=1)
-        scale = 1 / math.sqrt(math.sqrt(ch))
-        weight = th.einsum(
-            "bct,bcs->bts",
-            (q * scale).view(bs * self.n_heads, ch, length),
-            (k * scale).view(bs * self.n_heads, ch, length),
-        )  # More stable with f16 than dividing afterwards
-        weight = th.softmax(weight.float(), dim=-1).type(weight.dtype)
-        a = th.einsum("bts,bcs->bct", weight, v.reshape(bs * self.n_heads, ch, length))
-        return a.reshape(bs, -1, length)
-    @staticmethod
-    def count_flops(model, _x, y):
-        return count_flops_attn(model, _x, y)
-class UNetModel(nn.Module):
-    """
-    The full UNet model with attention and timestep embedding.
-    :param in_channels: channels in the input Tensor.
-    :param model_channels: base channel count for the model.
-    :param out_channels: channels in the output Tensor.
-    :param num_res_blocks: number of residual blocks per downsample.
-    :param attention_resolutions: a collection of downsample rates at which
-        attention will take place. May be a set, list, or tuple.
-        For example, if this contains 4, then at 4x downsampling, attention
-        will be used.
-    :param dropout: the dropout probability.
-    :param channel_mult: channel multiplier for each level of the UNet.
-    :param conv_resample: if True, use learned convolutions for upsampling and
-        downsampling.
-    :param dims: determines if the signal is 1D, 2D, or 3D.
-    :param num_classes: if specified (as an int), then this model will be
-        class-conditional with `num_classes` classes.
-    :param use_checkpoint: use gradient checkpointing to reduce memory usage.
-    :param num_heads: the number of attention heads in each attention layer.
-    :param num_heads_channels: if specified, ignore num_heads and instead use
-                               a fixed channel width per attention head.
-    :param num_heads_upsample: works with num_heads to set a different number
-                               of heads for upsampling. Deprecated.
-    :param use_scale_shift_norm: use a FiLM-like conditioning mechanism.
-    :param resblock_updown: use residual blocks for up/downsampling.
-    :param use_new_attention_order: use a different attention pattern for potentially
-                                    increased efficiency.
-    """
-    def __init__(
-        self,
-        image_size,
-        in_channels,
-        model_channels,
-        out_channels,
-        num_res_blocks,
-        attention_resolutions,
-        dropout=0,
-        channel_mult=(1, 2, 4, 8),
-        conv_resample=True,
-        dims=2,
-        num_classes=None,
-        use_checkpoint=False,
-        use_fp16=False,
-        num_heads=-1,
-        num_head_channels=-1,
-        num_heads_upsample=-1,
-        use_scale_shift_norm=False,
-        resblock_updown=False,
-        use_new_attention_order=False,
-        use_spatial_transformer=False,    # custom transformer support
-        transformer_depth=1,              # custom transformer support
-        context_dim=None,                 # custom transformer support
-        n_embed=None,                     # custom support for prediction of discrete ids into codebook of first stage vq model
-        legacy=True,
-    ):
-        super().__init__()
-        if use_spatial_transformer:
-            assert context_dim is not None, 'Fool!! You forgot to include the dimension of your cross-attention conditioning...'
-        if context_dim is not None:
-            assert use_spatial_transformer, 'Fool!! You forgot to use the spatial transformer for your cross-attention conditioning...'
-            from omegaconf.listconfig import ListConfig
-            if type(context_dim) == ListConfig:
-                context_dim = list(context_dim)
-        if num_heads_upsample == -1:
-            num_heads_upsample = num_heads
-        if num_heads == -1:
-            assert num_head_channels != -1, 'Either num_heads or num_head_channels has to be set'
-        if num_head_channels == -1:
-            assert num_heads != -1, 'Either num_heads or num_head_channels has to be set'
-        self.image_size = image_size
-        self.in_channels = in_channels
-        self.model_channels = model_channels
-        self.out_channels = out_channels
-        self.num_res_blocks = num_res_blocks
-        self.attention_resolutions = attention_resolutions
-        self.dropout = dropout
-        self.channel_mult = channel_mult
-        self.conv_resample = conv_resample
-        self.num_classes = num_classes
-        self.use_checkpoint = use_checkpoint
-        self.dtype = th.float16 if use_fp16 else th.float32
-        self.num_heads = num_heads
-        self.num_head_channels = num_head_channels
-        self.num_heads_upsample = num_heads_upsample
-        self.predict_codebook_ids = n_embed is not None
-        time_embed_dim = model_channels * 4
-        self.time_embed = nn.Sequential(
-            linear(model_channels, time_embed_dim),
-            nn.SiLU(),
-            linear(time_embed_dim, time_embed_dim),
-        )
-        if self.num_classes is not None:
-            self.label_emb = nn.Embedding(num_classes, time_embed_dim)
-        self.input_blocks = nn.ModuleList(
-            [
-                TimestepEmbedSequential(
-                    conv_nd(dims, in_channels, model_channels, 3, padding=1)# conv2d for txt2img/audio
-                )
-            ]
-        )
-        self._feature_size = model_channels
-        input_block_chans = [model_channels]
-        ch = model_channels
-        ds = 1
-        # downsample blocks
-        for level, mult in enumerate(channel_mult):
-            for _ in range(num_res_blocks):
-                layers = [
-                    ResBlock(
-                        ch,
-                        time_embed_dim,
-                        dropout,
-                        out_channels=mult * model_channels,
-                        dims=dims,
-                        use_checkpoint=use_checkpoint,
-                        use_scale_shift_norm=use_scale_shift_norm,
-                    )
-                ]
-                ch = mult * model_channels
-                if ds in attention_resolutions:
-                    if num_head_channels == -1:
-                        dim_head = ch // num_heads
-                    else:
-                        num_heads = ch // num_head_channels
-                        dim_head = num_head_channels
-                    if legacy:
-                        #num_heads = 1
-                        dim_head = ch // num_heads if use_spatial_transformer else num_head_channels
-                    layers.append(
-                        AttentionBlock(
-                            ch,
-                            use_checkpoint=use_checkpoint,
-                            num_heads=num_heads,
-                            num_head_channels=dim_head,
-                            use_new_attention_order=use_new_attention_order,
-                        ) if not use_spatial_transformer else SpatialTransformer(# transformer_depth is 1
-                            ch, num_heads, dim_head, depth=transformer_depth, context_dim=context_dim
-                        )
-                    )
-                self.input_blocks.append(TimestepEmbedSequential(*layers))
-                self._feature_size += ch
-                input_block_chans.append(ch)
-            if level != len(channel_mult) - 1:
-                out_ch = ch
-                self.input_blocks.append(
-                    TimestepEmbedSequential(
-                        ResBlock(
-                            ch,
-                            time_embed_dim,
-                            dropout,
-                            out_channels=out_ch,
-                            dims=dims,
-                            use_checkpoint=use_checkpoint,
-                            use_scale_shift_norm=use_scale_shift_norm,
-                            down=True,
-                        )
-                        if resblock_updown
-                        else Downsample(
-                            ch, conv_resample, dims=dims, out_channels=out_ch
-                        )
-                    )
-                )
-                ch = out_ch
-                input_block_chans.append(ch)
-                ds *= 2
-                self._feature_size += ch
-        if num_head_channels == -1:
-            dim_head = ch // num_heads
-        else:
-            num_heads = ch // num_head_channels
-            dim_head = num_head_channels
-        if legacy:
-            #num_heads = 1
-            dim_head = ch // num_heads if use_spatial_transformer else num_head_channels
-        self.middle_block = TimestepEmbedSequential(
-            ResBlock(
-                ch,
-                time_embed_dim,
-                dropout,
-                dims=dims,
-                use_checkpoint=use_checkpoint,
-                use_scale_shift_norm=use_scale_shift_norm,
-            ),
-            AttentionBlock(
-                ch,
-                use_checkpoint=use_checkpoint,
-                num_heads=num_heads,
-                num_head_channels=dim_head,
-                use_new_attention_order=use_new_attention_order,
-            ) if not use_spatial_transformer else SpatialTransformer(
-                            ch, num_heads, dim_head, depth=transformer_depth, context_dim=context_dim
-                        ),
-            ResBlock(
-                ch,
-                time_embed_dim,
-                dropout,
-                dims=dims,
-                use_checkpoint=use_checkpoint,
-                use_scale_shift_norm=use_scale_shift_norm,
-            ),
-        )
-        self._feature_size += ch
-        # upsample blocks
-        self.output_blocks = nn.ModuleList([])
-        for level, mult in list(enumerate(channel_mult))[::-1]:
-            for i in range(num_res_blocks + 1):
-                ich = input_block_chans.pop()
-                layers = [
-                    ResBlock(
-                        ch + ich,
-                        time_embed_dim,
-                        dropout,
-                        out_channels=model_channels * mult,
-                        dims=dims,
-                        use_checkpoint=use_checkpoint,
-                        use_scale_shift_norm=use_scale_shift_norm,
-                    )
-                ]
-                ch = model_channels * mult
-                if ds in attention_resolutions:
-                    if num_head_channels == -1:
-                        dim_head = ch // num_heads
-                    else:
-                        num_heads = ch // num_head_channels
-                        dim_head = num_head_channels
-                    if legacy:
-                        #num_heads = 1
-                        dim_head = ch // num_heads if use_spatial_transformer else num_head_channels
-                    layers.append(
-                        AttentionBlock(
-                            ch,
-                            use_checkpoint=use_checkpoint,
-                            num_heads=num_heads_upsample,
-                            num_head_channels=dim_head,
-                            use_new_attention_order=use_new_attention_order,
-                        ) if not use_spatial_transformer else SpatialTransformer(
-                            ch, num_heads, dim_head, depth=transformer_depth, context_dim=context_dim
-                        )
-                    )
-                if level and i == num_res_blocks:
-                    out_ch = ch
-                    layers.append(
-                        ResBlock(
-                            ch,
-                            time_embed_dim,
-                            dropout,
-                            out_channels=out_ch,
-                            dims=dims,
-                            use_checkpoint=use_checkpoint,
-                            use_scale_shift_norm=use_scale_shift_norm,
-                            up=True,
-                        )
-                        if resblock_updown
-                        else Upsample(ch, conv_resample, dims=dims, out_channels=out_ch)
-                    )
-                    ds //= 2
-                self.output_blocks.append(TimestepEmbedSequential(*layers))
-                self._feature_size += ch
-        self.out = nn.Sequential(
-            normalization(ch),
-            nn.SiLU(),
-            zero_module(conv_nd(dims, model_channels, out_channels, 3, padding=1)),
-        )
-        if self.predict_codebook_ids:
-            self.id_predictor = nn.Sequential(
-            normalization(ch),
-            conv_nd(dims, model_channels, n_embed, 1),
-            #nn.LogSoftmax(dim=1)  # change to cross_entropy and produce non-normalized logits
-        )
-    def convert_to_fp16(self):
-        """
-        Convert the torso of the model to float16.
-        """
-        self.input_blocks.apply(convert_module_to_f16)
-        self.middle_block.apply(convert_module_to_f16)
-        self.output_blocks.apply(convert_module_to_f16)
-    def convert_to_fp32(self):
-        """
-        Convert the torso of the model to float32.
-        """
-        self.input_blocks.apply(convert_module_to_f32)
-        self.middle_block.apply(convert_module_to_f32)
-        self.output_blocks.apply(convert_module_to_f32)
-    def forward(self, x, timesteps=None, context=None, y=None,**kwargs):
-        """
-        Apply the model to an input batch.
-        :param x: an [N x C x ...] Tensor of inputs.
-        :param timesteps: a 1-D batch of timesteps,shape [N]
-        :param context: conditioning plugged in via crossattn. for txt2img shape is [N,77,context_dim]
-        :param y: an [N] Tensor of labels, if class-conditional.
-        :return: an [N x C x ...] Tensor of outputs.
-        """
-        # print(f"in unet {x.shape}")
-        assert (y is not None) == (
-            self.num_classes is not None
-        ), "must specify y if and only if the model is class-conditional"
-        hs = []
-        t_emb = timestep_embedding(timesteps, self.model_channels, repeat_only=False)# shape [N,self.model_channels]
-        emb = self.time_embed(t_emb)# shape [N,context_dim]
-        if self.num_classes is not None:# only for class label
-            assert y.shape == (x.shape[0],)
-            emb = emb + self.label_emb(y)
-        h = x.type(self.dtype)# [N,C,10,106]
-        for module in self.input_blocks:
-            h = module(h, emb, context)# 0:[N,self.model_channels,10,106],1:[N,self.model_channels,10,106],2:[N,self.model_channels,10,106] 3:[N,self.model_channels,5,53] 4:[N,self.model_channels,5,53] 5:[N,self.model_channels*2,5,53]
-            hs.append(h)
-        h = self.middle_block(h, emb, context)# no shape change
-        for module in self.output_blocks:
-            h = th.cat([h, hs.pop()], dim=1)# 在这里c维度乘2或+self.model_channels，其余维度不变
-            h = module(h, emb, context)# 在这里c维度/2回到之前维度，h,w不变或*2
-        h = h.type(x.dtype)# 至此h维度和输入x维度回到相同状态
-        if self.predict_codebook_ids:
-            return self.id_predictor(h)
-        else:
-            return self.out(h)
-class EncoderUNetModel(nn.Module):
-    """
-    The half UNet model with attention and timestep embedding.
-    For usage, see UNet.
-    """
-    def __init__(
-        self,
-        image_size,
-        in_channels,
-        model_channels,
-        out_channels,
-        num_res_blocks,
-        attention_resolutions,
-        dropout=0,
-        channel_mult=(1, 2, 4, 8),
-        conv_resample=True,
-        dims=2,
-        use_checkpoint=False,
-        use_fp16=False,
-        num_heads=1,
-        num_head_channels=-1,
-        num_heads_upsample=-1,
-        use_scale_shift_norm=False,
-        resblock_updown=False,
-        use_new_attention_order=False,
-        pool="adaptive",
-        *args,
-        **kwargs
-    ):
-        super().__init__()
-        if num_heads_upsample == -1:
-            num_heads_upsample = num_heads
-        self.in_channels = in_channels
-        self.model_channels = model_channels
-        self.out_channels = out_channels
-        self.num_res_blocks = num_res_blocks
-        self.attention_resolutions = attention_resolutions
-        self.dropout = dropout
-        self.channel_mult = channel_mult
-        self.conv_resample = conv_resample
-        self.use_checkpoint = use_checkpoint
-        self.dtype = th.float16 if use_fp16 else th.float32
-        self.num_heads = num_heads
-        self.num_head_channels = num_head_channels
-        self.num_heads_upsample = num_heads_upsample
-        time_embed_dim = model_channels * 4
-        self.time_embed = nn.Sequential(
-            linear(model_channels, time_embed_dim),
-            nn.SiLU(),
-            linear(time_embed_dim, time_embed_dim),
-        )
-        self.input_blocks = nn.ModuleList(
-            [
-                TimestepEmbedSequential(
-                    conv_nd(dims, in_channels, model_channels, 3, padding=1)
-                )
-            ]
-        )
-        self._feature_size = model_channels
-        input_block_chans = [model_channels]
-        ch = model_channels
-        ds = 1
-        for level, mult in enumerate(channel_mult):
-            for _ in range(num_res_blocks):
-                layers = [
-                    ResBlock(
-                        ch,
-                        time_embed_dim,
-                        dropout,
-                        out_channels=mult * model_channels,
-                        dims=dims,
-                        use_checkpoint=use_checkpoint,
-                        use_scale_shift_norm=use_scale_shift_norm,
-                    )
-                ]
-                ch = mult * model_channels
-                if ds in attention_resolutions:
-                    layers.append(
-                        AttentionBlock(
-                            ch,
-                            use_checkpoint=use_checkpoint,
-                            num_heads=num_heads,
-                            num_head_channels=num_head_channels,
-                            use_new_attention_order=use_new_attention_order,
-                        )
-                    )
-                self.input_blocks.append(TimestepEmbedSequential(*layers))
-                self._feature_size += ch
-                input_block_chans.append(ch)
-            if level != len(channel_mult) - 1:
-                out_ch = ch
-                self.input_blocks.append(
-                    TimestepEmbedSequential(
-                        ResBlock(
-                            ch,
-                            time_embed_dim,
-                            dropout,
-                            out_channels=out_ch,
-                            dims=dims,
-                            use_checkpoint=use_checkpoint,
-                            use_scale_shift_norm=use_scale_shift_norm,
-                            down=True,
-                        )
-                        if resblock_updown
-                        else Downsample(
-                            ch, conv_resample, dims=dims, out_channels=out_ch
-                        )
-                    )
-                )
-                ch = out_ch
-                input_block_chans.append(ch)
-                ds *= 2
-                self._feature_size += ch
-        self.middle_block = TimestepEmbedSequential(
-            ResBlock(
-                ch,
-                time_embed_dim,
-                dropout,
-                dims=dims,
-                use_checkpoint=use_checkpoint,
-                use_scale_shift_norm=use_scale_shift_norm,
-            ),
-            AttentionBlock(
-                ch,
-                use_checkpoint=use_checkpoint,
-                num_heads=num_heads,
-                num_head_channels=num_head_channels,
-                use_new_attention_order=use_new_attention_order,
-            ),
-            ResBlock(
-                ch,
-                time_embed_dim,
-                dropout,
-                dims=dims,
-                use_checkpoint=use_checkpoint,
-                use_scale_shift_norm=use_scale_shift_norm,
-            ),
-        )
-        self._feature_size += ch
-        self.pool = pool
-        if pool == "adaptive":
-            self.out = nn.Sequential(
-                normalization(ch),
-                nn.SiLU(),
-                nn.AdaptiveAvgPool2d((1, 1)),
-                zero_module(conv_nd(dims, ch, out_channels, 1)),
-                nn.Flatten(),
-            )
-        elif pool == "attention":
-            assert num_head_channels != -1
-            self.out = nn.Sequential(
-                normalization(ch),
-                nn.SiLU(),
-                AttentionPool2d(
-                    (image_size // ds), ch, num_head_channels, out_channels
-                ),
-            )
-        elif pool == "spatial":
-            self.out = nn.Sequential(
-                nn.Linear(self._feature_size, 2048),
-                nn.ReLU(),
-                nn.Linear(2048, self.out_channels),
-            )
-        elif pool == "spatial_v2":
-            self.out = nn.Sequential(
-                nn.Linear(self._feature_size, 2048),
-                normalization(2048),
-                nn.SiLU(),
-                nn.Linear(2048, self.out_channels),
-            )
-        else:
-            raise NotImplementedError(f"Unexpected {pool} pooling")
-    def convert_to_fp16(self):
-        """
-        Convert the torso of the model to float16.
-        """
-        self.input_blocks.apply(convert_module_to_f16)
-        self.middle_block.apply(convert_module_to_f16)
-    def convert_to_fp32(self):
-        """
-        Convert the torso of the model to float32.
-        """
-        self.input_blocks.apply(convert_module_to_f32)
-        self.middle_block.apply(convert_module_to_f32)
-    def forward(self, x, timesteps):
-        """
-        Apply the model to an input batch.
-        :param x: an [N x C x ...] Tensor of inputs.
-        :param timesteps: a 1-D batch of timesteps.
-        :return: an [N x K] Tensor of outputs.
-        """
-        emb = self.time_embed(timestep_embedding(timesteps, self.model_channels))
-        results = []
-        h = x.type(self.dtype)
-        for module in self.input_blocks:
-            h = module(h, emb)
-            if self.pool.startswith("spatial"):
-                results.append(h.type(x.dtype).mean(dim=(2, 3)))
-        h = self.middle_block(h, emb)
-        if self.pool.startswith("spatial"):
-            results.append(h.type(x.dtype).mean(dim=(2, 3)))
-            h = th.cat(results, axis=-1)
-            return self.out(h)
-        else:
-            h = h.type(x.dtype)
-            return self.out(h)

spaces/AILab-CVC/EvalCrafter/test.py DELETED Viewed

File without changes

spaces/AchyuthGamer/OpenGPT/g4f/Provider/AiService.py DELETED Viewed

@@ -1,36 +0,0 @@
-from __future__ import annotations
-import requests
-from ..typing import Any, CreateResult
-from .base_provider import BaseProvider
-class AiService(BaseProvider):
-    url = "https://aiservice.vercel.app/"
-    working = False
-    supports_gpt_35_turbo = True
-    @staticmethod
-    def create_completion(
-        model: str,
-        messages: list[dict[str, str]],
-        stream: bool,
-        **kwargs: Any,
-    ) -> CreateResult:
-        base = "\n".join(f"{message['role']}: {message['content']}" for message in messages)
-        base += "\nassistant: "
-        headers = {
-            "accept": "*/*",
-            "content-type": "text/plain;charset=UTF-8",
-            "sec-fetch-dest": "empty",
-            "sec-fetch-mode": "cors",
-            "sec-fetch-site": "same-origin",
-            "Referer": "https://aiservice.vercel.app/chat",
-        }
-        data = {"input": base}
-        url = "https://aiservice.vercel.app/api/chat/answer"
-        response = requests.post(url, headers=headers, json=data)
-        response.raise_for_status()
-        yield response.json()["data"]

spaces/AchyuthGamer/OpenGPT/g4f/Provider/Bing.py DELETED Viewed

@@ -1,300 +0,0 @@
-from __future__ import annotations
-import random
-import uuid
-import json
-import os
-import uuid
-import urllib.parse
-from aiohttp        import ClientSession, ClientTimeout
-from ..typing       import AsyncGenerator
-from .base_provider import AsyncGeneratorProvider
-class Tones():
-    creative = "Creative"
-    balanced = "Balanced"
-    precise = "Precise"
-default_cookies = {
-    'SRCHD'         : 'AF=NOFORM',
-    'PPLState'      : '1',
-    'KievRPSSecAuth': '',
-    'SUID'          : '',
-    'SRCHUSR'       : '',
-    'SRCHHPGUSR'    : '',
-}
-class Bing(AsyncGeneratorProvider):
-    url             = "https://bing.com/chat"
-    working         = True
-    supports_gpt_4  = True
-    @staticmethod
-    def create_async_generator(
-        model: str,
-        messages: list[dict[str, str]],
-        cookies: dict = None,
-        tone: str = Tones.creative,
-        **kwargs
-    ) -> AsyncGenerator:
-        if len(messages) < 2:
-            prompt = messages[0]["content"]
-            context = None
-        else:
-            prompt = messages[-1]["content"]
-            context = create_context(messages[:-1])
-        if not cookies or "SRCHD" not in cookies:
-            cookies = default_cookies
-        return stream_generate(prompt, tone, context, cookies)
-def create_context(messages: list[dict[str, str]]):
-    context = "".join(f"[{message['role']}](#message)\n{message['content']}\n\n" for message in messages)
-    return context
-class Conversation():
-    def __init__(self, conversationId: str, clientId: str, conversationSignature: str) -> None:
-        self.conversationId = conversationId
-        self.clientId = clientId
-        self.conversationSignature = conversationSignature
-async def create_conversation(session: ClientSession) -> Conversation:
-    url = 'https://www.bing.com/turing/conversation/create?bundleVersion=1.1150.3'
-    async with await session.get(url) as response:
-        data = await response.json()
-        conversationId = data.get('conversationId')
-        clientId = data.get('clientId')
-        conversationSignature = response.headers.get('X-Sydney-Encryptedconversationsignature')
-        if not conversationId or not clientId or not conversationSignature:
-            raise Exception('Failed to create conversation.')
-        return Conversation(conversationId, clientId, conversationSignature)
-async def list_conversations(session: ClientSession) -> list:
-    url = "https://www.bing.com/turing/conversation/chats"
-    async with session.get(url) as response:
-        response = await response.json()
-        return response["chats"]
-async def delete_conversation(session: ClientSession, conversation: Conversation) -> list:
-    url = "https://sydney.bing.com/sydney/DeleteSingleConversation"
-    json = {
-        "conversationId": conversation.conversationId,
-        "conversationSignature": conversation.conversationSignature,
-        "participant": {"id": conversation.clientId},
-        "source": "cib",
-        "optionsSets": ["autosave"]
-    }
-    async with session.post(url, json=json) as response:
-        response = await response.json()
-        return response["result"]["value"] == "Success"
-class Defaults:
-    delimiter = "\x1e"
-    ip_address = f"13.{random.randint(104, 107)}.{random.randint(0, 255)}.{random.randint(0, 255)}"
-    allowedMessageTypes = [
-        "Chat",
-        "Disengaged",
-        "AdsQuery",
-        "SemanticSerp",
-        "GenerateContentQuery",
-        "SearchQuery",
-        "ActionRequest",
-        "Context",
-        "Progress",
-        "AdsQuery",
-        "SemanticSerp",
-    ]
-    sliceIds = [
-        "winmuid3tf",
-        "osbsdusgreccf",
-        "ttstmout",
-        "crchatrev",
-        "winlongmsgtf",
-        "ctrlworkpay",
-        "norespwtf",
-        "tempcacheread",
-        "temptacache",
-        "505scss0",
-        "508jbcars0",
-        "515enbotdets0",
-        "5082tsports",
-        "515vaoprvs",
-        "424dagslnv1s0",
-        "kcimgattcf",
-        "427startpms0",
-    ]
-    location = {
-        "locale": "en-US",
-        "market": "en-US",
-        "region": "US",
-        "locationHints": [
-            {
-                "country": "United States",
-                "state": "California",
-                "city": "Los Angeles",
-                "timezoneoffset": 8,
-                "countryConfidence": 8,
-                "Center": {"Latitude": 34.0536909, "Longitude": -118.242766},
-                "RegionType": 2,
-                "SourceType": 1,
-            }
-        ],
-    }
-    headers = {
-        'accept': '*/*',
-        'accept-language': 'en-US,en;q=0.9',
-        'cache-control': 'max-age=0',
-        'sec-ch-ua': '"Chromium";v="110", "Not A(Brand";v="24", "Microsoft Edge";v="110"',
-        'sec-ch-ua-arch': '"x86"',
-        'sec-ch-ua-bitness': '"64"',
-        'sec-ch-ua-full-version': '"110.0.1587.69"',
-        'sec-ch-ua-full-version-list': '"Chromium";v="110.0.5481.192", "Not A(Brand";v="24.0.0.0", "Microsoft Edge";v="110.0.1587.69"',
-        'sec-ch-ua-mobile': '?0',
-        'sec-ch-ua-model': '""',
-        'sec-ch-ua-platform': '"Windows"',
-        'sec-ch-ua-platform-version': '"15.0.0"',
-        'sec-fetch-dest': 'document',
-        'sec-fetch-mode': 'navigate',
-        'sec-fetch-site': 'none',
-        'sec-fetch-user': '?1',
-        'upgrade-insecure-requests': '1',
-        'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/110.0.0.0 Safari/537.36 Edg/110.0.1587.69',
-        'x-edge-shopping-flag': '1',
-        'x-forwarded-for': ip_address,
-    }
-    optionsSets = [
-        'saharasugg',
-        'enablenewsfc',
-        'clgalileo',
-        'gencontentv3',
-        "nlu_direct_response_filter",
-        "deepleo",
-        "disable_emoji_spoken_text",
-        "responsible_ai_policy_235",
-        "enablemm",
-        "h3precise"
-        "dtappid",
-        "cricinfo",
-        "cricinfov2",
-        "dv3sugg",
-        "nojbfedge"
-    ]
-def format_message(msg: dict) -> str:
-    return json.dumps(msg, ensure_ascii=False) + Defaults.delimiter
-def create_message(conversation: Conversation, prompt: str, tone: str, context: str=None) -> str:
-    request_id = str(uuid.uuid4())
-    struct = {
-        'arguments': [
-            {
-                'source': 'cib',
-                'optionsSets': Defaults.optionsSets,
-                'allowedMessageTypes': Defaults.allowedMessageTypes,
-                'sliceIds': Defaults.sliceIds,
-                'traceId': os.urandom(16).hex(),
-                'isStartOfSession': True,
-                'requestId': request_id,
-                'message': Defaults.location | {
-                    'author': 'user',
-                    'inputMethod': 'Keyboard',
-                    'text': prompt,
-                    'messageType': 'Chat',
-                    'requestId': request_id,
-                    'messageId': request_id,
-                },
-                'tone': tone,
-                'spokenTextMode': 'None',
-                'conversationId': conversation.conversationId,
-                'participant': {
-                    'id': conversation.clientId
-                },
-            }
-        ],
-        'invocationId': '1',
-        'target': 'chat',
-        'type': 4
-    }
-    if context:
-        struct['arguments'][0]['previousMessages'] = [{
-            "author": "user",
-            "description": context,
-            "contextType": "WebPage",
-            "messageType": "Context",
-            "messageId": "discover-web--page-ping-mriduna-----"
-        }]
-    return format_message(struct)
-async def stream_generate(
-        prompt: str,
-        tone: str,
-        context: str=None,
-        cookies: dict=None,
-    ):
-    async with ClientSession(
-        timeout=ClientTimeout(total=900),
-        cookies=cookies,
-        headers=Defaults.headers,
-    ) as session:
-        conversation = await create_conversation(session)
-        try:
-            async with session.ws_connect(
-                f'wss://sydney.bing.com/sydney/ChatHub',
-                autoping=False,
-                params={'sec_access_token': conversation.conversationSignature}
-            ) as wss:
-                await wss.send_str(format_message({'protocol': 'json', 'version': 1}))
-                await wss.receive(timeout=900)
-                await wss.send_str(create_message(conversation, prompt, tone, context))
-                response_txt = ''
-                returned_text = ''
-                final = False
-                while not final:
-                    msg = await wss.receive(timeout=900)
-                    objects = msg.data.split(Defaults.delimiter)
-                    for obj in objects:
-                        if obj is None or not obj:
-                            continue
-                        response = json.loads(obj)
-                        if response.get('type') == 1 and response['arguments'][0].get('messages'):
-                            message = response['arguments'][0]['messages'][0]
-                            if (message['contentOrigin'] != 'Apology'):
-                                if 'adaptiveCards' in message:
-                                    card = message['adaptiveCards'][0]['body'][0]
-                                    if "text" in card:
-                                        response_txt = card.get('text')
-                                    if message.get('messageType'):
-                                        inline_txt = card['inlines'][0].get('text')
-                                        response_txt += inline_txt + '\n'
-                                elif message.get('contentType') == "IMAGE":
-                                    query = urllib.parse.quote(message.get('text'))
-                                    url = f"\nhttps://www.bing.com/images/create?q={query}"
-                                    response_txt += url
-                                    final = True
-                            if response_txt.startswith(returned_text):
-                                new = response_txt[len(returned_text):]
-                                if new != "\n":
-                                    yield new
-                                    returned_text = response_txt
-                        elif response.get('type') == 2:
-                            result = response['item']['result']
-                            if result.get('error'):
-                                raise Exception(f"{result['value']}: {result['message']}")
-                            return
-        finally:
-            await delete_conversation(session, conversation)

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/plugins/toonifypipeline.d.ts DELETED Viewed

	@@ -1,2 +0,0 @@
1	- import ToonifyPostFxPipeline from './shaders/toonify/ToonifyPostFxPipeline';
2	- export default ToonifyPostFxPipeline;

spaces/Akim/claudeAPI/README.md DELETED Viewed

@@ -1,11 +0,0 @@
----
-title: ClaudeAPI
-emoji: 😻
-colorFrom: indigo
-colorTo: blue
-sdk: docker
-pinned: false
-license: unknown
----
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/Al-Chan/Vits_League_of_Legends_Yuumi_TTS/text/cantonese.py DELETED Viewed

@@ -1,59 +0,0 @@
-import re
-import cn2an
-import opencc
-converter = opencc.OpenCC('jyutjyu')
-# List of (Latin alphabet, ipa) pairs:
-_latin_to_ipa = [(re.compile('%s' % x[0]), x[1]) for x in [
-    ('A', 'ei˥'),
-    ('B', 'biː˥'),
-    ('C', 'siː˥'),
-    ('D', 'tiː˥'),
-    ('E', 'iː˥'),
-    ('F', 'e˥fuː˨˩'),
-    ('G', 'tsiː˥'),
-    ('H', 'ɪk̚˥tsʰyː˨˩'),
-    ('I', 'ɐi˥'),
-    ('J', 'tsei˥'),
-    ('K', 'kʰei˥'),
-    ('L', 'e˥llou˨˩'),
-    ('M', 'ɛːm˥'),
-    ('N', 'ɛːn˥'),
-    ('O', 'ou˥'),
-    ('P', 'pʰiː˥'),
-    ('Q', 'kʰiːu˥'),
-    ('R', 'aː˥lou˨˩'),
-    ('S', 'ɛː˥siː˨˩'),
-    ('T', 'tʰiː˥'),
-    ('U', 'juː˥'),
-    ('V', 'wiː˥'),
-    ('W', 'tʊk̚˥piː˥juː˥'),
-    ('X', 'ɪk̚˥siː˨˩'),
-    ('Y', 'waːi˥'),
-    ('Z', 'iː˨sɛːt̚˥')
-]]
-def number_to_cantonese(text):
-    return re.sub(r'\d+(?:\.?\d+)?', lambda x: cn2an.an2cn(x.group()), text)
-def latin_to_ipa(text):
-    for regex, replacement in _latin_to_ipa:
-        text = re.sub(regex, replacement, text)
-    return text
-def cantonese_to_ipa(text):
-    text = number_to_cantonese(text.upper())
-    text = converter.convert(text).replace('-','').replace('$',' ')
-    text = re.sub(r'[A-Z]', lambda x: latin_to_ipa(x.group())+' ', text)
-    text = re.sub(r'[、；：]', '，', text)
-    text = re.sub(r'\s*，\s*', ', ', text)
-    text = re.sub(r'\s*。\s*', '. ', text)
-    text = re.sub(r'\s*？\s*', '? ', text)
-    text = re.sub(r'\s*！\s*', '! ', text)
-    text = re.sub(r'\s*$', '', text)
-    return text

spaces/AlhitawiMohammed22/E2E_OCR/app.py DELETED Viewed

@@ -1,178 +0,0 @@
-import logging
-import time
-from pathlib import Path
-import contextlib
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s - %(levelname)s - %(message)s",
-)
-import gradio as gr
-import nltk
-import torch
-from det2rec import *
-_here = Path(__file__).parent
-nltk.download("stopwords")  # TODO=find where this requirement originates from
-def load_uploaded_file(file_obj, temp_dir: Path = None):
-    """
-    load_uploaded_file - process an uploaded file
-    Args:
-        file_obj (POTENTIALLY list): Gradio file object inside a list
-    Returns:
-        str, the uploaded file contents
-    """
-    # check if mysterious file object is a list
-    if isinstance(file_obj, list):
-        file_obj = file_obj[0]
-    file_path = Path(file_obj.name)
-    if temp_dir is None:
-        _temp_dir = _here / "temp"
-    _temp_dir.mkdir(exist_ok=True)
-    try:
-        pdf_bytes_obj = open(file_path, "rb").read()
-        temp_path = temp_dir / file_path.name if temp_dir else file_path
-        # save to PDF file
-        with open(temp_path, "wb") as f:
-            f.write(pdf_bytes_obj)
-        logging.info(f"The uploaded file saved  to {temp_path}")
-        return str(temp_path.resolve())
-    except Exception as e:
-        logging.error(f"Trying to load file with path {file_path}, error: {e}")
-        print(f"Trying to load file with path {file_path}, error: {e}")
-        return None
-def convert_PDF(
-    pdf_obj,
-    language: str = "en",
-    max_pages=20,
-):
-    """
-    convert_PDF - convert a PDF file to text
-    Args:
-        pdf_bytes_obj (bytes): PDF file contents
-        language (str, optional): Language to use for OCR. Defaults to "en".
-    Returns:
-        str, the PDF file contents as text
-    """
-    # clear local text cache
-    rm_local_text_files()
-    global ocr_model
-    st = time.perf_counter()
-    if isinstance(pdf_obj, list):
-        pdf_obj = pdf_obj[0]
-    file_path = Path(pdf_obj.name)
-    if not file_path.suffix == ".pdf":
-        logging.error(f"File {file_path} is not a PDF file")
-        html_error = f"""
-        <div style="color: red; font-size: 20px; font-weight: bold;">
-        File {file_path} is not a PDF file. Please upload a PDF file.
-        </div>
-        """
-        return "File is not a PDF file", html_error, None
-    conversion_stats = convert_PDF_to_Text(
-        file_path,
-        ocr_model=ocr_model,
-        max_pages=max_pages,
-    )
-    converted_txt = conversion_stats["converted_text"]
-    num_pages = conversion_stats["num_pages"]
-    was_truncated = conversion_stats["truncated"]
-    # if alt_lang: # TODO: fix this
-    rt = round((time.perf_counter() - st) / 60, 2)
-    print(f"Runtime: {rt} minutes")
-    html = ""
-    if was_truncated:
-        html += f"<p>WARNING - PDF was truncated to {max_pages} pages</p>"
-    html += f"<p>Runtime: {rt} minutes on CPU for {num_pages} pages</p>"
-    _output_name = f"RESULT_{file_path.stem}_OCR.txt"
-    with open(_output_name, "w", encoding="utf-8", errors="ignore") as f:
-        f.write(converted_txt)
-    return converted_txt, html, _output_name
-if __name__ == "__main__":
-    logging.info("Starting app")
-    use_GPU = torch.cuda.is_available()
-    logging.info(f"Using GPU status: {use_GPU}")
-    logging.info("Loading OCR model")
-    with contextlib.redirect_stdout(None):
-        ocr_model = ocr_predictor(
-            "db_resnet50",
-            "crnn_mobilenet_v3_large",
-            pretrained=True,
-            assume_straight_pages=True,
-        )
-    # define pdf bytes as None
-    pdf_obj = _here / "exampler.pdf"
-    pdf_obj = str(pdf_obj.resolve())
-    _temp_dir = _here / "temp"
-    _temp_dir.mkdir(exist_ok=True)
-    logging.info("starting demo")
-    demo = gr.Blocks()
-    with demo:
-        gr.Markdown("# PDF to Text")
-        gr.Markdown(
-            "A basic demo for end-to-end text detection and recognition where the input will be in pdf format and the result is text conversion using OCR from the [doctr](https://mindee.github.io/doctr/index.html) package"
-        )
-        gr.Markdown("---")
-        gr.Markdown("---")
-        with gr.Column():
-            gr.Markdown("## Load Inputs")
-            gr.Markdown("Upload your own file & replace the default. Files should be < 10MB to avoid upload issues - search for a PDF compressor online as needed.")
-            gr.Markdown(
-                "_If no file is uploaded, a sample PDF will be used. PDFs are truncated to 20 pages._"
-            )
-            uploaded_file = gr.File(
-                label="Upload a PDF file",
-                file_count="single",
-                type="file",
-                value=_here / "exampler.pdf",
-            )
-            gr.Markdown("---")
-        with gr.Column():
-            gr.Markdown("## Convert PDF to Text")
-            convert_button = gr.Button("Convert PDF!", variant="primary")
-            out_placeholder = gr.HTML("<p><em>Output will appear below:</em></p>")
-            gr.Markdown("### Output")
-            OCR_text = gr.Textbox(
-                label="OCR Result", placeholder="The OCR text will appear here"
-            )
-            text_file = gr.File(
-                label="Download Text File",
-                file_count="single",
-                type="file",
-                interactive=False,
-            )
-        convert_button.click(
-            fn=convert_PDF,
-            inputs=[uploaded_file],
-            outputs=[OCR_text, out_placeholder, text_file],
-        )
-    demo.launch(enable_queue=True)

spaces/AliUsama98/Aliusama_spellchecker/README.md DELETED Viewed

@@ -1,13 +0,0 @@
----
-title: Aliusama Spellchecker
-emoji: 👀
-colorFrom: blue
-colorTo: pink
-sdk: gradio
-sdk_version: 3.50.2
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/Alpaca233/ChatPDF-GUI/gpt_reader/prompt.py DELETED Viewed

@@ -1,26 +0,0 @@
-BASE_POINTS = """
-1. Who are the authors?
-2. What is the process of the proposed method?
-3. What is the performance of the proposed method? Please note down its performance metrics.
-4. What are the baseline models and their performances? Please note down these baseline methods.
-5. What dataset did this paper use?
-"""
-READING_PROMPT = """
-You are a researcher helper bot. You can help the user with research paper reading and summarizing. \n
-Now I am going to send you a paper. You need to read it and summarize it for me part by part. \n
-When you are reading, You need to focus on these key points:{}
-"""
-READING_PROMT_V2 = """
-You are a researcher helper bot. You can help the user with research paper reading and summarizing. \n
-Now I am going to send you a paper. You need to read it and summarize it for me part by part. \n
-When you are reading, You need to focus on these key points:{},
-And You need to generate a brief but informative title for this part.
-Your return format:
-- title: '...'
-- summary: '...'
-"""
-SUMMARY_PROMPT = "You are a researcher helper bot. Now you need to read the summaries of a research paper."

spaces/Alpaca233/SadTalker/src/face3d/models/arcface_torch/dataset.py DELETED Viewed

@@ -1,124 +0,0 @@
-import numbers
-import os
-import queue as Queue
-import threading
-import mxnet as mx
-import numpy as np
-import torch
-from torch.utils.data import DataLoader, Dataset
-from torchvision import transforms
-class BackgroundGenerator(threading.Thread):
-    def __init__(self, generator, local_rank, max_prefetch=6):
-        super(BackgroundGenerator, self).__init__()
-        self.queue = Queue.Queue(max_prefetch)
-        self.generator = generator
-        self.local_rank = local_rank
-        self.daemon = True
-        self.start()
-    def run(self):
-        torch.cuda.set_device(self.local_rank)
-        for item in self.generator:
-            self.queue.put(item)
-        self.queue.put(None)
-    def next(self):
-        next_item = self.queue.get()
-        if next_item is None:
-            raise StopIteration
-        return next_item
-    def __next__(self):
-        return self.next()
-    def __iter__(self):
-        return self
-class DataLoaderX(DataLoader):
-    def __init__(self, local_rank, **kwargs):
-        super(DataLoaderX, self).__init__(**kwargs)
-        self.stream = torch.cuda.Stream(local_rank)
-        self.local_rank = local_rank
-    def __iter__(self):
-        self.iter = super(DataLoaderX, self).__iter__()
-        self.iter = BackgroundGenerator(self.iter, self.local_rank)
-        self.preload()
-        return self
-    def preload(self):
-        self.batch = next(self.iter, None)
-        if self.batch is None:
-            return None
-        with torch.cuda.stream(self.stream):
-            for k in range(len(self.batch)):
-                self.batch[k] = self.batch[k].to(device=self.local_rank, non_blocking=True)
-    def __next__(self):
-        torch.cuda.current_stream().wait_stream(self.stream)
-        batch = self.batch
-        if batch is None:
-            raise StopIteration
-        self.preload()
-        return batch
-class MXFaceDataset(Dataset):
-    def __init__(self, root_dir, local_rank):
-        super(MXFaceDataset, self).__init__()
-        self.transform = transforms.Compose(
-            [transforms.ToPILImage(),
-             transforms.RandomHorizontalFlip(),
-             transforms.ToTensor(),
-             transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
-             ])
-        self.root_dir = root_dir
-        self.local_rank = local_rank
-        path_imgrec = os.path.join(root_dir, 'train.rec')
-        path_imgidx = os.path.join(root_dir, 'train.idx')
-        self.imgrec = mx.recordio.MXIndexedRecordIO(path_imgidx, path_imgrec, 'r')
-        s = self.imgrec.read_idx(0)
-        header, _ = mx.recordio.unpack(s)
-        if header.flag > 0:
-            self.header0 = (int(header.label[0]), int(header.label[1]))
-            self.imgidx = np.array(range(1, int(header.label[0])))
-        else:
-            self.imgidx = np.array(list(self.imgrec.keys))
-    def __getitem__(self, index):
-        idx = self.imgidx[index]
-        s = self.imgrec.read_idx(idx)
-        header, img = mx.recordio.unpack(s)
-        label = header.label
-        if not isinstance(label, numbers.Number):
-            label = label[0]
-        label = torch.tensor(label, dtype=torch.long)
-        sample = mx.image.imdecode(img).asnumpy()
-        if self.transform is not None:
-            sample = self.transform(sample)
-        return sample, label
-    def __len__(self):
-        return len(self.imgidx)
-class SyntheticDataset(Dataset):
-    def __init__(self, local_rank):
-        super(SyntheticDataset, self).__init__()
-        img = np.random.randint(0, 255, size=(112, 112, 3), dtype=np.int32)
-        img = np.transpose(img, (2, 0, 1))
-        img = torch.from_numpy(img).squeeze(0).float()
-        img = ((img / 255) - 0.5) / 0.5
-        self.img = img
-        self.label = 1
-    def __getitem__(self, index):
-        return self.img, self.label
-    def __len__(self):
-        return 1000000

spaces/Alpaca233/SadTalker/src/face3d/models/arcface_torch/partial_fc.py DELETED Viewed

@@ -1,222 +0,0 @@
-import logging
-import os
-import torch
-import torch.distributed as dist
-from torch.nn import Module
-from torch.nn.functional import normalize, linear
-from torch.nn.parameter import Parameter
-class PartialFC(Module):
-    """
-    Author: {Xiang An, Yang Xiao, XuHan Zhu} in DeepGlint,
-    Partial FC: Training 10 Million Identities on a Single Machine
-    See the original paper:
-    https://arxiv.org/abs/2010.05222
-    """
-    @torch.no_grad()
-    def __init__(self, rank, local_rank, world_size, batch_size, resume,
-                 margin_softmax, num_classes, sample_rate=1.0, embedding_size=512, prefix="./"):
-        """
-        rank: int
-            Unique process(GPU) ID from 0 to world_size - 1.
-        local_rank: int
-            Unique process(GPU) ID within the server from 0 to 7.
-        world_size: int
-            Number of GPU.
-        batch_size: int
-            Batch size on current rank(GPU).
-        resume: bool
-            Select whether to restore the weight of softmax.
-        margin_softmax: callable
-            A function of margin softmax, eg: cosface, arcface.
-        num_classes: int
-            The number of class center storage in current rank(CPU/GPU), usually is total_classes // world_size,
-            required.
-        sample_rate: float
-            The partial fc sampling rate, when the number of classes increases to more than 2 millions, Sampling
-            can greatly speed up training, and reduce a lot of GPU memory, default is 1.0.
-        embedding_size: int
-            The feature dimension, default is 512.
-        prefix: str
-            Path for save checkpoint, default is './'.
-        """
-        super(PartialFC, self).__init__()
-        #
-        self.num_classes: int = num_classes
-        self.rank: int = rank
-        self.local_rank: int = local_rank
-        self.device: torch.device = torch.device("cuda:{}".format(self.local_rank))
-        self.world_size: int = world_size
-        self.batch_size: int = batch_size
-        self.margin_softmax: callable = margin_softmax
-        self.sample_rate: float = sample_rate
-        self.embedding_size: int = embedding_size
-        self.prefix: str = prefix
-        self.num_local: int = num_classes // world_size + int(rank < num_classes % world_size)
-        self.class_start: int = num_classes // world_size * rank + min(rank, num_classes % world_size)
-        self.num_sample: int = int(self.sample_rate * self.num_local)
-        self.weight_name = os.path.join(self.prefix, "rank_{}_softmax_weight.pt".format(self.rank))
-        self.weight_mom_name = os.path.join(self.prefix, "rank_{}_softmax_weight_mom.pt".format(self.rank))
-        if resume:
-            try:
-                self.weight: torch.Tensor = torch.load(self.weight_name)
-                self.weight_mom: torch.Tensor = torch.load(self.weight_mom_name)
-                if self.weight.shape[0] != self.num_local or self.weight_mom.shape[0] != self.num_local:
-                    raise IndexError
-                logging.info("softmax weight resume successfully!")
-                logging.info("softmax weight mom resume successfully!")
-            except (FileNotFoundError, KeyError, IndexError):
-                self.weight = torch.normal(0, 0.01, (self.num_local, self.embedding_size), device=self.device)
-                self.weight_mom: torch.Tensor = torch.zeros_like(self.weight)
-                logging.info("softmax weight init!")
-                logging.info("softmax weight mom init!")
-        else:
-            self.weight = torch.normal(0, 0.01, (self.num_local, self.embedding_size), device=self.device)
-            self.weight_mom: torch.Tensor = torch.zeros_like(self.weight)
-            logging.info("softmax weight init successfully!")
-            logging.info("softmax weight mom init successfully!")
-        self.stream: torch.cuda.Stream = torch.cuda.Stream(local_rank)
-        self.index = None
-        if int(self.sample_rate) == 1:
-            self.update = lambda: 0
-            self.sub_weight = Parameter(self.weight)
-            self.sub_weight_mom = self.weight_mom
-        else:
-            self.sub_weight = Parameter(torch.empty((0, 0)).cuda(local_rank))
-    def save_params(self):
-        """ Save softmax weight for each rank on prefix
-        """
-        torch.save(self.weight.data, self.weight_name)
-        torch.save(self.weight_mom, self.weight_mom_name)
-    @torch.no_grad()
-    def sample(self, total_label):
-        """
-        Sample all positive class centers in each rank, and random select neg class centers to filling a fixed
-        `num_sample`.
-        total_label: tensor
-            Label after all gather, which cross all GPUs.
-        """
-        index_positive = (self.class_start <= total_label) & (total_label < self.class_start + self.num_local)
-        total_label[~index_positive] = -1
-        total_label[index_positive] -= self.class_start
-        if int(self.sample_rate) != 1:
-            positive = torch.unique(total_label[index_positive], sorted=True)
-            if self.num_sample - positive.size(0) >= 0:
-                perm = torch.rand(size=[self.num_local], device=self.device)
-                perm[positive] = 2.0
-                index = torch.topk(perm, k=self.num_sample)[1]
-                index = index.sort()[0]
-            else:
-                index = positive
-            self.index = index
-            total_label[index_positive] = torch.searchsorted(index, total_label[index_positive])
-            self.sub_weight = Parameter(self.weight[index])
-            self.sub_weight_mom = self.weight_mom[index]
-    def forward(self, total_features, norm_weight):
-        """ Partial fc forward, `logits = X * sample(W)`
-        """
-        torch.cuda.current_stream().wait_stream(self.stream)
-        logits = linear(total_features, norm_weight)
-        return logits
-    @torch.no_grad()
-    def update(self):
-        """ Set updated weight and weight_mom to memory bank.
-        """
-        self.weight_mom[self.index] = self.sub_weight_mom
-        self.weight[self.index] = self.sub_weight
-    def prepare(self, label, optimizer):
-        """
-        get sampled class centers for cal softmax.
-        label: tensor
-            Label tensor on each rank.
-        optimizer: opt
-            Optimizer for partial fc, which need to get weight mom.
-        """
-        with torch.cuda.stream(self.stream):
-            total_label = torch.zeros(
-                size=[self.batch_size * self.world_size], device=self.device, dtype=torch.long)
-            dist.all_gather(list(total_label.chunk(self.world_size, dim=0)), label)
-            self.sample(total_label)
-            optimizer.state.pop(optimizer.param_groups[-1]['params'][0], None)
-            optimizer.param_groups[-1]['params'][0] = self.sub_weight
-            optimizer.state[self.sub_weight]['momentum_buffer'] = self.sub_weight_mom
-            norm_weight = normalize(self.sub_weight)
-            return total_label, norm_weight
-    def forward_backward(self, label, features, optimizer):
-        """
-        Partial fc forward and backward with model parallel
-        label: tensor
-            Label tensor on each rank(GPU)
-        features: tensor
-            Features tensor on each rank(GPU)
-        optimizer: optimizer
-            Optimizer for partial fc
-        Returns:
-        --------
-        x_grad: tensor
-            The gradient of features.
-        loss_v: tensor
-            Loss value for cross entropy.
-        """
-        total_label, norm_weight = self.prepare(label, optimizer)
-        total_features = torch.zeros(
-            size=[self.batch_size * self.world_size, self.embedding_size], device=self.device)
-        dist.all_gather(list(total_features.chunk(self.world_size, dim=0)), features.data)
-        total_features.requires_grad = True
-        logits = self.forward(total_features, norm_weight)
-        logits = self.margin_softmax(logits, total_label)
-        with torch.no_grad():
-            max_fc = torch.max(logits, dim=1, keepdim=True)[0]
-            dist.all_reduce(max_fc, dist.ReduceOp.MAX)
-            # calculate exp(logits) and all-reduce
-            logits_exp = torch.exp(logits - max_fc)
-            logits_sum_exp = logits_exp.sum(dim=1, keepdims=True)
-            dist.all_reduce(logits_sum_exp, dist.ReduceOp.SUM)
-            # calculate prob
-            logits_exp.div_(logits_sum_exp)
-            # get one-hot
-            grad = logits_exp
-            index = torch.where(total_label != -1)[0]
-            one_hot = torch.zeros(size=[index.size()[0], grad.size()[1]], device=grad.device)
-            one_hot.scatter_(1, total_label[index, None], 1)
-            # calculate loss
-            loss = torch.zeros(grad.size()[0], 1, device=grad.device)
-            loss[index] = grad[index].gather(1, total_label[index, None])
-            dist.all_reduce(loss, dist.ReduceOp.SUM)
-            loss_v = loss.clamp_min_(1e-30).log_().mean() * (-1)
-            # calculate grad
-            grad[index] -= one_hot
-            grad.div_(self.batch_size * self.world_size)
-        logits.backward(grad)
-        if total_features.grad is not None:
-            total_features.grad.detach_()
-        x_grad: torch.Tensor = torch.zeros_like(features, requires_grad=True)
-        # feature gradient all-reduce
-        dist.reduce_scatter(x_grad, list(total_features.grad.chunk(self.world_size, dim=0)))
-        x_grad = x_grad * self.world_size
-        # backward backbone
-        return x_grad, loss_v

spaces/Amrrs/DragGan-Inversion/training/loss.py DELETED Viewed

@@ -1,159 +0,0 @@
-# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES.  All rights reserved.
-#
-# NVIDIA CORPORATION and its licensors retain all intellectual property
-# and proprietary rights in and to this software, related documentation
-# and any modifications thereto.  Any use, reproduction, disclosure or
-# distribution of this software and related documentation without an express
-# license agreement from NVIDIA CORPORATION is strictly prohibited.
-"""Loss functions."""
-import numpy as np
-import torch
-from torch_utils import training_stats
-from torch_utils.ops import conv2d_gradfix
-from torch_utils.ops import upfirdn2d
-# ----------------------------------------------------------------------------
-class Loss:
-    # to be overridden by subclass
-    def accumulate_gradients(self, phase, real_img, real_c, gen_z, gen_c, gain, cur_nimg):
-        raise NotImplementedError()
-# ----------------------------------------------------------------------------
-class StyleGAN2Loss(Loss):
-    def __init__(self, device, G, D, augment_pipe=None, r1_gamma=10, style_mixing_prob=0, pl_weight=0, pl_batch_shrink=2, pl_decay=0.01, pl_no_weight_grad=False, blur_init_sigma=0, blur_fade_kimg=0):
-        super().__init__()
-        self.device = device
-        self.G = G
-        self.D = D
-        self.augment_pipe = augment_pipe
-        self.r1_gamma = r1_gamma
-        self.style_mixing_prob = style_mixing_prob
-        self.pl_weight = pl_weight
-        self.pl_batch_shrink = pl_batch_shrink
-        self.pl_decay = pl_decay
-        self.pl_no_weight_grad = pl_no_weight_grad
-        self.pl_mean = torch.zeros([], device=device)
-        self.blur_init_sigma = blur_init_sigma
-        self.blur_fade_kimg = blur_fade_kimg
-    def run_G(self, z, c, update_emas=False):
-        ws = self.G.mapping(z, c, update_emas=update_emas)
-        if self.style_mixing_prob > 0:
-            with torch.autograd.profiler.record_function('style_mixing'):
-                cutoff = torch.empty([], dtype=torch.int64,
-                                     device=ws.device).random_(1, ws.shape[1])
-                cutoff = torch.where(torch.rand(
-                    [], device=ws.device) < self.style_mixing_prob, cutoff, torch.full_like(cutoff, ws.shape[1]))
-                ws[:, cutoff:] = self.G.mapping(
-                    torch.randn_like(z), c, update_emas=False)[:, cutoff:]
-        img = self.G.synthesis(ws, update_emas=update_emas)
-        return img, ws
-    def run_D(self, img, c, blur_sigma=0, update_emas=False):
-        blur_size = np.floor(blur_sigma * 3)
-        if blur_size > 0:
-            with torch.autograd.profiler.record_function('blur'):
-                f = torch.arange(-blur_size, blur_size + 1,
-                                 device=img.device).div(blur_sigma).square().neg().exp2()
-                img = upfirdn2d.filter2d(img, f / f.sum())
-        if self.augment_pipe is not None:
-            img = self.augment_pipe(img)
-        logits = self.D(img, c, update_emas=update_emas)
-        return logits
-    def accumulate_gradients(self, phase, real_img, real_c, gen_z, gen_c, gain, cur_nimg):
-        assert phase in ['Gmain', 'Greg', 'Gboth', 'Dmain', 'Dreg', 'Dboth']
-        if self.pl_weight == 0:
-            phase = {'Greg': 'none', 'Gboth': 'Gmain'}.get(phase, phase)
-        if self.r1_gamma == 0:
-            phase = {'Dreg': 'none', 'Dboth': 'Dmain'}.get(phase, phase)
-        blur_sigma = max(1 - cur_nimg / (self.blur_fade_kimg * 1e3), 0) * \
-            self.blur_init_sigma if self.blur_fade_kimg > 0 else 0
-        # Gmain: Maximize logits for generated images.
-        if phase in ['Gmain', 'Gboth']:
-            with torch.autograd.profiler.record_function('Gmain_forward'):
-                gen_img, _gen_ws = self.run_G(gen_z, gen_c)
-                gen_logits = self.run_D(gen_img, gen_c, blur_sigma=blur_sigma)
-                training_stats.report('Loss/scores/fake', gen_logits)
-                training_stats.report('Loss/signs/fake', gen_logits.sign())
-                # -log(sigmoid(gen_logits))
-                loss_Gmain = torch.nn.functional.softplus(-gen_logits)
-                training_stats.report('Loss/G/loss', loss_Gmain)
-            with torch.autograd.profiler.record_function('Gmain_backward'):
-                loss_Gmain.mean().mul(gain).backward()
-        # Gpl: Apply path length regularization.
-        if phase in ['Greg', 'Gboth']:
-            with torch.autograd.profiler.record_function('Gpl_forward'):
-                batch_size = gen_z.shape[0] // self.pl_batch_shrink
-                gen_img, gen_ws = self.run_G(
-                    gen_z[:batch_size], gen_c[:batch_size])
-                pl_noise = torch.randn_like(
-                    gen_img) / np.sqrt(gen_img.shape[2] * gen_img.shape[3])
-                with torch.autograd.profiler.record_function('pl_grads'), conv2d_gradfix.no_weight_gradients(self.pl_no_weight_grad):
-                    pl_grads = torch.autograd.grad(outputs=[(
-                        gen_img * pl_noise).sum()], inputs=[gen_ws], create_graph=True, only_inputs=True)[0]
-                pl_lengths = pl_grads.square().sum(2).mean(1).sqrt()
-                pl_mean = self.pl_mean.lerp(pl_lengths.mean(), self.pl_decay)
-                self.pl_mean.copy_(pl_mean.detach())
-                pl_penalty = (pl_lengths - pl_mean).square()
-                training_stats.report('Loss/pl_penalty', pl_penalty)
-                loss_Gpl = pl_penalty * self.pl_weight
-                training_stats.report('Loss/G/reg', loss_Gpl)
-            with torch.autograd.profiler.record_function('Gpl_backward'):
-                loss_Gpl.mean().mul(gain).backward()
-        # Dmain: Minimize logits for generated images.
-        loss_Dgen = 0
-        if phase in ['Dmain', 'Dboth']:
-            with torch.autograd.profiler.record_function('Dgen_forward'):
-                gen_img, _gen_ws = self.run_G(gen_z, gen_c, update_emas=True)
-                gen_logits = self.run_D(
-                    gen_img, gen_c, blur_sigma=blur_sigma, update_emas=True)
-                training_stats.report('Loss/scores/fake', gen_logits)
-                training_stats.report('Loss/signs/fake', gen_logits.sign())
-                loss_Dgen = torch.nn.functional.softplus(
-                    gen_logits)  # -log(1 - sigmoid(gen_logits))
-            with torch.autograd.profiler.record_function('Dgen_backward'):
-                loss_Dgen.mean().mul(gain).backward()
-        # Dmain: Maximize logits for real images.
-        # Dr1: Apply R1 regularization.
-        if phase in ['Dmain', 'Dreg', 'Dboth']:
-            name = 'Dreal' if phase == 'Dmain' else 'Dr1' if phase == 'Dreg' else 'Dreal_Dr1'
-            with torch.autograd.profiler.record_function(name + '_forward'):
-                real_img_tmp = real_img.detach().requires_grad_(
-                    phase in ['Dreg', 'Dboth'])
-                real_logits = self.run_D(
-                    real_img_tmp, real_c, blur_sigma=blur_sigma)
-                training_stats.report('Loss/scores/real', real_logits)
-                training_stats.report('Loss/signs/real', real_logits.sign())
-                loss_Dreal = 0
-                if phase in ['Dmain', 'Dboth']:
-                    # -log(sigmoid(real_logits))
-                    loss_Dreal = torch.nn.functional.softplus(-real_logits)
-                    training_stats.report(
-                        'Loss/D/loss', loss_Dgen + loss_Dreal)
-                loss_Dr1 = 0
-                if phase in ['Dreg', 'Dboth']:
-                    with torch.autograd.profiler.record_function('r1_grads'), conv2d_gradfix.no_weight_gradients():
-                        r1_grads = torch.autograd.grad(outputs=[real_logits.sum()], inputs=[
-                                                       real_img_tmp], create_graph=True, only_inputs=True)[0]
-                    r1_penalty = r1_grads.square().sum([1, 2, 3])
-                    loss_Dr1 = r1_penalty * (self.r1_gamma / 2)
-                    training_stats.report('Loss/r1_penalty', r1_penalty)
-                    training_stats.report('Loss/D/reg', loss_Dr1)
-            with torch.autograd.profiler.record_function(name + '_backward'):
-                (loss_Dreal + loss_Dr1).mean().mul(gain).backward()
-# ----------------------------------------------------------------------------

spaces/Andy1621/uniformer_image_detection/configs/_base_/schedules/schedule_20e.py DELETED Viewed

@@ -1,11 +0,0 @@
-# optimizer
-optimizer = dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001)
-optimizer_config = dict(grad_clip=None)
-# learning policy
-lr_config = dict(
-    policy='step',
-    warmup='linear',
-    warmup_iters=500,
-    warmup_ratio=0.001,
-    step=[16, 19])
-runner = dict(type='EpochBasedRunner', max_epochs=20)

spaces/Andy1621/uniformer_image_detection/configs/swin/mask_rcnn_swin_small_patch4_window7_mstrain_480-800_adamw_3x_coco.py DELETED Viewed

@@ -1,80 +0,0 @@
-_base_ = [
-    '../_base_/models/mask_rcnn_swin_fpn.py',
-    '../_base_/datasets/coco_instance.py',
-    '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py'
-]
-model = dict(
-    backbone=dict(
-        embed_dim=96,
-        depths=[2, 2, 18, 2],
-        num_heads=[3, 6, 12, 24],
-        window_size=7,
-        ape=False,
-        drop_path_rate=0.2,
-        patch_norm=True,
-        use_checkpoint=False
-    ),
-    neck=dict(in_channels=[96, 192, 384, 768]))
-img_norm_cfg = dict(
-    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
-# augmentation strategy originates from DETR / Sparse RCNN
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
-    dict(type='RandomFlip', flip_ratio=0.5),
-    dict(type='AutoAugment',
-         policies=[
-             [
-                 dict(type='Resize',
-                      img_scale=[(480, 1333), (512, 1333), (544, 1333), (576, 1333),
-                                 (608, 1333), (640, 1333), (672, 1333), (704, 1333),
-                                 (736, 1333), (768, 1333), (800, 1333)],
-                      multiscale_mode='value',
-                      keep_ratio=True)
-             ],
-             [
-                 dict(type='Resize',
-                      img_scale=[(400, 1333), (500, 1333), (600, 1333)],
-                      multiscale_mode='value',
-                      keep_ratio=True),
-                 dict(type='RandomCrop',
-                      crop_type='absolute_range',
-                      crop_size=(384, 600),
-                      allow_negative_crop=True),
-                 dict(type='Resize',
-                      img_scale=[(480, 1333), (512, 1333), (544, 1333),
-                                 (576, 1333), (608, 1333), (640, 1333),
-                                 (672, 1333), (704, 1333), (736, 1333),
-                                 (768, 1333), (800, 1333)],
-                      multiscale_mode='value',
-                      override=True,
-                      keep_ratio=True)
-             ]
-         ]),
-    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']),
-]
-data = dict(train=dict(pipeline=train_pipeline))
-optimizer = dict(_delete_=True, type='AdamW', lr=0.0001, betas=(0.9, 0.999), weight_decay=0.05,
-                 paramwise_cfg=dict(custom_keys={'absolute_pos_embed': dict(decay_mult=0.),
-                                                 'relative_position_bias_table': dict(decay_mult=0.),
-                                                 'norm': dict(decay_mult=0.)}))
-lr_config = dict(step=[27, 33])
-runner = dict(type='EpochBasedRunnerAmp', max_epochs=36)
-# do not use mmdet version fp16
-fp16 = None
-optimizer_config = dict(
-    type="DistOptimizerHook",
-    update_interval=1,
-    grad_clip=None,
-    coalesce=True,
-    bucket_size_mb=-1,
-    use_fp16=True,
-)

spaces/Andy1621/uniformer_image_segmentation/configs/hrnet/fcn_hr48_512x1024_160k_cityscapes.py DELETED Viewed

@@ -1,10 +0,0 @@
-_base_ = './fcn_hr18_512x1024_160k_cityscapes.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w48',
-    backbone=dict(
-        extra=dict(
-            stage2=dict(num_channels=(48, 96)),
-            stage3=dict(num_channels=(48, 96, 192)),
-            stage4=dict(num_channels=(48, 96, 192, 384)))),
-    decode_head=dict(
-        in_channels=[48, 96, 192, 384], channels=sum([48, 96, 192, 384])))

spaces/Armandoliv/t5-summarize-app-scitldr/app.py DELETED Viewed

@@ -1,47 +0,0 @@
-import gradio as gr
-import torch
-from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
-tokenizer = AutoTokenizer.from_pretrained("Armandoliv/t5-small-summarizer-scitldr")
-model = AutoModelForSeq2SeqLM.from_pretrained("Armandoliv/t5-small-summarizer-scitldr")
-device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-model = model.to(device)
-def main_summarizer(text):
-  max_input_length = 1024
-  preprocess_text = text.strip().replace("\n"," ").replace("’", "'").strip()
-  tokenized_text = tokenizer.encode(preprocess_text, return_tensors="pt", truncation=True, max_length=max_input_length,).to(device)
-  summary_ids = model.generate(
-              tokenized_text,
-              max_length=256,
-              num_beams=8,
-              repetition_penalty=3.0,
-              length_penalty=2.5,
-              early_stopping=False
-          )
-  output = tokenizer.decode(summary_ids[0], skip_special_tokens=True)
-  return output
-inputs = [gr.Textbox(lines=10, placeholder="Text Here...", label="Input")]
-outputs = gr.Text( label="Summary")
-title="Text summarisation app"
-description = "This demo uses AI Models to summarize long text.\nIt focus on scientific texts."
-io = gr.Interface(fn=main_summarizer, inputs=inputs, outputs=outputs, title=title, description = description,
-                  css= """.gr-button-primary { background: -webkit-linear-gradient(
-                    90deg, #355764 0%, #55a8a1 100% ) !important;     background: #355764;
-                        background: linear-gradient(
-                    90deg, #355764 0%, #55a8a1 100% ) !important;
-                        background: -moz-linear-gradient( 90deg, #355764 0%, #55a8a1 100% ) !important;
-                        background: -webkit-linear-gradient(
-                    90deg, #355764 0%, #55a8a1 100% ) !important;
-                    color:white !important}"""
-                  )
-io.launch()

spaces/Artrajz/vits-simple-api/bert_vits2/commons.py DELETED Viewed

@@ -1,161 +0,0 @@
-import math
-import numpy as np
-import torch
-from torch import nn
-from torch.nn import functional as F
-def init_weights(m, mean=0.0, std=0.01):
-    classname = m.__class__.__name__
-    if classname.find("Conv") != -1:
-        m.weight.data.normal_(mean, std)
-def get_padding(kernel_size, dilation=1):
-    return int((kernel_size * dilation - dilation) / 2)
-def convert_pad_shape(pad_shape):
-    l = pad_shape[::-1]
-    pad_shape = [item for sublist in l for item in sublist]
-    return pad_shape
-def intersperse(lst, item):
-    result = [item] * (len(lst) * 2 + 1)
-    result[1::2] = lst
-    return result
-def kl_divergence(m_p, logs_p, m_q, logs_q):
-    """KL(P||Q)"""
-    kl = (logs_q - logs_p) - 0.5
-    kl += 0.5 * (torch.exp(2. * logs_p) + ((m_p - m_q) ** 2)) * torch.exp(-2. * logs_q)
-    return kl
-def rand_gumbel(shape):
-    """Sample from the Gumbel distribution, protect from overflows."""
-    uniform_samples = torch.rand(shape) * 0.99998 + 0.00001
-    return -torch.log(-torch.log(uniform_samples))
-def rand_gumbel_like(x):
-    g = rand_gumbel(x.size()).to(dtype=x.dtype, device=x.device)
-    return g
-def slice_segments(x, ids_str, segment_size=4):
-    ret = torch.zeros_like(x[:, :, :segment_size])
-    for i in range(x.size(0)):
-        idx_str = ids_str[i]
-        idx_end = idx_str + segment_size
-        ret[i] = x[i, :, idx_str:idx_end]
-    return ret
-def rand_slice_segments(x, x_lengths=None, segment_size=4):
-    b, d, t = x.size()
-    if x_lengths is None:
-        x_lengths = t
-    ids_str_max = x_lengths - segment_size + 1
-    ids_str = (torch.rand([b]).to(device=x.device) * ids_str_max).to(dtype=torch.long)
-    ret = slice_segments(x, ids_str, segment_size)
-    return ret, ids_str
-def get_timing_signal_1d(
-        length, channels, min_timescale=1.0, max_timescale=1.0e4):
-    position = torch.arange(length, dtype=torch.float)
-    num_timescales = channels // 2
-    log_timescale_increment = (
-            math.log(float(max_timescale) / float(min_timescale)) /
-            (num_timescales - 1))
-    inv_timescales = min_timescale * torch.exp(
-        torch.arange(num_timescales, dtype=torch.float) * -log_timescale_increment)
-    scaled_time = position.unsqueeze(0) * inv_timescales.unsqueeze(1)
-    signal = torch.cat([torch.sin(scaled_time), torch.cos(scaled_time)], 0)
-    signal = F.pad(signal, [0, 0, 0, channels % 2])
-    signal = signal.view(1, channels, length)
-    return signal
-def add_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4):
-    b, channels, length = x.size()
-    signal = get_timing_signal_1d(length, channels, min_timescale, max_timescale)
-    return x + signal.to(dtype=x.dtype, device=x.device)
-def cat_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4, axis=1):
-    b, channels, length = x.size()
-    signal = get_timing_signal_1d(length, channels, min_timescale, max_timescale)
-    return torch.cat([x, signal.to(dtype=x.dtype, device=x.device)], axis)
-def subsequent_mask(length):
-    mask = torch.tril(torch.ones(length, length)).unsqueeze(0).unsqueeze(0)
-    return mask
-@torch.jit.script
-def fused_add_tanh_sigmoid_multiply(input_a, input_b, n_channels):
-    n_channels_int = n_channels[0]
-    in_act = input_a + input_b
-    t_act = torch.tanh(in_act[:, :n_channels_int, :])
-    s_act = torch.sigmoid(in_act[:, n_channels_int:, :])
-    acts = t_act * s_act
-    return acts
-def convert_pad_shape(pad_shape):
-    l = pad_shape[::-1]
-    pad_shape = [item for sublist in l for item in sublist]
-    return pad_shape
-def shift_1d(x):
-    x = F.pad(x, convert_pad_shape([[0, 0], [0, 0], [1, 0]]))[:, :, :-1]
-    return x
-def sequence_mask(length, max_length=None):
-    if max_length is None:
-        max_length = length.max()
-    x = torch.arange(max_length, dtype=length.dtype, device=length.device)
-    return x.unsqueeze(0) < length.unsqueeze(1)
-def generate_path(duration, mask):
-    """
-    duration: [b, 1, t_x]
-    mask: [b, 1, t_y, t_x]
-    """
-    device = duration.device
-    b, _, t_y, t_x = mask.shape
-    cum_duration = torch.cumsum(duration, -1)
-    cum_duration_flat = cum_duration.view(b * t_x)
-    path = sequence_mask(cum_duration_flat, t_y).to(mask.dtype)
-    path = path.view(b, t_x, t_y)
-    path = path - F.pad(path, convert_pad_shape([[0, 0], [1, 0], [0, 0]]))[:, :-1]
-    path = path.unsqueeze(1).transpose(2, 3) * mask
-    return path
-def clip_grad_value_(parameters, clip_value, norm_type=2):
-    if isinstance(parameters, torch.Tensor):
-        parameters = [parameters]
-    parameters = list(filter(lambda p: p.grad is not None, parameters))
-    norm_type = float(norm_type)
-    if clip_value is not None:
-        clip_value = float(clip_value)
-    total_norm = 0
-    for p in parameters:
-        param_norm = p.grad.data.norm(norm_type)
-        total_norm += param_norm.item() ** norm_type
-        if clip_value is not None:
-            p.grad.data.clamp_(min=-clip_value, max=clip_value)
-    total_norm = total_norm ** (1. / norm_type)
-    return total_norm

spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_internal/network/auth.py DELETED Viewed

@@ -1,559 +0,0 @@
-"""Network Authentication Helpers
-Contains interface (MultiDomainBasicAuth) and associated glue code for
-providing credentials in the context of network requests.
-"""
-import logging
-import os
-import shutil
-import subprocess
-import sysconfig
-import typing
-import urllib.parse
-from abc import ABC, abstractmethod
-from functools import lru_cache
-from os.path import commonprefix
-from pathlib import Path
-from typing import Any, Dict, List, NamedTuple, Optional, Tuple
-from pip._vendor.requests.auth import AuthBase, HTTPBasicAuth
-from pip._vendor.requests.models import Request, Response
-from pip._vendor.requests.utils import get_netrc_auth
-from pip._internal.utils.logging import getLogger
-from pip._internal.utils.misc import (
-    ask,
-    ask_input,
-    ask_password,
-    remove_auth_from_url,
-    split_auth_netloc_from_url,
-)
-from pip._internal.vcs.versioncontrol import AuthInfo
-logger = getLogger(__name__)
-KEYRING_DISABLED = False
-class Credentials(NamedTuple):
-    url: str
-    username: str
-    password: str
-class KeyRingBaseProvider(ABC):
-    """Keyring base provider interface"""
-    has_keyring: bool
-    @abstractmethod
-    def get_auth_info(self, url: str, username: Optional[str]) -> Optional[AuthInfo]:
-        ...
-    @abstractmethod
-    def save_auth_info(self, url: str, username: str, password: str) -> None:
-        ...
-class KeyRingNullProvider(KeyRingBaseProvider):
-    """Keyring null provider"""
-    has_keyring = False
-    def get_auth_info(self, url: str, username: Optional[str]) -> Optional[AuthInfo]:
-        return None
-    def save_auth_info(self, url: str, username: str, password: str) -> None:
-        return None
-class KeyRingPythonProvider(KeyRingBaseProvider):
-    """Keyring interface which uses locally imported `keyring`"""
-    has_keyring = True
-    def __init__(self) -> None:
-        import keyring
-        self.keyring = keyring
-    def get_auth_info(self, url: str, username: Optional[str]) -> Optional[AuthInfo]:
-        # Support keyring's get_credential interface which supports getting
-        # credentials without a username. This is only available for
-        # keyring>=15.2.0.
-        if hasattr(self.keyring, "get_credential"):
-            logger.debug("Getting credentials from keyring for %s", url)
-            cred = self.keyring.get_credential(url, username)
-            if cred is not None:
-                return cred.username, cred.password
-            return None
-        if username is not None:
-            logger.debug("Getting password from keyring for %s", url)
-            password = self.keyring.get_password(url, username)
-            if password:
-                return username, password
-        return None
-    def save_auth_info(self, url: str, username: str, password: str) -> None:
-        self.keyring.set_password(url, username, password)
-class KeyRingCliProvider(KeyRingBaseProvider):
-    """Provider which uses `keyring` cli
-    Instead of calling the keyring package installed alongside pip
-    we call keyring on the command line which will enable pip to
-    use which ever installation of keyring is available first in
-    PATH.
-    """
-    has_keyring = True
-    def __init__(self, cmd: str) -> None:
-        self.keyring = cmd
-    def get_auth_info(self, url: str, username: Optional[str]) -> Optional[AuthInfo]:
-        # This is the default implementation of keyring.get_credential
-        # https://github.com/jaraco/keyring/blob/97689324abcf01bd1793d49063e7ca01e03d7d07/keyring/backend.py#L134-L139
-        if username is not None:
-            password = self._get_password(url, username)
-            if password is not None:
-                return username, password
-        return None
-    def save_auth_info(self, url: str, username: str, password: str) -> None:
-        return self._set_password(url, username, password)
-    def _get_password(self, service_name: str, username: str) -> Optional[str]:
-        """Mirror the implementation of keyring.get_password using cli"""
-        if self.keyring is None:
-            return None
-        cmd = [self.keyring, "get", service_name, username]
-        env = os.environ.copy()
-        env["PYTHONIOENCODING"] = "utf-8"
-        res = subprocess.run(
-            cmd,
-            stdin=subprocess.DEVNULL,
-            stdout=subprocess.PIPE,
-            env=env,
-        )
-        if res.returncode:
-            return None
-        return res.stdout.decode("utf-8").strip(os.linesep)
-    def _set_password(self, service_name: str, username: str, password: str) -> None:
-        """Mirror the implementation of keyring.set_password using cli"""
-        if self.keyring is None:
-            return None
-        env = os.environ.copy()
-        env["PYTHONIOENCODING"] = "utf-8"
-        subprocess.run(
-            [self.keyring, "set", service_name, username],
-            input=f"{password}{os.linesep}".encode("utf-8"),
-            env=env,
-            check=True,
-        )
-        return None
-@lru_cache(maxsize=None)
-def get_keyring_provider(provider: str) -> KeyRingBaseProvider:
-    logger.verbose("Keyring provider requested: %s", provider)
-    # keyring has previously failed and been disabled
-    if KEYRING_DISABLED:
-        provider = "disabled"
-    if provider in ["import", "auto"]:
-        try:
-            impl = KeyRingPythonProvider()
-            logger.verbose("Keyring provider set: import")
-            return impl
-        except ImportError:
-            pass
-        except Exception as exc:
-            # In the event of an unexpected exception
-            # we should warn the user
-            msg = "Installed copy of keyring fails with exception %s"
-            if provider == "auto":
-                msg = msg + ", trying to find a keyring executable as a fallback"
-            logger.warning(msg, exc, exc_info=logger.isEnabledFor(logging.DEBUG))
-    if provider in ["subprocess", "auto"]:
-        cli = shutil.which("keyring")
-        if cli and cli.startswith(sysconfig.get_path("scripts")):
-            # all code within this function is stolen from shutil.which implementation
-            @typing.no_type_check
-            def PATH_as_shutil_which_determines_it() -> str:
-                path = os.environ.get("PATH", None)
-                if path is None:
-                    try:
-                        path = os.confstr("CS_PATH")
-                    except (AttributeError, ValueError):
-                        # os.confstr() or CS_PATH is not available
-                        path = os.defpath
-                # bpo-35755: Don't use os.defpath if the PATH environment variable is
-                # set to an empty string
-                return path
-            scripts = Path(sysconfig.get_path("scripts"))
-            paths = []
-            for path in PATH_as_shutil_which_determines_it().split(os.pathsep):
-                p = Path(path)
-                try:
-                    if not p.samefile(scripts):
-                        paths.append(path)
-                except FileNotFoundError:
-                    pass
-            path = os.pathsep.join(paths)
-            cli = shutil.which("keyring", path=path)
-        if cli:
-            logger.verbose("Keyring provider set: subprocess with executable %s", cli)
-            return KeyRingCliProvider(cli)
-    logger.verbose("Keyring provider set: disabled")
-    return KeyRingNullProvider()
-class MultiDomainBasicAuth(AuthBase):
-    def __init__(
-        self,
-        prompting: bool = True,
-        index_urls: Optional[List[str]] = None,
-        keyring_provider: str = "auto",
-    ) -> None:
-        self.prompting = prompting
-        self.index_urls = index_urls
-        self.keyring_provider = keyring_provider  # type: ignore[assignment]
-        self.passwords: Dict[str, AuthInfo] = {}
-        # When the user is prompted to enter credentials and keyring is
-        # available, we will offer to save them. If the user accepts,
-        # this value is set to the credentials they entered. After the
-        # request authenticates, the caller should call
-        # ``save_credentials`` to save these.
-        self._credentials_to_save: Optional[Credentials] = None
-    @property
-    def keyring_provider(self) -> KeyRingBaseProvider:
-        return get_keyring_provider(self._keyring_provider)
-    @keyring_provider.setter
-    def keyring_provider(self, provider: str) -> None:
-        # The free function get_keyring_provider has been decorated with
-        # functools.cache. If an exception occurs in get_keyring_auth that
-        # cache will be cleared and keyring disabled, take that into account
-        # if you want to remove this indirection.
-        self._keyring_provider = provider
-    @property
-    def use_keyring(self) -> bool:
-        # We won't use keyring when --no-input is passed unless
-        # a specific provider is requested because it might require
-        # user interaction
-        return self.prompting or self._keyring_provider not in ["auto", "disabled"]
-    def _get_keyring_auth(
-        self,
-        url: Optional[str],
-        username: Optional[str],
-    ) -> Optional[AuthInfo]:
-        """Return the tuple auth for a given url from keyring."""
-        # Do nothing if no url was provided
-        if not url:
-            return None
-        try:
-            return self.keyring_provider.get_auth_info(url, username)
-        except Exception as exc:
-            logger.warning(
-                "Keyring is skipped due to an exception: %s",
-                str(exc),
-            )
-            global KEYRING_DISABLED
-            KEYRING_DISABLED = True
-            get_keyring_provider.cache_clear()
-            return None
-    def _get_index_url(self, url: str) -> Optional[str]:
-        """Return the original index URL matching the requested URL.
-        Cached or dynamically generated credentials may work against
-        the original index URL rather than just the netloc.
-        The provided url should have had its username and password
-        removed already. If the original index url had credentials then
-        they will be included in the return value.
-        Returns None if no matching index was found, or if --no-index
-        was specified by the user.
-        """
-        if not url or not self.index_urls:
-            return None
-        url = remove_auth_from_url(url).rstrip("/") + "/"
-        parsed_url = urllib.parse.urlsplit(url)
-        candidates = []
-        for index in self.index_urls:
-            index = index.rstrip("/") + "/"
-            parsed_index = urllib.parse.urlsplit(remove_auth_from_url(index))
-            if parsed_url == parsed_index:
-                return index
-            if parsed_url.netloc != parsed_index.netloc:
-                continue
-            candidate = urllib.parse.urlsplit(index)
-            candidates.append(candidate)
-        if not candidates:
-            return None
-        candidates.sort(
-            reverse=True,
-            key=lambda candidate: commonprefix(
-                [
-                    parsed_url.path,
-                    candidate.path,
-                ]
-            ).rfind("/"),
-        )
-        return urllib.parse.urlunsplit(candidates[0])
-    def _get_new_credentials(
-        self,
-        original_url: str,
-        *,
-        allow_netrc: bool = True,
-        allow_keyring: bool = False,
-    ) -> AuthInfo:
-        """Find and return credentials for the specified URL."""
-        # Split the credentials and netloc from the url.
-        url, netloc, url_user_password = split_auth_netloc_from_url(
-            original_url,
-        )
-        # Start with the credentials embedded in the url
-        username, password = url_user_password
-        if username is not None and password is not None:
-            logger.debug("Found credentials in url for %s", netloc)
-            return url_user_password
-        # Find a matching index url for this request
-        index_url = self._get_index_url(url)
-        if index_url:
-            # Split the credentials from the url.
-            index_info = split_auth_netloc_from_url(index_url)
-            if index_info:
-                index_url, _, index_url_user_password = index_info
-                logger.debug("Found index url %s", index_url)
-        # If an index URL was found, try its embedded credentials
-        if index_url and index_url_user_password[0] is not None:
-            username, password = index_url_user_password
-            if username is not None and password is not None:
-                logger.debug("Found credentials in index url for %s", netloc)
-                return index_url_user_password
-        # Get creds from netrc if we still don't have them
-        if allow_netrc:
-            netrc_auth = get_netrc_auth(original_url)
-            if netrc_auth:
-                logger.debug("Found credentials in netrc for %s", netloc)
-                return netrc_auth
-        # If we don't have a password and keyring is available, use it.
-        if allow_keyring:
-            # The index url is more specific than the netloc, so try it first
-            # fmt: off
-            kr_auth = (
-                self._get_keyring_auth(index_url, username) or
-                self._get_keyring_auth(netloc, username)
-            )
-            # fmt: on
-            if kr_auth:
-                logger.debug("Found credentials in keyring for %s", netloc)
-                return kr_auth
-        return username, password
-    def _get_url_and_credentials(
-        self, original_url: str
-    ) -> Tuple[str, Optional[str], Optional[str]]:
-        """Return the credentials to use for the provided URL.
-        If allowed, netrc and keyring may be used to obtain the
-        correct credentials.
-        Returns (url_without_credentials, username, password). Note
-        that even if the original URL contains credentials, this
-        function may return a different username and password.
-        """
-        url, netloc, _ = split_auth_netloc_from_url(original_url)
-        # Try to get credentials from original url
-        username, password = self._get_new_credentials(original_url)
-        # If credentials not found, use any stored credentials for this netloc.
-        # Do this if either the username or the password is missing.
-        # This accounts for the situation in which the user has specified
-        # the username in the index url, but the password comes from keyring.
-        if (username is None or password is None) and netloc in self.passwords:
-            un, pw = self.passwords[netloc]
-            # It is possible that the cached credentials are for a different username,
-            # in which case the cache should be ignored.
-            if username is None or username == un:
-                username, password = un, pw
-        if username is not None or password is not None:
-            # Convert the username and password if they're None, so that
-            # this netloc will show up as "cached" in the conditional above.
-            # Further, HTTPBasicAuth doesn't accept None, so it makes sense to
-            # cache the value that is going to be used.
-            username = username or ""
-            password = password or ""
-            # Store any acquired credentials.
-            self.passwords[netloc] = (username, password)
-        assert (
-            # Credentials were found
-            (username is not None and password is not None)
-            # Credentials were not found
-            or (username is None and password is None)
-        ), f"Could not load credentials from url: {original_url}"
-        return url, username, password
-    def __call__(self, req: Request) -> Request:
-        # Get credentials for this request
-        url, username, password = self._get_url_and_credentials(req.url)
-        # Set the url of the request to the url without any credentials
-        req.url = url
-        if username is not None and password is not None:
-            # Send the basic auth with this request
-            req = HTTPBasicAuth(username, password)(req)
-        # Attach a hook to handle 401 responses
-        req.register_hook("response", self.handle_401)
-        return req
-    # Factored out to allow for easy patching in tests
-    def _prompt_for_password(
-        self, netloc: str
-    ) -> Tuple[Optional[str], Optional[str], bool]:
-        username = ask_input(f"User for {netloc}: ") if self.prompting else None
-        if not username:
-            return None, None, False
-        if self.use_keyring:
-            auth = self._get_keyring_auth(netloc, username)
-            if auth and auth[0] is not None and auth[1] is not None:
-                return auth[0], auth[1], False
-        password = ask_password("Password: ")
-        return username, password, True
-    # Factored out to allow for easy patching in tests
-    def _should_save_password_to_keyring(self) -> bool:
-        if (
-            not self.prompting
-            or not self.use_keyring
-            or not self.keyring_provider.has_keyring
-        ):
-            return False
-        return ask("Save credentials to keyring [y/N]: ", ["y", "n"]) == "y"
-    def handle_401(self, resp: Response, **kwargs: Any) -> Response:
-        # We only care about 401 responses, anything else we want to just
-        #   pass through the actual response
-        if resp.status_code != 401:
-            return resp
-        username, password = None, None
-        # Query the keyring for credentials:
-        if self.use_keyring:
-            username, password = self._get_new_credentials(
-                resp.url,
-                allow_netrc=False,
-                allow_keyring=True,
-            )
-        # We are not able to prompt the user so simply return the response
-        if not self.prompting and not username and not password:
-            return resp
-        parsed = urllib.parse.urlparse(resp.url)
-        # Prompt the user for a new username and password
-        save = False
-        if not username and not password:
-            username, password, save = self._prompt_for_password(parsed.netloc)
-        # Store the new username and password to use for future requests
-        self._credentials_to_save = None
-        if username is not None and password is not None:
-            self.passwords[parsed.netloc] = (username, password)
-            # Prompt to save the password to keyring
-            if save and self._should_save_password_to_keyring():
-                self._credentials_to_save = Credentials(
-                    url=parsed.netloc,
-                    username=username,
-                    password=password,
-                )
-        # Consume content and release the original connection to allow our new
-        #   request to reuse the same one.
-        resp.content
-        resp.raw.release_conn()
-        # Add our new username and password to the request
-        req = HTTPBasicAuth(username or "", password or "")(resp.request)
-        req.register_hook("response", self.warn_on_401)
-        # On successful request, save the credentials that were used to
-        # keyring. (Note that if the user responded "no" above, this member
-        # is not set and nothing will be saved.)
-        if self._credentials_to_save:
-            req.register_hook("response", self.save_credentials)
-        # Send our new request
-        new_resp = resp.connection.send(req, **kwargs)
-        new_resp.history.append(resp)
-        return new_resp
-    def warn_on_401(self, resp: Response, **kwargs: Any) -> None:
-        """Response callback to warn about incorrect credentials."""
-        if resp.status_code == 401:
-            logger.warning(
-                "401 Error, Credentials not correct for %s",
-                resp.request.url,
-            )
-    def save_credentials(self, resp: Response, **kwargs: Any) -> None:
-        """Response callback to save credentials on success."""
-        assert (
-            self.keyring_provider.has_keyring
-        ), "should never reach here without keyring"
-        creds = self._credentials_to_save
-        self._credentials_to_save = None
-        if creds and resp.status_code < 400:
-            try:
-                logger.info("Saving credentials to keyring")
-                self.keyring_provider.save_auth_info(
-                    creds.url, creds.username, creds.password
-                )
-            except Exception:
-                logger.exception("Failed to save credentials")

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

@@ -1,141 +0,0 @@
-"""
-requests.exceptions
-~~~~~~~~~~~~~~~~~~~
-This module contains the set of Requests' exceptions.
-"""
-from pip._vendor.urllib3.exceptions import HTTPError as BaseHTTPError
-from .compat import JSONDecodeError as CompatJSONDecodeError
-class RequestException(IOError):
-    """There was an ambiguous exception that occurred while handling your
-    request.
-    """
-    def __init__(self, *args, **kwargs):
-        """Initialize RequestException with `request` and `response` objects."""
-        response = kwargs.pop("response", None)
-        self.response = response
-        self.request = kwargs.pop("request", None)
-        if response is not None and not self.request and hasattr(response, "request"):
-            self.request = self.response.request
-        super().__init__(*args, **kwargs)
-class InvalidJSONError(RequestException):
-    """A JSON error occurred."""
-class JSONDecodeError(InvalidJSONError, CompatJSONDecodeError):
-    """Couldn't decode the text into json"""
-    def __init__(self, *args, **kwargs):
-        """
-        Construct the JSONDecodeError instance first with all
-        args. Then use it's args to construct the IOError so that
-        the json specific args aren't used as IOError specific args
-        and the error message from JSONDecodeError is preserved.
-        """
-        CompatJSONDecodeError.__init__(self, *args)
-        InvalidJSONError.__init__(self, *self.args, **kwargs)
-class HTTPError(RequestException):
-    """An HTTP error occurred."""
-class ConnectionError(RequestException):
-    """A Connection error occurred."""
-class ProxyError(ConnectionError):
-    """A proxy error occurred."""
-class SSLError(ConnectionError):
-    """An SSL error occurred."""
-class Timeout(RequestException):
-    """The request timed out.
-    Catching this error will catch both
-    :exc:`~requests.exceptions.ConnectTimeout` and
-    :exc:`~requests.exceptions.ReadTimeout` errors.
-    """
-class ConnectTimeout(ConnectionError, Timeout):
-    """The request timed out while trying to connect to the remote server.
-    Requests that produced this error are safe to retry.
-    """
-class ReadTimeout(Timeout):
-    """The server did not send any data in the allotted amount of time."""
-class URLRequired(RequestException):
-    """A valid URL is required to make a request."""
-class TooManyRedirects(RequestException):
-    """Too many redirects."""
-class MissingSchema(RequestException, ValueError):
-    """The URL scheme (e.g. http or https) is missing."""
-class InvalidSchema(RequestException, ValueError):
-    """The URL scheme provided is either invalid or unsupported."""
-class InvalidURL(RequestException, ValueError):
-    """The URL provided was somehow invalid."""
-class InvalidHeader(RequestException, ValueError):
-    """The header value provided was somehow invalid."""
-class InvalidProxyURL(InvalidURL):
-    """The proxy URL provided is invalid."""
-class ChunkedEncodingError(RequestException):
-    """The server declared chunked encoding but sent an invalid chunk."""
-class ContentDecodingError(RequestException, BaseHTTPError):
-    """Failed to decode response content."""
-class StreamConsumedError(RequestException, TypeError):
-    """The content for this response was already consumed."""
-class RetryError(RequestException):
-    """Custom retries logic failed"""
-class UnrewindableBodyError(RequestException):
-    """Requests encountered an error when trying to rewind a body."""
-# Warnings
-class RequestsWarning(Warning):
-    """Base warning for Requests."""
-class FileModeWarning(RequestsWarning, DeprecationWarning):
-    """A file was opened in text mode, but Requests determined its binary length."""
-class RequestsDependencyWarning(RequestsWarning):
-    """An imported dependency doesn't match the expected version range."""

spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/configs/common/models/fcos.py DELETED Viewed

@@ -1,23 +0,0 @@
-from detectron2.modeling.meta_arch.fcos import FCOS, FCOSHead
-from .retinanet import model
-model._target_ = FCOS
-del model.anchor_generator
-del model.box2box_transform
-del model.anchor_matcher
-del model.input_format
-# Use P5 instead of C5 to compute P6/P7
-# (Sec 2.2 of https://arxiv.org/abs/2006.09214)
-model.backbone.top_block.in_feature = "p5"
-model.backbone.top_block.in_channels = 256
-# New score threshold determined based on sqrt(cls_score * centerness)
-model.test_score_thresh = 0.2
-model.test_nms_thresh = 0.6
-model.head._target_ = FCOSHead
-del model.head.num_anchors
-model.head.norm = "GN"

spaces/AzumaSeren100/XuanShen-Bert-VITS2/app.py DELETED Viewed

@@ -1,144 +0,0 @@
-import sys, os
-if sys.platform == "darwin":
-    os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] = "1"
-import logging
-logging.getLogger("numba").setLevel(logging.WARNING)
-logging.getLogger("markdown_it").setLevel(logging.WARNING)
-logging.getLogger("urllib3").setLevel(logging.WARNING)
-logging.getLogger("matplotlib").setLevel(logging.WARNING)
-logging.basicConfig(level=logging.INFO, format="| %(name)s | %(levelname)s | %(message)s")
-logger = logging.getLogger(__name__)
-import torch
-import argparse
-import commons
-import utils
-from models import SynthesizerTrn
-from text.symbols import symbols
-from text import cleaned_text_to_sequence, get_bert
-from text.cleaner import clean_text
-import gradio as gr
-import webbrowser
-net_g = None
-def get_text(text, language_str, hps):
-    norm_text, phone, tone, word2ph = clean_text(text, language_str)
-    phone, tone, language = cleaned_text_to_sequence(phone, tone, language_str)
-    if hps.data.add_blank:
-        phone = commons.intersperse(phone, 0)
-        tone = commons.intersperse(tone, 0)
-        language = commons.intersperse(language, 0)
-        for i in range(len(word2ph)):
-            word2ph[i] = word2ph[i] * 2
-        word2ph[0] += 1
-    bert = get_bert(norm_text, word2ph, language_str)
-    del word2ph
-    assert bert.shape[-1] == len(phone)
-    phone = torch.LongTensor(phone)
-    tone = torch.LongTensor(tone)
-    language = torch.LongTensor(language)
-    return bert, phone, tone, language
-def infer(text, sdp_ratio, noise_scale, noise_scale_w, length_scale, sid):
-    global net_g
-    bert, phones, tones, lang_ids = get_text(text, "ZH", hps)
-    with torch.no_grad():
-        x_tst=phones.to(device).unsqueeze(0)
-        tones=tones.to(device).unsqueeze(0)
-        lang_ids=lang_ids.to(device).unsqueeze(0)
-        bert = bert.to(device).unsqueeze(0)
-        x_tst_lengths = torch.LongTensor([phones.size(0)]).to(device)
-        del phones
-        speakers = torch.LongTensor([hps.data.spk2id[sid]]).to(device)
-        audio = net_g.infer(x_tst, x_tst_lengths, speakers, tones, lang_ids, bert, sdp_ratio=sdp_ratio
-                           , noise_scale=noise_scale, noise_scale_w=noise_scale_w, length_scale=length_scale)[0][0,0].data.cpu().float().numpy()
-        del x_tst, tones, lang_ids, bert, x_tst_lengths, speakers
-        return audio
-def tts_fn(text, speaker, sdp_ratio, noise_scale, noise_scale_w, length_scale):
-    with torch.no_grad():
-        audio = infer(text, sdp_ratio=sdp_ratio, noise_scale=noise_scale, noise_scale_w=noise_scale_w, length_scale=length_scale, sid=speaker)
-    return "Success", (hps.data.sampling_rate, audio)
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # parser.add_argument("-m", "--model", default="./logs/dxl/G21200.pth", help="path of your model")
-    parser.add_argument("-mn", "--model_name", default="xuanshen", help="path of your model")
-    parser.add_argument("-m", "--model", default="null", help="path of your model")
-    parser.add_argument("-c", "--config", default="./configs/config.json", help="path of your config file")
-    parser.add_argument("--share", default=True, help="make link public")
-    parser.add_argument("-d", "--debug", action="store_true", help="enable DEBUG-LEVEL log")
-    args = parser.parse_args()
-    if args.debug:
-        logger.info("Enable DEBUG-LEVEL log")
-        logging.basicConfig(level=logging.DEBUG)
-    hps = utils.get_hparams_from_file(args.config)
-    device = (
-        "cuda:0"
-        if torch.cuda.is_available()
-        else (
-            "mps"
-            if sys.platform == "darwin" and torch.backends.mps.is_available()
-            else "cpu"
-        )
-    )
-    net_g = SynthesizerTrn(
-        len(symbols),
-        hps.data.filter_length // 2 + 1,
-        hps.train.segment_size // hps.data.hop_length,
-        n_speakers=hps.data.n_speakers,
-        **hps.model).to(device)
-    _ = net_g.eval()
-    model_path = args.model
-    if not os.path.exists(model_path) or model_path == "null":
-        model_path = utils.latest_checkpoint_path(os.path.join("./logs/",args.model_name), "G_*.pth")
-    _ = utils.load_checkpoint(model_path, net_g, None, skip_optimizer=True)
-    speaker_ids = hps.data.spk2id
-    speakers = list(speaker_ids.keys())
-    with gr.Blocks() as app:
-        with gr.Row():
-            with gr.Column():
-                gr.Markdown(value="""
-                炫神Bert-vits2语音在线生成\n
-                作者：东洋雪莲 https://space.bilibili.com/1060544882\n
-                声音归属：炫神 https://space.bilibili.com/299013902\n
-                Bert-VITS2项目：https://github.com/Stardust-minus/Bert-VITS2\n
-                使用请严格遵守法律法规！\n
-                二创请标注项目链接、简介声明使用Bert-VITS2生成\n
-                """)
-                text = gr.TextArea(label="Text", placeholder="Input Text Here",
-                                      value="你妈的我��死你！")
-                speaker = gr.Dropdown(choices=speakers, value=speakers[0], label='Speaker')
-                sdp_ratio = gr.Slider(minimum=0, maximum=1, value=0.2, step=0.1, label='SDP Ratio')
-                noise_scale = gr.Slider(minimum=0.1, maximum=2, value=0.6, step=0.1, label='Noise Scale')
-                noise_scale_w = gr.Slider(minimum=0.1, maximum=2, value=0.9, step=0.1, label='Noise Scale W')
-                length_scale = gr.Slider(minimum=0.1, maximum=2, value=1, step=0.1, label='Length Scale')
-                btn = gr.Button("Generate!", variant="primary")
-            with gr.Column():
-                text_output = gr.Textbox(label="Message")
-                audio_output = gr.Audio(label="Output Audio")
-        btn.click(tts_fn,
-                inputs=[text, speaker, sdp_ratio, noise_scale, noise_scale_w, length_scale],
-                outputs=[text_output, audio_output])
-    webbrowser.open("http://127.0.0.1:7860")
-    app.launch(share=args.share)

spaces/Bart92/RVC_HF/infer/lib/uvr5_pack/lib_v5/layers_537227KB.py DELETED Viewed

@@ -1,126 +0,0 @@
-import torch
-import torch.nn.functional as F
-from torch import nn
-from . import spec_utils
-class Conv2DBNActiv(nn.Module):
-    def __init__(self, nin, nout, ksize=3, stride=1, pad=1, dilation=1, activ=nn.ReLU):
-        super(Conv2DBNActiv, self).__init__()
-        self.conv = nn.Sequential(
-            nn.Conv2d(
-                nin,
-                nout,
-                kernel_size=ksize,
-                stride=stride,
-                padding=pad,
-                dilation=dilation,
-                bias=False,
-            ),
-            nn.BatchNorm2d(nout),
-            activ(),
-        )
-    def __call__(self, x):
-        return self.conv(x)
-class SeperableConv2DBNActiv(nn.Module):
-    def __init__(self, nin, nout, ksize=3, stride=1, pad=1, dilation=1, activ=nn.ReLU):
-        super(SeperableConv2DBNActiv, self).__init__()
-        self.conv = nn.Sequential(
-            nn.Conv2d(
-                nin,
-                nin,
-                kernel_size=ksize,
-                stride=stride,
-                padding=pad,
-                dilation=dilation,
-                groups=nin,
-                bias=False,
-            ),
-            nn.Conv2d(nin, nout, kernel_size=1, bias=False),
-            nn.BatchNorm2d(nout),
-            activ(),
-        )
-    def __call__(self, x):
-        return self.conv(x)
-class Encoder(nn.Module):
-    def __init__(self, nin, nout, ksize=3, stride=1, pad=1, activ=nn.LeakyReLU):
-        super(Encoder, self).__init__()
-        self.conv1 = Conv2DBNActiv(nin, nout, ksize, 1, pad, activ=activ)
-        self.conv2 = Conv2DBNActiv(nout, nout, ksize, stride, pad, activ=activ)
-    def __call__(self, x):
-        skip = self.conv1(x)
-        h = self.conv2(skip)
-        return h, skip
-class Decoder(nn.Module):
-    def __init__(
-        self, nin, nout, ksize=3, stride=1, pad=1, activ=nn.ReLU, dropout=False
-    ):
-        super(Decoder, self).__init__()
-        self.conv = Conv2DBNActiv(nin, nout, ksize, 1, pad, activ=activ)
-        self.dropout = nn.Dropout2d(0.1) if dropout else None
-    def __call__(self, x, skip=None):
-        x = F.interpolate(x, scale_factor=2, mode="bilinear", align_corners=True)
-        if skip is not None:
-            skip = spec_utils.crop_center(skip, x)
-            x = torch.cat([x, skip], dim=1)
-        h = self.conv(x)
-        if self.dropout is not None:
-            h = self.dropout(h)
-        return h
-class ASPPModule(nn.Module):
-    def __init__(self, nin, nout, dilations=(4, 8, 16, 32, 64), activ=nn.ReLU):
-        super(ASPPModule, self).__init__()
-        self.conv1 = nn.Sequential(
-            nn.AdaptiveAvgPool2d((1, None)),
-            Conv2DBNActiv(nin, nin, 1, 1, 0, activ=activ),
-        )
-        self.conv2 = Conv2DBNActiv(nin, nin, 1, 1, 0, activ=activ)
-        self.conv3 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[0], dilations[0], activ=activ
-        )
-        self.conv4 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[1], dilations[1], activ=activ
-        )
-        self.conv5 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[2], dilations[2], activ=activ
-        )
-        self.conv6 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[2], dilations[2], activ=activ
-        )
-        self.conv7 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[2], dilations[2], activ=activ
-        )
-        self.bottleneck = nn.Sequential(
-            Conv2DBNActiv(nin * 7, nout, 1, 1, 0, activ=activ), nn.Dropout2d(0.1)
-        )
-    def forward(self, x):
-        _, _, h, w = x.size()
-        feat1 = F.interpolate(
-            self.conv1(x), size=(h, w), mode="bilinear", align_corners=True
-        )
-        feat2 = self.conv2(x)
-        feat3 = self.conv3(x)
-        feat4 = self.conv4(x)
-        feat5 = self.conv5(x)
-        feat6 = self.conv6(x)
-        feat7 = self.conv7(x)
-        out = torch.cat((feat1, feat2, feat3, feat4, feat5, feat6, feat7), dim=1)
-        bottle = self.bottleneck(out)
-        return bottle

spaces/Benson/text-generation/Examples/Bombsquad Mod Apk ltima Versin.md DELETED Viewed

@@ -1,97 +0,0 @@
-<h1>BombSquad Mod APK última versión: Todo lo que necesita saber</h1>
-<p>¿Te encanta volar cosas con tus amigos? ¿Te gusta jugar minijuegos que involucran piratas, ninjas, bárbaros y chefs locos? Si respondiste afirmativamente a cualquiera de estas preguntas, quizás quieras echar un vistazo a BombSquad, un divertido y explosivo juego multijugador que te mantendrá entretenido durante horas. Y si quieres hacer el juego aún más emocionante, se puede descargar el BombSquad Mod APK última versión, que le da acceso a todas las características desbloqueadas y recursos ilimitados. En este artículo, le diremos todo lo que necesita saber sobre BombSquad y su versión modded, incluyendo cómo descargar, instalar y jugar. </p>
-<h2>bombsquad mod apk última versión</h2><br /><p><b><b>DOWNLOAD</b> &gt; <a href="https://bltlly.com/2v6Jyb">https://bltlly.com/2v6Jyb</a></b></p><br /><br />
- <h2>¿Qué es BombSquad? </h2>
-<h3>Un divertido y explosivo juego multijugador</h3>
-<p>BombSquad es un juego lleno de acción que te permite volar a tus amigos en varios minijuegos que van desde la captura de la bandera de hockey. Puedes jugar con hasta 8 jugadores a nivel local o online, usando tus dispositivos como controladores. El juego cuenta con la física avanzada ragdoll, explosiones gratuitas y personajes hilarantes que te harán reír en voz alta. También puedes personalizar tu personaje con diferentes atuendos, accesorios y burlas. </p>
- <h3>Características de BombSquad</h3>
-<p>Algunas de las características que hacen de BombSquad un gran juego son:</p>
-<ul>
-<li>Más de 20 minijuegos diferentes para elegir, como King of the Hill, Bomber Hockey, Capture the Flag, Epic Slow Motion Elimination y más. </li>
-<li>Una variedad de mapas y entornos para explorar, como islas, castillos, estadios y barcos piratas. </li>
-<li>Una amplia gama de bombas y armas para usar, como bombas pegajosas, bombas de hielo, guantes de boxeo, minas terrestres y más. </li>
-<li>Una interfaz divertida y fácil de usar que te permite crear tus propios minijuegos y compartirlos con otros jugadores. </li>
-<li>Una banda sonora que coincide con el estado de ánimo y la intensidad del juego. </li>
-</ul>
- <h2>¿Qué es BombSquad Mod APK? </h2>
-<p>BombSquad Mod APK es una versión modificada del juego original que le da algunos beneficios y ventajas adicionales. No es una aplicación oficial del desarrollador, sino una aplicación de terceros que ha sido modificada por algunas fuentes desconocidas. Al descargar e instalar BombSquad Mod APK, puede disfrutar de las siguientes características:</p>
- <h3>Beneficios de BombSquad Mod APK</h3>
-<p>Algunos de los beneficios que BombSquad Mod APK ofrece son:</p>
-<ul>
-<li> Todos los caracteres están desbloqueados, por lo que puede jugar como cualquier personaje que desee. </li>
-<li> Todos los minijuegos están desbloqueados, por lo que puede jugar cualquier mini-juego que desee. </li>
-<li> Todos los mapas están desbloqueados, por lo que puede explorar cualquier mapa que desee. </li>
-<li> Todas las bombas y armas están desbloqueadas, por lo que puede utilizar cualquier bomba o arma que desee. </li>
-<li>Tienes entradas ilimitadas, que se utilizan para comprar artículos en el juego. </li>
-<li>Tienes salud ilimitada, lo que significa que no morirás fácilmente en el juego. </li>
-<li>No tienes anuncios, lo que significa que no serás interrumpido por anuncios molestos mientras juegas el juego. </li>
-</ul>
- <h2>¿Cómo descargar e instalar BombSquad Mod APK? </h2>
-<h3>Pasos para descargar e instalar BombSquad Mod APK</h3>
-<p>Si desea descargar e instalar BombSquad Mod APK en su dispositivo, es necesario seguir estos pasos:</p>
-<p></p>
-<ol>
-<li <li>Ir a un sitio web de confianza que proporciona el enlace para descargar BombSquad Mod APK. Puede buscar "BombSquad Mod APK download" en Bing y elegir uno de los resultados. Por ejemplo, puede utilizar este enlace: </li>
-<li>Haga clic en el botón de descarga y espere a que el archivo se descargue en su dispositivo. El tamaño del archivo es de unos 60 MB, así que asegúrese de tener suficiente espacio y una conexión a Internet estable. </li>
-<li>Una vez que el archivo se descarga, ir a la configuración del dispositivo y permitir la opción de instalar aplicaciones de fuentes desconocidas. Esto es necesario porque BombSquad Mod APK no es de la Google Play Store y su dispositivo podría bloquearlo de lo contrario. </li>
-<li> Después de la instalación se hace, puede iniciar el juego y disfrutar de BombSquad Mod APK en su dispositivo. </li>
-</ol>
- <h3>Consejos para evitar malware y virus</h3>
-<p>Si bien BombSquad Mod APK es un juego divertido y emocionante, también debe tener cuidado con la descarga e instalación de fuentes desconocidas. Algunos sitios web pueden proporcionar archivos falsos o dañados que pueden dañar su dispositivo o robar su información personal. Aquí hay algunos consejos para evitar el malware y los virus al descargar BombSquad Mod APK:</p>
-<ul>
-<li>Siempre use un software antivirus confiable en su dispositivo y escanee el archivo antes de instalarlo. </li>
-<li>Compruebe siempre las opiniones y calificaciones del sitio web y el archivo antes de descargarlo. </li>
-<li>Siempre compare el tamaño del archivo y el nombre con el juego original y asegúrese de que coincidan. </li>
-<li>Siempre copia de seguridad de los datos y el dispositivo antes de instalar cualquier aplicación modded. </li>
-<li>Siempre desinstale el juego original antes de instalar la versión modificada para evitar conflictos o errores. </li>
-</ul>
- <h2>¿Cómo se juega BombSquad Mod APK? </h2>
-<h3>Modos de juego y minijuegos</h3>
-<p>BombSquad Mod APK le ofrece una variedad de modos de juego y mini-juegos para jugar con sus amigos u otros jugadores en línea. Usted puede elegir entre:</p>
-<ul>
-<li>Modo cooperativo: puedes formar equipo con otros jugadores y trabajar juntos para completar misiones y desafíos. </li>
-<li>Modo versus: Puedes competir con otros jugadores e intentar derrotarlos en diferentes minijuegos. </li>
-<li>Modo de torneo: Puedes unirte a un torneo e intentar ganar premios y trofeos. </li>
-<li>Modo solitario: Puedes jugar solo y practicar tus habilidades o poner a prueba tus límites. </li>
-</ul>
- <p>Algunos de los mini-juegos que se pueden jugar en BombSquad Mod APK son:</p>
-<tabla>
-<tr><th>Nombre</th><th>Descripción</th></tr>
-<tr><td>Captura la bandera</td><td>Tienes que capturar la bandera del enemigo y llevarla de vuelta a tu base mientras defiendes tu propia bandera. </td></tr>
-<tr><td>Epic Slow Motion Elimination</td><td>Tienes que eliminar a todos los demás jugadores lanzándoles bombas mientras esquivan sus bombas en cámara lenta. </td></tr>
-<tr><td>Ninja Fight</td><td>Tienes que luchar con otros ninjas usando espadas, shurikens y bombas mientras saltas en plataformas. </td></tr>
-<tr><td>Pirate Plunder</td><td>Tienes que recoger tantas monedas como sea posible mientras navegas en un barco pirata y evitas las balas de cañón y los tiburones. </td></tr>
-</tabla>
- <h3>Controles y ajustes</h3>
-<p>BombSquad Mod APK tiene controles simples e intuitivos que le permiten jugar el juego con facilidad. Puede usar su dispositivo como controlador o conectar un controlador externo a través de Bluetooth o USB. También puede personalizar sus controles en el menú de configuración. Los controles básicos son:</p>
-<ul>
-<li>Mover: Usa el joystick izquierdo o inclina tu dispositivo para mover a tu personaje. </li>
-<li>Saltar: Pulse o pulse el botón A para saltar. </li>
-<li>Pick up/Throw: Toque o pulse el botón B para recoger o lanzar bombas, armas, banderas, etc.</li>
-<li>Punch: Toque o presione el botón X para perforar o usar armas. </li>
-<li>Bomba: Pulse o pulse el botón Y para lanzar una bomba. </li>
-</ul>
- <p>También puedes ajustar otros ajustes en el juego, como sonido, gráficos, idioma, red, etc. También puedes crear tu propio perfil y personalizar tu personaje en el juego. </p>
- <h2>Conclusión</h2>
-<h3>Resumen de los puntos principales</h3>
- <h3>Preguntas frecuentes</h3>
-<p>Aquí hay algunas preguntas frecuentes sobre BombSquad Mod APK:</p>
-<ul>
-<li>Q: ¿Es BombSquad Mod APK seguro de usar? </li>
-<li>A: BombSquad Mod APK es generalmente seguro de usar, pero siempre debe descargarlo desde un sitio web de confianza y escanearlo con un software antivirus antes de instalarlo. También debe realizar una copia de seguridad de sus datos y dispositivo antes de instalar cualquier aplicación modded. </li>
-<li>Q: Es BombSquad Mod APK legal de usar? </li>
-<li>A: BombSquad Mod APK no es una aplicación oficial del desarrollador, sino una aplicación de terceros que ha sido modificada por algunas fuentes desconocidas. Puede violar los términos y condiciones del juego original y la Google Play Store. Por lo tanto, debe usarlo bajo su propio riesgo y discreción. </li>
-<li>Q: ¿Puedo jugar BombSquad Mod APK con mis amigos? </li>
-<li>A: Sí, puede jugar BombSquad Mod APK con sus amigos a nivel local o en línea, utilizando sus dispositivos como controladores. También puede invitar a sus amigos a unirse a su juego o unirse a su juego. </li>
-<li>Q: ¿Puedo actualizar BombSquad Mod APK? </li>
-<li>A: No, no se puede actualizar BombSquad Mod APK desde la Google Play Store o el juego original. Tienes que descargar e instalar la última versión de la aplicación modded desde un sitio web de confianza cada vez que hay una actualización. </li>
-<li>Q: ¿Puedo usar BombSquad Mod APK en dispositivos iOS? </li>
-<li>A: No, no se puede utilizar BombSquad Mod APK en dispositivos iOS, ya que solo es compatible con dispositivos Android. Sin embargo, puede jugar el juego original en dispositivos iOS descargándolo desde la App Store.</li>
-</ul></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/BigChungux/Pet_Survey/README.md DELETED Viewed

@@ -1,13 +0,0 @@
----
-title: Pet Survey
-emoji: 📚
-colorFrom: pink
-colorTo: blue
-sdk: gradio
-sdk_version: 3.19.1
-app_file: app.py
-pinned: false
-license: afl-3.0
----
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/CVPR/LIVE/parallel.h DELETED Viewed

@@ -1,91 +0,0 @@
-#pragma once
-#include "vector.h"
-#include <mutex>
-#include <condition_variable>
-#include <functional>
-#include <atomic>
-#include <cstdint>
-#include <cassert>
-#include <algorithm>
-// From https://github.com/mmp/pbrt-v3/blob/master/src/core/parallel.h
-class Barrier {
-  public:
-    Barrier(int count) : count(count) { assert(count > 0); }
-    ~Barrier() { assert(count == 0); }
-    void Wait();
-  private:
-    std::mutex mutex;
-    std::condition_variable cv;
-    int count;
-};
-void parallel_for_host(const std::function<void(int64_t)> &func,
-                       int64_t count,
-                       int chunkSize = 1);
-extern thread_local int ThreadIndex;
-void parallel_for_host(
-    std::function<void(Vector2i)> func, const Vector2i count);
-int num_system_cores();
-void parallel_init();
-void parallel_cleanup();
-#ifdef __CUDACC__
-template <typename T>
-__global__ void parallel_for_device_kernel(T functor, int count) {
-    auto idx = threadIdx.x + blockIdx.x * blockDim.x;
-    if (idx >= count) {
-        return;
-    }
-    functor(idx);
-}
-template <typename T>
-inline void parallel_for_device(T functor,
-                                int count,
-                                int work_per_thread = 256) {
-    if (count <= 0) {
-        return;
-    }
-    auto block_size = work_per_thread;
-    auto block_count = idiv_ceil(count, block_size);
-    parallel_for_device_kernel<T><<<block_count, block_size>>>(functor, count);
-}
-#endif
-template <typename T>
-inline void parallel_for(T functor,
-                         int count,
-                         bool use_gpu,
-                         int work_per_thread = -1) {
-    if (work_per_thread == -1) {
-        work_per_thread = use_gpu ? 64 : 256;
-    }
-    if (count <= 0) {
-        return;
-    }
-    if (use_gpu) {
-#ifdef __CUDACC__
-        auto block_size = work_per_thread;
-        auto block_count = idiv_ceil(count, block_size);
-        parallel_for_device_kernel<T><<<block_count, block_size>>>(functor, count);
-#else
-        throw std::runtime_error("diffvg not compiled with GPU");
-        assert(false);
-#endif
-    } else {
-        auto num_threads = idiv_ceil(count, work_per_thread);
-        parallel_for_host([&](int thread_index) {
-            auto id_offset = work_per_thread * thread_index;
-            auto work_end = std::min(id_offset + work_per_thread, count);
-            for (int work_id = id_offset; work_id < work_end; work_id++) {
-                auto idx = work_id;
-                assert(idx < count);
-                functor(idx);
-            }
-        }, num_threads);
-    }
-}

spaces/CVPR/LIVE/thrust/thrust/detail/complex/clogf.h DELETED Viewed

@@ -1,198 +0,0 @@
-/*
- *  Copyright 2008-2013 NVIDIA Corporation
- *  Copyright 2013 Filipe RNC Maia
- *
- *  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.
- */
-/*-
- * Copyright (c) 2012 Stephen Montgomery-Smith <[email protected]>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-/* adapted from FreeBSDs msun:*/
-#pragma once
-#include <thrust/complex.h>
-#include <thrust/detail/complex/math_private.h>
-namespace thrust{
-namespace detail{
-namespace complex{
-using thrust::complex;
-/* round down to 8 = 24/3 bits */
-__host__ __device__ inline
-float trim(float x){
-  uint32_t hx;
-  get_float_word(hx, x);
-  hx &= 0xffff0000;
-  float ret;
-  set_float_word(ret,hx);
-  return ret;
-}
-__host__ __device__ inline
-complex<float> clogf(const complex<float>& z){
-  // Adapted from FreeBSDs msun
-  float x, y;
-  float ax, ay;
-  float x0, y0, x1, y1, x2, y2, t, hm1;
-  float val[12];
-  int i, sorted;
-  const float e = 2.7182818284590452354f;
-  x = z.real();
-  y = z.imag();
-  /* Handle NaNs using the general formula to mix them right. */
-  if (x != x || y != y){
-    return (complex<float>(std::log(norm(z)), std::atan2(y, x)));
-  }
-  ax = std::abs(x);
-  ay = std::abs(y);
-  if (ax < ay) {
-    t = ax;
-    ax = ay;
-    ay = t;
-  }
-  /*
-   * To avoid unnecessary overflow, if x and y are very large, divide x
-   * and y by M_E, and then add 1 to the logarithm.  This depends on
-   * M_E being larger than sqrt(2).
-   * There is a potential loss of accuracy caused by dividing by M_E,
-   * but this case should happen extremely rarely.
-   */
-  // For high values of ay -> hypotf(FLT_MAX,ay) = inf
-  // We expect that for values at or below ay = 1e34f this should not happen
-  if (ay > 1e34f){
-    return (complex<float>(std::log(hypotf(x / e, y / e)) + 1.0f, std::atan2(y, x)));
-  }
-  if (ax == 1.f) {
-    if (ay < 1e-19f){
-      return (complex<float>((ay * 0.5f) * ay, std::atan2(y, x)));
-    }
-    return (complex<float>(log1pf(ay * ay) * 0.5f, std::atan2(y, x)));
-  }
-  /*
-   * Because atan2 and hypot conform to C99, this also covers all the
-   * edge cases when x or y are 0 or infinite.
-   */
-  if (ax < 1e-6f || ay < 1e-6f || ax > 1e6f || ay > 1e6f){
-    return (complex<float>(std::log(hypotf(x, y)), std::atan2(y, x)));
-  }
-  /*
-   * From this point on, we don't need to worry about underflow or
-   * overflow in calculating ax*ax or ay*ay.
-   */
-  /* Some easy cases. */
-  if (ax >= 1.0f){
-    return (complex<float>(log1pf((ax-1.f)*(ax+1.f) + ay*ay) * 0.5f, atan2(y, x)));
-  }
-  if (ax*ax + ay*ay <= 0.7f){
-    return (complex<float>(std::log(ax*ax + ay*ay) * 0.5f, std::atan2(y, x)));
-  }
-  /*
-   * Take extra care so that ULP of real part is small if hypot(x,y) is
-   * moderately close to 1.
-   */
-  x0 = trim(ax);
-  ax = ax-x0;
-  x1 = trim(ax);
-  x2 = ax-x1;
-  y0 = trim(ay);
-  ay = ay-y0;
-  y1 = trim(ay);
-  y2 = ay-y1;
-  val[0] = x0*x0;
-  val[1] = y0*y0;
-  val[2] = 2*x0*x1;
-  val[3] = 2*y0*y1;
-  val[4] = x1*x1;
-  val[5] = y1*y1;
-  val[6] = 2*x0*x2;
-  val[7] = 2*y0*y2;
-  val[8] = 2*x1*x2;
-  val[9] = 2*y1*y2;
-  val[10] = x2*x2;
-  val[11] = y2*y2;
-  /* Bubble sort. */
-  do {
-    sorted = 1;
-    for (i=0;i<11;i++) {
-      if (val[i] < val[i+1]) {
-	sorted = 0;
-	t = val[i];
-	val[i] = val[i+1];
-	val[i+1] = t;
-      }
-    }
-  } while (!sorted);
-  hm1 = -1;
-  for (i=0;i<12;i++){
-    hm1 += val[i];
-  }
-  return (complex<float>(0.5f * log1pf(hm1), atan2(y, x)));
-}
-} // namespace complex
-} // namespace detail
-template <>
-__host__ __device__
-inline complex<float> log(const complex<float>& z){
-  return detail::complex::clogf(z);
-}
-} // namespace thrust

spaces/CVPR/WALT/walt/datasets/custom.py DELETED Viewed

@@ -1,324 +0,0 @@
-import os.path as osp
-import warnings
-from collections import OrderedDict
-import mmcv
-import numpy as np
-from mmcv.utils import print_log
-from torch.utils.data import Dataset
-from mmdet.core import eval_map, eval_recalls
-from .builder import DATASETS
-from .pipelines import Compose
-@DATASETS.register_module()
-class CustomDatasetLocal(Dataset):
-    """Custom dataset for detection.
-    The annotation format is shown as follows. The `ann` field is optional for
-    testing.
-    .. code-block:: none
-        [
-            {
-                'filename': 'a.jpg',
-                'width': 1280,
-                'height': 720,
-                'ann': {
-                    'bboxes': <np.ndarray> (n, 4) in (x1, y1, x2, y2) order.
-                    'labels': <np.ndarray> (n, ),
-                    'bboxes_ignore': <np.ndarray> (k, 4), (optional field)
-                    'labels_ignore': <np.ndarray> (k, 4) (optional field)
-                }
-            },
-            ...
-        ]
-    Args:
-        ann_file (str): Annotation file path.
-        pipeline (list[dict]): Processing pipeline.
-        classes (str | Sequence[str], optional): Specify classes to load.
-            If is None, ``cls.CLASSES`` will be used. Default: None.
-        data_root (str, optional): Data root for ``ann_file``,
-            ``img_prefix``, ``seg_prefix``, ``proposal_file`` if specified.
-        test_mode (bool, optional): If set True, annotation will not be loaded.
-        filter_empty_gt (bool, optional): If set true, images without bounding
-            boxes of the dataset's classes will be filtered out. This option
-            only works when `test_mode=False`, i.e., we never filter images
-            during tests.
-    """
-    CLASSES = None
-    def __init__(self,
-                 ann_file,
-                 pipeline,
-                 classes=None,
-                 data_root=None,
-                 img_prefix='',
-                 seg_prefix=None,
-                 proposal_file=None,
-                 test_mode=False,
-                 filter_empty_gt=True):
-        self.ann_file = ann_file
-        self.data_root = data_root
-        self.img_prefix = img_prefix
-        self.seg_prefix = seg_prefix
-        self.proposal_file = proposal_file
-        self.test_mode = test_mode
-        self.filter_empty_gt = filter_empty_gt
-        self.CLASSES = self.get_classes(classes)
-        # join paths if data_root is specified
-        if self.data_root is not None:
-            if not osp.isabs(self.ann_file):
-                self.ann_file = osp.join(self.data_root, self.ann_file)
-            if not (self.img_prefix is None or osp.isabs(self.img_prefix)):
-                self.img_prefix = osp.join(self.data_root, self.img_prefix)
-            if not (self.seg_prefix is None or osp.isabs(self.seg_prefix)):
-                self.seg_prefix = osp.join(self.data_root, self.seg_prefix)
-            if not (self.proposal_file is None
-                    or osp.isabs(self.proposal_file)):
-                self.proposal_file = osp.join(self.data_root,
-                                              self.proposal_file)
-        # load annotations (and proposals)
-        self.data_infos = self.load_annotations(self.ann_file)
-        if self.proposal_file is not None:
-            self.proposals = self.load_proposals(self.proposal_file)
-        else:
-            self.proposals = None
-        # filter images too small and containing no annotations
-        if not test_mode:
-            valid_inds = self._filter_imgs()
-            self.data_infos = [self.data_infos[i] for i in valid_inds]
-            if self.proposals is not None:
-                self.proposals = [self.proposals[i] for i in valid_inds]
-            # set group flag for the sampler
-            self._set_group_flag()
-        # processing pipeline
-        self.pipeline = Compose(pipeline)
-    def __len__(self):
-        """Total number of samples of data."""
-        return len(self.data_infos)
-    def load_annotations(self, ann_file):
-        """Load annotation from annotation file."""
-        return mmcv.load(ann_file)
-    def load_proposals(self, proposal_file):
-        """Load proposal from proposal file."""
-        return mmcv.load(proposal_file)
-    def get_ann_info(self, idx):
-        """Get annotation by index.
-        Args:
-            idx (int): Index of data.
-        Returns:
-            dict: Annotation info of specified index.
-        """
-        return self.data_infos[idx]['ann']
-    def get_cat_ids(self, idx):
-        """Get category ids by index.
-        Args:
-            idx (int): Index of data.
-        Returns:
-            list[int]: All categories in the image of specified index.
-        """
-        return self.data_infos[idx]['ann']['labels'].astype(np.int).tolist()
-    def pre_pipeline(self, results):
-        """Prepare results dict for pipeline."""
-        results['img_prefix'] = self.img_prefix
-        results['seg_prefix'] = self.seg_prefix
-        results['proposal_file'] = self.proposal_file
-        results['bbox_fields'] = []
-        results['bbox3d_fields'] = []
-        results['mask_fields'] = []
-        results['seg_fields'] = []
-    def _filter_imgs(self, min_size=32):
-        """Filter images too small."""
-        if self.filter_empty_gt:
-            warnings.warn(
-                'CustomDataset does not support filtering empty gt images.')
-        valid_inds = []
-        for i, img_info in enumerate(self.data_infos):
-            if min(img_info['width'], img_info['height']) >= min_size:
-                valid_inds.append(i)
-        return valid_inds
-    def _set_group_flag(self):
-        """Set flag according to image aspect ratio.
-        Images with aspect ratio greater than 1 will be set as group 1,
-        otherwise group 0.
-        """
-        self.flag = np.zeros(len(self), dtype=np.uint8)
-        for i in range(len(self)):
-            img_info = self.data_infos[i]
-            if img_info['width'] / img_info['height'] > 1:
-                self.flag[i] = 1
-    def _rand_another(self, idx):
-        """Get another random index from the same group as the given index."""
-        pool = np.where(self.flag == self.flag[idx])[0]
-        return np.random.choice(pool)
-    def __getitem__(self, idx):
-        """Get training/test data after pipeline.
-        Args:
-            idx (int): Index of data.
-        Returns:
-            dict: Training/test data (with annotation if `test_mode` is set \
-                True).
-        """
-        if self.test_mode:
-            return self.prepare_test_img(idx)
-        while True:
-            data = self.prepare_train_img(idx)
-            if data is None:
-                idx = self._rand_another(idx)
-                continue
-            return data
-    def prepare_train_img(self, idx):
-        """Get training data and annotations after pipeline.
-        Args:
-            idx (int): Index of data.
-        Returns:
-            dict: Training data and annotation after pipeline with new keys \
-                introduced by pipeline.
-        """
-        img_info = self.data_infos[idx]
-        ann_info = self.get_ann_info(idx)
-        results = dict(img_info=img_info, ann_info=ann_info)
-        if self.proposals is not None:
-            results['proposals'] = self.proposals[idx]
-        self.pre_pipeline(results)
-        return self.pipeline(results)
-    def prepare_test_img(self, idx):
-        """Get testing data  after pipeline.
-        Args:
-            idx (int): Index of data.
-        Returns:
-            dict: Testing data after pipeline with new keys introduced by \
-                pipeline.
-        """
-        img_info = self.data_infos[idx]
-        results = dict(img_info=img_info)
-        if self.proposals is not None:
-            results['proposals'] = self.proposals[idx]
-        self.pre_pipeline(results)
-        return self.pipeline(results)
-    @classmethod
-    def get_classes(cls, classes=None):
-        """Get class names of current dataset.
-        Args:
-            classes (Sequence[str] | str | None): If classes is None, use
-                default CLASSES defined by builtin dataset. If classes is a
-                string, take it as a file name. The file contains the name of
-                classes where each line contains one class name. If classes is
-                a tuple or list, override the CLASSES defined by the dataset.
-        Returns:
-            tuple[str] or list[str]: Names of categories of the dataset.
-        """
-        if classes is None:
-            return cls.CLASSES
-        if isinstance(classes, str):
-            # take it as a file path
-            class_names = mmcv.list_from_file(classes)
-        elif isinstance(classes, (tuple, list)):
-            class_names = classes
-        else:
-            raise ValueError(f'Unsupported type {type(classes)} of classes.')
-        return class_names
-    def format_results(self, results, **kwargs):
-        """Place holder to format result to dataset specific output."""
-    def evaluate(self,
-                 results,
-                 metric='mAP',
-                 logger=None,
-                 proposal_nums=(100, 300, 1000),
-                 iou_thr=0.5,
-                 scale_ranges=None):
-        """Evaluate the dataset.
-        Args:
-            results (list): Testing results of the dataset.
-            metric (str | list[str]): Metrics to be evaluated.
-            logger (logging.Logger | None | str): Logger used for printing
-                related information during evaluation. Default: None.
-            proposal_nums (Sequence[int]): Proposal number used for evaluating
-                recalls, such as recall@100, recall@1000.
-                Default: (100, 300, 1000).
-            iou_thr (float | list[float]): IoU threshold. Default: 0.5.
-            scale_ranges (list[tuple] | None): Scale ranges for evaluating mAP.
-                Default: None.
-        """
-        if not isinstance(metric, str):
-            assert len(metric) == 1
-            metric = metric[0]
-        allowed_metrics = ['mAP', 'recall']
-        if metric not in allowed_metrics:
-            raise KeyError(f'metric {metric} is not supported')
-        annotations = [self.get_ann_info(i) for i in range(len(self))]
-        eval_results = OrderedDict()
-        iou_thrs = [iou_thr] if isinstance(iou_thr, float) else iou_thr
-        if metric == 'mAP':
-            assert isinstance(iou_thrs, list)
-            mean_aps = []
-            for iou_thr in iou_thrs:
-                print_log(f'\n{"-" * 15}iou_thr: {iou_thr}{"-" * 15}')
-                mean_ap, _ = eval_map(
-                    results,
-                    annotations,
-                    scale_ranges=scale_ranges,
-                    iou_thr=iou_thr,
-                    dataset=self.CLASSES,
-                    logger=logger)
-                mean_aps.append(mean_ap)
-                eval_results[f'AP{int(iou_thr * 100):02d}'] = round(mean_ap, 3)
-            eval_results['mAP'] = sum(mean_aps) / len(mean_aps)
-        elif metric == 'recall':
-            gt_bboxes = [ann['bboxes'] for ann in annotations]
-            recalls = eval_recalls(
-                gt_bboxes, results, proposal_nums, iou_thr, logger=logger)
-            for i, num in enumerate(proposal_nums):
-                for j, iou in enumerate(iou_thrs):
-                    eval_results[f'recall@{num}@{iou}'] = recalls[i, j]
-            if recalls.shape[1] > 1:
-                ar = recalls.mean(axis=1)
-                for i, num in enumerate(proposal_nums):
-                    eval_results[f'AR@{num}'] = ar[i]
-        return eval_results

spaces/CVPR/regionclip-demo/detectron2/data/samplers/__init__.py DELETED Viewed

@@ -1,10 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-from .distributed_sampler import InferenceSampler, RepeatFactorTrainingSampler, TrainingSampler
-from .grouped_batch_sampler import GroupedBatchSampler
-__all__ = [
-    "GroupedBatchSampler",
-    "TrainingSampler",
-    "InferenceSampler",
-    "RepeatFactorTrainingSampler",
-]

spaces/CVPR/regionclip-demo/detectron2/evaluation/sem_seg_evaluation.py DELETED Viewed

@@ -1,184 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import itertools
-import json
-import logging
-import numpy as np
-import os
-from collections import OrderedDict
-import PIL.Image as Image
-import pycocotools.mask as mask_util
-import torch
-from detectron2.data import DatasetCatalog, MetadataCatalog
-from detectron2.utils.comm import all_gather, is_main_process, synchronize
-from detectron2.utils.file_io import PathManager
-from .evaluator import DatasetEvaluator
-class SemSegEvaluator(DatasetEvaluator):
-    """
-    Evaluate semantic segmentation metrics.
-    """
-    def __init__(
-        self,
-        dataset_name,
-        distributed=True,
-        output_dir=None,
-        *,
-        num_classes=None,
-        ignore_label=None,
-    ):
-        """
-        Args:
-            dataset_name (str): name of the dataset to be evaluated.
-            distributed (bool): if True, will collect results from all ranks for evaluation.
-                Otherwise, will evaluate the results in the current process.
-            output_dir (str): an output directory to dump results.
-            num_classes, ignore_label: deprecated argument
-        """
-        self._logger = logging.getLogger(__name__)
-        if num_classes is not None:
-            self._logger.warn(
-                "SemSegEvaluator(num_classes) is deprecated! It should be obtained from metadata."
-            )
-        if ignore_label is not None:
-            self._logger.warn(
-                "SemSegEvaluator(ignore_label) is deprecated! It should be obtained from metadata."
-            )
-        self._dataset_name = dataset_name
-        self._distributed = distributed
-        self._output_dir = output_dir
-        self._cpu_device = torch.device("cpu")
-        self.input_file_to_gt_file = {
-            dataset_record["file_name"]: dataset_record["sem_seg_file_name"]
-            for dataset_record in DatasetCatalog.get(dataset_name)
-        }
-        meta = MetadataCatalog.get(dataset_name)
-        # Dict that maps contiguous training ids to COCO category ids
-        try:
-            c2d = meta.stuff_dataset_id_to_contiguous_id
-            self._contiguous_id_to_dataset_id = {v: k for k, v in c2d.items()}
-        except AttributeError:
-            self._contiguous_id_to_dataset_id = None
-        self._class_names = meta.stuff_classes
-        self._num_classes = len(meta.stuff_classes)
-        if num_classes is not None:
-            assert self._num_classes == num_classes, f"{self._num_classes} != {num_classes}"
-        self._ignore_label = ignore_label if ignore_label is not None else meta.ignore_label
-    def reset(self):
-        self._conf_matrix = np.zeros((self._num_classes + 1, self._num_classes + 1), dtype=np.int64)
-        self._predictions = []
-    def process(self, inputs, outputs):
-        """
-        Args:
-            inputs: the inputs to a model.
-                It is a list of dicts. Each dict corresponds to an image and
-                contains keys like "height", "width", "file_name".
-            outputs: the outputs of a model. It is either list of semantic segmentation predictions
-                (Tensor [H, W]) or list of dicts with key "sem_seg" that contains semantic
-                segmentation prediction in the same format.
-        """
-        for input, output in zip(inputs, outputs):
-            output = output["sem_seg"].argmax(dim=0).to(self._cpu_device)
-            pred = np.array(output, dtype=np.int)
-            with PathManager.open(self.input_file_to_gt_file[input["file_name"]], "rb") as f:
-                gt = np.array(Image.open(f), dtype=np.int)
-            gt[gt == self._ignore_label] = self._num_classes
-            self._conf_matrix += np.bincount(
-                (self._num_classes + 1) * pred.reshape(-1) + gt.reshape(-1),
-                minlength=self._conf_matrix.size,
-            ).reshape(self._conf_matrix.shape)
-            self._predictions.extend(self.encode_json_sem_seg(pred, input["file_name"]))
-    def evaluate(self):
-        """
-        Evaluates standard semantic segmentation metrics (http://cocodataset.org/#stuff-eval):
-        * Mean intersection-over-union averaged across classes (mIoU)
-        * Frequency Weighted IoU (fwIoU)
-        * Mean pixel accuracy averaged across classes (mACC)
-        * Pixel Accuracy (pACC)
-        """
-        if self._distributed:
-            synchronize()
-            conf_matrix_list = all_gather(self._conf_matrix)
-            self._predictions = all_gather(self._predictions)
-            self._predictions = list(itertools.chain(*self._predictions))
-            if not is_main_process():
-                return
-            self._conf_matrix = np.zeros_like(self._conf_matrix)
-            for conf_matrix in conf_matrix_list:
-                self._conf_matrix += conf_matrix
-        if self._output_dir:
-            PathManager.mkdirs(self._output_dir)
-            file_path = os.path.join(self._output_dir, "sem_seg_predictions.json")
-            with PathManager.open(file_path, "w") as f:
-                f.write(json.dumps(self._predictions))
-        acc = np.full(self._num_classes, np.nan, dtype=np.float)
-        iou = np.full(self._num_classes, np.nan, dtype=np.float)
-        tp = self._conf_matrix.diagonal()[:-1].astype(np.float)
-        pos_gt = np.sum(self._conf_matrix[:-1, :-1], axis=0).astype(np.float)
-        class_weights = pos_gt / np.sum(pos_gt)
-        pos_pred = np.sum(self._conf_matrix[:-1, :-1], axis=1).astype(np.float)
-        acc_valid = pos_gt > 0
-        acc[acc_valid] = tp[acc_valid] / pos_gt[acc_valid]
-        iou_valid = (pos_gt + pos_pred) > 0
-        union = pos_gt + pos_pred - tp
-        iou[acc_valid] = tp[acc_valid] / union[acc_valid]
-        macc = np.sum(acc[acc_valid]) / np.sum(acc_valid)
-        miou = np.sum(iou[acc_valid]) / np.sum(iou_valid)
-        fiou = np.sum(iou[acc_valid] * class_weights[acc_valid])
-        pacc = np.sum(tp) / np.sum(pos_gt)
-        res = {}
-        res["mIoU"] = 100 * miou
-        res["fwIoU"] = 100 * fiou
-        for i, name in enumerate(self._class_names):
-            res["IoU-{}".format(name)] = 100 * iou[i]
-        res["mACC"] = 100 * macc
-        res["pACC"] = 100 * pacc
-        for i, name in enumerate(self._class_names):
-            res["ACC-{}".format(name)] = 100 * acc[i]
-        if self._output_dir:
-            file_path = os.path.join(self._output_dir, "sem_seg_evaluation.pth")
-            with PathManager.open(file_path, "wb") as f:
-                torch.save(res, f)
-        results = OrderedDict({"sem_seg": res})
-        self._logger.info(results)
-        return results
-    def encode_json_sem_seg(self, sem_seg, input_file_name):
-        """
-        Convert semantic segmentation to COCO stuff format with segments encoded as RLEs.
-        See http://cocodataset.org/#format-results
-        """
-        json_list = []
-        for label in np.unique(sem_seg):
-            if self._contiguous_id_to_dataset_id is not None:
-                assert (
-                    label in self._contiguous_id_to_dataset_id
-                ), "Label {} is not in the metadata info for {}".format(label, self._dataset_name)
-                dataset_id = self._contiguous_id_to_dataset_id[label]
-            else:
-                dataset_id = int(label)
-            mask = (sem_seg == label).astype(np.uint8)
-            mask_rle = mask_util.encode(np.array(mask[:, :, None], order="F"))[0]
-            mask_rle["counts"] = mask_rle["counts"].decode("utf-8")
-            json_list.append(
-                {"file_name": input_file_name, "category_id": dataset_id, "segmentation": mask_rle}
-            )
-        return json_list

spaces/CVPR/regionclip-demo/detectron2/modeling/proposal_generator/proposal_utils.py DELETED Viewed

@@ -1,200 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import logging
-import math
-from typing import List, Tuple, Union
-import torch
-from detectron2.layers import batched_nms, cat
-from detectron2.structures import Boxes, Instances
-from detectron2.utils.env import TORCH_VERSION
-logger = logging.getLogger(__name__)
-def _is_tracing():
-    if torch.jit.is_scripting():
-        # https://github.com/pytorch/pytorch/issues/47379
-        return False
-    else:
-        return TORCH_VERSION >= (1, 7) and torch.jit.is_tracing()
-def find_top_rpn_proposals(
-    proposals: List[torch.Tensor],
-    pred_objectness_logits: List[torch.Tensor],
-    image_sizes: List[Tuple[int, int]],
-    nms_thresh: float,
-    pre_nms_topk: int,
-    post_nms_topk: int,
-    min_box_size: float,
-    training: bool,
-):
-    """
-    For each feature map, select the `pre_nms_topk` highest scoring proposals,
-    apply NMS, clip proposals, and remove small boxes. Return the `post_nms_topk`
-    highest scoring proposals among all the feature maps for each image.
-    Args:
-        proposals (list[Tensor]): A list of L tensors. Tensor i has shape (N, Hi*Wi*A, 4).
-            All proposal predictions on the feature maps.
-        pred_objectness_logits (list[Tensor]): A list of L tensors. Tensor i has shape (N, Hi*Wi*A).
-        image_sizes (list[tuple]): sizes (h, w) for each image
-        nms_thresh (float): IoU threshold to use for NMS
-        pre_nms_topk (int): number of top k scoring proposals to keep before applying NMS.
-            When RPN is run on multiple feature maps (as in FPN) this number is per
-            feature map.
-        post_nms_topk (int): number of top k scoring proposals to keep after applying NMS.
-            When RPN is run on multiple feature maps (as in FPN) this number is total,
-            over all feature maps.
-        min_box_size (float): minimum proposal box side length in pixels (absolute units
-            wrt input images).
-        training (bool): True if proposals are to be used in training, otherwise False.
-            This arg exists only to support a legacy bug; look for the "NB: Legacy bug ..."
-            comment.
-    Returns:
-        list[Instances]: list of N Instances. The i-th Instances
-            stores post_nms_topk object proposals for image i, sorted by their
-            objectness score in descending order.
-    """
-    num_images = len(image_sizes)
-    device = proposals[0].device
-    # 1. Select top-k anchor for every level and every image
-    topk_scores = []  # #lvl Tensor, each of shape N x topk
-    topk_proposals = []
-    level_ids = []  # #lvl Tensor, each of shape (topk,)
-    batch_idx = torch.arange(num_images, device=device)
-    for level_id, (proposals_i, logits_i) in enumerate(zip(proposals, pred_objectness_logits)):
-        Hi_Wi_A = logits_i.shape[1]
-        if isinstance(Hi_Wi_A, torch.Tensor):  # it's a tensor in tracing
-            num_proposals_i = torch.clamp(Hi_Wi_A, max=pre_nms_topk)
-        else:
-            num_proposals_i = min(Hi_Wi_A, pre_nms_topk)
-        # sort is faster than topk: https://github.com/pytorch/pytorch/issues/22812
-        # topk_scores_i, topk_idx = logits_i.topk(num_proposals_i, dim=1)
-        logits_i, idx = logits_i.sort(descending=True, dim=1)
-        topk_scores_i = logits_i.narrow(1, 0, num_proposals_i)
-        topk_idx = idx.narrow(1, 0, num_proposals_i)
-        # each is N x topk
-        topk_proposals_i = proposals_i[batch_idx[:, None], topk_idx]  # N x topk x 4
-        topk_proposals.append(topk_proposals_i)
-        topk_scores.append(topk_scores_i)
-        level_ids.append(torch.full((num_proposals_i,), level_id, dtype=torch.int64, device=device))
-    # 2. Concat all levels together
-    topk_scores = cat(topk_scores, dim=1)
-    topk_proposals = cat(topk_proposals, dim=1)
-    level_ids = cat(level_ids, dim=0)
-    # 3. For each image, run a per-level NMS, and choose topk results.
-    results: List[Instances] = []
-    for n, image_size in enumerate(image_sizes):
-        boxes = Boxes(topk_proposals[n])
-        scores_per_img = topk_scores[n]
-        lvl = level_ids
-        valid_mask = torch.isfinite(boxes.tensor).all(dim=1) & torch.isfinite(scores_per_img)
-        if not valid_mask.all():
-            if training:
-                raise FloatingPointError(
-                    "Predicted boxes or scores contain Inf/NaN. Training has diverged."
-                )
-            boxes = boxes[valid_mask]
-            scores_per_img = scores_per_img[valid_mask]
-            lvl = lvl[valid_mask]
-        boxes.clip(image_size)
-        # filter empty boxes
-        keep = boxes.nonempty(threshold=min_box_size)
-        if _is_tracing() or keep.sum().item() != len(boxes):
-            boxes, scores_per_img, lvl = boxes[keep], scores_per_img[keep], lvl[keep]
-        keep = batched_nms(boxes.tensor, scores_per_img, lvl, nms_thresh)
-        # In Detectron1, there was different behavior during training vs. testing.
-        # (https://github.com/facebookresearch/Detectron/issues/459)
-        # During training, topk is over the proposals from *all* images in the training batch.
-        # During testing, it is over the proposals for each image separately.
-        # As a result, the training behavior becomes batch-dependent,
-        # and the configuration "POST_NMS_TOPK_TRAIN" end up relying on the batch size.
-        # This bug is addressed in Detectron2 to make the behavior independent of batch size.
-        keep = keep[:post_nms_topk]  # keep is already sorted
-        res = Instances(image_size)
-        res.proposal_boxes = boxes[keep]
-        res.objectness_logits = scores_per_img[keep]
-        results.append(res)
-    return results
-def add_ground_truth_to_proposals(
-    gt: Union[List[Instances], List[Boxes]], proposals: List[Instances]
-) -> List[Instances]:
-    """
-    Call `add_ground_truth_to_proposals_single_image` for all images.
-    Args:
-        gt(Union[List[Instances], List[Boxes]): list of N elements. Element i is a Instances
-            representing the ground-truth for image i.
-        proposals (list[Instances]): list of N elements. Element i is a Instances
-            representing the proposals for image i.
-    Returns:
-        list[Instances]: list of N Instances. Each is the proposals for the image,
-            with field "proposal_boxes" and "objectness_logits".
-    """
-    assert gt is not None
-    if len(proposals) != len(gt):
-        raise ValueError("proposals and gt should have the same length as the number of images!")
-    if len(proposals) == 0:
-        return proposals
-    return [
-        add_ground_truth_to_proposals_single_image(gt_i, proposals_i)
-        for gt_i, proposals_i in zip(gt, proposals)
-    ]
-def add_ground_truth_to_proposals_single_image(
-    gt: Union[Instances, Boxes], proposals: Instances
-) -> Instances:
-    """
-    Augment `proposals` with `gt`.
-    Args:
-        Same as `add_ground_truth_to_proposals`, but with gt and proposals
-        per image.
-    Returns:
-        Same as `add_ground_truth_to_proposals`, but for only one image.
-    """
-    if isinstance(gt, Boxes):
-        # convert Boxes to Instances
-        gt = Instances(proposals.image_size, gt_boxes=gt)
-    gt_boxes = gt.gt_boxes
-    device = proposals.objectness_logits.device
-    # Assign all ground-truth boxes an objectness logit corresponding to
-    # P(object) = sigmoid(logit) =~ 1.
-    gt_logit_value = math.log((1.0 - 1e-10) / (1 - (1.0 - 1e-10)))
-    gt_logits = gt_logit_value * torch.ones(len(gt_boxes), device=device)
-    # Concatenating gt_boxes with proposals requires them to have the same fields
-    gt_proposal = Instances(proposals.image_size, **gt.get_fields())
-    gt_proposal.proposal_boxes = gt_boxes
-    gt_proposal.objectness_logits = gt_logits
-    for key in proposals.get_fields().keys():
-        assert gt_proposal.has(
-            key
-        ), "The attribute '{}' in `proposals` does not exist in `gt`".format(key)
-    # NOTE: Instances.cat only use fields from the first item. Extra fields in latter items
-    # will be thrown away.
-    new_proposals = Instances.cat([proposals, gt_proposal])
-    return new_proposals

spaces/ChenyangSi/FreeU/free_lunch_utils.py DELETED Viewed

@@ -1,340 +0,0 @@
-import torch
-import torch.fft as fft
-from diffusers.models.unet_2d_condition import logger
-from diffusers.utils import is_torch_version
-from typing import Any, Dict, List, Optional, Tuple, Union
-def isinstance_str(x: object, cls_name: str):
-    """
-    Checks whether x has any class *named* cls_name in its ancestry.
-    Doesn't require access to the class's implementation.
-    Useful for patching!
-    """
-    for _cls in x.__class__.__mro__:
-        if _cls.__name__ == cls_name:
-            return True
-    return False
-def Fourier_filter(x, threshold, scale):
-    dtype = x.dtype
-    x = x.type(torch.float32)
-    # FFT
-    x_freq = fft.fftn(x, dim=(-2, -1))
-    x_freq = fft.fftshift(x_freq, dim=(-2, -1))
-    B, C, H, W = x_freq.shape
-    mask = torch.ones((B, C, H, W)).cuda()
-    crow, ccol = H // 2, W //2
-    mask[..., crow - threshold:crow + threshold, ccol - threshold:ccol + threshold] = scale
-    x_freq = x_freq * mask
-    # IFFT
-    x_freq = fft.ifftshift(x_freq, dim=(-2, -1))
-    x_filtered = fft.ifftn(x_freq, dim=(-2, -1)).real
-    x_filtered = x_filtered.type(dtype)
-    return x_filtered
-def register_upblock2d(model):
-    def up_forward(self):
-        def forward(hidden_states, res_hidden_states_tuple, temb=None, upsample_size=None):
-            for resnet in self.resnets:
-                # pop res hidden states
-                res_hidden_states = res_hidden_states_tuple[-1]
-                res_hidden_states_tuple = res_hidden_states_tuple[:-1]
-                #print(f"in upblock2d, hidden states shape: {hidden_states.shape}")
-                hidden_states = torch.cat([hidden_states, res_hidden_states], dim=1)
-                if self.training and self.gradient_checkpointing:
-                    def create_custom_forward(module):
-                        def custom_forward(*inputs):
-                            return module(*inputs)
-                        return custom_forward
-                    if is_torch_version(">=", "1.11.0"):
-                        hidden_states = torch.utils.checkpoint.checkpoint(
-                            create_custom_forward(resnet), hidden_states, temb, use_reentrant=False
-                        )
-                    else:
-                        hidden_states = torch.utils.checkpoint.checkpoint(
-                            create_custom_forward(resnet), hidden_states, temb
-                        )
-                else:
-                    hidden_states = resnet(hidden_states, temb)
-            if self.upsamplers is not None:
-                for upsampler in self.upsamplers:
-                    hidden_states = upsampler(hidden_states, upsample_size)
-            return hidden_states
-        return forward
-    for i, upsample_block in enumerate(model.unet.up_blocks):
-        if isinstance_str(upsample_block, "UpBlock2D"):
-            upsample_block.forward = up_forward(upsample_block)
-def register_free_upblock2d(model, b1=1.2, b2=1.4, s1=0.9, s2=0.2):
-    def up_forward(self):
-        def forward(hidden_states, res_hidden_states_tuple, temb=None, upsample_size=None):
-            for resnet in self.resnets:
-                # pop res hidden states
-                res_hidden_states = res_hidden_states_tuple[-1]
-                res_hidden_states_tuple = res_hidden_states_tuple[:-1]
-                #print(f"in free upblock2d, hidden states shape: {hidden_states.shape}")
-                # # --------------- FreeU code -----------------------
-                # # Only operate on the first two stages
-                # if hidden_states.shape[1] == 1280:
-                #     hidden_states[:,:640] = hidden_states[:,:640] * self.b1
-                #     res_hidden_states = Fourier_filter(res_hidden_states, threshold=1, scale=self.s1)
-                # if hidden_states.shape[1] == 640:
-                #     hidden_states[:,:320] = hidden_states[:,:320] * self.b2
-                #     res_hidden_states = Fourier_filter(res_hidden_states, threshold=1, scale=self.s2)
-                # # ---------------------------------------------------------
-                # --------------- FreeU code -----------------------
-                # Only operate on the first two stages
-                if hidden_states.shape[1] == 1280:
-                    hidden_mean = hidden_states.mean(1).unsqueeze(1)
-                    B = hidden_mean.shape[0]
-                    hidden_max, _ = torch.max(hidden_mean.view(B, -1), dim=-1, keepdim=True)
-                    hidden_min, _ = torch.min(hidden_mean.view(B, -1), dim=-1, keepdim=True)
-                    hidden_mean = (hidden_mean - hidden_min.unsqueeze(2).unsqueeze(3)) / (hidden_max - hidden_min).unsqueeze(2).unsqueeze(3)
-                    hidden_states[:,:640] = hidden_states[:,:640] * ((self.b1 - 1 ) * hidden_mean + 1)
-                    res_hidden_states = Fourier_filter(res_hidden_states, threshold=1, scale=self.s1)
-                if hidden_states.shape[1] == 640:
-                    hidden_mean = hidden_states.mean(1).unsqueeze(1)
-                    B = hidden_mean.shape[0]
-                    hidden_max, _ = torch.max(hidden_mean.view(B, -1), dim=-1, keepdim=True)
-                    hidden_min, _ = torch.min(hidden_mean.view(B, -1), dim=-1, keepdim=True)
-                    hidden_mean = (hidden_mean - hidden_min.unsqueeze(2).unsqueeze(3)) / (hidden_max - hidden_min).unsqueeze(2).unsqueeze(3)
-                    hidden_states[:,:320] = hidden_states[:,:320] * ((self.b2 - 1 ) * hidden_mean + 1)
-                    res_hidden_states = Fourier_filter(res_hidden_states, threshold=1, scale=self.s2)
-                # ---------------------------------------------------------
-                hidden_states = torch.cat([hidden_states, res_hidden_states], dim=1)
-                if self.training and self.gradient_checkpointing:
-                    def create_custom_forward(module):
-                        def custom_forward(*inputs):
-                            return module(*inputs)
-                        return custom_forward
-                    if is_torch_version(">=", "1.11.0"):
-                        hidden_states = torch.utils.checkpoint.checkpoint(
-                            create_custom_forward(resnet), hidden_states, temb, use_reentrant=False
-                        )
-                    else:
-                        hidden_states = torch.utils.checkpoint.checkpoint(
-                            create_custom_forward(resnet), hidden_states, temb
-                        )
-                else:
-                    hidden_states = resnet(hidden_states, temb)
-            if self.upsamplers is not None:
-                for upsampler in self.upsamplers:
-                    hidden_states = upsampler(hidden_states, upsample_size)
-            return hidden_states
-        return forward
-    for i, upsample_block in enumerate(model.unet.up_blocks):
-        if isinstance_str(upsample_block, "UpBlock2D"):
-            upsample_block.forward = up_forward(upsample_block)
-            setattr(upsample_block, 'b1', b1)
-            setattr(upsample_block, 'b2', b2)
-            setattr(upsample_block, 's1', s1)
-            setattr(upsample_block, 's2', s2)
-def register_crossattn_upblock2d(model):
-    def up_forward(self):
-        def forward(
-            hidden_states: torch.FloatTensor,
-            res_hidden_states_tuple: Tuple[torch.FloatTensor, ...],
-            temb: Optional[torch.FloatTensor] = None,
-            encoder_hidden_states: Optional[torch.FloatTensor] = None,
-            cross_attention_kwargs: Optional[Dict[str, Any]] = None,
-            upsample_size: Optional[int] = None,
-            attention_mask: Optional[torch.FloatTensor] = None,
-            encoder_attention_mask: Optional[torch.FloatTensor] = None,
-        ):
-            for resnet, attn in zip(self.resnets, self.attentions):
-                # pop res hidden states
-                #print(f"in crossatten upblock2d, hidden states shape: {hidden_states.shape}")
-                res_hidden_states = res_hidden_states_tuple[-1]
-                res_hidden_states_tuple = res_hidden_states_tuple[:-1]
-                hidden_states = torch.cat([hidden_states, res_hidden_states], dim=1)
-                if self.training and self.gradient_checkpointing:
-                    def create_custom_forward(module, return_dict=None):
-                        def custom_forward(*inputs):
-                            if return_dict is not None:
-                                return module(*inputs, return_dict=return_dict)
-                            else:
-                                return module(*inputs)
-                        return custom_forward
-                    ckpt_kwargs: Dict[str, Any] = {"use_reentrant": False} if is_torch_version(">=", "1.11.0") else {}
-                    hidden_states = torch.utils.checkpoint.checkpoint(
-                        create_custom_forward(resnet),
-                        hidden_states,
-                        temb,
-                        **ckpt_kwargs,
-                    )
-                    hidden_states = torch.utils.checkpoint.checkpoint(
-                        create_custom_forward(attn, return_dict=False),
-                        hidden_states,
-                        encoder_hidden_states,
-                        None,  # timestep
-                        None,  # class_labels
-                        cross_attention_kwargs,
-                        attention_mask,
-                        encoder_attention_mask,
-                        **ckpt_kwargs,
-                    )[0]
-                else:
-                    hidden_states = resnet(hidden_states, temb)
-                    hidden_states = attn(
-                        hidden_states,
-                        encoder_hidden_states=encoder_hidden_states,
-                        cross_attention_kwargs=cross_attention_kwargs,
-                        attention_mask=attention_mask,
-                        encoder_attention_mask=encoder_attention_mask,
-                        return_dict=False,
-                    )[0]
-            if self.upsamplers is not None:
-                for upsampler in self.upsamplers:
-                    hidden_states = upsampler(hidden_states, upsample_size)
-            return hidden_states
-        return forward
-    for i, upsample_block in enumerate(model.unet.up_blocks):
-        if isinstance_str(upsample_block, "CrossAttnUpBlock2D"):
-            upsample_block.forward = up_forward(upsample_block)
-def register_free_crossattn_upblock2d(model, b1=1.2, b2=1.4, s1=0.9, s2=0.2):
-    def up_forward(self):
-        def forward(
-            hidden_states: torch.FloatTensor,
-            res_hidden_states_tuple: Tuple[torch.FloatTensor, ...],
-            temb: Optional[torch.FloatTensor] = None,
-            encoder_hidden_states: Optional[torch.FloatTensor] = None,
-            cross_attention_kwargs: Optional[Dict[str, Any]] = None,
-            upsample_size: Optional[int] = None,
-            attention_mask: Optional[torch.FloatTensor] = None,
-            encoder_attention_mask: Optional[torch.FloatTensor] = None,
-        ):
-            for resnet, attn in zip(self.resnets, self.attentions):
-                # pop res hidden states
-                #print(f"in free crossatten upblock2d, hidden states shape: {hidden_states.shape}")
-                res_hidden_states = res_hidden_states_tuple[-1]
-                res_hidden_states_tuple = res_hidden_states_tuple[:-1]
-                # --------------- FreeU code -----------------------
-                # Only operate on the first two stages
-                if hidden_states.shape[1] == 1280:
-                    hidden_mean = hidden_states.mean(1).unsqueeze(1)
-                    B = hidden_mean.shape[0]
-                    hidden_max, _ = torch.max(hidden_mean.view(B, -1), dim=-1, keepdim=True)
-                    hidden_min, _ = torch.min(hidden_mean.view(B, -1), dim=-1, keepdim=True)
-                    hidden_mean = (hidden_mean - hidden_min.unsqueeze(2).unsqueeze(3)) / (hidden_max - hidden_min).unsqueeze(2).unsqueeze(3)
-                    hidden_states[:,:640] = hidden_states[:,:640] * ((self.b1 - 1 ) * hidden_mean + 1)
-                    res_hidden_states = Fourier_filter(res_hidden_states, threshold=1, scale=self.s1)
-                if hidden_states.shape[1] == 640:
-                    hidden_mean = hidden_states.mean(1).unsqueeze(1)
-                    B = hidden_mean.shape[0]
-                    hidden_max, _ = torch.max(hidden_mean.view(B, -1), dim=-1, keepdim=True)
-                    hidden_min, _ = torch.min(hidden_mean.view(B, -1), dim=-1, keepdim=True)
-                    hidden_mean = (hidden_mean - hidden_min.unsqueeze(2).unsqueeze(3)) / (hidden_max - hidden_min).unsqueeze(2).unsqueeze(3)
-                    hidden_states[:,:320] = hidden_states[:,:320] * ((self.b2 - 1 ) * hidden_mean + 1)
-                    res_hidden_states = Fourier_filter(res_hidden_states, threshold=1, scale=self.s2)
-                # ---------------------------------------------------------
-                hidden_states = torch.cat([hidden_states, res_hidden_states], dim=1)
-                if self.training and self.gradient_checkpointing:
-                    def create_custom_forward(module, return_dict=None):
-                        def custom_forward(*inputs):
-                            if return_dict is not None:
-                                return module(*inputs, return_dict=return_dict)
-                            else:
-                                return module(*inputs)
-                        return custom_forward
-                    ckpt_kwargs: Dict[str, Any] = {"use_reentrant": False} if is_torch_version(">=", "1.11.0") else {}
-                    hidden_states = torch.utils.checkpoint.checkpoint(
-                        create_custom_forward(resnet),
-                        hidden_states,
-                        temb,
-                        **ckpt_kwargs,
-                    )
-                    hidden_states = torch.utils.checkpoint.checkpoint(
-                        create_custom_forward(attn, return_dict=False),
-                        hidden_states,
-                        encoder_hidden_states,
-                        None,  # timestep
-                        None,  # class_labels
-                        cross_attention_kwargs,
-                        attention_mask,
-                        encoder_attention_mask,
-                        **ckpt_kwargs,
-                    )[0]
-                else:
-                    hidden_states = resnet(hidden_states, temb)
-                    # hidden_states = attn(
-                    #     hidden_states,
-                    #     encoder_hidden_states=encoder_hidden_states,
-                    #     cross_attention_kwargs=cross_attention_kwargs,
-                    #     encoder_attention_mask=encoder_attention_mask,
-                    #     return_dict=False,
-                    # )[0]
-                    hidden_states = attn(
-                        hidden_states,
-                        encoder_hidden_states=encoder_hidden_states,
-                        cross_attention_kwargs=cross_attention_kwargs,
-                    )[0]
-            if self.upsamplers is not None:
-                for upsampler in self.upsamplers:
-                    hidden_states = upsampler(hidden_states, upsample_size)
-            return hidden_states
-        return forward
-    for i, upsample_block in enumerate(model.unet.up_blocks):
-        if isinstance_str(upsample_block, "CrossAttnUpBlock2D"):
-            upsample_block.forward = up_forward(upsample_block)
-            setattr(upsample_block, 'b1', b1)
-            setattr(upsample_block, 'b2', b2)
-            setattr(upsample_block, 's1', s1)
-            setattr(upsample_block, 's2', s2)

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/dateutil/tz/__init__.py DELETED Viewed

@@ -1,12 +0,0 @@
-# -*- coding: utf-8 -*-
-from .tz import *
-from .tz import __doc__
-__all__ = ["tzutc", "tzoffset", "tzlocal", "tzfile", "tzrange",
-           "tzstr", "tzical", "tzwin", "tzwinlocal", "gettz",
-           "enfold", "datetime_ambiguous", "datetime_exists",
-           "resolve_imaginary", "UTC", "DeprecatedTzFormatWarning"]
-class DeprecatedTzFormatWarning(Warning):
-    """Warning raised when time zones are parsed from deprecated formats."""

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fsspec/parquet.py DELETED Viewed

@@ -1,551 +0,0 @@
-import io
-import json
-import warnings
-from .core import url_to_fs
-from .utils import merge_offset_ranges
-# Parquet-Specific Utilities for fsspec
-#
-# Most of the functions defined in this module are NOT
-# intended for public consumption. The only exception
-# to this is `open_parquet_file`, which should be used
-# place of `fs.open()` to open parquet-formatted files
-# on remote file systems.
-def open_parquet_file(
-    path,
-    mode="rb",
-    fs=None,
-    metadata=None,
-    columns=None,
-    row_groups=None,
-    storage_options=None,
-    strict=False,
-    engine="auto",
-    max_gap=64_000,
-    max_block=256_000_000,
-    footer_sample_size=1_000_000,
-    **kwargs,
-):
-    """
-    Return a file-like object for a single Parquet file.
-    The specified parquet `engine` will be used to parse the
-    footer metadata, and determine the required byte ranges
-    from the file. The target path will then be opened with
-    the "parts" (`KnownPartsOfAFile`) caching strategy.
-    Note that this method is intended for usage with remote
-    file systems, and is unlikely to improve parquet-read
-    performance on local file systems.
-    Parameters
-    ----------
-    path: str
-        Target file path.
-    mode: str, optional
-        Mode option to be passed through to `fs.open`. Default is "rb".
-    metadata: Any, optional
-        Parquet metadata object. Object type must be supported
-        by the backend parquet engine. For now, only the "fastparquet"
-        engine supports an explicit `ParquetFile` metadata object.
-        If a metadata object is supplied, the remote footer metadata
-        will not need to be transferred into local memory.
-    fs: AbstractFileSystem, optional
-        Filesystem object to use for opening the file. If nothing is
-        specified, an `AbstractFileSystem` object will be inferred.
-    engine : str, default "auto"
-        Parquet engine to use for metadata parsing. Allowed options
-        include "fastparquet", "pyarrow", and "auto". The specified
-        engine must be installed in the current environment. If
-        "auto" is specified, and both engines are installed,
-        "fastparquet" will take precedence over "pyarrow".
-    columns: list, optional
-        List of all column names that may be read from the file.
-    row_groups : list, optional
-        List of all row-groups that may be read from the file. This
-        may be a list of row-group indices (integers), or it may be
-        a list of `RowGroup` metadata objects (if the "fastparquet"
-        engine is used).
-    storage_options : dict, optional
-        Used to generate an `AbstractFileSystem` object if `fs` was
-        not specified.
-    strict : bool, optional
-        Whether the resulting `KnownPartsOfAFile` cache should
-        fetch reads that go beyond a known byte-range boundary.
-        If `False` (the default), any read that ends outside a
-        known part will be zero padded. Note that using
-        `strict=True` may be useful for debugging.
-    max_gap : int, optional
-        Neighboring byte ranges will only be merged when their
-        inter-range gap is <= `max_gap`. Default is 64KB.
-    max_block : int, optional
-        Neighboring byte ranges will only be merged when the size of
-        the aggregated range is <= `max_block`. Default is 256MB.
-    footer_sample_size : int, optional
-        Number of bytes to read from the end of the path to look
-        for the footer metadata. If the sampled bytes do not contain
-        the footer, a second read request will be required, and
-        performance will suffer. Default is 1MB.
-    **kwargs :
-        Optional key-word arguments to pass to `fs.open`
-    """
-    # Make sure we have an `AbstractFileSystem` object
-    # to work with
-    if fs is None:
-        fs = url_to_fs(path, **(storage_options or {}))[0]
-    # For now, `columns == []` not supported. Just use
-    # default `open` command with `path` input
-    if columns is not None and len(columns) == 0:
-        return fs.open(path, mode=mode)
-    # Set the engine
-    engine = _set_engine(engine)
-    # Fetch the known byte ranges needed to read
-    # `columns` and/or `row_groups`
-    data = _get_parquet_byte_ranges(
-        [path],
-        fs,
-        metadata=metadata,
-        columns=columns,
-        row_groups=row_groups,
-        engine=engine,
-        max_gap=max_gap,
-        max_block=max_block,
-        footer_sample_size=footer_sample_size,
-    )
-    # Extract file name from `data`
-    fn = next(iter(data)) if data else path
-    # Call self.open with "parts" caching
-    options = kwargs.pop("cache_options", {}).copy()
-    return fs.open(
-        fn,
-        mode=mode,
-        cache_type="parts",
-        cache_options={
-            **options,
-            **{
-                "data": data.get(fn, {}),
-                "strict": strict,
-            },
-        },
-        **kwargs,
-    )
-def _get_parquet_byte_ranges(
-    paths,
-    fs,
-    metadata=None,
-    columns=None,
-    row_groups=None,
-    max_gap=64_000,
-    max_block=256_000_000,
-    footer_sample_size=1_000_000,
-    engine="auto",
-):
-    """Get a dictionary of the known byte ranges needed
-    to read a specific column/row-group selection from a
-    Parquet dataset. Each value in the output dictionary
-    is intended for use as the `data` argument for the
-    `KnownPartsOfAFile` caching strategy of a single path.
-    """
-    # Set engine if necessary
-    if isinstance(engine, str):
-        engine = _set_engine(engine)
-    # Pass to specialized function if metadata is defined
-    if metadata is not None:
-        # Use the provided parquet metadata object
-        # to avoid transferring/parsing footer metadata
-        return _get_parquet_byte_ranges_from_metadata(
-            metadata,
-            fs,
-            engine,
-            columns=columns,
-            row_groups=row_groups,
-            max_gap=max_gap,
-            max_block=max_block,
-        )
-    # Get file sizes asynchronously
-    file_sizes = fs.sizes(paths)
-    # Populate global paths, starts, & ends
-    result = {}
-    data_paths = []
-    data_starts = []
-    data_ends = []
-    add_header_magic = True
-    if columns is None and row_groups is None:
-        # We are NOT selecting specific columns or row-groups.
-        #
-        # We can avoid sampling the footers, and just transfer
-        # all file data with cat_ranges
-        for i, path in enumerate(paths):
-            result[path] = {}
-            for b in range(0, file_sizes[i], max_block):
-                data_paths.append(path)
-                data_starts.append(b)
-                data_ends.append(min(b + max_block, file_sizes[i]))
-        add_header_magic = False  # "Magic" should already be included
-    else:
-        # We ARE selecting specific columns or row-groups.
-        #
-        # Gather file footers.
-        # We just take the last `footer_sample_size` bytes of each
-        # file (or the entire file if it is smaller than that)
-        footer_starts = []
-        footer_ends = []
-        for i, path in enumerate(paths):
-            footer_ends.append(file_sizes[i])
-            sample_size = max(0, file_sizes[i] - footer_sample_size)
-            footer_starts.append(sample_size)
-        footer_samples = fs.cat_ranges(paths, footer_starts, footer_ends)
-        # Check our footer samples and re-sample if necessary.
-        missing_footer_starts = footer_starts.copy()
-        large_footer = 0
-        for i, path in enumerate(paths):
-            footer_size = int.from_bytes(footer_samples[i][-8:-4], "little")
-            real_footer_start = file_sizes[i] - (footer_size + 8)
-            if real_footer_start < footer_starts[i]:
-                missing_footer_starts[i] = real_footer_start
-                large_footer = max(large_footer, (footer_size + 8))
-        if large_footer:
-            warnings.warn(
-                f"Not enough data was used to sample the parquet footer. "
-                f"Try setting footer_sample_size >= {large_footer}."
-            )
-            for i, block in enumerate(
-                fs.cat_ranges(
-                    paths,
-                    missing_footer_starts,
-                    footer_starts,
-                )
-            ):
-                footer_samples[i] = block + footer_samples[i]
-                footer_starts[i] = missing_footer_starts[i]
-        # Calculate required byte ranges for each path
-        for i, path in enumerate(paths):
-            # Deal with small-file case.
-            # Just include all remaining bytes of the file
-            # in a single range.
-            if file_sizes[i] < max_block:
-                if footer_starts[i] > 0:
-                    # Only need to transfer the data if the
-                    # footer sample isn't already the whole file
-                    data_paths.append(path)
-                    data_starts.append(0)
-                    data_ends.append(footer_starts[i])
-                continue
-            # Use "engine" to collect data byte ranges
-            path_data_starts, path_data_ends = engine._parquet_byte_ranges(
-                columns,
-                row_groups=row_groups,
-                footer=footer_samples[i],
-                footer_start=footer_starts[i],
-            )
-            data_paths += [path] * len(path_data_starts)
-            data_starts += path_data_starts
-            data_ends += path_data_ends
-        # Merge adjacent offset ranges
-        data_paths, data_starts, data_ends = merge_offset_ranges(
-            data_paths,
-            data_starts,
-            data_ends,
-            max_gap=max_gap,
-            max_block=max_block,
-            sort=False,  # Should already be sorted
-        )
-        # Start by populating `result` with footer samples
-        for i, path in enumerate(paths):
-            result[path] = {(footer_starts[i], footer_ends[i]): footer_samples[i]}
-    # Transfer the data byte-ranges into local memory
-    _transfer_ranges(fs, result, data_paths, data_starts, data_ends)
-    # Add b"PAR1" to header if necessary
-    if add_header_magic:
-        _add_header_magic(result)
-    return result
-def _get_parquet_byte_ranges_from_metadata(
-    metadata,
-    fs,
-    engine,
-    columns=None,
-    row_groups=None,
-    max_gap=64_000,
-    max_block=256_000_000,
-):
-    """Simplified version of `_get_parquet_byte_ranges` for
-    the case that an engine-specific `metadata` object is
-    provided, and the remote footer metadata does not need to
-    be transferred before calculating the required byte ranges.
-    """
-    # Use "engine" to collect data byte ranges
-    data_paths, data_starts, data_ends = engine._parquet_byte_ranges(
-        columns,
-        row_groups=row_groups,
-        metadata=metadata,
-    )
-    # Merge adjacent offset ranges
-    data_paths, data_starts, data_ends = merge_offset_ranges(
-        data_paths,
-        data_starts,
-        data_ends,
-        max_gap=max_gap,
-        max_block=max_block,
-        sort=False,  # Should be sorted
-    )
-    # Transfer the data byte-ranges into local memory
-    result = {fn: {} for fn in list(set(data_paths))}
-    _transfer_ranges(fs, result, data_paths, data_starts, data_ends)
-    # Add b"PAR1" to header
-    _add_header_magic(result)
-    return result
-def _transfer_ranges(fs, blocks, paths, starts, ends):
-    # Use cat_ranges to gather the data byte_ranges
-    ranges = (paths, starts, ends)
-    for path, start, stop, data in zip(*ranges, fs.cat_ranges(*ranges)):
-        blocks[path][(start, stop)] = data
-def _add_header_magic(data):
-    # Add b"PAR1" to file headers
-    for i, path in enumerate(list(data.keys())):
-        add_magic = True
-        for k in data[path].keys():
-            if k[0] == 0 and k[1] >= 4:
-                add_magic = False
-                break
-        if add_magic:
-            data[path][(0, 4)] = b"PAR1"
-def _set_engine(engine_str):
-    # Define a list of parquet engines to try
-    if engine_str == "auto":
-        try_engines = ("fastparquet", "pyarrow")
-    elif not isinstance(engine_str, str):
-        raise ValueError(
-            "Failed to set parquet engine! "
-            "Please pass 'fastparquet', 'pyarrow', or 'auto'"
-        )
-    elif engine_str not in ("fastparquet", "pyarrow"):
-        raise ValueError(f"{engine_str} engine not supported by `fsspec.parquet`")
-    else:
-        try_engines = [engine_str]
-    # Try importing the engines in `try_engines`,
-    # and choose the first one that succeeds
-    for engine in try_engines:
-        try:
-            if engine == "fastparquet":
-                return FastparquetEngine()
-            elif engine == "pyarrow":
-                return PyarrowEngine()
-        except ImportError:
-            pass
-    # Raise an error if a supported parquet engine
-    # was not found
-    raise ImportError(
-        f"The following parquet engines are not installed "
-        f"in your python environment: {try_engines}."
-        f"Please install 'fastparquert' or 'pyarrow' to "
-        f"utilize the `fsspec.parquet` module."
-    )
-class FastparquetEngine:
-    # The purpose of the FastparquetEngine class is
-    # to check if fastparquet can be imported (on initialization)
-    # and to define a `_parquet_byte_ranges` method. In the
-    # future, this class may also be used to define other
-    # methods/logic that are specific to fastparquet.
-    def __init__(self):
-        import fastparquet as fp
-        self.fp = fp
-    def _row_group_filename(self, row_group, pf):
-        return pf.row_group_filename(row_group)
-    def _parquet_byte_ranges(
-        self,
-        columns,
-        row_groups=None,
-        metadata=None,
-        footer=None,
-        footer_start=None,
-    ):
-        # Initialize offset ranges and define ParqetFile metadata
-        pf = metadata
-        data_paths, data_starts, data_ends = [], [], []
-        if pf is None:
-            pf = self.fp.ParquetFile(io.BytesIO(footer))
-        # Convert columns to a set and add any index columns
-        # specified in the pandas metadata (just in case)
-        column_set = None if columns is None else set(columns)
-        if column_set is not None and hasattr(pf, "pandas_metadata"):
-            md_index = [
-                ind
-                for ind in pf.pandas_metadata.get("index_columns", [])
-                # Ignore RangeIndex information
-                if not isinstance(ind, dict)
-            ]
-            column_set |= set(md_index)
-        # Check if row_groups is a list of integers
-        # or a list of row-group metadata
-        if row_groups and not isinstance(row_groups[0], int):
-            # Input row_groups contains row-group metadata
-            row_group_indices = None
-        else:
-            # Input row_groups contains row-group indices
-            row_group_indices = row_groups
-            row_groups = pf.row_groups
-        # Loop through column chunks to add required byte ranges
-        for r, row_group in enumerate(row_groups):
-            # Skip this row-group if we are targeting
-            # specific row-groups
-            if row_group_indices is None or r in row_group_indices:
-                # Find the target parquet-file path for `row_group`
-                fn = self._row_group_filename(row_group, pf)
-                for column in row_group.columns:
-                    name = column.meta_data.path_in_schema[0]
-                    # Skip this column if we are targeting a
-                    # specific columns
-                    if column_set is None or name in column_set:
-                        file_offset0 = column.meta_data.dictionary_page_offset
-                        if file_offset0 is None:
-                            file_offset0 = column.meta_data.data_page_offset
-                        num_bytes = column.meta_data.total_compressed_size
-                        if footer_start is None or file_offset0 < footer_start:
-                            data_paths.append(fn)
-                            data_starts.append(file_offset0)
-                            data_ends.append(
-                                min(
-                                    file_offset0 + num_bytes,
-                                    footer_start or (file_offset0 + num_bytes),
-                                )
-                            )
-        if metadata:
-            # The metadata in this call may map to multiple
-            # file paths. Need to include `data_paths`
-            return data_paths, data_starts, data_ends
-        return data_starts, data_ends
-class PyarrowEngine:
-    # The purpose of the PyarrowEngine class is
-    # to check if pyarrow can be imported (on initialization)
-    # and to define a `_parquet_byte_ranges` method. In the
-    # future, this class may also be used to define other
-    # methods/logic that are specific to pyarrow.
-    def __init__(self):
-        import pyarrow.parquet as pq
-        self.pq = pq
-    def _row_group_filename(self, row_group, metadata):
-        raise NotImplementedError
-    def _parquet_byte_ranges(
-        self,
-        columns,
-        row_groups=None,
-        metadata=None,
-        footer=None,
-        footer_start=None,
-    ):
-        if metadata is not None:
-            raise ValueError("metadata input not supported for PyarrowEngine")
-        data_starts, data_ends = [], []
-        md = self.pq.ParquetFile(io.BytesIO(footer)).metadata
-        # Convert columns to a set and add any index columns
-        # specified in the pandas metadata (just in case)
-        column_set = None if columns is None else set(columns)
-        if column_set is not None:
-            schema = md.schema.to_arrow_schema()
-            has_pandas_metadata = (
-                schema.metadata is not None and b"pandas" in schema.metadata
-            )
-            if has_pandas_metadata:
-                md_index = [
-                    ind
-                    for ind in json.loads(
-                        schema.metadata[b"pandas"].decode("utf8")
-                    ).get("index_columns", [])
-                    # Ignore RangeIndex information
-                    if not isinstance(ind, dict)
-                ]
-                column_set |= set(md_index)
-        # Loop through column chunks to add required byte ranges
-        for r in range(md.num_row_groups):
-            # Skip this row-group if we are targeting
-            # specific row-groups
-            if row_groups is None or r in row_groups:
-                row_group = md.row_group(r)
-                for c in range(row_group.num_columns):
-                    column = row_group.column(c)
-                    name = column.path_in_schema
-                    # Skip this column if we are targeting a
-                    # specific columns
-                    split_name = name.split(".")[0]
-                    if (
-                        column_set is None
-                        or name in column_set
-                        or split_name in column_set
-                    ):
-                        file_offset0 = column.dictionary_page_offset
-                        if file_offset0 is None:
-                            file_offset0 = column.data_page_offset
-                        num_bytes = column.total_compressed_size
-                        if file_offset0 < footer_start:
-                            data_starts.append(file_offset0)
-                            data_ends.append(
-                                min(file_offset0 + num_bytes, footer_start)
-                            )
-        return data_starts, data_ends

spaces/Datasculptor/3D-Room-Layout-Estimation_LGT-Net/models/modules/transformer.py DELETED Viewed

@@ -1,44 +0,0 @@
-from models.modules.transformer_modules import *
-class Transformer(nn.Module):
-    def __init__(self, dim, depth, heads, win_size, dim_head, mlp_dim,
-                 dropout=0., patch_num=None, ape=None, rpe=None, rpe_pos=1):
-        super().__init__()
-        self.absolute_pos_embed = None if patch_num is None or ape is None else AbsolutePosition(dim, dropout,
-                                                                                                 patch_num, ape)
-        self.pos_dropout = nn.Dropout(dropout)
-        self.layers = nn.ModuleList([])
-        for _ in range(depth):
-            self.layers.append(nn.ModuleList([
-                PreNorm(dim, Attention(dim, heads=heads, dim_head=dim_head, dropout=dropout, patch_num=patch_num,
-                                       rpe=rpe, rpe_pos=rpe_pos)),
-                PreNorm(dim, FeedForward(dim, mlp_dim, dropout=dropout))
-            ]))
-    def forward(self, x):
-        if self.absolute_pos_embed is not None:
-            x = self.absolute_pos_embed(x)
-        x = self.pos_dropout(x)
-        for attn, ff in self.layers:
-            x = attn(x) + x
-            x = ff(x) + x
-        return x
-if __name__ == '__main__':
-    token_dim = 1024
-    toke_len = 256
-    transformer = Transformer(dim=token_dim, depth=6, heads=16,
-                              dim_head=64, mlp_dim=2048, dropout=0.1,
-                              patch_num=256, ape='lr_parameter', rpe='lr_parameter_mirror')
-    total = sum(p.numel() for p in transformer.parameters())
-    trainable = sum(p.numel() for p in transformer.parameters() if p.requires_grad)
-    print('parameter total:{:,}, trainable:{:,}'.format(total, trainable))
-    input = torch.randn(1, toke_len, token_dim)
-    output = transformer(input)
-    print(output.shape)

spaces/DevashishBhake/Face_Mask_Detection/README.md DELETED Viewed

@@ -1,13 +0,0 @@
----
-title: Face Mask Detection
-emoji: 🔥
-colorFrom: green
-colorTo: blue
-sdk: gradio
-sdk_version: 3.27.0
-app_file: app.py
-pinned: false
-license: mit
----
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/Docfile/open_llm_leaderboard/Makefile DELETED Viewed

@@ -1,13 +0,0 @@
-.PHONY: style format
-style:
-	python -m black --line-length 119 .
-	python -m isort .
-	ruff check --fix .
-quality:
-	python -m black --check --line-length 119 .
-	python -m isort --check-only .
-	ruff check .

spaces/DragGan/DragGan/stylegan_human/utils/__init__.py DELETED Viewed

File without changes

spaces/Eddycrack864/Applio-Inference/diffq/diffq.py DELETED Viewed

@@ -1,286 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-"""
-Differentiable quantizer based on scaled noise injection.
-"""
-from dataclasses import dataclass
-import math
-import typing as tp
-import torch
-from .base import BaseQuantizer
-from .uniform import uniform_quantize, uniform_unquantize
-from .utils import simple_repr
-class DiffQuantizer(BaseQuantizer):
-    @dataclass
-    class _QuantizedParam(BaseQuantizer._QuantizedParam):
-        logit: torch.nn.Parameter
-    def __init__(self, model: torch.nn.Module, min_size: float = 0.01, float16: bool = False,
-                 group_size: int = 1, min_bits: float = 2, max_bits: float = 15,
-                 param="bits", noise="gaussian",
-                 init_bits: float = 8, extra_bits: float = 0, suffix: str = "_diffq",
-                 exclude: tp.List[str] = [], detect_bound: bool = True):
-        """
-        Differentiable quantizer based on scaled noise injection.
-        For every parameter `p` in the model, this introduces a number of bits parameter
-        `b` with the same dimensions (when group_size = 1).
-        Before each forward, `p` is replaced by `p + U`
-        with U uniform iid noise with range [-d/2, d/2], with `d` the uniform quantization
-        step for `b` bits.
-        This noise approximates the quantization noise in a differentiable manner, both
-        with respect to the unquantized parameter `p` and the number of bits `b`.
-        At eveluation (as detected with `model.eval()`), the model is replaced
-        by its true quantized version, and restored when going back to training.
-        When doing actual quantization (for serialization, or evaluation),
-        the number of bits is rounded to the nearest integer, and needs to be stored along.
-        This will cost a few bits per dimension. To reduce this cost, one can use `group_size`,
-        which will use a single noise level for multiple weight entries.
-        You can use the `DiffQuantizer.model_size` method to get a differentiable estimate of the
-        model size in MB. You can then use this estimate as a penalty in your training loss.
-        Args:
-            model (torch.nn.Module): model to quantize
-            min_size (float): minimum size in MB of a parameter to be quantized.
-            float16 (bool): if a layer is smaller than min_size, should we still do float16?
-            group_size (int): weight entries are groupped together to reduce the number
-                of noise scales to store. This should divide the size of all parameters
-                bigger than min_size.
-            min_bits (float): minimal number of bits.
-            max_bits (float): maximal number of bits.
-            init_bits (float): initial number of bits.
-            extra_bits (float): extra bits to add for actual quantization (before roundoff).
-            suffix (str): suffix used for the name of the extra noise scale parameters.
-            exclude (list[str]): list of patterns used to match parameters to exclude.
-                For instance `['bias']` to exclude all bias terms.
-            detect_bound (bool): if True, will detect bound parameters and reuse
-                the same quantized tensor for both, as well as the same number of bits.
-        ..Warning::
-            You must call `model.training()` and `model.eval()` for `DiffQuantizer` work properly.
-        """
-        self.group_size = group_size
-        self.min_bits = min_bits
-        self.max_bits = max_bits
-        self.init_bits = init_bits
-        self.extra_bits = extra_bits
-        self.suffix = suffix
-        self.param = param
-        self.noise = noise
-        assert noise in ["gaussian", "uniform"]
-        self._optimizer_setup = False
-        self._min_noise = 1 / (2 ** self.max_bits - 1)
-        self._max_noise = 1 / (2 ** self.min_bits - 1)
-        assert group_size >= 0
-        assert min_bits < init_bits < max_bits, \
-               "init_bits must be between min_bits and max_bits excluded3"
-        for name, _ in model.named_parameters():
-            if name.endswith(suffix):
-                raise RuntimeError("The model already has some noise scales parameters, "
-                                   "maybe you used twice a DiffQuantizer on the same model?.")
-        super().__init__(model, min_size, float16, exclude, detect_bound)
-    def _get_bits(self, logit: torch.Tensor):
-        if self.param == "noise":
-            return torch.log2(1 + 1 / self._get_noise_scale(logit))
-        else:
-            t = torch.sigmoid(logit)
-            return self.max_bits * t + (1 - t) * self.min_bits
-    def _get_noise_scale(self, logit: torch.Tensor):
-        if self.param == "noise":
-            t = torch.sigmoid(logit)
-            return torch.exp(t * math.log(self._min_noise) + (1 - t) * math.log(self._max_noise))
-        else:
-            return 1 / (2 ** self._get_bits(logit) - 1)
-    def _register_param(self, name, param, module, other):
-        if other is not None:
-            return self.__class__._QuantizedParam(
-               name=name, param=param, module=module, logit=other.logit, other=other)
-        assert self.group_size == 0 or param.numel() % self.group_size == 0
-        # we want the initial number of bits to be init_bits.
-        if self.param == "noise":
-            noise_scale = 1 / (2 ** self.init_bits - 1)
-            t = (math.log(noise_scale) - math.log(self._max_noise)) / (
-                math.log(self._min_noise) - math.log(self._max_noise))
-        else:
-            t = (self.init_bits - self.min_bits) / (self.max_bits - self.min_bits)
-        assert 0 < t < 1
-        logit = torch.logit(torch.tensor(float(t)))
-        assert abs(self._get_bits(logit) - self.init_bits) < 1e-5
-        if self.group_size > 0:
-            nparam = param.numel() // self.group_size
-        else:
-            nparam = 1
-        logit = torch.nn.Parameter(
-            torch.full(
-                (nparam,),
-                logit,
-                device=param.device))
-        module.register_parameter(name + self.suffix, logit)
-        return self.__class__._QuantizedParam(
-           name=name, param=param, module=module, logit=logit, other=None)
-    def clear_optimizer(self, optimizer: torch.optim.Optimizer):
-        params = [qp.logit for qp in self._qparams]
-        for group in optimizer.param_groups:
-            new_params = []
-            for q in list(group["params"]):
-                matched = False
-                for p in params:
-                    if p is q:
-                        matched = True
-                if not matched:
-                    new_params.append(q)
-            group["params"][:] = new_params
-    def setup_optimizer(self, optimizer: torch.optim.Optimizer,
-                        lr: float = 1e-3, **kwargs):
-        """
-        Setup the optimizer to tune the number of bits. In particular, this will deactivate
-        weight decay for the bits parameters.
-        Args:
-            optimizer (torch.Optimizer): optimizer to use.
-            lr (float): specific learning rate for the bits parameters. 1e-3
-                is perfect for Adam.,w
-            kwargs (dict): overrides for other optimization parameters for the bits.
-        """
-        assert not self._optimizer_setup
-        self._optimizer_setup = True
-        params = [qp.logit for qp in self._qparams]
-        for group in optimizer.param_groups:
-            for q in list(group["params"]):
-                for p in params:
-                    if p is q:
-                        raise RuntimeError("You should create the optimizer "
-                                           "before the quantizer!")
-        group = {"params": params, "lr": lr, "weight_decay": 0}
-        group.update(kwargs)
-        optimizer.add_param_group(group)
-    def no_optimizer(self):
-        """
-        Call this if you do not want to use an optimizer.
-        """
-        self._optimizer_setup = True
-    def check_unused(self):
-        for qparam in self._qparams:
-            if qparam.other is not None:
-                continue
-            grad = qparam.param.grad
-            if grad is None or (grad == 0).all():
-                if qparam.logit.grad is not None:
-                    qparam.logit.grad.data.zero_()
-    def model_size(self, exact=False):
-        """
-        Differentiable estimate of the model size.
-        The size is returned in MB.
-        If `exact` is True, then the output is no longer differentiable but
-        reflect exactly an achievable size, even without compression,
-        i.e.same as returned by `naive_model_size()`.
-        """
-        total = super().model_size()
-        subtotal = 0
-        for qparam in self._qparams:
-            # only count the first appearance of a Parameter
-            if qparam.other is not None:
-                continue
-            bits = self.extra_bits + self._get_bits(qparam.logit)
-            if exact:
-                bits = bits.round().clamp(1, 15)
-            if self.group_size == 0:
-                group_size = qparam.param.numel()
-            else:
-                group_size = self.group_size
-            subtotal += group_size * bits.sum()
-            subtotal += 2 * 32  # param scale
-            # Number of bits to represent each number of bits
-            bits_bits = math.ceil(math.log2(1 + (bits.max().round().item() - self.min_bits)))
-            subtotal += 8  # 8 bits for bits_bits
-            subtotal += bits_bits * bits.numel()
-        subtotal /= 2 ** 20 * 8  # bits -> MegaBytes
-        return total + subtotal
-    def true_model_size(self):
-        """
-        Naive model size without zlib compression.
-        """
-        return self.model_size(exact=True).item()
-    def _pre_forward_train(self):
-        if not self._optimizer_setup:
-            raise RuntimeError("You must call `setup_optimizer()` on your optimizer "
-                               "before starting training.")
-        for qparam in self._qparams:
-            if qparam.other is not None:
-                noisy = qparam.other.module._parameters[qparam.other.name]
-            else:
-                bits = self._get_bits(qparam.logit)[:, None]
-                if self.group_size == 0:
-                    p_flat = qparam.param.view(-1)
-                else:
-                    p_flat = qparam.param.view(-1, self.group_size)
-                scale = p_flat.max() - p_flat.min()
-                unit = 1 / (2**bits - 1)
-                if self.noise == "uniform":
-                    noise_source = (torch.rand_like(p_flat) - 0.5)
-                elif self.noise == "gaussian":
-                    noise_source = torch.randn_like(p_flat) / 2
-                noise = scale * unit * noise_source
-                noisy = p_flat + noise
-            # We bypass the checks by PyTorch on parameters being leafs
-            qparam.module._parameters[qparam.name] = noisy.view_as(qparam.param)
-        return True
-    def _post_forward_train(self):
-        for qparam in self._qparams:
-            qparam.module._parameters[qparam.name] = qparam.param
-        return True
-    def _quantize_param(self, qparam: _QuantizedParam) -> tp.Any:
-        bits = self.extra_bits + self._get_bits(qparam.logit)
-        bits = bits.round().clamp(1, 15)[:, None].byte()
-        if self.group_size == 0:
-            p = qparam.param.data.view(-1)
-        else:
-            p = qparam.param.data.view(-1, self.group_size)
-        levels, scales = uniform_quantize(p, bits)
-        return levels, scales, bits
-    def _unquantize_param(self, qparam: _QuantizedParam, quantized: tp.Any) -> torch.Tensor:
-        levels, param_scale, bits = quantized
-        return uniform_unquantize(levels, param_scale, bits).view_as(qparam.param.data)
-    def detach(self):
-        super().detach()
-        for qparam in self._qparams:
-            delattr(qparam.module, qparam.name + self.suffix)
-    def __repr__(self):
-        return simple_repr(self)