Update parquet files (step 4 of 121)

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA crack free The ultimate guide to the most popular game in the series.md

@@ -1,168 +0,0 @@
-<br />
-<h1>Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA crack free</h1>
- <h2>Introduction</h2>
- <p>If you are a fan of role-playing games, you have probably heard of Final Fantasy VII, one of the most popular and influential titles in the genre. But did you know that you can download and play it for free on your PC, thanks to a lossless repack by RG ILITA? In this article, we will explain what Final Fantasy VII is, what a lossless repack is, who RG ILITA is, how to download and install the game, and why you should play it.</p>
-<h2>Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA crack free</h2><br /><p><b><b>DOWNLOAD</b> &bull;&bull;&bull; <a href="https://byltly.com/2uKvsO">https://byltly.com/2uKvsO</a></b></p><br /><br />
- <h3>What is Final Fantasy VII?</h3>
- <p>Final Fantasy VII is a 1997 role-playing video game developed by Square for the PlayStation console. It is the seventh main installment in the Final Fantasy series, which is known for its epic stories, memorable characters, and innovative gameplay. The game's story follows Cloud Strife, a mercenary who joins an eco-terrorist organization called AVALANCHE to stop a world-controlling megacorporation called Shinra from using the planet's life essence as an energy source. Along the way, he and his allies face Sephiroth, a superhuman who seeks to wound the planet and harness its healing power in order to be reborn as a demigod. The game features 3D graphics, full motion video, and a turn-based combat system with real-time elements. The game has been widely praised for its story, characters, music, and gameplay, and has sold over 13 million copies worldwide. It has also spawned several spin-offs, sequels, and a remake.</p>
- <h3>What is a lossless repack?</h3>
- <p>A lossless repack is a compressed version of a game that retains all the original data and quality without any loss or degradation. A lossless repack reduces the size of the game file by removing unnecessary or redundant data, such as languages, videos, or sounds that are not used by the player. A lossless repack also includes a crack that bypasses the copy protection or digital rights management (DRM) of the game, allowing it to be played without a license or activation. A lossless repack is different from a lossy repack, which reduces the size of the game file by lowering the quality or resolution of some data, such as graphics or audio.</p>
- <h3>Who is RG ILITA?</h3>
- <p>RG ILITA is a group of hackers and programmers who specialize in creating lossless repacks of games for PC. They are known for their high-quality repacks that are fast to download and easy to install. They also provide detailed instructions and troubleshooting tips for their repacks. RG ILITA stands for Russian Guys In Lossless IT Adventures.</p>
- <h2>How to download and install Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA crack free</h2>
- <h3>Requirements</h3>
- <p>Before you download and install Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA crack free, you need to make sure that your PC meets the minimum requirements for the game. Here are the minimum requirements:</p>
- <table>
-<tr>
-<th>OS</th>
-<th>Processor</th>
-<th>Memory</th>
-<th>Graphics</th>
-<th>DirectX</th>
-<th>Hard Drive</th>
-</tr>
-<tr>
-<td>Microsoft Windows XP/Vista/7 (32/64bits)</td>
-<td>2GHz</td>
-<td>1 GB RAM</td>
-<td>DirectX 9.0c-compatible graphic card</td>
-<td>9.0c</td>
-<td>3 GB HD space</td>
-</tr>
-</table>
- <p>You also need to have a Square Enix account to play the game.</p>
- <h3>Steps</h3>
- <p>To download and install Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA crack free, follow these steps:</p>
- <ol>
-<li>Go to <a href="https://rgilita.com/final-fantasy-vii-eng-lossless-repack-by-rg-ilita-crack-free/">https://rgilita.com/final-fantasy-vii-eng-lossless-repack-by-rg-ilita-crack-free/</a>, which is the official website of RG ILITA.</li>
-<li>Click on the "Download" button and choose a mirror site from where you want to download the game file.</li>
-<li>The game file is about 1.5 GB in size and will be downloaded as a .rar archive.</li>
-<li>Extract the .rar archive using WinRAR or any other software that can handle .rar files.</li>
-<li>You will get a folder named "Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA". Open it and run "setup.exe" as administrator.</li>
-<li>Follow the instructions on the screen and choose where you want to install the game.</li>
-<li>The installation process will take some time depending on your PC's performance.</li>
-<li>After the installation is complete, run "FF7_Launcher.exe" from the game folder as administrator.</li>
-<li>Login with your Square Enix account or create one if you don't have one.</li>
-<li>You can now play Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA crack free on your PC!</li>
-</ol>
- <h3>Troubleshooting</h3>
- <p>If you encounter any problems while downloading or installing Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA crack free, here are some possible solutions:</p>
- <ul>
-<li>If you get an error message saying "The program can't start because MSVCR100.dll is missing from your computer", you need to install Microsoft Visual C++ 2010 Redistributable Package from <a href="https://www.microsoft.com/en-us/download/details.aspx?id=5555">https://www.microsoft.com/en-us/download/details.aspx?id=5555</a>.</li>
-<li>If you get an error message saying "The program can't start because MSVCP100.dll is missing from your computer", you need to install Microsoft Visual C++ 2010 SP1 Redistributable Package from <a href="https://www.microsoft.com/en-us/download/details.aspx?id=8328">https://www.microsoft.com/en-us/download/details.aspx?id=8328</a>.</li>
-<li>If you get an error message saying "The program can't start because MSVCR120.dll is missing from your computer", you need to install Microsoft Visual C++ 2013 Redistributable Package from <a href="https://www.microsoft.com/en-us/download/details.aspx?id=40784">https://www.microsoft.com/en-us/download/details.aspx?id=40784</a>.</li>
-<li>If you get an error message saying "The program can't start because MSVCP120.dll is missing from your computer", you need to install Microsoft Visual C++ 2013 Redistributable Package from <a href="https://www.microsoft.com/en-us/download/details.aspx?id=40784">https://www.microsoft.com/en-us/download/details.aspx?id=40784</a>.</li>
-<li>If you get an error message saying "The program can't start because api-ms-win-crt-runtime-l1-1-0.dll is missing from your computer", you need to install Windows Update KB2999226 from <a href="https://support.microsoft.com/en-us/help/2999226/update-for-universal-c-runtime-in-windows">https://support.microsoft.com/en-us/help/2999226/update-for-universal-c-runtime-in-windows</a>.</li>
-<li>If you get an error message saying "The program can't start because api-ms-win-crt-heap-l1-1-0.dll is missing from your computer", you need to install Windows Update KB2999226 from <a href="https://support.microsoft.com/en-us/help/2999226/update-for-universal-c-runtime-in-windows">https://support.microsoft.com/en-us/help/2999226/update-for-universal-c-runtime-in-windows</a>.</li>
-<li>If you Here is the continuation of the article. <h2>Why play Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA crack free</h2>
- <h3>Benefits of a lossless repack</h3>
- <p>By downloading and playing Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA crack free, you can enjoy several benefits that a lossless repack offers, such as:</p>
-<p>Download Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA no virus<br />
-How to install Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA on PC<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA gameplay and review<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA torrent magnet link<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA system requirements and compatibility<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA update and patch notes<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA mods and cheats<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA best settings and optimization<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA walkthrough and guide<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA comparison and benchmark<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA crack fix and error solutions<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA online multiplayer and co-op<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA DLC and bonus content<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA secrets and easter eggs<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA remake and remaster differences<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA soundtrack and OST download<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA speedrun and challenge mode<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA tips and tricks for beginners<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA characters and story analysis<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA fan art and cosplay gallery<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA trivia and fun facts<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA alternatives and similar games<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA ranking and rating among RPGs<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA developer interview and behind the scenes<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA merchandise and collectibles<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA emulator and controller support<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA achievements and trophies guide<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA save file and backup location<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA voice actors and cast members<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA memes and jokes compilation<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA opinions and feedback from players<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA history and legacy of the franchise<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA references and influences in pop culture<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA theories and speculations about the plot<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA differences between original and re-release versions<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA side quests and optional content guide<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA combat system and mechanics explanation<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA graphics and performance improvement mods<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA recommended party members and equipment choices<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA endings and epilogue scenes video<br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA fan-made projects and spin-offs <br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA cloud saves and cross-play features <br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA localization and translation issues <br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA censorship and controversy topics <br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA VR support and compatibility <br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA modding tools and tutorials <br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA official website and social media links <br />
-Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA future plans and announcements</p>
- <ul>
-<li>Smaller file size: A lossless repack reduces the size of the game file by removing unnecessary or redundant data, such as languages, videos, or sounds that are not used by the player. This means that you can save disk space and bandwidth when downloading and installing the game.</li>
-<li>Faster download and installation: A smaller file size also means that you can download and install the game faster than the original version. This is especially useful if you have a slow internet connection or a limited data plan.</li>
-<li>No quality loss: A lossless repack retains all the original data and quality of the game without any loss or degradation. This means that you can enjoy the game as it was intended by the developers, with no compromise on graphics, audio, or gameplay.</li>
-<li>No license or activation required: A lossless repack includes a crack that bypasses the copy protection or digital rights management (DRM) of the game, allowing it to be played without a license or activation. This means that you can play the game without any restrictions or limitations, such as online verification, region lock, or time limit.</li>
-</ul>
- <h3>Features of Final Fantasy VII</h3>
- <p>Final Fantasy VII is not only a classic role-playing game, but also a masterpiece of storytelling, character development, and gameplay. By playing Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA crack free, you can experience the following features of the game:</p>
- <ul>
-<li>A captivating story: Final Fantasy VII has a rich and complex story that spans over four discs and involves multiple plot twists, flashbacks, and revelations. The story explores themes such as environmentalism, identity, love, betrayal, and redemption. The story also features memorable characters, such as Cloud Strife, Aerith Gainsborough, Sephiroth, Tifa Lockhart, Barret Wallace, and many more.</li>
-<li>A dynamic combat system: Final Fantasy VII has a turn-based combat system with real-time elements. The combat system allows you to control up to three characters in a party and use various commands, such as attack, magic, summon, item, and limit break. The combat system also features the Materia system, which lets you customize your characters' abilities by equipping them with magical orbs called Materia. The Materia system allows you to create different combinations of spells and skills depending on your preference and strategy.</li>
-<li>A stunning soundtrack: Final Fantasy VII has a beautiful and diverse soundtrack composed by Nobuo Uematsu. The soundtrack consists of over 80 tracks that range from orchestral to rock to techno. The soundtrack also includes iconic themes, such as "One-Winged Angel", "Aerith's Theme", "The Prelude", and "Main Theme of Final Fantasy VII". The soundtrack enhances the mood and atmosphere of the game and creates an emotional connection with the player.</li>
-<li>A vast world to explore: Final Fantasy VII has a huge and varied world to explore that consists of different locations, such as cities, towns, villages, forests, deserts, mountains, oceans, and even outer space. The world also contains hidden secrets, side quests, mini-games, and optional bosses that add more depth and replay value to the game. The world also changes depending on your actions and decisions in the game.</li>
-</ul>
- <h3>Reviews and ratings of Final Fantasy VII</h3>
- <p>Final Fantasy VII has received widespread critical acclaim and commercial success since its release in 1997. It has won numerous awards and accolades from various publications and organizations. It has also been ranked among the best video games of all time by many critics and fans. Here are some examples of reviews and ratings of Final Fantasy VII:</p>
- <table>
-<tr>
-<th>Publication / Organization</th>
-<th>Score / Rating</th>
-<th>Comment</th>
-</tr>
-<tr>
-<td>Metacritic</td>
-<td>92/100 (based on 20 reviews)</td>
-<td>"Final Fantasy VII is one of those rare games that manages to transcend its genre and appeal to gamers of all tastes."</td>
-</tr>
-<tr>
-<td>GameSpot</td>
-<td>9.5/10</td>
-<td>"Final Fantasy VII is quite simply one of the best games ever made."</td>
-</tr>
-<tr>
-<td>IGN</td>
-<td>9.5/10</td>
-<td>"Final Fantasy VII is an experience that everyone should try at least once."</td>
-</tr>
-<tr>
-<td>Famitsu</td>
-<td>38/40</td>
-<td>"Final Fantasy VII is a masterpiece that will remain in history."</td>
-</tr>
-<tr>
-<td>Gamerankings</td>
-<td>92.39% (based on 46 reviews)</td>
-<td>"Final Fantasy VII is a landmark title that revolutionized the role-playing genre."</td>
-</tr>
-<tr Here is the continuation of the article. <h2>Conclusion</h2>
- <p>Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA crack free is a great way to enjoy one of the best role-playing games of all time on your PC. By downloading and playing this lossless repack, you can save disk space and bandwidth, experience the game in its original quality, and play it without any license or activation issues. You can also enjoy the features of Final Fantasy VII, such as its captivating story, dynamic combat system, stunning soundtrack, and vast world to explore. If you are a fan of Final Fantasy VII or role-playing games in general, you should not miss this opportunity to download and play Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA crack free.</p>
- <h2>FAQs</h2>
- <p>Here are some frequently asked questions about Final Fantasy VII - (ENG) [Lossless Repack] by RG ILITA crack free:</p>
- <ol>
-<li>Q: Is this repack safe and virus-free?<br>A: Yes, this repack is safe and virus-free. RG ILITA is a reputable group of hackers and programmers who create high-quality lossless repacks of games for PC. They also provide detailed instructions and troubleshooting tips for their repacks. You can trust their repacks and download them without any worries.</li>
-<li>Q: Is this repack the full game or only a part of it?<br>A: This repack is the full game of Final Fantasy VII. It covers the entire story of the original game, from the beginning to the end. It also includes all the bonus content and features that were added in later releases, such as the International version and the Remaster version.</li>
-<li>Q: How long does it take to download and install this repack?<br>A: The download and installation time depends on your internet speed and PC performance. The game file is about 1.5 GB in size and will be downloaded as a .rar archive. The installation process will take some time depending on your PC's performance. On average, it may take about 15 minutes to download and 30 minutes to install.</li>
-<li>Q: Can I play this repack online or with other players?<br>A: No, this repack is only for single-player mode. You cannot play this repack online or with other players. This repack includes a crack that bypasses the copy protection or digital rights management (DRM) of the game, which prevents it from connecting to online servers or multiplayer modes.</li>
-<li>Q: What are the differences between this repack and the original game?<br>A: The main difference between this repack and the original game is the file size. This repack reduces the size of the game file by removing unnecessary or redundant data, such as languages, videos, or sounds that are not used by the player. This means that you can save disk space and bandwidth when downloading and installing the game. However, there is no quality loss or gameplay change in this repack. You can enjoy the game as it was intended by the developers, with no compromise on graphics, audio, or gameplay.</li>
-</ol>
- </p> 0a6ba089eb<br />
-<br />
-<br />

spaces/1gistliPinn/ChatGPT4/Examples/Cars 2 Tamil Dubbed Movie Torrent Download [Extra Quality].md

@@ -1,6 +0,0 @@
-<h2>Cars 2 Tamil Dubbed Movie Torrent Download</h2><br /><p><b><b>Download File</b> &#10026; <a href="https://imgfil.com/2uy0Yc">https://imgfil.com/2uy0Yc</a></b></p><br /><br />
-
-More Tamil Movies, comedy, songs videos ... 2020 Tamil Horror Movie - Bloody Ballet - Fantasma || Hollywood ... 1fdad05405<br />
-<br />
-<br />
-<p></p>

spaces/1gistliPinn/ChatGPT4/Examples/El Adefesio Rafael Alberti Pdf Free Download.md

@@ -1,6 +0,0 @@
-<h2>el adefesio rafael alberti pdf download</h2><br /><p><b><b>Download</b> &#11088; <a href="https://imgfil.com/2uy1oB">https://imgfil.com/2uy1oB</a></b></p><br /><br />
-
-Leer la poesía Canción a Altaír del poeta Rafael Alberti en el sitio ... En nuestro sitio, le ofrecemos descargar el libro Canciones para altair a PDF de ... El trébol florido (1940), El adefesio (1944), La Gallarda (1944-45) y Noche de guerra. 1fdad05405<br />
-<br />
-<br />
-<p></p>

spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Crazy Drop A Fun and Addictive Game to Collect Coins and Rewards.md

@@ -1,98 +0,0 @@
-
-<h1>Crazy Drop APK: A Fun and Addictive Casual Game for Android</h1>
-<p>If you are looking for a casual game that can keep you entertained and relaxed, you should try Crazy Drop APK. This is a game that lets you drop balls and hit targets, collect coins and gems, and win rewards. It is simple, fun, and addictive. In this article, we will tell you more about what Crazy Drop APK is, how to play it, why you should play it, and how to download and install it on your Android device.</p>
-<h2>crazy drop apk</h2><br /><p><b><b>DOWNLOAD</b> &#9658; <a href="https://urlin.us/2uSS67">https://urlin.us/2uSS67</a></b></p><br /><br />
-<h2>What is Crazy Drop APK?</h2>
-<p>Crazy Drop APK is a casual game developed by DoraBmonkey, a developer that specializes in creating games that are easy to play but hard to put down. Crazy Drop APK is one of their most popular games, with over 84 downloads on Uptodown.com. Here are some of the features of Crazy Drop APK:</p>
-<h3>A game that lets you drop balls and win rewards</h3>
-<p>In Crazy Drop APK, your goal is to drop balls from the top of the screen and hit the targets at the bottom. The targets can be coins, gems, power-ups, or bonuses. The more targets you hit, the more rewards you get. You can use the rewards to unlock more balls and levels in the game.</p>
-<h3>A game that has simple controls and graphics</h3>
-<p>Crazy Drop APK is a game that anyone can play, regardless of their skill level or experience. The controls are very simple: just tap the screen to drop a ball. The graphics are also simple but colorful and appealing. The game has a minimalist design that does not distract from the gameplay.</p>
-<h3>A game that is free to download and play</h3>
-<p>Crazy Drop APK is a game that does not cost you anything to download or play. You can enjoy the game without spending any money. However, if you want to support the developer or get some extra features, you can also make in-app purchases in the game.</p>
-<h2>How to play Crazy Drop APK?</h2>
-<p>Crazy Drop APK is a game that is easy to learn but hard to master. Here are some tips on how to play it:</p>
-<h3>Tap to drop balls and hit targets</h3>
-<p>The basic gameplay of Crazy Drop APK is very simple: just tap the screen to drop a ball from the top of the screen. The ball will bounce off the pegs and obstacles on its way down, and hopefully hit some targets at the bottom. The targets can be coins, gems, power-ups, or bonuses. The more targets you hit, the higher your score will be.</p>
-<h3>Collect coins and gems to unlock more balls and levels</h3>
-<p>As you play Crazy Drop APK, you will collect coins and gems as rewards. You can use these coins and gems to unlock more balls and levels in the game. Each ball has a different shape, color, size, and speed. Each level has a different layout, difficulty, and goal. You can choose the ball and level that suit your preference and challenge yourself.</p>
-<p>crazy drop android game download<br />
-crazy drop mod apk unlimited coins<br />
-crazy drop game online free<br />
-crazy drop apk latest version<br />
-crazy drop game review<br />
-crazy drop apk for pc<br />
-crazy drop mod apk download<br />
-crazy drop game tips and tricks<br />
-crazy drop apk old version<br />
-crazy drop game hack<br />
-crazy drop apk no ads<br />
-crazy drop game play store<br />
-crazy drop apk uptodown<br />
-crazy drop game strategy<br />
-crazy drop apk modradar<br />
-crazy drop game cheats<br />
-crazy drop apk pure<br />
-crazy drop game features<br />
-crazy drop apk combo<br />
-crazy drop game rules<br />
-crazy drop apk mirror<br />
-crazy drop game guide<br />
-crazy drop apk android 1<br />
-crazy drop game levels<br />
-crazy drop apk rexdl<br />
-crazy drop game rewards<br />
-crazy drop apk mob.org<br />
-crazy drop game challenges<br />
-crazy drop apk apkpure<br />
-crazy drop game coins<br />
-crazy drop apk happymod<br />
-crazy drop game screenshots<br />
-crazy drop apk android oyun club<br />
-crazy drop game developer<br />
-crazy drop apk revdl<br />
-crazy drop game rating<br />
-crazy drop apk malavida<br />
-crazy drop game support<br />
-crazy drop apk apkmirror<br />
-crazy drop game update<br />
-crazy drop apk apkmody<br />
-crazy drop game genre<br />
-crazy drop apk apknite<br />
-crazy drop game forum<br />
-crazy drop apk apktada.com</p>
-<h3>Use power-ups and bonuses to boost your score and chances</h3>
-<p>Crazy Drop APK also has some power-ups and bonuses that can help you improve your performance in the game. For example, you can use the magnet power-up to attract more coins and gems, or the bomb power-up to explode more targets. You can also get bonuses such as extra balls, extra time, or extra lives. These power-ups and bonuses can boost your score and chances of completing the level.</p>
-<h2>Why should you play Crazy Drop APK?</h2>
-<p>Crazy Drop APK is a game that has many benefits for its players. Here are some of the reasons why you should play it:</p>
-<h3>It is fun and relaxing to play</h3>
-<p>Crazy Drop APK is a game that can make you feel happy and relaxed. It is a game that does not require too much thinking or strategy, but rather relies on your intuition and luck. It is a game that can help you relieve stress and boredom, and enjoy some quality time.</p>
-<h3>It is challenging and rewarding to master</h3>
-<p>Crazy Drop APK is also a game that can challenge and reward you. It is a game that has many levels and goals to complete, each with different difficulties and obstacles. It is a game that can test your skills and reflexes, and make you feel proud and satisfied when you achieve a high score or clear a level.</p>
-<h3>It is suitable for all ages and preferences</h3>
-<p>Crazy Drop APK is a game that can appeal to anyone, regardless of their age or preference. It is a game that has simple but attractive graphics, sound effects, and music. It is a game that has easy but addictive gameplay, with various balls and levels to choose from. It is a game that can be played anytime, anywhere, with or without an internet connection.</p>
-<h2>How to download and install Crazy Drop APK?</h2>
-<p>If you are interested in playing Crazy Drop APK, you can download and install it on your Android device easily. Here are the steps to follow:</p>
-<h3>Download the APK file from Uptodown.com</h3>
-<p>The first step is to download the APK file of Crazy Drop APK from Uptodown.com, a website that offers safe and verified APK files for Android apps and games. You can use the link below to access the download page of Crazy Drop APK:</p>
-<p><a href="">Crazy Drop APK 1.0.0 for Android - Download</a></p>
-<h3>Enable unknown sources on your device settings</h3>
-<p>The second step is to enable unknown sources on your device settings, which will allow you to install apps from sources other than the Google Play Store. To do this, go to your device settings, then security or privacy, then toggle on the option for unknown sources.</p>
-<h3>Install the APK file and enjoy the game</h3>
-<p>The final step is to install the APK file of Crazy Drop APK on your device. To do this, locate the downloaded file in your file manager or downloads folder, then tap on it to start the installation process. Follow the instructions on the screen, then wait for the installation to finish. Once done, you can launch the game and enjoy it.</p>
- <h2>Conclusion</h2>
-<p>Crazy Drop APK is a fun and addictive casual game for Android that lets you drop balls and hit targets, collect coins and gems, and win rewards. It is a game that has simple controls and graphics, but challenging and rewarding gameplay. It is a game that is free to download and play, but also offers in-app purchases for extra features. It is a game that is suitable for all ages and preferences, and can be played anytime, anywhere. If you are looking for a casual game that can keep you entertained and relaxed, you should try Crazy Drop APK.</p>
- <h2>FAQs</h2>
-<p>Here are some of the frequently asked questions about Crazy Drop APK:</p>
-<h4>Q: How many balls and levels are there in Crazy Drop APK?</h4>
-<p>A: There are over 100 balls and over 1000 levels in Crazy Drop APK, each with different shapes, colors, sizes, speeds, layouts, difficulties, and goals.</p>
-<h4>Q: How can I get more coins and gems in Crazy Drop APK?</h4>
-<p>A: You can get more coins and gems in Crazy Drop APK by hitting more targets, completing more levels, watching ads, or making in-app purchases.</p>
-<h4>Q: What are the power-ups and bonuses in Crazy Drop APK?</h4>
-<p>A: The power-ups in Crazy Drop APK are magnet, bomb, fireball, lightning, rainbow, starburst, and shield. The bonuses are extra balls, extra time, extra lives, and double coins.</p>
-<h4>Q: What are the requirements to play Crazy Drop APK?</h4>
-<p>A: You need an Android device with Android 5.0 or higher version, and at least 50 MB of free space on your device. You also need an internet connection to download and install the game, and to access some of the features such as ads and in-app purchases.</p>
-<h4>Q: Is Crazy Drop APK safe and secure to download and play?</h4>
-<p>A: Yes, Crazy Drop APK is safe and secure to download and play. The APK file is verified by Uptodown.com, a trusted website that offers safe and verified APK files for Android apps and games. The game does not contain any viruses, malware, or spyware that can harm your device or data.</p> 197e85843d<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Download 5 Nights At Freddy 39s 2 [VERIFIED].md

@@ -1,75 +0,0 @@
-
-<h1>How to Download Five Nights at Freddy's 2</h1>
-<p>If you are a fan of horror games, you might have heard of Five Nights at Freddy's 2, a sequel to the popular indie game Five Nights at Freddy's. In this game, you play as a night guard at a pizzeria where animatronic characters come alive at night and try to kill you. You have to survive five nights using a mask, a flashlight, cameras, and other tools.</p>
-<p>Five Nights at Freddy's 2 is a thrilling and challenging game that will keep you on edge with its jumpscares, suspenseful atmosphere, and creepy characters. It has received positive reviews from critics and players alike, and has spawned several spin-offs and adaptations.</p>
-<h2>download 5 nights at freddy 39;s 2</h2><br /><p><b><b>Download File</b> &#10037;&#10037;&#10037; <a href="https://jinyurl.com/2uNOi0">https://jinyurl.com/2uNOi0</a></b></p><br /><br />
-<p>If you want to download Five Nights at Freddy's 2 on your PC, you will need a few things first. Here are some steps you can follow to get the game safely and easily.</p>
-<h2>What You Need to Download the Game</h2>
-<h3>A PC with Windows OS</h3>
-<p>Five Nights at Freddy's 2 is compatible with Windows XP, Vista, 7, 8, and 10 operating systems. You will also need at least 1 GB of RAM, 250 MB of free disk space, and a 2 GHz processor. You can check your PC specs by right-clicking on My Computer or This PC icon and selecting Properties.</p>
-<h3>A verified download platform</h3>
-<p>It is important to use a verified download platform when you want to download games online. This way, you can avoid viruses, malware, fraud, and other risks that might harm your PC or compromise your personal information. Some of the verified platforms that you can use to download Five Nights at Freddy's 2 are Steam, Epic Games Downloader, and Microsoft Store. These platforms have secure payment methods, customer support, and user reviews that can help you make an informed decision.</p>
-<h3>A stable internet connection</h3>
-<p>You will also need a stable internet connection to download the game without interruptions or errors. You can check your internet speed by using online tools such as Speedtest or Fast. You will need at least 5 Mbps of download speed and 1 Mbps of upload speed to download the game smoothly. If your internet connection is slow or unstable, you might want to pause other downloads, close unnecessary tabs or apps, or use a wired connection instead of Wi-Fi.</p>
-<p></p>
-<h2>How to Download the Game from Steam</h2>
-<h3>Create a Steam account or log in</h3>
-<p>Steam is one of the most popular and trusted platforms for downloading games online. It has a large library of games, including Five Nights at Freddy's 2, and offers discounts, achievements, cloud saves, and other features. To download the game from Steam, you will need to create a Steam account or log in to your existing one. You can do this by visiting the Steam website or downloading the Steam app on your PC. You will need to provide your email address, password, username, and other details to create an account.</p>
-<h3>Search for the game on Steam</h3>
-<p>Once you have logged in to your Steam account, you can search for Five Nights at Freddy's 2 on the Steam store. You can use the search bar on the top right corner of the screen or browse through the categories and genres. You can also filter your search by price, rating, release date, and other criteria. When you find the game, click on it to see more information, such as screenshots, videos, description, system requirements, and user reviews.</p>
-<h3>Purchase and install the game on Steam</h3>
-<p>If you decide to buy the game, you will need to add it to your cart and proceed to checkout. You will need to choose your payment method, such as credit card, PayPal, or Steam Wallet. You will also need to agree to the terms and conditions and confirm your purchase. The game costs $7.99 on Steam as of June 2023.</p>
-<p>After you have purchased the game, you can download and install it on your PC. You can do this by going to your library and clicking on the game. You will see a button that says "Install" or "Play" depending on whether you have installed it before or not. Click on it and follow the instructions to start the download and installation process. The game size is about 215 MB on Steam.</p>
-<h2>How to Download the Game from Epic Games Downloader</h2>
-<h3>Download and install Epic Games Downloader</h3>
-<p>Epic Games Downloader is another platform that you can use to download games online. It is the official launcher for games developed by Epic Games, such as Fortnite and Unreal Engine, but it also offers other games from different developers and publishers. To download Five Nights at Freddy's 2 from Epic Games Downloader, you will need to download and install the Epic Games Downloader app on your PC first. You can do this by visiting the Epic Games website and clicking on "Get Epic Games" on the top right corner of the screen.</p> <p>After you have downloaded the app, you will need to run it and follow the instructions to install it on your PC. You will also need to create an Epic Games account or log in to your existing one. You can do this by clicking on "Sign In" or "Sign Up" on the top right corner of the app. You will need to provide your email address, password, username, and other details to create an account.</p>
-<h3>Search for the game on Epic Games Downloader</h3>
-<p>Once you have logged in to your Epic Games account, you can search for Five Nights at Freddy's 2 on the Epic Games Downloader app. You can use the search bar on the top left corner of the screen or browse through the categories and genres. You can also filter your search by price, rating, release date, and other criteria. When you find the game, click on it to see more information, such as screenshots, videos, description, system requirements, and user reviews.</p>
-<h3>Purchase and install the game on Epic Games Downloader</h3>
-<p>If you decide to buy the game, you will need to add it to your cart and proceed to checkout. You will need to choose your payment method, such as credit card, PayPal, or Epic Games Wallet. You will also need to agree to the terms and conditions and confirm your purchase. The game costs $7.99 on Epic Games Downloader as of June 2023.</p>
-<p>After you have purchased the game, you can download and install it on your PC. You can do this by going to your library and clicking on the game. You will see a button that says "Install" or "Play" depending on whether you have installed it before or not. Click on it and follow the instructions to start the download and installation process. The game size is about 215 MB on Epic Games Downloader.</p>
-<h2>How to Download the Game from Microsoft Store</h2>
-<h3>Open the Microsoft Store app or website</h3>
-<p>Microsoft Store is another platform that you can use to download games online. It is the official store for Windows apps and games, and it also offers movies, music, books, and other content. To download Five Nights at Freddy's 2 from Microsoft Store, you will need to open the Microsoft Store app or website on your PC. You can do this by clicking on the Microsoft Store icon on your taskbar or Start menu, or by visiting the Microsoft Store website on your browser.</p>
-<h3>Search for the game on Microsoft Store</h3>
-<p>Once you have opened the Microsoft Store app or website, you can search for Five Nights at Freddy's 2 on the Microsoft Store. You can use the search bar on the top right corner of the screen or browse through the categories and genres. You can also filter your search by price, rating, release date, and other criteria. When you find the game, click on it to see more information, such as screenshots, videos, description, system requirements, and user reviews.</p>
-<h3>Purchase and install the game on Microsoft Store</h3>
-<p>If you decide to buy the game, you will need to add it to your cart and proceed to checkout. You will need to choose your payment method, such as credit card, PayPal, or Microsoft account balance. You will also need to agree to the terms and conditions and confirm your purchase. The game costs $7.99 on Microsoft Store as of June 2023.</p>
-<p>After you have purchased the game, you can download and install it on your PC. You can do this by going to your library and clicking on the game. You will see a button that says "Install" or "Play" depending on whether you have installed it before or not. Click on it and follow the instructions to start the download and installation process. The game size is about 215 MB on Microsoft Store.</p>
-<h2>How to Play the Game Safely and Enjoyably</h2>
-<h3>Check your antivirus software and firewall settings</h3>
-<p>Before you start playing Five Nights at Freddy's 2, you should make sure that your antivirus software and firewall settings are up to date and allow you to play the game safely. Some antivirus software or firewall settings might block or interfere with the game's files or functions, causing errors or crashes. To avoid this, you should whitelist or exclude the game's folder or executable file from your antivirus software or firewall settings. You can also temporarily disable them while playing the game if necessary.</p>
-<h3>Adjust your graphics and sound settings</h3>
-<p>To enjoy Five Nights at Freddy's 2 fully, you should also adjust your graphics and sound settings according to your preferences and PC capabilities. You can access these settings by clicking on "Options" on the main menu of the game. You can change the resolution, fullscreen mode, quality, and brightness of the graphics, and the volume and mute options of the sound. You can also enable or disable subtitles and hints. You should choose the settings that suit your taste and make the game run smoothly on your PC.</p>
-<h3>Follow the game rules and tips</h3>
-<p>Finally, you should follow the game rules and tips to play the game effectively and survive the five nights. The game rules are explained by a phone call at the beginning of each night, but you can also read them on the main menu by clicking on "How to Play". Some of the basic rules are:</p>
-<ul>
-<li>You have to monitor the cameras to keep track of the animatronics' movements and locations.</li>
-<li>You have to use the mask to fool the animatronics that come into your office, except for Foxy and The Puppet.</li>
-<li>You have to use the flashlight to check the vents and the hallway, and to ward off Foxy.</li>
-<li>You have to wind up the music box to keep The Puppet from escaping.</li>
-<li>You have a limited power supply for your flashlight and cameras, so use them wisely.</li>
-</ul>
-<p>Some of the tips that can help you are:</p>
-<ul>
-<li>Listen carefully to the sounds and noises that indicate the presence or movement of the animatronics.</li>
-<li>Check the cameras frequently, but not too much, to avoid wasting power and missing important events.</li>
-<li>Use the mask as soon as you see an animatronic in your office or in the vents, and take it off as soon as they leave.</li>
-<li>Wind up the music box regularly, but not too much, to avoid wasting time and power.</li>
-<li>Don't panic or lose focus when you encounter a jumpscare or a hallucination.</li>
-</ul>
-<h2>Conclusion</h2>
-<p>Five Nights at Freddy's 2 is a fun and scary game that will test your nerves and skills. It is easy to download and play on your PC, as long as you have the right equipment and platform. You can choose from Steam, Epic Games Downloader, or Microsoft Store to get the game safely and easily. You can also adjust your settings and follow some tips to play the game optimally. If you are ready to face the horror of Freddy Fazbear's Pizza, download Five Nights at Freddy's 2 today and see if you can survive!</p>
- <h2>Frequently Asked Questions</h2>
-<h3>Is Five Nights at Freddy's 2 a free game?</h3>
-<p>No, Five Nights at Freddy's 2 is not a free game. It costs $7.99 on Steam, Epic Games Downloader, and Microsoft Store as of June 2023. However, you might find some discounts or offers on these platforms from time to time.</p>
-<h3>Is Five Nights at Freddy's 2 a multiplayer game?</h3>
-<p>No, Five Nights at Freddy's 2 is not a multiplayer game. It is a single-player game that requires you to play alone against the animatronics. However, you can share your gameplay videos or screenshots with other players online or watch other players' gameplay videos or streams.</p>
-<h3>Is Five Nights at Freddy's 2 a scary game?</h3>
-<p>Yes, Five Nights at Freddy's 2 is a scary game. It is a horror game that features jumpscares, suspenseful atmosphere, creepy characters, and disturbing events. It is not recommended for people who are easily scared or have heart problems. However, some people might find it funny or amusing instead of scary.</p>
-<h3>Is Five Nights at Freddy's 2 a sequel or a prequel?</h3>
-<p>Five Nights at Freddy's 2 is a prequel to Five Nights at Freddy's. It takes place in 1987, before the events of Five Nights at Freddy's, which takes place in 1993. It reveals some backstory and lore about the animatronics, the pizzeria, and the phone guy.</p>
-<h3>Is Five Nights at Freddy's 2 a safe game?</h3>
-<p>Yes, Five Nights at Freddy's 2 is a safe game. It does not contain any viruses, malware, fraud, or other risks that might harm your PC or compromise your personal information. However, you should always use a verified download platform and check your antivirus software and firewall settings before playing the game.</p> 401be4b1e0<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Download Chinese FIFA Mobile and Join the 3rd Anniversary Celebration.md

@@ -1,114 +0,0 @@
-
-<h1>How to Download Chinese FIFA Mobile</h1>
-<p>If you are a fan of FIFA Mobile, you might be interested in trying out the Chinese version of the game. The Chinese version, also known as FIFA World of Football, is developed by Tencent and authorized by FIFA. It offers some unique features and benefits that are not available in other versions of the game. In this article, we will show you how to download and install Chinese FIFA Mobile on your Android or iOS device, and how to play it with English language settings.</p>
- <h2>What is Chinese FIFA Mobile?</h2>
-<p>Chinese FIFA Mobile is the first football-themed competitive mobile game to land in the Chinese market. It is the only independent mobile game authorized by FIFA in China. It features more than 10,000 real stars, more than 30 real leagues, and major clubs from all over the world. You can create your own team, compete with other players, and participate in various events and modes.</p>
-<h2>download chinese fifa mobile</h2><br /><p><b><b>DOWNLOAD</b> &#9999; <a href="https://jinyurl.com/2uNO3A">https://jinyurl.com/2uNO3A</a></b></p><br /><br />
- <h3>The features and benefits of playing Chinese FIFA Mobile</h3>
-<p>Some of the features and benefits of playing Chinese FIFA Mobile are:</p>
-<ul>
-<li>Smooth and realistic gameplay, inherited from the classic terminal game operation. You can choose between two different operating modes: traditional roulette operation and dot and stroke operation. The former is more suitable for competitive players who want to perform difficult operations and skills, while the latter is more user-friendly for casual players who want to enjoy the touch screen advantages.</li>
-<li>Original development, allowing you to create exclusive superstars freely. You can develop any player you like, even if he is not a superstar in reality, into a top player comparable to Cristiano Ronaldo and Messi. You can also customize your team's formation, tactics, style, and appearance.</li>
-<li>Rich and diverse content, including various events, modes, challenges, and rewards. You can play in the World Cup mode, where you can represent your country and compete with other players from different regions. You can also play in the Eternal Icon mode, where you can collect legendary players from different eras and form your dream team.</li>
-</ul>
- <h3>The differences between Chinese FIFA Mobile and other versions</h3>
-<p>Some of the differences between Chinese FIFA Mobile and other versions are:</p>
-<ul>
-<li>Chinese FIFA Mobile is developed by Tencent, while other versions are developed by EA Sports.</li>
-<li>Chinese FIFA Mobile requires you to log in with a QQ or WeChat account, while other versions require you to log in with an EA account or a Facebook account.</li>
-<li>Chinese FIFA Mobile has some exclusive events, modes, players, and items that are not available in other versions.</li>
-<li>Chinese FIFA Mobile has a different currency system than other versions. The game token "point coupon" purchased by the user in the game can only be used in this application. Virtual currencies on the Tencent platform, such as Q coins and Q points, cannot be used in the game.</li>
-</ul>
- <h2>How to download and install Chinese FIFA Mobile on Android devices</h2>
-<p>If you want to play Chinese FIFA Mobile on your Android device, you need to download and install the APK file from a reliable source. Here are the steps you need to follow:</p>
- <h3>Step 1: Find a reliable source for the APK file</h3>
-<p>Since Chinese FIFA Mobile is not available on the Google Play Store, you need to find a trustworthy website that provides the APK file for the game. You can use a search engine or a third-party app store to look for the APK file. Some of the popular websites that offer the APK file are APKPure, APKCombo, and TapTap.</p>
- <h3>Step 2: Enable unknown sources on your device settings</h3>
-<p>Before you can install the APK file, you need to enable unknown sources on your device settings. This will allow you to install apps from sources other than the Google Play Store. To do this, go to your device settings, then security, then toggle on the option for unknown sources. You may see a warning message that installing apps from unknown sources may harm your device. Tap OK to proceed.</p>
-<p>How to download chinese fifa mobile on android<br />
-Chinese fifa mobile apk download for free<br />
-Download fifa mobile world cn - fifa足球世界 apk<br />
-Chinese fifa mobile 3rd anniversary update download<br />
-Download fifa mobile with eternal icon class and transfer market<br />
-Chinese version of fifa mobile download for pc<br />
-Download fifa mobile with new free kick and penalty kick animations<br />
-Chinese fifa mobile mod apk download unlimited coins and gems<br />
-Download fifa mobile with 32 qualified national teams and 15 non-qualified national teams<br />
-Chinese fifa mobile hack apk download no root<br />
-Download fifa mobile with improved set piece camera and gameplay experience<br />
-Chinese fifa mobile ios download without jailbreak<br />
-Download fifa mobile with korea superconducting tokamak advanced research facility<br />
-Chinese fifa mobile online download play with friends<br />
-Download fifa mobile with latest players and events<br />
-Chinese fifa mobile offline download no internet required<br />
-Download fifa mobile with nexon company and tencent games<br />
-Chinese fifa mobile 2023 download new season update<br />
-Download fifa mobile with google play store and aptoide<br />
-Chinese fifa mobile cheats download get free resources and tips<br />
-Download fifa mobile with game guardian and aurora store<br />
-Chinese fifa mobile english patch download change language settings<br />
-Download fifa mobile with uptodown and apkcombo installer<br />
-Chinese fifa mobile reddit download join the community and discussion<br />
-Download fifa mobile with ea sports and electronic arts<br />
-Chinese fifa mobile facebook download connect with social media and friends<br />
-Download fifa mobile with google account manager and google play services<br />
-Chinese fifa mobile youtube download watch videos and tutorials<br />
-Download fifa mobile with tradutor inglês para português apk<br />
-Chinese fifa mobile twitter download follow the official account and news<br />
-Download fifa mobile with lensa dawn ai and wink ai mirror<br />
-Chinese fifa mobile instagram download share your screenshots and stories<br />
-Download fifa mobile with geforce now and nintendo switch online<br />
-Chinese fifa mobile discord download chat with other players and join servers<br />
-Download fifa mobile with outline vpn and toffee vpn<br />
-Chinese fifa mobile tiktok download create and watch short videos<br />
-Download fifa mobile with meitu and faceplay apps<br />
-Chinese fifa mobile quora download ask and answer questions about the game<br />
-Download fifa mobile with digiwards and rumble apps<br />
-Chinese fifa mobile wikipedia download learn more about the game and its history</p>
- <h3>Step 3: Download and install the APK file</h3>
-<p>Once you have enabled unknown sources, you can download and install the APK file from the website you chose. Tap on the download button and wait for the file to be downloaded. Then, tap on the file and follow the instructions to install it. You may need to grant some permissions to the app during the installation process.</p>
- <h3>Step 4: Launch the game and log in with your QQ or WeChat account</h3>
-<p>After you have installed the game, you can launch it from your app drawer or home screen. You will see a splash screen with the Tencent and FIFA logos, followed by a login screen. You need to log in with your QQ or WeChat account to play the game. If you don't have one, you can create one for free by following the prompts on the screen.</p>
- <h2>How to download and install Chinese FIFA Mobile on iOS devices</h2>
-<p>If you want to play Chinese FIFA Mobile on your iOS device, you need to create a Chinese Apple ID and change your region to China. Here are the steps you need to follow:</p>
- <h3>Step 1: Create a Chinese Apple ID</h3>
-<p>To create a Chinese Apple ID, you need to have a valid phone number and email address from China. You can use a friend's or a relative's phone number and email address if you have one, or you can use a virtual phone number and email address service such as Dingtone or Temp Mail.</p>
-<p>Once you have a phone number and email address from China, you can go to appleid.apple.com and click on Create Your Apple ID. Fill in your personal information, including your name, birthday, country or region (choose China), phone number, email address, password, and security questions. Then, verify your phone number and email address by entering the codes sent to them. Finally, agree to the terms and conditions and click on Create Apple ID.</p>
- <h3>Step 2: Log in with your Chinese Apple ID and change your region to China</h3>
-<p>After you have created your Chinese Apple ID, you need to log in with it on your iOS device and change your region to China. To do this, go to your device settings, then iTunes & App Store, then tap on your Apple ID and sign out. Then, sign in with your Chinese Apple ID and password.</p>
-<p>Next, go back to your device settings, then General, then Language & Region, then tap on Region and choose China. You may see a message that changing your region will affect some features of your device. Tap Continue to confirm.</p>
- <h3>Step 3: Search for FIFA Mobile in the App Store and download it</h3>
-<p>Once you have logged in with your Chinese Apple ID and changed your region to China, you can search for FIFA Mobile in the App Store and download it. You may need to enter your password or use Touch ID or Face ID to confirm the download.</p>
- <h3>Step 4: Launch the game and log in with your QQ or WeChat account</h3>
-<p>After you have downloaded the game, you can launch it from your home screen. You will see a splash screen with the Tencent and FIFA logos, followed by a login screen. You need to log in with your QQ or WeChat account to play the game. If you don't have one, you can create one for free by following the prompts on the screen.</p>
- <h2>How to play Chinese FIFA Mobile with English language settings</h 2></h2>
-<p>Unfortunately, Chinese FIFA Mobile does not have an option to change the language settings to English or any other language. The game is only available in Simplified Chinese. However, there are some ways to play the game with English language settings, such as using a third-party app to translate the game interface or using a guide or a video tutorial to navigate the game menus.</p>
- <h3>Option 1: Use a third-party app to translate the game interface</h3>
-<p>One way to play Chinese FIFA Mobile with English language settings is to use a third-party app that can translate the game interface in real time. For example, you can use Google Translate, which has a feature called Tap to Translate that allows you to copy and paste any text from any app and get an instant translation.</p>
-<p>To use this feature, you need to download and install Google Translate from the Google Play Store or the App Store. Then, go to the app settings and enable Tap to Translate. You will see a floating icon on your screen that you can tap to access the translation feature.</p>
-<p>When you launch Chinese FIFA Mobile, you can use Tap to Translate to copy and paste any text from the game interface and get an English translation. For example, you can copy and paste the text from the game menus, buttons, dialogs, instructions, and notifications. You can also use the camera mode to scan and translate any text on your screen.</p>
-<p>However, this method has some limitations and drawbacks. First, it may not be very accurate or reliable, as some translations may be incorrect or incomplete. Second, it may be inconvenient or time-consuming, as you have to switch between the game and the translation app frequently. Third, it may affect your game performance or battery life, as you have to run two apps at the same time.</p>
- <h3>Option 2: Use a guide or a video tutorial to navigate the game menus</h3>
-<p>Another way to play Chinese FIFA Mobile with English language settings is to use a guide or a video tutorial that can help you navigate the game menus and understand the game features. For example, you can use this guide by FIFA Mobile Reddit user u/antwansturdivant, which explains the basic functions and icons of the game interface.</p>
-<p>To use this guide, you need to open it on your browser or download it as a PDF file. Then, you can refer to it whenever you need help with the game menus or features. You can also use the screenshots and illustrations provided in the guide to compare them with your game screen.</p>
-<p>Alternatively, you can use this video tutorial by YouTube user FIFAMobileVN TV, which shows you how to download and install Chinese FIFA Mobile on your Android device and how to play it with English language settings.</p>
-<p>To use this video tutorial, you need to watch it on your browser or download it as a video file. Then, you can follow the steps and instructions shown in the video while playing the game. You can also pause or rewind the video if you need more time or clarification.</p>
-<p>However, this method also has some limitations and drawbacks. First, it may not be very comprehensive or updated, as some guides or videos may not cover all aspects of the game or reflect the latest changes or updates. Second, it may be difficult or confusing, as some guides or videos may not be clear or easy to follow. Third, it may require internet access or storage space, as you have to open or download the guides or videos.</p>
- <h2>Conclusion</h2>
-<p>In conclusion, Chinese FIFA Mobile is a popular and exciting mobile game that offers some unique features and benefits that are not available in other versions of the game. However, it is only available in Simplified Chinese and requires a QQ or WeChat account to play. If you want to play Chinese FIFA Mobile on your Android or iOS device with English language settings, you can either use a third-party app to translate the game interface or use a guide or a video tutorial to navigate the game menus.</p>
-<p>We hope this article has helped you learn how to download and install Chinese FIFA Mobile on your device and how to play it with English language settings. If you have any questions or feedback, please feel free to leave a comment below.</p>
- <h2>FAQs</h2>
-<ul>
-<li><b>Q: Is Chinese FIFA Mobile free to play?</b></li>
-<li>A: Yes, Chinese FIFA Mobile is free to play. However, it may contain some in-app purchases that require real money.</li>
-<li><b>Q: Is Chinese FIFA Mobile safe to play?</b></li>
-<li>A: Yes, Chinese FIFA Mobile is safe to play. However, you should always download and install it from a reliable source and scan it for viruses or malware before installing it. You should also be careful about sharing your personal information or payment details with the game or any third-party app.</li>
-<li><b>Q: Can I play Chinese FIFA Mobile with other players from different regions?</b></li>
-<li>A: Yes, you can play Chinese FIFA Mobile with other players from different regions. However, you may experience some lag or connection issues due to the distance or the server. You may also encounter some language barriers or cultural differences with other players.</li>
-<li><b>Q: Can I transfer my progress or data from other versions of FIFA Mobile to Chinese FIFA Mobile?</b></li>
-<li>A: No, you cannot transfer your progress or data from other versions of FIFA Mobile to Chinese FIFA Mobile. They are separate and independent games that have different developers, accounts, currencies, and systems. You have to start from scratch if you want to play Chinese FIFA Mobile.</li>
-<li><b>Q: Can I play Chinese FIFA Mobile offline?</b></li>
-<li>A: No, you cannot play Chinese FIFA Mobile offline. You need an internet connection to play the game, as it is an online multiplayer game that requires constant communication with the server and other players.</li>
-</ul></p> 401be4b1e0<br />
-<br />
-<br />

spaces/A00001/bingothoo/src/components/button-scroll-to-bottom.tsx

@@ -1,34 +0,0 @@
-'use client'
-
-import * as React from 'react'
-
-import { cn } from '@/lib/utils'
-import { useAtBottom } from '@/lib/hooks/use-at-bottom'
-import { Button, type ButtonProps } from '@/components/ui/button'
-import { IconArrowDown } from '@/components/ui/icons'
-
-export function ButtonScrollToBottom({ className, ...props }: ButtonProps) {
-  const isAtBottom = useAtBottom()
-
-  return (
-    <Button
-      variant="outline"
-      size="icon"
-      className={cn(
-        'fixed right-4 bottom-24 z-50 bg-background transition-opacity duration-300 sm:right-20',
-        isAtBottom ? 'opacity-0' : 'opacity-100',
-        className
-      )}
-      onClick={() =>
-        window.scrollTo({
-          top: document.body.offsetHeight,
-          behavior: 'smooth'
-        })
-      }
-      {...props}
-    >
-      <IconArrowDown />
-      <span className="sr-only">Scroll to bottom</span>
-    </Button>
-  )
-}

spaces/AIFILMS/generate_human_motion/VQ-Trans/utils/utils_model.py

@@ -1,66 +0,0 @@
-import numpy as np 
-import torch
-import torch.optim as optim
-import logging
-import os 
-import sys 
-
-def getCi(accLog):
-
-    mean = np.mean(accLog)
-    std = np.std(accLog)
-    ci95 = 1.96*std/np.sqrt(len(accLog))
-
-    return mean, ci95
-
-def get_logger(out_dir):
-    logger = logging.getLogger('Exp')
-    logger.setLevel(logging.INFO)
-    formatter = logging.Formatter("%(asctime)s %(levelname)s %(message)s")
-
-    file_path = os.path.join(out_dir, "run.log")
-    file_hdlr = logging.FileHandler(file_path)
-    file_hdlr.setFormatter(formatter)
-
-    strm_hdlr = logging.StreamHandler(sys.stdout)
-    strm_hdlr.setFormatter(formatter)
-
-    logger.addHandler(file_hdlr)
-    logger.addHandler(strm_hdlr)
-    return logger
-
-## Optimizer
-def initial_optim(decay_option, lr, weight_decay, net, optimizer) : 
-    
-    if optimizer == 'adamw' : 
-        optimizer_adam_family = optim.AdamW
-    elif optimizer == 'adam' : 
-        optimizer_adam_family = optim.Adam
-    if decay_option == 'all':
-        #optimizer = optimizer_adam_family(net.parameters(), lr=lr, betas=(0.9, 0.999), weight_decay=weight_decay)
-        optimizer = optimizer_adam_family(net.parameters(), lr=lr, betas=(0.5, 0.9), weight_decay=weight_decay)
-        
-    elif decay_option == 'noVQ':
-        all_params = set(net.parameters())
-        no_decay = set([net.vq_layer])
-        
-        decay = all_params - no_decay
-        optimizer = optimizer_adam_family([
-                    {'params': list(no_decay), 'weight_decay': 0}, 
-                    {'params': list(decay), 'weight_decay' : weight_decay}], lr=lr)
-        
-    return optimizer
-
-
-def get_motion_with_trans(motion, velocity) : 
-    '''
-    motion : torch.tensor, shape (batch_size, T, 72), with the global translation = 0
-    velocity : torch.tensor, shape (batch_size, T, 3), contain the information of velocity = 0
-    
-    '''
-    trans = torch.cumsum(velocity, dim=1)
-    trans = trans - trans[:, :1] ## the first root is initialized at 0 (just for visualization)
-    trans = trans.repeat((1, 1, 21))
-    motion_with_trans = motion + trans
-    return motion_with_trans
-    

spaces/AIGC-Audio/AudioGPT/NeuralSeq/modules/parallel_wavegan/layers/residual_stack.py

@@ -1,75 +0,0 @@
-# -*- coding: utf-8 -*-
-
-# Copyright 2020 Tomoki Hayashi
-#  MIT License (https://opensource.org/licenses/MIT)
-
-"""Residual stack module in MelGAN."""
-
-import torch
-
-from . import CausalConv1d
-
-
-class ResidualStack(torch.nn.Module):
-    """Residual stack module introduced in MelGAN."""
-
-    def __init__(self,
-                 kernel_size=3,
-                 channels=32,
-                 dilation=1,
-                 bias=True,
-                 nonlinear_activation="LeakyReLU",
-                 nonlinear_activation_params={"negative_slope": 0.2},
-                 pad="ReflectionPad1d",
-                 pad_params={},
-                 use_causal_conv=False,
-                 ):
-        """Initialize ResidualStack module.
-
-        Args:
-            kernel_size (int): Kernel size of dilation convolution layer.
-            channels (int): Number of channels of convolution layers.
-            dilation (int): Dilation factor.
-            bias (bool): Whether to add bias parameter in convolution layers.
-            nonlinear_activation (str): Activation function module name.
-            nonlinear_activation_params (dict): Hyperparameters for activation function.
-            pad (str): Padding function module name before dilated convolution layer.
-            pad_params (dict): Hyperparameters for padding function.
-            use_causal_conv (bool): Whether to use causal convolution.
-
-        """
-        super(ResidualStack, self).__init__()
-
-        # defile residual stack part
-        if not use_causal_conv:
-            assert (kernel_size - 1) % 2 == 0, "Not support even number kernel size."
-            self.stack = torch.nn.Sequential(
-                getattr(torch.nn, nonlinear_activation)(**nonlinear_activation_params),
-                getattr(torch.nn, pad)((kernel_size - 1) // 2 * dilation, **pad_params),
-                torch.nn.Conv1d(channels, channels, kernel_size, dilation=dilation, bias=bias),
-                getattr(torch.nn, nonlinear_activation)(**nonlinear_activation_params),
-                torch.nn.Conv1d(channels, channels, 1, bias=bias),
-            )
-        else:
-            self.stack = torch.nn.Sequential(
-                getattr(torch.nn, nonlinear_activation)(**nonlinear_activation_params),
-                CausalConv1d(channels, channels, kernel_size, dilation=dilation,
-                             bias=bias, pad=pad, pad_params=pad_params),
-                getattr(torch.nn, nonlinear_activation)(**nonlinear_activation_params),
-                torch.nn.Conv1d(channels, channels, 1, bias=bias),
-            )
-
-        # defile extra layer for skip connection
-        self.skip_layer = torch.nn.Conv1d(channels, channels, 1, bias=bias)
-
-    def forward(self, c):
-        """Calculate forward propagation.
-
-        Args:
-            c (Tensor): Input tensor (B, channels, T).
-
-        Returns:
-            Tensor: Output tensor (B, chennels, T).
-
-        """
-        return self.stack(c) + self.skip_layer(c)

spaces/AIGC-Audio/AudioGPT/NeuralSeq/tasks/tts/ps.py

@@ -1,194 +0,0 @@
-import os
-import torch
-import torch.nn.functional as F
-from torch import nn
-
-from modules.portaspeech.portaspeech import PortaSpeech
-from tasks.tts.fs2 import FastSpeech2Task
-from utils.tts_utils import mel2token_to_dur
-from utils.hparams import hparams
-from utils.tts_utils import get_focus_rate, get_phone_coverage_rate, get_diagonal_focus_rate
-from utils import num_params
-import numpy as np
-
-from utils.plot import spec_to_figure
-from data_gen.tts.data_gen_utils import build_token_encoder
-
-
-class PortaSpeechTask(FastSpeech2Task):
-    def __init__(self):
-        super().__init__()
-        data_dir = hparams['binary_data_dir']
-        self.word_encoder = build_token_encoder(f'{data_dir}/word_set.json')
-
-    def build_tts_model(self):
-        ph_dict_size = len(self.token_encoder)
-        word_dict_size = len(self.word_encoder)
-        self.model = PortaSpeech(ph_dict_size, word_dict_size, hparams)
-
-    def on_train_start(self):
-        super().on_train_start()
-        for n, m in self.model.named_children():
-            num_params(m, model_name=n)
-        if hasattr(self.model, 'fvae'):
-            for n, m in self.model.fvae.named_children():
-                num_params(m, model_name=f'fvae.{n}')
-
-    def run_model(self, sample, infer=False, *args, **kwargs):
-        txt_tokens = sample['txt_tokens']
-        word_tokens = sample['word_tokens']
-        spk_embed = sample.get('spk_embed')
-        spk_id = sample.get('spk_ids')
-        if not infer:
-            output = self.model(txt_tokens, word_tokens,
-                                ph2word=sample['ph2word'],
-                                mel2word=sample['mel2word'],
-                                mel2ph=sample['mel2ph'],
-                                word_len=sample['word_lengths'].max(),
-                                tgt_mels=sample['mels'],
-                                pitch=sample.get('pitch'),
-                                spk_embed=spk_embed,
-                                spk_id=spk_id,
-                                infer=False,
-                                global_step=self.global_step)
-            losses = {}
-            losses['kl_v'] = output['kl'].detach()
-            losses_kl = output['kl']
-            losses_kl = torch.clamp(losses_kl, min=hparams['kl_min'])
-            losses_kl = min(self.global_step / hparams['kl_start_steps'], 1) * losses_kl
-            losses_kl = losses_kl * hparams['lambda_kl']
-            losses['kl'] = losses_kl
-            self.add_mel_loss(output['mel_out'], sample['mels'], losses)
-            if hparams['dur_level'] == 'word':
-                self.add_dur_loss(
-                    output['dur'], sample['mel2word'], sample['word_lengths'], sample['txt_tokens'], losses)
-                self.get_attn_stats(output['attn'], sample, losses)
-            else:
-                super(PortaSpeechTask, self).add_dur_loss(output['dur'], sample['mel2ph'], sample['txt_tokens'], losses)
-            return losses, output
-        else:
-            use_gt_dur = kwargs.get('infer_use_gt_dur', hparams['use_gt_dur'])
-            output = self.model(
-                txt_tokens, word_tokens,
-                ph2word=sample['ph2word'],
-                word_len=sample['word_lengths'].max(),
-                pitch=sample.get('pitch'),
-                mel2ph=sample['mel2ph'] if use_gt_dur else None,
-                mel2word=sample['mel2word'] if use_gt_dur else None,
-                tgt_mels=sample['mels'],
-                infer=True,
-                spk_embed=spk_embed,
-                spk_id=spk_id,
-            )
-            return output
-
-    def add_dur_loss(self, dur_pred, mel2token, word_len, txt_tokens, losses=None):
-        T = word_len.max()
-        dur_gt = mel2token_to_dur(mel2token, T).float()
-        nonpadding = (torch.arange(T).to(dur_pred.device)[None, :] < word_len[:, None]).float()
-        dur_pred = dur_pred * nonpadding
-        dur_gt = dur_gt * nonpadding
-        wdur = F.l1_loss((dur_pred + 1).log(), (dur_gt + 1).log(), reduction='none')
-        wdur = (wdur * nonpadding).sum() / nonpadding.sum()
-        if hparams['lambda_word_dur'] > 0:
-            losses['wdur'] = wdur * hparams['lambda_word_dur']
-        if hparams['lambda_sent_dur'] > 0:
-            sent_dur_p = dur_pred.sum(-1)
-            sent_dur_g = dur_gt.sum(-1)
-            sdur_loss = F.l1_loss(sent_dur_p, sent_dur_g, reduction='mean')
-            losses['sdur'] = sdur_loss.mean() * hparams['lambda_sent_dur']
-
-    def validation_step(self, sample, batch_idx):
-        return super().validation_step(sample, batch_idx)
-
-    def save_valid_result(self, sample, batch_idx, model_out):
-        super(PortaSpeechTask, self).save_valid_result(sample, batch_idx, model_out)
-        if self.global_step > 0 and hparams['dur_level'] == 'word':
-            self.logger.add_figure(f'attn_{batch_idx}', spec_to_figure(model_out['attn'][0]), self.global_step)
-
-    def get_attn_stats(self, attn, sample, logging_outputs, prefix=''):
-        # diagonal_focus_rate
-        txt_lengths = sample['txt_lengths'].float()
-        mel_lengths = sample['mel_lengths'].float()
-        src_padding_mask = sample['txt_tokens'].eq(0)
-        target_padding_mask = sample['mels'].abs().sum(-1).eq(0)
-        src_seg_mask = sample['txt_tokens'].eq(self.seg_idx)
-        attn_ks = txt_lengths.float() / mel_lengths.float()
-
-        focus_rate = get_focus_rate(attn, src_padding_mask, target_padding_mask).mean().data
-        phone_coverage_rate = get_phone_coverage_rate(
-            attn, src_padding_mask, src_seg_mask, target_padding_mask).mean()
-        diagonal_focus_rate, diag_mask = get_diagonal_focus_rate(
-            attn, attn_ks, mel_lengths, src_padding_mask, target_padding_mask)
-        logging_outputs[f'{prefix}fr'] = focus_rate.mean().data
-        logging_outputs[f'{prefix}pcr'] = phone_coverage_rate.mean().data
-        logging_outputs[f'{prefix}dfr'] = diagonal_focus_rate.mean().data
-
-    def get_plot_dur_info(self, sample, model_out):
-        if hparams['dur_level'] == 'word':
-            T_txt = sample['word_lengths'].max()
-            dur_gt = mel2token_to_dur(sample['mel2word'], T_txt)[0]
-            dur_pred = model_out['dur'] if 'dur' in model_out else dur_gt
-            txt = sample['ph_words'][0].split(" ")
-        else:
-            T_txt = sample['txt_tokens'].shape[1]
-            dur_gt = mel2token_to_dur(sample['mel2ph'], T_txt)[0]
-            dur_pred = model_out['dur'] if 'dur' in model_out else dur_gt
-            txt = self.token_encoder.decode(sample['txt_tokens'][0].cpu().numpy())
-            txt = txt.split(" ")
-        return {'dur_gt': dur_gt, 'dur_pred': dur_pred, 'txt': txt}
-
-    def build_optimizer(self, model):
-        self.optimizer = torch.optim.AdamW(
-            self.model.parameters(),
-            lr=hparams['lr'],
-            betas=(hparams['optimizer_adam_beta1'], hparams['optimizer_adam_beta2']),
-            weight_decay=hparams['weight_decay'])
-        return self.optimizer
-
-    def build_scheduler(self, optimizer):
-        return FastSpeechTask.build_scheduler(self, optimizer)
-
-    ############
-    # infer
-    ############
-    def test_start(self):
-        super().test_start()
-        if hparams.get('save_attn', False):
-            os.makedirs(f'{self.gen_dir}/attn', exist_ok=True)
-        self.model.store_inverse_all()
-
-    def test_step(self, sample, batch_idx):
-        assert sample['txt_tokens'].shape[0] == 1, 'only support batch_size=1 in inference'
-        outputs = self.run_model(sample, infer=True)
-        text = sample['text'][0]
-        item_name = sample['item_name'][0]
-        tokens = sample['txt_tokens'][0].cpu().numpy()
-        mel_gt = sample['mels'][0].cpu().numpy()
-        mel_pred = outputs['mel_out'][0].cpu().numpy()
-        mel2ph = sample['mel2ph'][0].cpu().numpy()
-        mel2ph_pred = None
-        str_phs = self.token_encoder.decode(tokens, strip_padding=True)
-        base_fn = f'[{batch_idx:06d}][{item_name.replace("%", "_")}][%s]'
-        if text is not None:
-            base_fn += text.replace(":", "$3A")[:80]
-        base_fn = base_fn.replace(' ', '_')
-        gen_dir = self.gen_dir
-        wav_pred = self.vocoder.spec2wav(mel_pred)
-        self.saving_result_pool.add_job(self.save_result, args=[
-            wav_pred, mel_pred, base_fn % 'P', gen_dir, str_phs, mel2ph_pred])
-        if hparams['save_gt']:
-            wav_gt = self.vocoder.spec2wav(mel_gt)
-            self.saving_result_pool.add_job(self.save_result, args=[
-                wav_gt, mel_gt, base_fn % 'G', gen_dir, str_phs, mel2ph])
-        if hparams.get('save_attn', False):
-            attn = outputs['attn'][0].cpu().numpy()
-            np.save(f'{gen_dir}/attn/{item_name}.npy', attn)
-        print(f"Pred_shape: {mel_pred.shape}, gt_shape: {mel_gt.shape}")
-        return {
-            'item_name': item_name,
-            'text': text,
-            'ph_tokens': self.token_encoder.decode(tokens.tolist()),
-            'wav_fn_pred': base_fn % 'P',
-            'wav_fn_gt': base_fn % 'G',
-        }

spaces/AIGC-Audio/AudioGPT/text_to_speech/modules/tts/syntaspeech/syntactic_graph_buider.py

@@ -1,294 +0,0 @@
-from copy import deepcopy
-import torch
-import dgl
-import stanza 
-import networkx as nx
-
-class Sentence2GraphParser:
-    def __init__(self, language='zh', use_gpu=False, download=False):
-        self.language = language
-        if download:
-            self.stanza_parser = stanza.Pipeline(lang=language, use_gpu=use_gpu)
-        else:
-            self.stanza_parser = stanza.Pipeline(lang=language, use_gpu=use_gpu, download_method=None)
-
-    def parse(self, clean_sentence=None, words=None, ph_words=None):
-        if self.language == 'zh':
-            assert words is not None and ph_words is not None
-            ret = self._parse_zh(words, ph_words)
-        elif self.language == 'en':
-            assert clean_sentence is not None
-            ret = self._parse_en(clean_sentence)
-        else:
-            raise NotImplementedError
-        return ret
-
-    def _parse_zh(self, words, ph_words, enable_backward_edge=True, enable_recur_edge=True,
-                  enable_inter_sentence_edge=True, sequential_edge=False):
-        """
-        words: <List of str>, each character in chinese is one item
-        ph_words: <List of str>, each character in chinese is one item, represented by the phoneme
-        Example:
-                text1 = '宝马配挂跛骡鞍,貂蝉怨枕董翁榻.'
-                words = ['<BOS>', '宝', '马', '配', '挂', '跛', '骡', '鞍', ','
-                        , '貂', '蝉', '怨', '枕', '董', '翁', '榻', '<EOS>']
-                ph_words = ['<BOS>', 'b_ao3_|', 'm_a3_#', 'p_ei4_|', 'g_ua4_#',
-                            'b_o3_#', 'l_uo2_|', 'an1', ',', 'd_iao1_|',
-                            'ch_an2_#', 'van4_#', 'zh_en3_#', 'd_ong3_|', 'ueng1_#', 't_a4', '<EOS>']
-        """
-        words, ph_words = words[1:-1], ph_words[1:-1]  # delete <BOS> and <EOS>
-        for i, p_w in enumerate(ph_words):
-            if p_w == ',':
-                # change english ',' into chinese
-                # we found it necessary in stanza's dependency parsing
-                words[i], ph_words[i] = '，', '，'
-        tmp_words = deepcopy(words)
-        num_added_space = 0
-        for i, p_w in enumerate(ph_words):
-            if p_w.endswith("#"):
-                # add a blank after the p_w with '#', to separate words
-                tmp_words.insert(num_added_space + i + 1, " ")
-                num_added_space += 1
-            if p_w in ['，', ',']:
-                # add one blank before and after ', ', respectively
-                tmp_words.insert(num_added_space + i + 1, " ")  # insert behind ',' first
-                tmp_words.insert(num_added_space + i, " ")  # insert before
-                num_added_space += 2
-        clean_text = ''.join(tmp_words).strip()
-        parser_out = self.stanza_parser(clean_text)
-
-        idx_to_word = {i + 1: w for i, w in enumerate(words)}
-
-        vocab_nodes = {}
-        vocab_idx_offset = 0
-        for sentence in parser_out.sentences:
-            num_nodes_in_current_sentence = 0
-            for vocab_node in sentence.words:
-                num_nodes_in_current_sentence += 1
-                vocab_idx = vocab_node.id + vocab_idx_offset
-                vocab_text = vocab_node.text.replace(" ", "")  # delete blank in vocab
-                vocab_nodes[vocab_idx] = vocab_text
-            vocab_idx_offset += num_nodes_in_current_sentence
-
-        # start vocab-to-word alignment
-        vocab_to_word = {}
-        current_word_idx = 1
-        for vocab_i in vocab_nodes.keys():
-            vocab_to_word[vocab_i] = []
-            for w_in_vocab_i in vocab_nodes[vocab_i]:
-                if w_in_vocab_i != idx_to_word[current_word_idx]:
-                    raise ValueError("Word Mismatch!")
-                vocab_to_word[vocab_i].append(current_word_idx)  # add a path (vocab_node_idx, word_global_idx)
-                current_word_idx += 1
-
-        # then we compute the vocab-level edges
-        if len(parser_out.sentences) > 5:
-            print("Detect more than 5 input sentence! pls check whether the sentence is too long!")
-        vocab_level_source_id, vocab_level_dest_id = [], []
-        vocab_level_edge_types = []
-        sentences_heads = []
-        vocab_id_offset = 0
-        # get forward edges
-        for s in parser_out.sentences:
-            for w in s.words:
-                w_idx = w.id + vocab_id_offset  # it starts from 1, just same as binarizer
-                w_dest_idx = w.head + vocab_id_offset
-                if w.head == 0:
-                    sentences_heads.append(w_idx)
-                    continue
-                vocab_level_source_id.append(w_idx)
-                vocab_level_dest_id.append(w_dest_idx)
-            vocab_id_offset += len(s.words)
-        vocab_level_edge_types += [0] * len(vocab_level_source_id)
-        num_vocab = vocab_id_offset
-
-        # optional: get backward edges
-        if enable_backward_edge:
-            back_source, back_dest = deepcopy(vocab_level_dest_id), deepcopy(vocab_level_source_id)
-            vocab_level_source_id += back_source
-            vocab_level_dest_id += back_dest
-            vocab_level_edge_types += [1] * len(back_source)
-
-        # optional: get inter-sentence edges if num_sentences > 1
-        inter_sentence_source, inter_sentence_dest = [], []
-        if enable_inter_sentence_edge and len(sentences_heads) > 1:
-            def get_full_graph_edges(nodes):
-                tmp_edges = []
-                for i, node_i in enumerate(nodes):
-                    for j, node_j in enumerate(nodes):
-                        if i == j:
-                            continue
-                        tmp_edges.append((node_i, node_j))
-                return tmp_edges
-
-            tmp_edges = get_full_graph_edges(sentences_heads)
-            for (source, dest) in tmp_edges:
-                inter_sentence_source.append(source)
-                inter_sentence_dest.append(dest)
-            vocab_level_source_id += inter_sentence_source
-            vocab_level_dest_id += inter_sentence_dest
-            vocab_level_edge_types += [3] * len(inter_sentence_source)
-
-        if sequential_edge:
-            seq_source, seq_dest = list(range(1, num_vocab)) + list(range(num_vocab, 0, -1)), \
-                                   list(range(2, num_vocab + 1)) + list(range(num_vocab - 1, -1, -1))
-            vocab_level_source_id += seq_source
-            vocab_level_dest_id += seq_dest
-            vocab_level_edge_types += [4] * (num_vocab - 1) + [5] * (num_vocab - 1)
-
-        # Then, we use the vocab-level edges and the vocab-to-word path, to construct the word-level graph
-        num_word = len(words)
-        source_id, dest_id, edge_types = [], [], []
-        for (vocab_start, vocab_end, vocab_edge_type) in zip(vocab_level_source_id, vocab_level_dest_id,
-                                                             vocab_level_edge_types):
-            # connect the first word in the vocab
-            word_start = min(vocab_to_word[vocab_start])
-            word_end = min(vocab_to_word[vocab_end])
-            source_id.append(word_start)
-            dest_id.append(word_end)
-            edge_types.append(vocab_edge_type)
-
-        # sequential connection in words
-        for word_indices_in_v in vocab_to_word.values():
-            for i, word_idx in enumerate(word_indices_in_v):
-                if i + 1 < len(word_indices_in_v):
-                    source_id.append(word_idx)
-                    dest_id.append(word_idx + 1)
-                    edge_types.append(4)
-                if i - 1 >= 0:
-                    source_id.append(word_idx)
-                    dest_id.append(word_idx - 1)
-                    edge_types.append(5)
-
-        # optional: get recurrent edges
-        if enable_recur_edge:
-            recur_source, recur_dest = list(range(1, num_word + 1)), list(range(1, num_word + 1))
-            source_id += recur_source
-            dest_id += recur_dest
-            edge_types += [2] * len(recur_source)
-
-        # add <BOS> and <EOS>
-        source_id += [0, num_word + 1, 1, num_word]
-        dest_id += [1, num_word, 0, num_word + 1]
-        edge_types += [4, 4, 5, 5]  # 4 represents sequentially forward, 5 is sequential backward
-
-        edges = (torch.LongTensor(source_id), torch.LongTensor(dest_id))
-        dgl_graph = dgl.graph(edges)
-        assert dgl_graph.num_edges() == len(edge_types)
-        return dgl_graph, torch.LongTensor(edge_types)
-
-    def _parse_en(self, clean_sentence, enable_backward_edge=True, enable_recur_edge=True,
-                  enable_inter_sentence_edge=True, sequential_edge=False, consider_bos_for_index=True):
-        """
-        clean_sentence: <str>, each word or punctuation should be separated by one blank.
-        """
-        edge_types = []  # required for gated graph neural network
-        clean_sentence = clean_sentence.strip()
-        if clean_sentence.endswith((" .", " ,", " ;", " :", " ?", " !")):
-            clean_sentence = clean_sentence[:-2]
-        if clean_sentence.startswith(". "):
-            clean_sentence = clean_sentence[2:]
-        parser_out = self.stanza_parser(clean_sentence)
-        if len(parser_out.sentences) > 5:
-            print("Detect more than 5 input sentence! pls check whether the sentence is too long!")
-            print(clean_sentence)
-        source_id, dest_id = [], []
-        sentences_heads = []
-        word_id_offset = 0
-        # get forward edges
-        for s in parser_out.sentences:
-            for w in s.words:
-                w_idx = w.id + word_id_offset  # it starts from 1, just same as binarizer
-                w_dest_idx = w.head + word_id_offset
-                if w.head == 0:
-                    sentences_heads.append(w_idx)
-                    continue
-                source_id.append(w_idx)
-                dest_id.append(w_dest_idx)
-            word_id_offset += len(s.words)
-        num_word = word_id_offset
-        edge_types += [0] * len(source_id)
-
-        # optional: get backward edges
-        if enable_backward_edge:
-            back_source, back_dest = deepcopy(dest_id), deepcopy(source_id)
-            source_id += back_source
-            dest_id += back_dest
-            edge_types += [1] * len(back_source)
-
-        # optional: get recurrent edges
-        if enable_recur_edge:
-            recur_source, recur_dest = list(range(1, num_word + 1)), list(range(1, num_word + 1))
-            source_id += recur_source
-            dest_id += recur_dest
-            edge_types += [2] * len(recur_source)
-
-        # optional: get inter-sentence edges if num_sentences > 1
-        inter_sentence_source, inter_sentence_dest = [], []
-        if enable_inter_sentence_edge and len(sentences_heads) > 1:
-            def get_full_graph_edges(nodes):
-                tmp_edges = []
-                for i, node_i in enumerate(nodes):
-                    for j, node_j in enumerate(nodes):
-                        if i == j:
-                            continue
-                        tmp_edges.append((node_i, node_j))
-                return tmp_edges
-
-            tmp_edges = get_full_graph_edges(sentences_heads)
-            for (source, dest) in tmp_edges:
-                inter_sentence_source.append(source)
-                inter_sentence_dest.append(dest)
-            source_id += inter_sentence_source
-            dest_id += inter_sentence_dest
-            edge_types += [3] * len(inter_sentence_source)
-
-        # add <BOS> and <EOS>
-        source_id += [0, num_word + 1, 1, num_word]
-        dest_id += [1, num_word, 0, num_word + 1]
-        edge_types += [4, 4, 5, 5]  # 4 represents sequentially forward, 5 is sequential backward
-
-        # optional: sequential edge
-        if sequential_edge:
-            seq_source, seq_dest = list(range(1, num_word)) + list(range(num_word, 0, -1)), \
-                                   list(range(2, num_word + 1)) + list(range(num_word - 1, -1, -1))
-            source_id += seq_source
-            dest_id += seq_dest
-            edge_types += [4] * (num_word - 1) + [5] * (num_word - 1)
-        if consider_bos_for_index:
-            edges = (torch.LongTensor(source_id), torch.LongTensor(dest_id))
-        else:
-            edges = (torch.LongTensor(source_id) - 1, torch.LongTensor(dest_id) - 1)
-        dgl_graph = dgl.graph(edges)
-        assert dgl_graph.num_edges() == len(edge_types)
-        return dgl_graph, torch.LongTensor(edge_types)
-
-
-def plot_dgl_sentence_graph(dgl_graph, labels):
-    """
-    labels = {idx: word for idx,word in enumerate(sentence.split(" ")) }
-    """
-    import matplotlib.pyplot as plt
-    nx_graph = dgl_graph.to_networkx()
-    pos = nx.random_layout(nx_graph)
-    nx.draw(nx_graph, pos, with_labels=False)
-    nx.draw_networkx_labels(nx_graph, pos, labels)
-    plt.show()
-
-if __name__ == '__main__':
-
-    # Unit Test for Chinese Graph Builder
-    parser = Sentence2GraphParser("zh")
-    text1 = '宝马配挂跛骡鞍,貂蝉怨枕董翁榻.'
-    words = ['<BOS>', '宝', '马', '配', '挂', '跛', '骡', '鞍', ',', '貂', '蝉', '怨', '枕', '董', '翁', '榻', '<EOS>']
-    ph_words = ['<BOS>', 'b_ao3_|', 'm_a3_#', 'p_ei4_|', 'g_ua4_#', 'b_o3_#', 'l_uo2_|', 'an1', ',', 'd_iao1_|',
-                'ch_an2_#', 'van4_#', 'zh_en3_#', 'd_ong3_|', 'ueng1_#', 't_a4', '<EOS>']
-    graph1, etypes1 = parser.parse(text1, words, ph_words)
-    plot_dgl_sentence_graph(graph1, {i: w for i, w in enumerate(ph_words)})
-
-    # Unit Test for English Graph Builder
-    parser = Sentence2GraphParser("en")
-    text2 = "I love you . You love me . Mixue ice-scream and tea ."
-    graph2, etypes2 = parser.parse(text2)
-    plot_dgl_sentence_graph(graph2, {i: w for i, w in enumerate(("<BOS> " + text2 + " <EOS>").split(" "))})
-    

spaces/AILab-CVC/SEED-LLaMA/Dockerfile

@@ -1,80 +0,0 @@
-# Use the official Python 3.11 image
-FROM nvidia/cuda:11.7.1-cudnn8-devel-ubuntu22.04
-
-ENV DEBIAN_FRONTEND=noninteractive
-
-RUN apt-get update && \
-    apt-get upgrade -y && \
-    apt-get install -y --no-install-recommends \
-    git \
-    git-lfs \
-    wget \
-    curl \
-    # python build dependencies \
-    build-essential \
-    libssl-dev \
-    zlib1g-dev \
-    libbz2-dev \
-    libreadline-dev \
-    libsqlite3-dev \
-    libncursesw5-dev \
-    xz-utils \
-    tk-dev \
-    libxml2-dev \
-    libxmlsec1-dev \
-    libffi-dev \
-    liblzma-dev \
-    # gradio dependencies \
-    ffmpeg && \
-    apt-get clean && \
-    rm -rf /var/lib/apt/lists/*
-
-
-# Copy the current directory contents into the container at /code
-# COPY ./requirements.txt /code/requirements.txt
-# RUN cat /code/requirements.txt
-
-# Install requirements.txt
-# RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
-# RUN pip install -r /code/requirements.txt
-
-# Set up a new user named "user" with user ID 1000
-RUN useradd -m -u 1000 user
-# Switch to the "user" user
-USER user
-# Set home to the user's home directory
-ENV HOME=/home/user \
-    PATH=/home/user/.local/bin:$PATH \
-    HF_HOME=/data/.huggingface \
-    TORCH_HOME=/data/.huggingface
-
-# Set the working directory to the user's home directory
-WORKDIR $HOME/app
-
-
-RUN curl https://pyenv.run | bash
-ENV PATH=${HOME}/.pyenv/shims:${HOME}/.pyenv/bin:${PATH}
-ARG PYTHON_VERSION=3.10.12
-RUN pyenv install ${PYTHON_VERSION} && \
-    pyenv global ${PYTHON_VERSION} && \
-    pyenv rehash && \
-    pip install --no-cache-dir -U pip setuptools wheel
-
-# Copy the current directory contents into the container at $HOME/app setting the owner to the user
-COPY --chown=user . $HOME/app
-
-RUN git lfs install
-
-RUN pip install -r requirements.txt
-
-# RUN ls -lh
-
-# WORKDIR $HOME/app/pretrained
-# RUN git lfs install
-# RUN git clone https://huggingface.co/stabilityai/stable-diffusion-2-1-unclip
-# RUN git clone https://huggingface.co/AILab-CVC/seed-tokenizer-2
-# RUn git clone https://huggingface.co/AILab-CVC/seed-llama-14b-sft
-
-# WORKDIR $HOME/app
-CMD ["bash", "start.sh"]
-# CMD ["python", 'start.py']

spaces/AdVisual/MaskCut/model.py

@@ -1,75 +0,0 @@
-# This file is adapted from https://github.com/facebookresearch/CutLER/blob/077938c626341723050a1971107af552a6ca6697/maskcut/demo.py
-# The original license file is the file named LICENSE.CutLER in this repo.
-
-import os
-import sys
-sys.path.append('./CutLER/')
-sys.path.append('./CutLER/maskcut/')
-
-import numpy as np
-import PIL.Image as Image
-import torch
-from scipy import ndimage
-
-from CutLER.maskcut.dino import ViTFeat  # model
-from CutLER.maskcut.crf import densecrf
-from CutLER.maskcut.maskcut import maskcut
-from CutLER.third_party.TokenCut.unsupervised_saliency_detection import metric
-
-
-class Model:
-    def __init__(self, device: str):
-        self.device = torch.device(device)
-        self.backbone = self.load_backbone()
-
-    def load_backbone(self):
-        # DINO hyperparameters
-        vit_arch = 'base'
-        vit_feat = 'k'
-        patch_size = 8
-        # DINO pre-trained model
-        url = 'https://dl.fbaipublicfiles.com/dino/dino_vitbase8_pretrain/dino_vitbase8_pretrain.pth'
-        feat_dim = 768
-
-        # extract patch features with a pretrained DINO model
-        backbone = ViTFeat(url, feat_dim, vit_arch, vit_feat, patch_size)
-        backbone.eval()
-        backbone.to(self.device)
-        return backbone
-
-    def __call__(self, image, tau, n, fixed_size=480):
-        # get pseudo-masks with MaskCut
-        bipartitions, _, I_new = maskcut(image,
-                                         self.backbone,
-                                         self.backbone.patch_size,
-                                         tau,
-                                         N=n,
-                                         fixed_size=fixed_size,
-                                         cpu=self.device.type == 'cpu')
-        I = image.convert('RGB')
-        width, height = I.size
-        pseudo_mask_list = []
-        for idx, bipartition in enumerate(bipartitions):
-            # post-process pseudo-masks with CRF
-            pseudo_mask = densecrf(np.array(I_new), bipartition)
-            pseudo_mask = ndimage.binary_fill_holes(pseudo_mask >= 0.5)
-
-            # filter out the mask that have a very different pseudo-mask after the CRF
-            mask1 = torch.from_numpy(bipartition).to(self.device)
-            mask2 = torch.from_numpy(pseudo_mask).to(self.device)
-            if metric.IoU(mask1, mask2) < 0.5:
-                pseudo_mask = pseudo_mask * -1
-
-            # construct binary pseudo-masks
-            pseudo_mask[pseudo_mask < 0] = 0
-            pseudo_mask = Image.fromarray(np.uint8(pseudo_mask * 255))
-            pseudo_mask = np.asarray(pseudo_mask.resize((width, height)))
-
-            pseudo_mask = pseudo_mask.astype(np.uint8)
-            upper = np.max(pseudo_mask)
-            lower = np.min(pseudo_mask)
-            thresh = upper / 2.0
-            pseudo_mask[pseudo_mask > thresh] = upper
-            pseudo_mask[pseudo_mask <= thresh] = lower
-            pseudo_mask_list.append(pseudo_mask)
-        return pseudo_mask_list

spaces/Adithedev/Keyword-Extractor/model.py

@@ -1,39 +0,0 @@
-import re
-import nltk
-import numpy as np
-import pandas as pd
-from nltk.corpus import stopwords
-from nltk.stem import WordNetLemmatizer
-from nltk.tokenize import word_tokenize
-from sklearn.feature_extraction.text import TfidfTransformer,CountVectorizer,TfidfVectorizer
-
-nltk.download('stopwords')
-nltk.download('wordnet')
-nltk.download('punkt')
-
-class KeywordExtraction:
-    
-    @staticmethod
-    def fit(text):
-        wnl = WordNetLemmatizer()
-        processed_re_text = re.sub("[^\s\w]"," ",text).lower()
-        stopwords_corpus = stopwords.words("english")
-        tokenized_text = word_tokenize(processed_re_text)
-        processed_text = []
-
-        for i in tokenized_text:
-            if i not in stopwords_corpus:
-                processed_text.append(wnl.lemmatize(i))
-        return " ".join(processed_text)
-    
-    @staticmethod
-    def train(processed_text, top_n=5):
-        tfidf_vectorizer = TfidfVectorizer()
-        tfidf_matrix = tfidf_vectorizer.fit_transform(processed_text)
-        feature_names = tfidf_vectorizer.get_feature_names_out()
-        idf_scores = tfidf_vectorizer.idf_
-        
-        idf_df = pd.DataFrame({'Word': feature_names, 'IDF': idf_scores})
-        idf_df = idf_df.sort_values(by='IDF', ascending=False).head(top_n)
-        
-        return idf_df

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

@@ -1,35 +0,0 @@
-import Scale from './scale.js';
-import ScaleDown from './behaviors/scale/ScaleDown.js';
-import ScaleDownDestroy from './scale-down-destroy.js';
-import Popup from './popup.js';
-import Yoyo from './behaviors/scale/Yoyo.js';
-
-class ScalePlugin extends Phaser.Plugins.BasePlugin {
-
-    constructor(pluginManager) {
-        super(pluginManager);
-    }
-
-    start() {
-        var eventEmitter = this.game.events;
-        eventEmitter.on('destroy', this.destroy, this);
-    }
-
-    add(gameObject, config) {
-        return new Scale(gameObject, config);
-    }
-}
-
-// mixin
-var methods = {
-    scaleDown: ScaleDown,
-    scaleDownDestroy: ScaleDownDestroy,
-    popup: Popup,
-    yoyo: Yoyo,
-}
-Object.assign(
-    ScalePlugin.prototype,
-    methods
-);
-
-export default ScalePlugin;

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

@@ -1,5 +0,0 @@
-import ColorInput from './ColorInput';
-
-export default function (
-    config?: ColorInput.IConfig
-): ColorInput;

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/knob/Knob.d.ts

@@ -1,63 +0,0 @@
-// import * as Phaser from 'phaser';
-import OverlapSizer from '../overlapsizer/OverlapSizer';
-
-
-export default Knob;
-
-declare namespace Knob {
-
-    type InputTypes = 0 | 1 | -1 | 'drag' | 'pan' | 'click' | 'none';
-
-    interface IConfig extends OverlapSizer.IConfig {
-        background?: Phaser.GameObjects.GameObject,
-
-        color?: number | string,
-        trackColor?: number | string,
-        centerColor?: number | string,
-        thickness?: number,
-        startAngle?: number,
-        anticlockwise?: boolean,
-        knobDepth?: number,
-
-        text?: Phaser.GameObjects.GameObject,
-        textFormatCallback?: (value: number) => string,
-        textFormatCallbackScope?: object,
-
-        input?: InputTypes,
-
-        value?: number,
-
-        gap?: number,
-
-        easeValue?: {
-            duration?: number,
-            ease?: string
-        },
-
-        valuechangeCallback: (newValue: number, oldValue: number, knob: Knob) => void,
-
-        enable?: boolean,
-
-    }
-
-}
-
-declare class Knob extends OverlapSizer {
-    constructor(
-        scene: Phaser.Scene,
-        config?: Knob.IConfig
-    );
-
-    value: number;
-    getValue(min?: number, max?: number): number;
-    setValue(value?: number, min?: number, max?: number): this;
-    addValue(inc?: number, min?: number, max?: number): this;
-
-    easeValueTo(value?: number, min?: number, max?: number): this;
-    stopEaseValue(): this;
-    setEaseValueDuration(duration: number): this;
-    setEaseValueFunction(ease: string): this;
-
-    setEnable(enable?: boolean): this;
-    enable: boolean;
-}

spaces/AlexZou/Deploy_Restoration/net/CMSFFT.py

@@ -1,377 +0,0 @@
-# -*- coding: utf-8 -*-
-# @Author  : Lintao Peng
-# @File    : CMSFFT.py
-# coding=utf-8
-# Design based on the CTrans
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-import copy
-import logging
-import math
-import torch
-import torch.nn as nn
-import numpy as np
-from torch.nn import Dropout, Softmax, Conv2d, LayerNorm
-from torch.nn.modules.utils import _pair
-
-
-#KV_size = 480
-#transformer.num_heads  = 4
-#transformer.num_layers = 4
-#expand_ratio           = 4
-
-
-
-#线性编码
-class Channel_Embeddings(nn.Module):
-    """Construct the embeddings from patch, position embeddings.
-    """
-    def __init__(self, patchsize, img_size, in_channels):
-        super().__init__()
-        img_size = _pair(img_size)
-        patch_size = _pair(patchsize)
-        n_patches = (img_size[0] // patch_size[0]) * (img_size[1] // patch_size[1])
-
-        self.patch_embeddings = Conv2d(in_channels=in_channels,
-                                       out_channels=in_channels,
-                                       kernel_size=patch_size,
-                                       stride=patch_size)
-        self.position_embeddings = nn.Parameter(torch.zeros(1, n_patches, in_channels))
-        self.dropout = Dropout(0.1)
-
-    def forward(self, x):
-        if x is None:
-            return None
-        x = self.patch_embeddings(x)  # (B, hidden，n_patches^(1/2), n_patches^(1/2))
-        x = x.flatten(2)
-        x = x.transpose(-1, -2)  # (B, n_patches, hidden)
-        embeddings = x + self.position_embeddings
-        embeddings = self.dropout(embeddings)
-        return embeddings
-
-
-#特征重组
-class Reconstruct(nn.Module):
-    def __init__(self, in_channels, out_channels, kernel_size, scale_factor):
-        super(Reconstruct, self).__init__()
-        if kernel_size == 3:
-            padding = 1
-        else:
-            padding = 0
-        self.conv = nn.Conv2d(in_channels, out_channels,kernel_size=kernel_size, padding=padding)
-        self.norm = nn.BatchNorm2d(out_channels)
-        self.activation = nn.ReLU(inplace=True)
-        self.scale_factor = scale_factor
-
-    def forward(self, x):
-        if x is None:
-            return None
-
-        # reshape from (B, n_patch, hidden) to (B, h, w, hidden)
-        B, n_patch, hidden = x.size()  
-        h, w = int(np.sqrt(n_patch)), int(np.sqrt(n_patch))
-        x = x.permute(0, 2, 1)
-        x = x.contiguous().view(B, hidden, h, w)
-        x = nn.Upsample(scale_factor=self.scale_factor)(x)
-
-        out = self.conv(x)
-        out = self.norm(out)
-        out = self.activation(out)
-        return out
-
-class Attention_org(nn.Module):
-    def __init__(self, vis,channel_num, KV_size=480, num_heads=4):
-        super(Attention_org, self).__init__()
-        self.vis = vis
-        self.KV_size = KV_size
-        self.channel_num = channel_num
-        self.num_attention_heads = num_heads
-
-        self.query1 = nn.ModuleList()
-        self.query2 = nn.ModuleList()
-        self.query3 = nn.ModuleList()
-        self.query4 = nn.ModuleList()
-        self.key = nn.ModuleList()
-        self.value = nn.ModuleList()
-
-        for _ in range(num_heads):
-            query1 = nn.Linear(channel_num[0], channel_num[0], bias=False)
-            query2 = nn.Linear(channel_num[1], channel_num[1], bias=False)
-            query3 = nn.Linear(channel_num[2], channel_num[2], bias=False)
-            query4 = nn.Linear(channel_num[3], channel_num[3], bias=False)
-            key = nn.Linear( self.KV_size,  self.KV_size, bias=False)
-            value = nn.Linear(self.KV_size,  self.KV_size, bias=False)
-            #把所有的值都重新复制一遍，deepcopy为深复制，完全脱离原来的值，即将被复制对象完全再复制一遍作为独立的新个体单独存在
-            self.query1.append(copy.deepcopy(query1))
-            self.query2.append(copy.deepcopy(query2))
-            self.query3.append(copy.deepcopy(query3))
-            self.query4.append(copy.deepcopy(query4))
-            self.key.append(copy.deepcopy(key))
-            self.value.append(copy.deepcopy(value))
-        self.psi = nn.InstanceNorm2d(self.num_attention_heads)
-        self.softmax = Softmax(dim=3)
-        self.out1 = nn.Linear(channel_num[0], channel_num[0], bias=False)
-        self.out2 = nn.Linear(channel_num[1], channel_num[1], bias=False)
-        self.out3 = nn.Linear(channel_num[2], channel_num[2], bias=False)
-        self.out4 = nn.Linear(channel_num[3], channel_num[3], bias=False)
-        self.attn_dropout = Dropout(0.1)
-        self.proj_dropout = Dropout(0.1)
-
-
-
-    def forward(self, emb1,emb2,emb3,emb4, emb_all):
-        multi_head_Q1_list = []
-        multi_head_Q2_list = []
-        multi_head_Q3_list = []
-        multi_head_Q4_list = []
-        multi_head_K_list = []
-        multi_head_V_list = []
-        if emb1 is not None:
-            for query1 in self.query1:
-                Q1 = query1(emb1)
-                multi_head_Q1_list.append(Q1)
-        if emb2 is not None:
-            for query2 in self.query2:
-                Q2 = query2(emb2)
-                multi_head_Q2_list.append(Q2)
-        if emb3 is not None:
-            for query3 in self.query3:
-                Q3 = query3(emb3)
-                multi_head_Q3_list.append(Q3)
-        if emb4 is not None:
-            for query4 in self.query4:
-                Q4 = query4(emb4)
-                multi_head_Q4_list.append(Q4)
-        for key in self.key:
-            K = key(emb_all)
-            multi_head_K_list.append(K)
-        for value in self.value:
-            V = value(emb_all)
-            multi_head_V_list.append(V)
-        # print(len(multi_head_Q4_list))
-
-        multi_head_Q1 = torch.stack(multi_head_Q1_list, dim=1) if emb1 is not None else None
-        multi_head_Q2 = torch.stack(multi_head_Q2_list, dim=1) if emb2 is not None else None
-        multi_head_Q3 = torch.stack(multi_head_Q3_list, dim=1) if emb3 is not None else None
-        multi_head_Q4 = torch.stack(multi_head_Q4_list, dim=1) if emb4 is not None else None
-        multi_head_K = torch.stack(multi_head_K_list, dim=1)
-        multi_head_V = torch.stack(multi_head_V_list, dim=1)
-
-        multi_head_Q1 = multi_head_Q1.transpose(-1, -2) if emb1 is not None else None
-        multi_head_Q2 = multi_head_Q2.transpose(-1, -2) if emb2 is not None else None
-        multi_head_Q3 = multi_head_Q3.transpose(-1, -2) if emb3 is not None else None
-        multi_head_Q4 = multi_head_Q4.transpose(-1, -2) if emb4 is not None else None
-
-        attention_scores1 = torch.matmul(multi_head_Q1, multi_head_K) if emb1 is not None else None
-        attention_scores2 = torch.matmul(multi_head_Q2, multi_head_K) if emb2 is not None else None
-        attention_scores3 = torch.matmul(multi_head_Q3, multi_head_K) if emb3 is not None else None
-        attention_scores4 = torch.matmul(multi_head_Q4, multi_head_K) if emb4 is not None else None
-
-        attention_scores1 = attention_scores1 / math.sqrt(self.KV_size) if emb1 is not None else None
-        attention_scores2 = attention_scores2 / math.sqrt(self.KV_size) if emb2 is not None else None
-        attention_scores3 = attention_scores3 / math.sqrt(self.KV_size) if emb3 is not None else None
-        attention_scores4 = attention_scores4 / math.sqrt(self.KV_size) if emb4 is not None else None
-
-        attention_probs1 = self.softmax(self.psi(attention_scores1)) if emb1 is not None else None
-        attention_probs2 = self.softmax(self.psi(attention_scores2)) if emb2 is not None else None
-        attention_probs3 = self.softmax(self.psi(attention_scores3)) if emb3 is not None else None
-        attention_probs4 = self.softmax(self.psi(attention_scores4)) if emb4 is not None else None
-        # print(attention_probs4.size())
-
-        if self.vis:
-            weights =  []
-            weights.append(attention_probs1.mean(1))
-            weights.append(attention_probs2.mean(1))
-            weights.append(attention_probs3.mean(1))
-            weights.append(attention_probs4.mean(1))
-        else: weights=None
-
-        attention_probs1 = self.attn_dropout(attention_probs1) if emb1 is not None else None
-        attention_probs2 = self.attn_dropout(attention_probs2) if emb2 is not None else None
-        attention_probs3 = self.attn_dropout(attention_probs3) if emb3 is not None else None
-        attention_probs4 = self.attn_dropout(attention_probs4) if emb4 is not None else None
-
-        multi_head_V = multi_head_V.transpose(-1, -2)
-        context_layer1 = torch.matmul(attention_probs1, multi_head_V) if emb1 is not None else None
-        context_layer2 = torch.matmul(attention_probs2, multi_head_V) if emb2 is not None else None
-        context_layer3 = torch.matmul(attention_probs3, multi_head_V) if emb3 is not None else None
-        context_layer4 = torch.matmul(attention_probs4, multi_head_V) if emb4 is not None else None
-
-        context_layer1 = context_layer1.permute(0, 3, 2, 1).contiguous() if emb1 is not None else None
-        context_layer2 = context_layer2.permute(0, 3, 2, 1).contiguous() if emb2 is not None else None
-        context_layer3 = context_layer3.permute(0, 3, 2, 1).contiguous() if emb3 is not None else None
-        context_layer4 = context_layer4.permute(0, 3, 2, 1).contiguous() if emb4 is not None else None
-        context_layer1 = context_layer1.mean(dim=3) if emb1 is not None else None
-        context_layer2 = context_layer2.mean(dim=3) if emb2 is not None else None
-        context_layer3 = context_layer3.mean(dim=3) if emb3 is not None else None
-        context_layer4 = context_layer4.mean(dim=3) if emb4 is not None else None
-
-        O1 = self.out1(context_layer1) if emb1 is not None else None
-        O2 = self.out2(context_layer2) if emb2 is not None else None
-        O3 = self.out3(context_layer3) if emb3 is not None else None
-        O4 = self.out4(context_layer4) if emb4 is not None else None
-        O1 = self.proj_dropout(O1) if emb1 is not None else None
-        O2 = self.proj_dropout(O2) if emb2 is not None else None
-        O3 = self.proj_dropout(O3) if emb3 is not None else None
-        O4 = self.proj_dropout(O4) if emb4 is not None else None
-        return O1,O2,O3,O4, weights
-
-
-
-
-class Mlp(nn.Module):
-    def __init__(self, in_channel, mlp_channel):
-        super(Mlp, self).__init__()
-        self.fc1 = nn.Linear(in_channel, mlp_channel)
-        self.fc2 = nn.Linear(mlp_channel, in_channel)
-        self.act_fn = nn.GELU()
-        self.dropout = Dropout(0.0)
-        self._init_weights()
-
-    def _init_weights(self):
-        nn.init.xavier_uniform_(self.fc1.weight)
-        nn.init.xavier_uniform_(self.fc2.weight)
-        nn.init.normal_(self.fc1.bias, std=1e-6)
-        nn.init.normal_(self.fc2.bias, std=1e-6)
-
-    def forward(self, x):
-        x = self.fc1(x)
-        x = self.act_fn(x)
-        x = self.dropout(x)
-        x = self.fc2(x)
-        x = self.dropout(x)
-        return x
-
-class Block_ViT(nn.Module):
-    def __init__(self, vis, channel_num, expand_ratio=4,KV_size=480):
-        super(Block_ViT, self).__init__()
-        expand_ratio = 4
-        self.attn_norm1 = LayerNorm(channel_num[0],eps=1e-6)
-        self.attn_norm2 = LayerNorm(channel_num[1],eps=1e-6)
-        self.attn_norm3 = LayerNorm(channel_num[2],eps=1e-6)
-        self.attn_norm4 = LayerNorm(channel_num[3],eps=1e-6)
-        self.attn_norm =  LayerNorm(KV_size,eps=1e-6)
-        self.channel_attn = Attention_org(vis, channel_num)
-
-        self.ffn_norm1 = LayerNorm(channel_num[0],eps=1e-6)
-        self.ffn_norm2 = LayerNorm(channel_num[1],eps=1e-6)
-        self.ffn_norm3 = LayerNorm(channel_num[2],eps=1e-6)
-        self.ffn_norm4 = LayerNorm(channel_num[3],eps=1e-6)
-        self.ffn1 = Mlp(channel_num[0],channel_num[0]*expand_ratio)
-        self.ffn2 = Mlp(channel_num[1],channel_num[1]*expand_ratio)
-        self.ffn3 = Mlp(channel_num[2],channel_num[2]*expand_ratio)
-        self.ffn4 = Mlp(channel_num[3],channel_num[3]*expand_ratio)
-
-
-    def forward(self, emb1,emb2,emb3,emb4):
-        embcat = []
-        org1 = emb1
-        org2 = emb2
-        org3 = emb3
-        org4 = emb4
-        for i in range(4):
-            var_name = "emb"+str(i+1)  #emb1,emb2,emb3,emb4
-            tmp_var = locals()[var_name]
-            if tmp_var is not None:
-                embcat.append(tmp_var)
-
-        emb_all = torch.cat(embcat,dim=2)
-        cx1 = self.attn_norm1(emb1) if emb1 is not None else None
-        cx2 = self.attn_norm2(emb2) if emb2 is not None else None
-        cx3 = self.attn_norm3(emb3) if emb3 is not None else None
-        cx4 = self.attn_norm4(emb4) if emb4 is not None else None
-        emb_all = self.attn_norm(emb_all)
-        cx1,cx2,cx3,cx4, weights = self.channel_attn(cx1,cx2,cx3,cx4,emb_all)
-        #残差
-        cx1 = org1 + cx1 if emb1 is not None else None
-        cx2 = org2 + cx2 if emb2 is not None else None
-        cx3 = org3 + cx3 if emb3 is not None else None
-        cx4 = org4 + cx4 if emb4 is not None else None
-
-        org1 = cx1
-        org2 = cx2
-        org3 = cx3
-        org4 = cx4
-        x1 = self.ffn_norm1(cx1) if emb1 is not None else None
-        x2 = self.ffn_norm2(cx2) if emb2 is not None else None
-        x3 = self.ffn_norm3(cx3) if emb3 is not None else None
-        x4 = self.ffn_norm4(cx4) if emb4 is not None else None
-        x1 = self.ffn1(x1) if emb1 is not None else None
-        x2 = self.ffn2(x2) if emb2 is not None else None
-        x3 = self.ffn3(x3) if emb3 is not None else None
-        x4 = self.ffn4(x4) if emb4 is not None else None
-        #残差
-        x1 = x1 + org1 if emb1 is not None else None
-        x2 = x2 + org2 if emb2 is not None else None
-        x3 = x3 + org3 if emb3 is not None else None
-        x4 = x4 + org4 if emb4 is not None else None
-
-        return x1, x2, x3, x4, weights
-
-
-class Encoder(nn.Module):
-    def __init__(self, vis, channel_num, num_layers=4):
-        super(Encoder, self).__init__()
-        self.vis = vis
-        self.layer = nn.ModuleList()
-        self.encoder_norm1 = LayerNorm(channel_num[0],eps=1e-6)
-        self.encoder_norm2 = LayerNorm(channel_num[1],eps=1e-6)
-        self.encoder_norm3 = LayerNorm(channel_num[2],eps=1e-6)
-        self.encoder_norm4 = LayerNorm(channel_num[3],eps=1e-6)
-        for _ in range(num_layers):
-            layer = Block_ViT(vis, channel_num)
-            self.layer.append(copy.deepcopy(layer))
-
-    def forward(self, emb1,emb2,emb3,emb4):
-        attn_weights = []
-        for layer_block in self.layer:
-            emb1,emb2,emb3,emb4, weights = layer_block(emb1,emb2,emb3,emb4)
-            if self.vis:
-                attn_weights.append(weights)
-        emb1 = self.encoder_norm1(emb1) if emb1 is not None else None
-        emb2 = self.encoder_norm2(emb2) if emb2 is not None else None
-        emb3 = self.encoder_norm3(emb3) if emb3 is not None else None
-        emb4 = self.encoder_norm4(emb4) if emb4 is not None else None
-        return emb1,emb2,emb3,emb4, attn_weights
-
-
-class ChannelTransformer(nn.Module):
-    def __init__(self,  vis=False, img_size=256, channel_num=[64, 128, 256, 512], patchSize=[32, 16, 8, 4]):
-        super().__init__()
-
-        self.patchSize_1 = patchSize[0]
-        self.patchSize_2 = patchSize[1]
-        self.patchSize_3 = patchSize[2]
-        self.patchSize_4 = patchSize[3]
-        self.embeddings_1 = Channel_Embeddings(self.patchSize_1, img_size=img_size,    in_channels=channel_num[0])
-        self.embeddings_2 = Channel_Embeddings(self.patchSize_2, img_size=img_size//2, in_channels=channel_num[1])
-        self.embeddings_3 = Channel_Embeddings(self.patchSize_3, img_size=img_size//4, in_channels=channel_num[2])
-        self.embeddings_4 = Channel_Embeddings(self.patchSize_4, img_size=img_size//8, in_channels=channel_num[3])
-        self.encoder = Encoder( vis, channel_num)
-
-        self.reconstruct_1 = Reconstruct(channel_num[0], channel_num[0], kernel_size=1,scale_factor=(self.patchSize_1,self.patchSize_1))
-        self.reconstruct_2 = Reconstruct(channel_num[1], channel_num[1], kernel_size=1,scale_factor=(self.patchSize_2,self.patchSize_2))
-        self.reconstruct_3 = Reconstruct(channel_num[2], channel_num[2], kernel_size=1,scale_factor=(self.patchSize_3,self.patchSize_3))
-        self.reconstruct_4 = Reconstruct(channel_num[3], channel_num[3], kernel_size=1,scale_factor=(self.patchSize_4,self.patchSize_4))
-
-    def forward(self,en1,en2,en3,en4):
-
-        emb1 = self.embeddings_1(en1)
-        emb2 = self.embeddings_2(en2)
-        emb3 = self.embeddings_3(en3)
-        emb4 = self.embeddings_4(en4)
-
-        encoded1, encoded2, encoded3, encoded4, attn_weights = self.encoder(emb1,emb2,emb3,emb4)  # (B, n_patch, hidden)
-        x1 = self.reconstruct_1(encoded1) if en1 is not None else None
-        x2 = self.reconstruct_2(encoded2) if en2 is not None else None
-        x3 = self.reconstruct_3(encoded3) if en3 is not None else None
-        x4 = self.reconstruct_4(encoded4) if en4 is not None else None
-
-        x1 = x1 + en1  if en1 is not None else None
-        x2 = x2 + en2  if en2 is not None else None
-        x3 = x3 + en3  if en3 is not None else None
-        x4 = x4 + en4  if en4 is not None else None
-
-        return x1, x2, x3, x4, attn_weights
-

spaces/Alpaca233/SadTalker/src/generate_batch.py

@@ -1,120 +0,0 @@
-import os
-
-from tqdm import tqdm
-import torch
-import numpy as np
-import random
-import scipy.io as scio
-import src.utils.audio as audio
-
-def crop_pad_audio(wav, audio_length):
-    if len(wav) > audio_length:
-        wav = wav[:audio_length]
-    elif len(wav) < audio_length:
-        wav = np.pad(wav, [0, audio_length - len(wav)], mode='constant', constant_values=0)
-    return wav
-
-def parse_audio_length(audio_length, sr, fps):
-    bit_per_frames = sr / fps
-
-    num_frames = int(audio_length / bit_per_frames)
-    audio_length = int(num_frames * bit_per_frames)
-
-    return audio_length, num_frames
-
-def generate_blink_seq(num_frames):
-    ratio = np.zeros((num_frames,1))
-    frame_id = 0
-    while frame_id in range(num_frames):
-        start = 80
-        if frame_id+start+9<=num_frames - 1:
-            ratio[frame_id+start:frame_id+start+9, 0] = [0.5,0.6,0.7,0.9,1, 0.9, 0.7,0.6,0.5]
-            frame_id = frame_id+start+9
-        else:
-            break
-    return ratio 
-
-def generate_blink_seq_randomly(num_frames):
-    ratio = np.zeros((num_frames,1))
-    if num_frames<=20:
-        return ratio
-    frame_id = 0
-    while frame_id in range(num_frames):
-        start = random.choice(range(min(10,num_frames), min(int(num_frames/2), 70))) 
-        if frame_id+start+5<=num_frames - 1:
-            ratio[frame_id+start:frame_id+start+5, 0] = [0.5, 0.9, 1.0, 0.9, 0.5]
-            frame_id = frame_id+start+5
-        else:
-            break
-    return ratio
-
-def get_data(first_coeff_path, audio_path, device, ref_eyeblink_coeff_path, still=False, idlemode=False, length_of_audio=False, use_blink=True):
-
-    syncnet_mel_step_size = 16
-    fps = 25
-
-    pic_name = os.path.splitext(os.path.split(first_coeff_path)[-1])[0]
-    audio_name = os.path.splitext(os.path.split(audio_path)[-1])[0]
-
-    
-    if idlemode:
-        num_frames = int(length_of_audio * 25)
-        indiv_mels = np.zeros((num_frames, 80, 16))
-    else:
-        wav = audio.load_wav(audio_path, 16000) 
-        wav_length, num_frames = parse_audio_length(len(wav), 16000, 25)
-        wav = crop_pad_audio(wav, wav_length)
-        orig_mel = audio.melspectrogram(wav).T
-        spec = orig_mel.copy()         # nframes 80
-        indiv_mels = []
-
-        for i in tqdm(range(num_frames), 'mel:'):
-            start_frame_num = i-2
-            start_idx = int(80. * (start_frame_num / float(fps)))
-            end_idx = start_idx + syncnet_mel_step_size
-            seq = list(range(start_idx, end_idx))
-            seq = [ min(max(item, 0), orig_mel.shape[0]-1) for item in seq ]
-            m = spec[seq, :]
-            indiv_mels.append(m.T)
-        indiv_mels = np.asarray(indiv_mels)         # T 80 16
-
-    ratio = generate_blink_seq_randomly(num_frames)      # T
-    source_semantics_path = first_coeff_path
-    source_semantics_dict = scio.loadmat(source_semantics_path)
-    ref_coeff = source_semantics_dict['coeff_3dmm'][:1,:70]         #1 70
-    ref_coeff = np.repeat(ref_coeff, num_frames, axis=0)
-
-    if ref_eyeblink_coeff_path is not None:
-        ratio[:num_frames] = 0
-        refeyeblink_coeff_dict = scio.loadmat(ref_eyeblink_coeff_path)
-        refeyeblink_coeff = refeyeblink_coeff_dict['coeff_3dmm'][:,:64]
-        refeyeblink_num_frames = refeyeblink_coeff.shape[0]
-        if refeyeblink_num_frames<num_frames:
-            div = num_frames//refeyeblink_num_frames
-            re = num_frames%refeyeblink_num_frames
-            refeyeblink_coeff_list = [refeyeblink_coeff for i in range(div)]
-            refeyeblink_coeff_list.append(refeyeblink_coeff[:re, :64])
-            refeyeblink_coeff = np.concatenate(refeyeblink_coeff_list, axis=0)
-            print(refeyeblink_coeff.shape[0])
-
-        ref_coeff[:, :64] = refeyeblink_coeff[:num_frames, :64] 
-    
-    indiv_mels = torch.FloatTensor(indiv_mels).unsqueeze(1).unsqueeze(0) # bs T 1 80 16
-
-    if use_blink:
-        ratio = torch.FloatTensor(ratio).unsqueeze(0)                       # bs T
-    else:
-        ratio = torch.FloatTensor(ratio).unsqueeze(0).fill_(0.) 
-                               # bs T
-    ref_coeff = torch.FloatTensor(ref_coeff).unsqueeze(0)                # bs 1 70
-
-    indiv_mels = indiv_mels.to(device)
-    ratio = ratio.to(device)
-    ref_coeff = ref_coeff.to(device)
-
-    return {'indiv_mels': indiv_mels,  
-            'ref': ref_coeff, 
-            'num_frames': num_frames, 
-            'ratio_gt': ratio,
-            'audio_name': audio_name, 'pic_name': pic_name}
-

spaces/Ameaou/academic-chatgpt3.1/crazy_functions/test_project/latex/attention/model_architecture.tex

@@ -1,155 +0,0 @@
-
-\begin{figure}
-  \centering
-  \includegraphics[scale=0.6]{Figures/ModalNet-21}
-  \caption{The Transformer - model architecture.}
-  \label{fig:model-arch}
-\end{figure}
-
-% Although the primary workhorse of our model is attention, 
-%Our model maintains the encoder-decoder structure that is common to many so-called sequence-to-sequence models \citep{bahdanau2014neural,sutskever14}.  As in all such architectures, the encoder computes a representation of the input sequence, and the decoder consumes these representations along with the output tokens to autoregressively produce the output sequence.  Where, traditionally, the encoder and decoder contain stacks of recurrent or convolutional layers, our encoder and decoder stacks are composed of attention layers and position-wise feed-forward layers (Figure~\ref{fig:model-arch}).  The following sections describe the gross architecture and these particular components in detail.
-
-Most competitive neural sequence transduction models have an encoder-decoder structure \citep{cho2014learning,bahdanau2014neural,sutskever14}. Here, the encoder maps an input sequence of symbol representations $(x_1, ..., x_n)$ to a sequence of continuous representations $\mathbf{z} = (z_1, ..., z_n)$. Given $\mathbf{z}$, the decoder then generates an output sequence $(y_1,...,y_m)$ of symbols one element at a time. At each step the model is auto-regressive \citep{graves2013generating}, consuming the previously generated symbols as additional input when generating the next.
-
-The Transformer follows this overall architecture using stacked self-attention and point-wise, fully connected layers for both the encoder and decoder, shown in the left and right halves of Figure~\ref{fig:model-arch}, respectively.
-
-\subsection{Encoder and Decoder Stacks}
-
-\paragraph{Encoder:}The encoder is composed of a stack of $N=6$ identical layers. Each layer has two sub-layers. The first is a multi-head self-attention mechanism, and the second is a simple, position-wise fully connected feed-forward network.   We employ a residual connection \citep{he2016deep} around each of the two sub-layers, followed by layer normalization \cite{layernorm2016}.  That is, the output of each sub-layer is $\mathrm{LayerNorm}(x + \mathrm{Sublayer}(x))$, where $\mathrm{Sublayer}(x)$ is the function implemented by the sub-layer itself.  To facilitate these residual connections, all sub-layers in the model, as well as the embedding layers, produce outputs of dimension $\dmodel=512$.
-
-\paragraph{Decoder:}The decoder is also composed of a stack of $N=6$ identical layers.  In addition to the two sub-layers in each encoder layer, the decoder inserts a third sub-layer, which performs multi-head attention over the output of the encoder stack.  Similar to the encoder, we employ residual connections around each of the sub-layers, followed by layer normalization.  We also modify the self-attention sub-layer in the decoder stack to prevent positions from attending to subsequent positions.  This masking, combined with fact that the output embeddings are offset by one position, ensures that the predictions for position $i$ can depend only on the known outputs at positions less than $i$.
-
-% In our model (Figure~\ref{fig:model-arch}), the encoder and decoder are composed of stacks of alternating self-attention layers (for cross-positional communication) and position-wise feed-forward layers (for in-place computation).  In addition, the decoder stack contains encoder-decoder attention layers.  Since attention is agnostic to the distances between words, our model requires a "positional encoding" to be added to the encoder and decoder input. The following sections describe all of these components in detail.
-
-\subsection{Attention} \label{sec:attention}
-An attention function can be described as mapping a query and a set of key-value pairs to an output, where the query, keys, values, and output are all vectors.  The output is computed as a weighted sum of the values, where the weight assigned to each value is computed by a compatibility function of the query with the corresponding key.
-
-\subsubsection{Scaled Dot-Product Attention} \label{sec:scaled-dot-prod}
-
-% \begin{figure}
-%   \centering
-%   \includegraphics[scale=0.6]{Figures/ModalNet-19}
-%   \caption{Scaled Dot-Product Attention.}
-%   \label{fig:multi-head-att}
-% \end{figure}
-
-We call our particular attention "Scaled Dot-Product Attention" (Figure~\ref{fig:multi-head-att}).   The input consists of queries and keys of dimension $d_k$, and values of dimension $d_v$.  We compute the dot products of the query with all keys, divide each by $\sqrt{d_k}$, and apply a softmax function to obtain the weights on the values.
-
-In practice, we compute the attention function on a set of queries simultaneously, packed together into a matrix $Q$.   The keys and values are also packed together into matrices $K$ and $V$.  We compute the matrix of outputs as:
-
-\begin{equation}
-   \mathrm{Attention}(Q, K, V) = \mathrm{softmax}(\frac{QK^T}{\sqrt{d_k}})V
-\end{equation}
-
-The two most commonly used attention functions are additive attention \citep{bahdanau2014neural}, and dot-product (multiplicative) attention.  Dot-product attention is identical to our algorithm, except for the scaling factor of $\frac{1}{\sqrt{d_k}}$. Additive attention computes the compatibility function using a feed-forward network with a single hidden layer.  While the two are similar in theoretical complexity, dot-product attention is much faster and more space-efficient in practice, since it can be implemented using highly optimized matrix multiplication code. 
-
-%We scale the dot products by $1/\sqrt{d_k}$ to limit the magnitude of the dot products, which works well in practice. Otherwise, we found applying the softmax to often result in weights very close to 0 or 1, and hence minuscule gradients.
-
-% Already described in the subsequent section
-%When used as part of decoder self-attention, an optional mask function is applied just before the softmax to prevent positions from attending to subsequent positions.   This mask simply sets the logits corresponding to all illegal connections (those outside of the lower triangle) to $-\infty$.
-
-%\paragraph{Comparison to Additive Attention: } We choose dot product attention over additive attention \citep{bahdanau2014neural} since it can be computed using highly optimized matrix multiplication code.  This optimization is particularly important to us, as we employ many attention layers in our model.
-
-While for small values of $d_k$ the two mechanisms perform similarly, additive attention outperforms dot product attention without scaling for larger values of $d_k$ \citep{DBLP:journals/corr/BritzGLL17}. We suspect that for large values of $d_k$, the dot products grow large in magnitude, pushing the softmax function into regions where it has extremely small gradients  \footnote{To illustrate why the dot products get large, assume that the components of $q$ and $k$ are independent random variables with mean $0$ and variance $1$.  Then their dot product, $q \cdot k = \sum_{i=1}^{d_k} q_ik_i$, has mean $0$ and variance $d_k$.}. To counteract this effect, we scale the dot products by $\frac{1}{\sqrt{d_k}}$.
-
-
-%We suspect this to be caused by the dot products growing too large in magnitude to result in useful gradients after applying the softmax function.  To counteract this, we scale the dot product by $1/\sqrt{d_k}$.
-
-
-\subsubsection{Multi-Head Attention} \label{sec:multihead}
-
-\begin{figure}
-\begin{minipage}[t]{0.5\textwidth}
-  \centering
-  Scaled Dot-Product Attention \\
-  \vspace{0.5cm}
-  \includegraphics[scale=0.6]{Figures/ModalNet-19}
-\end{minipage}
-\begin{minipage}[t]{0.5\textwidth}
-  \centering 
-  Multi-Head Attention \\
-  \vspace{0.1cm}
-  \includegraphics[scale=0.6]{Figures/ModalNet-20}  
-\end{minipage}
-
-
-  % \centering
-
-  \caption{(left) Scaled Dot-Product Attention. (right) Multi-Head Attention consists of several attention layers running in parallel.}
-  \label{fig:multi-head-att}
-\end{figure}
-
-Instead of performing a single attention function with $\dmodel$-dimensional keys, values and queries, we found it beneficial to linearly project the queries, keys and values $h$ times with different, learned linear projections to $d_k$, $d_k$ and $d_v$ dimensions, respectively.
-On each of these projected versions of queries, keys and values we then perform the attention function in parallel, yielding $d_v$-dimensional output values. These are concatenated and once again projected, resulting in the final values, as depicted in Figure~\ref{fig:multi-head-att}.
-
-Multi-head attention allows the model to jointly attend to information from different representation subspaces at different positions. With a single attention head, averaging inhibits this.
-
-\begin{align*}
-    \mathrm{MultiHead}(Q, K, V) &= \mathrm{Concat}(\mathrm{head_1}, ..., \mathrm{head_h})W^O\\
-%    \mathrm{where} \mathrm{head_i} &= \mathrm{Attention}(QW_Q_i^{\dmodel \times d_q}, KW_K_i^{\dmodel \times d_k}, VW^V_i^{\dmodel \times d_v})\\
-    \text{where}~\mathrm{head_i} &= \mathrm{Attention}(QW^Q_i, KW^K_i, VW^V_i)\\
-\end{align*}
-
-Where the projections are parameter matrices $W^Q_i \in \mathbb{R}^{\dmodel \times d_k}$, $W^K_i \in \mathbb{R}^{\dmodel \times d_k}$, $W^V_i \in \mathbb{R}^{\dmodel \times d_v}$ and $W^O \in \mathbb{R}^{hd_v \times \dmodel}$.
-
-
-%find it better (and no more expensive) to have multiple parallel attention layers (each over the full set of positions) with proportionally lower-dimensional keys, values and queries.  We call this "Multi-Head Attention" (Figure~\ref{fig:multi-head-att}).  The keys, values, and queries for each of these parallel attention layers are computed by learned linear transformations of the inputs to the multi-head attention.  We use different linear transformations across different parallel attention layers.  The output of the parallel attention layers are concatenated, and then passed through a final learned linear transformation. 
-
-In this work we employ $h=8$ parallel attention layers, or heads. For each of these we use $d_k=d_v=\dmodel/h=64$.
-Due to the reduced dimension of each head, the total computational cost is similar to that of single-head attention with full dimensionality.
-
-\subsubsection{Applications of Attention in our Model}
-
-The Transformer uses multi-head attention in three different ways: 
-\begin{itemize}
- \item In "encoder-decoder attention" layers, the queries come from the previous decoder layer, and the memory keys and values come from the output of the encoder.   This allows every position in the decoder to attend over all positions in the input sequence.  This mimics the typical encoder-decoder attention mechanisms in sequence-to-sequence models such as \citep{wu2016google, bahdanau2014neural,JonasFaceNet2017}.
-
- \item The encoder contains self-attention layers.  In a self-attention layer all of the keys, values and queries come from the same place, in this case, the output of the previous layer in the encoder.   Each position in the encoder can attend to all positions in the previous layer of the encoder.
-
- \item Similarly, self-attention layers in the decoder allow each position in the decoder to attend to all positions in the decoder up to and including that position.  We need to prevent leftward information flow in the decoder to preserve the auto-regressive property.  We implement this inside of scaled dot-product attention by masking out (setting to $-\infty$) all values in the input of the softmax which correspond to illegal connections.  See Figure~\ref{fig:multi-head-att}.
-
-\end{itemize}
-
-\subsection{Position-wise Feed-Forward Networks}\label{sec:ffn}
-
-In addition to attention sub-layers, each of the layers in our encoder and decoder contains a fully connected feed-forward network, which is applied to each position separately and identically.  This consists of two linear transformations with a ReLU activation in between.
-
-\begin{equation}
-   \mathrm{FFN}(x)=\max(0, xW_1 + b_1) W_2 + b_2
-\end{equation}
-
-While the linear transformations are the same across different positions, they use different parameters from layer to layer. Another way of describing this is as two convolutions with kernel size 1.  The dimensionality of input and output is $\dmodel=512$, and the inner-layer has dimensionality $d_{ff}=2048$.
-
-
-
-%In the appendix, we describe how the position-wise feed-forward network can also be seen as a form of attention.
-
-%from Jakob: The number of operations required for the model to relate signals from two arbitrary input or output positions grows in the distance between positions in input or output, linearly for ConvS2S and logarithmically for ByteNet, making it harder to learn dependencies between these positions \citep{hochreiter2001gradient}. In the transformer this is reduced to a constant number of operations, albeit at the cost of effective resolution caused by averaging attention-weighted positions, an effect we aim to counteract with multi-headed attention.
-
-
-%Figure~\ref{fig:simple-att} presents a simple attention function, $A$, with a single head, that forms the basis of our multi-head attention. $A$ takes a query key vector $\kq$, matrices of memory keys $\km$ and memory values $\vm$ ,and produces a query value vector $\vq$ as 
-%\begin{equation*} \label{eq:attention}
-%    A(\kq, \km, \vm) = {\vm}^T (Softmax(\km \kq).
-%\end{equation*}
-%We linearly transform $\kq,\,\km$, and $\vm$ with learned matrices ${\Wkq \text{,} \, \Wkm}$, and ${\Wvm}$ before calling the attention function, and transform the output query with $\Wvq$ before handing it to the feed forward layer. Each attention layer has it's own set of transformation matrices, which are shared across all query positions. $A$ is applied in parallel for each query position, and is implemented very efficiently as a batch of matrix multiplies. The self-attention and encoder-decoder attention layers use $A$, but with different arguments. For example, in encdoder self-attention, queries in encoder layer $i$ attention to memories in encoder layer $i-1$. To ensure that decoder self-attention layers do not look at future words, we add $- \inf$ to the softmax logits in positions $j+1$ to query length for query position $l$.  
-
-%In simple attention, the query value is a weighted combination of the memory values where the attention weights sum to one. Although this function performs well in practice, the constraint on attention weights can restrict the amount of information that flows from memories to queries because the query cannot focus on multiple memory positions at once, which might be desirable when translating long sequences. \marginpar{@usz, could you think of an example of this ?} We remedy this by maintaining multiple attention heads at each query position that attend to all memory positions in parallel, with a different set of parameters  per attention head $h$. 
-%\marginpar{}
-
-\subsection{Embeddings and Softmax}
-Similarly to other sequence transduction models, we use learned embeddings to convert the input tokens and output tokens to vectors of dimension $\dmodel$.  We also use the usual learned linear transformation and softmax function to convert the decoder output to predicted next-token probabilities.  In our model, we share the same weight matrix between the two embedding layers and the pre-softmax linear transformation, similar to \citep{press2016using}.   In the embedding layers, we multiply those weights by $\sqrt{\dmodel}$.
-
-
-\subsection{Positional Encoding}
-Since our model contains no recurrence and no convolution, in order for the model to make use of the order of the sequence, we must inject some information about the relative or absolute position of the tokens in the sequence.  To this end, we add "positional encodings" to the input embeddings at the bottoms of the encoder and decoder stacks.  The positional encodings have the same dimension $\dmodel$ as the embeddings, so that the two can be summed.   There are many choices of positional encodings, learned and fixed \citep{JonasFaceNet2017}.
-
-In this work, we use sine and cosine functions of different frequencies:
-
-\begin{align*}
-    PE_{(pos,2i)} = sin(pos / 10000^{2i/\dmodel}) \\
-    PE_{(pos,2i+1)} = cos(pos / 10000^{2i/\dmodel})
-\end{align*}
-
-where $pos$ is the position and $i$ is the dimension.  That is, each dimension of the positional encoding corresponds to a sinusoid.  The wavelengths form a geometric progression from $2\pi$ to $10000 \cdot 2\pi$.  We chose this function because we hypothesized it would allow the model to easily learn to attend by relative positions, since for any fixed offset $k$, $PE_{pos+k}$ can be represented as a linear function of $PE_{pos}$.
-
-We also experimented with using learned positional embeddings \citep{JonasFaceNet2017} instead, and found that the two versions produced nearly identical results (see Table~\ref{tab:variations} row (E)).  We chose the sinusoidal version because it may allow the model to extrapolate to sequence lengths longer than the ones encountered during training.

spaces/Amrrs/DragGan-Inversion/PTI/editings/ganspace.py

@@ -1,21 +0,0 @@
-import torch
-
-
-def edit(latents, pca, edit_directions):
-    edit_latents = []
-    for latent in latents:
-        for pca_idx, start, end, strength in edit_directions:
-            delta = get_delta(pca, latent, pca_idx, strength)
-            delta_padded = torch.zeros(latent.shape).to('cuda')
-            delta_padded[start:end] += delta.repeat(end - start, 1)
-            edit_latents.append(latent + delta_padded)
-    return torch.stack(edit_latents)
-
-
-def get_delta(pca, latent, idx, strength):
-    w_centered = latent - pca['mean'].to('cuda')
-    lat_comp = pca['comp'].to('cuda')
-    lat_std = pca['std'].to('cuda')
-    w_coord = torch.sum(w_centered[0].reshape(-1)*lat_comp[idx].reshape(-1)) / lat_std[idx]
-    delta = (strength - w_coord)*lat_comp[idx]*lat_std[idx]
-    return delta

spaces/Amrrs/DragGan-Inversion/PTI/models/StyleCLIP/mapper/training/coach.py

@@ -1,242 +0,0 @@
-import os
-
-import clip
-import torch
-import torchvision
-from torch import nn
-from torch.utils.data import DataLoader
-from torch.utils.tensorboard import SummaryWriter
-
-import criteria.clip_loss as clip_loss
-from criteria import id_loss
-from mapper.datasets.latents_dataset import LatentsDataset
-from mapper.styleclip_mapper import StyleCLIPMapper
-from mapper.training.ranger import Ranger
-from mapper.training import train_utils
-
-
-class Coach:
-	def __init__(self, opts):
-		self.opts = opts
-
-		self.global_step = 0
-
-		self.device = 'cuda:0'
-		self.opts.device = self.device
-
-		# Initialize network
-		self.net = StyleCLIPMapper(self.opts).to(self.device)
-
-		# Initialize loss
-		if self.opts.id_lambda > 0:
-			self.id_loss = id_loss.IDLoss(self.opts).to(self.device).eval()
-		if self.opts.clip_lambda > 0:
-			self.clip_loss = clip_loss.CLIPLoss(opts)
-		if self.opts.latent_l2_lambda > 0:
-			self.latent_l2_loss = nn.MSELoss().to(self.device).eval()
-
-		# Initialize optimizer
-		self.optimizer = self.configure_optimizers()
-
-		# Initialize dataset
-		self.train_dataset, self.test_dataset = self.configure_datasets()
-		self.train_dataloader = DataLoader(self.train_dataset,
-										   batch_size=self.opts.batch_size,
-										   shuffle=True,
-										   num_workers=int(self.opts.workers),
-										   drop_last=True)
-		self.test_dataloader = DataLoader(self.test_dataset,
-										  batch_size=self.opts.test_batch_size,
-										  shuffle=False,
-										  num_workers=int(self.opts.test_workers),
-										  drop_last=True)
-
-		self.text_inputs = torch.cat([clip.tokenize(self.opts.description)]).cuda()
-
-		# Initialize logger
-		log_dir = os.path.join(opts.exp_dir, 'logs')
-		os.makedirs(log_dir, exist_ok=True)
-		self.log_dir = log_dir
-		self.logger = SummaryWriter(log_dir=log_dir)
-
-		# Initialize checkpoint dir
-		self.checkpoint_dir = os.path.join(opts.exp_dir, 'checkpoints')
-		os.makedirs(self.checkpoint_dir, exist_ok=True)
-		self.best_val_loss = None
-		if self.opts.save_interval is None:
-			self.opts.save_interval = self.opts.max_steps
-
-	def train(self):
-		self.net.train()
-		while self.global_step < self.opts.max_steps:
-			for batch_idx, batch in enumerate(self.train_dataloader):
-				self.optimizer.zero_grad()
-				w = batch
-				w = w.to(self.device)
-				with torch.no_grad():
-					x, _ = self.net.decoder([w], input_is_latent=True, randomize_noise=False, truncation=1)
-				w_hat = w + 0.1 * self.net.mapper(w)
-				x_hat, w_hat = self.net.decoder([w_hat], input_is_latent=True, return_latents=True, randomize_noise=False, truncation=1)
-				loss, loss_dict = self.calc_loss(w, x, w_hat, x_hat)
-				loss.backward()
-				self.optimizer.step()
-
-				# Logging related
-				if self.global_step % self.opts.image_interval == 0 or (
-						self.global_step < 1000 and self.global_step % 1000 == 0):
-					self.parse_and_log_images(x, x_hat, title='images_train')
-				if self.global_step % self.opts.board_interval == 0:
-					self.print_metrics(loss_dict, prefix='train')
-					self.log_metrics(loss_dict, prefix='train')
-
-				# Validation related
-				val_loss_dict = None
-				if self.global_step % self.opts.val_interval == 0 or self.global_step == self.opts.max_steps:
-					val_loss_dict = self.validate()
-					if val_loss_dict and (self.best_val_loss is None or val_loss_dict['loss'] < self.best_val_loss):
-						self.best_val_loss = val_loss_dict['loss']
-						self.checkpoint_me(val_loss_dict, is_best=True)
-
-				if self.global_step % self.opts.save_interval == 0 or self.global_step == self.opts.max_steps:
-					if val_loss_dict is not None:
-						self.checkpoint_me(val_loss_dict, is_best=False)
-					else:
-						self.checkpoint_me(loss_dict, is_best=False)
-
-				if self.global_step == self.opts.max_steps:
-					print('OMG, finished training!')
-					break
-
-				self.global_step += 1
-
-	def validate(self):
-		self.net.eval()
-		agg_loss_dict = []
-		for batch_idx, batch in enumerate(self.test_dataloader):
-			if batch_idx > 200:
-				break
-
-			w = batch
-
-			with torch.no_grad():
-				w = w.to(self.device).float()
-				x, _ = self.net.decoder([w], input_is_latent=True, randomize_noise=True, truncation=1)
-				w_hat = w + 0.1 * self.net.mapper(w)
-				x_hat, _ = self.net.decoder([w_hat], input_is_latent=True, randomize_noise=True, truncation=1)
-				loss, cur_loss_dict = self.calc_loss(w, x, w_hat, x_hat)
-			agg_loss_dict.append(cur_loss_dict)
-
-			# Logging related
-			self.parse_and_log_images(x, x_hat, title='images_val', index=batch_idx)
-
-			# For first step just do sanity test on small amount of data
-			if self.global_step == 0 and batch_idx >= 4:
-				self.net.train()
-				return None  # Do not log, inaccurate in first batch
-
-		loss_dict = train_utils.aggregate_loss_dict(agg_loss_dict)
-		self.log_metrics(loss_dict, prefix='test')
-		self.print_metrics(loss_dict, prefix='test')
-
-		self.net.train()
-		return loss_dict
-
-	def checkpoint_me(self, loss_dict, is_best):
-		save_name = 'best_model.pt' if is_best else 'iteration_{}.pt'.format(self.global_step)
-		save_dict = self.__get_save_dict()
-		checkpoint_path = os.path.join(self.checkpoint_dir, save_name)
-		torch.save(save_dict, checkpoint_path)
-		with open(os.path.join(self.checkpoint_dir, 'timestamp.txt'), 'a') as f:
-			if is_best:
-				f.write('**Best**: Step - {}, Loss - {:.3f} \n{}\n'.format(self.global_step, self.best_val_loss, loss_dict))
-			else:
-				f.write('Step - {}, \n{}\n'.format(self.global_step, loss_dict))
-
-	def configure_optimizers(self):
-		params = list(self.net.mapper.parameters())
-		if self.opts.optim_name == 'adam':
-			optimizer = torch.optim.Adam(params, lr=self.opts.learning_rate)
-		else:
-			optimizer = Ranger(params, lr=self.opts.learning_rate)
-		return optimizer
-
-	def configure_datasets(self):
-		if self.opts.latents_train_path:
-			train_latents = torch.load(self.opts.latents_train_path)
-		else:
-			train_latents_z = torch.randn(self.opts.train_dataset_size, 512).cuda()
-			train_latents = []
-			for b in range(self.opts.train_dataset_size // self.opts.batch_size):
-				with torch.no_grad():
-					_, train_latents_b = self.net.decoder([train_latents_z[b: b + self.opts.batch_size]],
-														  truncation=0.7, truncation_latent=self.net.latent_avg, return_latents=True)
-					train_latents.append(train_latents_b)
-			train_latents = torch.cat(train_latents)
-
-		if self.opts.latents_test_path:
-			test_latents = torch.load(self.opts.latents_test_path)
-		else:
-			test_latents_z = torch.randn(self.opts.train_dataset_size, 512).cuda()
-			test_latents = []
-			for b in range(self.opts.test_dataset_size // self.opts.test_batch_size):
-				with torch.no_grad():
-					_, test_latents_b = self.net.decoder([test_latents_z[b: b + self.opts.test_batch_size]],
-													  truncation=0.7, truncation_latent=self.net.latent_avg, return_latents=True)
-					test_latents.append(test_latents_b)
-			test_latents = torch.cat(test_latents)
-
-		train_dataset_celeba = LatentsDataset(latents=train_latents.cpu(),
-		                                      opts=self.opts)
-		test_dataset_celeba = LatentsDataset(latents=test_latents.cpu(),
-		                                      opts=self.opts)
-		train_dataset = train_dataset_celeba
-		test_dataset = test_dataset_celeba
-		print("Number of training samples: {}".format(len(train_dataset)))
-		print("Number of test samples: {}".format(len(test_dataset)))
-		return train_dataset, test_dataset
-
-	def calc_loss(self, w, x, w_hat, x_hat):
-		loss_dict = {}
-		loss = 0.0
-		if self.opts.id_lambda > 0:
-			loss_id, sim_improvement = self.id_loss(x_hat, x)
-			loss_dict['loss_id'] = float(loss_id)
-			loss_dict['id_improve'] = float(sim_improvement)
-			loss = loss_id * self.opts.id_lambda
-		if self.opts.clip_lambda > 0:
-			loss_clip = self.clip_loss(x_hat, self.text_inputs).mean()
-			loss_dict['loss_clip'] = float(loss_clip)
-			loss += loss_clip * self.opts.clip_lambda
-		if self.opts.latent_l2_lambda > 0:
-			loss_l2_latent = self.latent_l2_loss(w_hat, w)
-			loss_dict['loss_l2_latent'] = float(loss_l2_latent)
-			loss += loss_l2_latent * self.opts.latent_l2_lambda
-		loss_dict['loss'] = float(loss)
-		return loss, loss_dict
-
-	def log_metrics(self, metrics_dict, prefix):
-		for key, value in metrics_dict.items():
-			#pass
-			print(f"step: {self.global_step} \t metric: {prefix}/{key} \t value: {value}")
-			self.logger.add_scalar('{}/{}'.format(prefix, key), value, self.global_step)
-
-	def print_metrics(self, metrics_dict, prefix):
-		print('Metrics for {}, step {}'.format(prefix, self.global_step))
-		for key, value in metrics_dict.items():
-			print('\t{} = '.format(key), value)
-
-	def parse_and_log_images(self, x, x_hat, title, index=None):
-		if index is None:
-			path = os.path.join(self.log_dir, title, f'{str(self.global_step).zfill(5)}.jpg')
-		else:
-			path = os.path.join(self.log_dir, title, f'{str(self.global_step).zfill(5)}_{str(index).zfill(5)}.jpg')
-		os.makedirs(os.path.dirname(path), exist_ok=True)
-		torchvision.utils.save_image(torch.cat([x.detach().cpu(), x_hat.detach().cpu()]), path,
-									 normalize=True, scale_each=True, range=(-1, 1), nrow=self.opts.batch_size)
-
-	def __get_save_dict(self):
-		save_dict = {
-			'state_dict': self.net.state_dict(),
-			'opts': vars(self.opts)
-		}
-		return save_dict

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/models/adapter.py

@@ -1,291 +0,0 @@
-# Copyright 2022 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from typing import List, Optional
-
-import torch
-import torch.nn as nn
-
-from ..configuration_utils import ConfigMixin, register_to_config
-from .modeling_utils import ModelMixin
-from .resnet import Downsample2D
-
-
-class MultiAdapter(ModelMixin):
-    r"""
-    MultiAdapter is a wrapper model that contains multiple adapter models and merges their outputs according to
-    user-assigned weighting.
-
-    This model inherits from [`ModelMixin`]. Check the superclass documentation for the generic methods the library
-    implements for all the model (such as downloading or saving, etc.)
-
-    Parameters:
-        adapters (`List[T2IAdapter]`, *optional*, defaults to None):
-            A list of `T2IAdapter` model instances.
-    """
-
-    def __init__(self, adapters: List["T2IAdapter"]):
-        super(MultiAdapter, self).__init__()
-
-        self.num_adapter = len(adapters)
-        self.adapters = nn.ModuleList(adapters)
-
-    def forward(self, xs: torch.Tensor, adapter_weights: Optional[List[float]] = None) -> List[torch.Tensor]:
-        r"""
-        Args:
-            xs (`torch.Tensor`):
-                (batch, channel, height, width) input images for multiple adapter models concated along dimension 1,
-                `channel` should equal to `num_adapter` * "number of channel of image".
-            adapter_weights (`List[float]`, *optional*, defaults to None):
-                List of floats representing the weight which will be multiply to each adapter's output before adding
-                them together.
-        """
-        if adapter_weights is None:
-            adapter_weights = torch.tensor([1 / self.num_adapter] * self.num_adapter)
-        else:
-            adapter_weights = torch.tensor(adapter_weights)
-
-        if xs.shape[1] % self.num_adapter != 0:
-            raise ValueError(
-                f"Expecting multi-adapter's input have number of channel that cab be evenly divisible "
-                f"by num_adapter: {xs.shape[1]} % {self.num_adapter} != 0"
-            )
-        x_list = torch.chunk(xs, self.num_adapter, dim=1)
-        accume_state = None
-        for x, w, adapter in zip(x_list, adapter_weights, self.adapters):
-            features = adapter(x)
-            if accume_state is None:
-                accume_state = features
-            else:
-                for i in range(len(features)):
-                    accume_state[i] += w * features[i]
-        return accume_state
-
-
-class T2IAdapter(ModelMixin, ConfigMixin):
-    r"""
-    A simple ResNet-like model that accepts images containing control signals such as keyposes and depth. The model
-    generates multiple feature maps that are used as additional conditioning in [`UNet2DConditionModel`]. The model's
-    architecture follows the original implementation of
-    [Adapter](https://github.com/TencentARC/T2I-Adapter/blob/686de4681515662c0ac2ffa07bf5dda83af1038a/ldm/modules/encoders/adapter.py#L97)
-     and
-     [AdapterLight](https://github.com/TencentARC/T2I-Adapter/blob/686de4681515662c0ac2ffa07bf5dda83af1038a/ldm/modules/encoders/adapter.py#L235).
-
-    This model inherits from [`ModelMixin`]. Check the superclass documentation for the generic methods the library
-    implements for all the model (such as downloading or saving, etc.)
-
-    Parameters:
-        in_channels (`int`, *optional*, defaults to 3):
-            Number of channels of Aapter's input(*control image*). Set this parameter to 1 if you're using gray scale
-            image as *control image*.
-        channels (`List[int]`, *optional*, defaults to `(320, 640, 1280, 1280)`):
-            The number of channel of each downsample block's output hidden state. The `len(block_out_channels)` will
-            also determine the number of downsample blocks in the Adapter.
-        num_res_blocks (`int`, *optional*, defaults to 2):
-            Number of ResNet blocks in each downsample block
-    """
-
-    @register_to_config
-    def __init__(
-        self,
-        in_channels: int = 3,
-        channels: List[int] = [320, 640, 1280, 1280],
-        num_res_blocks: int = 2,
-        downscale_factor: int = 8,
-        adapter_type: str = "full_adapter",
-    ):
-        super().__init__()
-
-        if adapter_type == "full_adapter":
-            self.adapter = FullAdapter(in_channels, channels, num_res_blocks, downscale_factor)
-        elif adapter_type == "light_adapter":
-            self.adapter = LightAdapter(in_channels, channels, num_res_blocks, downscale_factor)
-        else:
-            raise ValueError(f"unknown adapter_type: {type}. Choose either 'full_adapter' or 'simple_adapter'")
-
-    def forward(self, x: torch.Tensor) -> List[torch.Tensor]:
-        return self.adapter(x)
-
-    @property
-    def total_downscale_factor(self):
-        return self.adapter.total_downscale_factor
-
-
-# full adapter
-
-
-class FullAdapter(nn.Module):
-    def __init__(
-        self,
-        in_channels: int = 3,
-        channels: List[int] = [320, 640, 1280, 1280],
-        num_res_blocks: int = 2,
-        downscale_factor: int = 8,
-    ):
-        super().__init__()
-
-        in_channels = in_channels * downscale_factor**2
-
-        self.unshuffle = nn.PixelUnshuffle(downscale_factor)
-        self.conv_in = nn.Conv2d(in_channels, channels[0], kernel_size=3, padding=1)
-
-        self.body = nn.ModuleList(
-            [
-                AdapterBlock(channels[0], channels[0], num_res_blocks),
-                *[
-                    AdapterBlock(channels[i - 1], channels[i], num_res_blocks, down=True)
-                    for i in range(1, len(channels))
-                ],
-            ]
-        )
-
-        self.total_downscale_factor = downscale_factor * 2 ** (len(channels) - 1)
-
-    def forward(self, x: torch.Tensor) -> List[torch.Tensor]:
-        x = self.unshuffle(x)
-        x = self.conv_in(x)
-
-        features = []
-
-        for block in self.body:
-            x = block(x)
-            features.append(x)
-
-        return features
-
-
-class AdapterBlock(nn.Module):
-    def __init__(self, in_channels, out_channels, num_res_blocks, down=False):
-        super().__init__()
-
-        self.downsample = None
-        if down:
-            self.downsample = Downsample2D(in_channels)
-
-        self.in_conv = None
-        if in_channels != out_channels:
-            self.in_conv = nn.Conv2d(in_channels, out_channels, kernel_size=1)
-
-        self.resnets = nn.Sequential(
-            *[AdapterResnetBlock(out_channels) for _ in range(num_res_blocks)],
-        )
-
-    def forward(self, x):
-        if self.downsample is not None:
-            x = self.downsample(x)
-
-        if self.in_conv is not None:
-            x = self.in_conv(x)
-
-        x = self.resnets(x)
-
-        return x
-
-
-class AdapterResnetBlock(nn.Module):
-    def __init__(self, channels):
-        super().__init__()
-        self.block1 = nn.Conv2d(channels, channels, kernel_size=3, padding=1)
-        self.act = nn.ReLU()
-        self.block2 = nn.Conv2d(channels, channels, kernel_size=1)
-
-    def forward(self, x):
-        h = x
-        h = self.block1(h)
-        h = self.act(h)
-        h = self.block2(h)
-
-        return h + x
-
-
-# light adapter
-
-
-class LightAdapter(nn.Module):
-    def __init__(
-        self,
-        in_channels: int = 3,
-        channels: List[int] = [320, 640, 1280],
-        num_res_blocks: int = 4,
-        downscale_factor: int = 8,
-    ):
-        super().__init__()
-
-        in_channels = in_channels * downscale_factor**2
-
-        self.unshuffle = nn.PixelUnshuffle(downscale_factor)
-
-        self.body = nn.ModuleList(
-            [
-                LightAdapterBlock(in_channels, channels[0], num_res_blocks),
-                *[
-                    LightAdapterBlock(channels[i], channels[i + 1], num_res_blocks, down=True)
-                    for i in range(len(channels) - 1)
-                ],
-                LightAdapterBlock(channels[-1], channels[-1], num_res_blocks, down=True),
-            ]
-        )
-
-        self.total_downscale_factor = downscale_factor * (2 ** len(channels))
-
-    def forward(self, x):
-        x = self.unshuffle(x)
-
-        features = []
-
-        for block in self.body:
-            x = block(x)
-            features.append(x)
-
-        return features
-
-
-class LightAdapterBlock(nn.Module):
-    def __init__(self, in_channels, out_channels, num_res_blocks, down=False):
-        super().__init__()
-        mid_channels = out_channels // 4
-
-        self.downsample = None
-        if down:
-            self.downsample = Downsample2D(in_channels)
-
-        self.in_conv = nn.Conv2d(in_channels, mid_channels, kernel_size=1)
-        self.resnets = nn.Sequential(*[LightAdapterResnetBlock(mid_channels) for _ in range(num_res_blocks)])
-        self.out_conv = nn.Conv2d(mid_channels, out_channels, kernel_size=1)
-
-    def forward(self, x):
-        if self.downsample is not None:
-            x = self.downsample(x)
-
-        x = self.in_conv(x)
-        x = self.resnets(x)
-        x = self.out_conv(x)
-
-        return x
-
-
-class LightAdapterResnetBlock(nn.Module):
-    def __init__(self, channels):
-        super().__init__()
-        self.block1 = nn.Conv2d(channels, channels, kernel_size=3, padding=1)
-        self.act = nn.ReLU()
-        self.block2 = nn.Conv2d(channels, channels, kernel_size=3, padding=1)
-
-    def forward(self, x):
-        h = x
-        h = self.block1(h)
-        h = self.act(h)
-        h = self.block2(h)
-
-        return h + x

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

@@ -1,376 +0,0 @@
-# coding=utf-8
-# Copyright 2023 HuggingFace Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import tempfile
-import unittest
-
-import numpy as np
-
-from diffusers import (
-    DDIMScheduler,
-    DPMSolverMultistepScheduler,
-    EulerAncestralDiscreteScheduler,
-    EulerDiscreteScheduler,
-    LMSDiscreteScheduler,
-    OnnxStableDiffusionPipeline,
-    PNDMScheduler,
-)
-from diffusers.utils.testing_utils import is_onnx_available, nightly, require_onnxruntime, require_torch_gpu
-
-from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin
-
-
-if is_onnx_available():
-    import onnxruntime as ort
-
-
-class OnnxStableDiffusionPipelineFastTests(OnnxPipelineTesterMixin, unittest.TestCase):
-    hub_checkpoint = "hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline"
-
-    def get_dummy_inputs(self, seed=0):
-        generator = np.random.RandomState(seed)
-        inputs = {
-            "prompt": "A painting of a squirrel eating a burger",
-            "generator": generator,
-            "num_inference_steps": 2,
-            "guidance_scale": 7.5,
-            "output_type": "numpy",
-        }
-        return inputs
-
-    def test_pipeline_default_ddim(self):
-        pipe = OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint, provider="CPUExecutionProvider")
-        pipe.set_progress_bar_config(disable=None)
-
-        inputs = self.get_dummy_inputs()
-        image = pipe(**inputs).images
-        image_slice = image[0, -3:, -3:, -1]
-
-        assert image.shape == (1, 128, 128, 3)
-        expected_slice = np.array([0.65072, 0.58492, 0.48219, 0.55521, 0.53180, 0.55939, 0.50697, 0.39800, 0.46455])
-
-        assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-2
-
-    def test_pipeline_pndm(self):
-        pipe = OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint, provider="CPUExecutionProvider")
-        pipe.scheduler = PNDMScheduler.from_config(pipe.scheduler.config, skip_prk_steps=True)
-        pipe.set_progress_bar_config(disable=None)
-
-        inputs = self.get_dummy_inputs()
-        image = pipe(**inputs).images
-        image_slice = image[0, -3:, -3:, -1]
-
-        assert image.shape == (1, 128, 128, 3)
-        expected_slice = np.array([0.65863, 0.59425, 0.49326, 0.56313, 0.53875, 0.56627, 0.51065, 0.39777, 0.46330])
-
-        assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-2
-
-    def test_pipeline_lms(self):
-        pipe = OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint, provider="CPUExecutionProvider")
-        pipe.scheduler = LMSDiscreteScheduler.from_config(pipe.scheduler.config)
-        pipe.set_progress_bar_config(disable=None)
-
-        inputs = self.get_dummy_inputs()
-        image = pipe(**inputs).images
-        image_slice = image[0, -3:, -3:, -1]
-
-        assert image.shape == (1, 128, 128, 3)
-        expected_slice = np.array([0.53755, 0.60786, 0.47402, 0.49488, 0.51869, 0.49819, 0.47985, 0.38957, 0.44279])
-
-        assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-2
-
-    def test_pipeline_euler(self):
-        pipe = OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint, provider="CPUExecutionProvider")
-        pipe.scheduler = EulerDiscreteScheduler.from_config(pipe.scheduler.config)
-        pipe.set_progress_bar_config(disable=None)
-
-        inputs = self.get_dummy_inputs()
-        image = pipe(**inputs).images
-        image_slice = image[0, -3:, -3:, -1]
-
-        assert image.shape == (1, 128, 128, 3)
-        expected_slice = np.array([0.53755, 0.60786, 0.47402, 0.49488, 0.51869, 0.49819, 0.47985, 0.38957, 0.44279])
-
-        assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-2
-
-    def test_pipeline_euler_ancestral(self):
-        pipe = OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint, provider="CPUExecutionProvider")
-        pipe.scheduler = EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config)
-        pipe.set_progress_bar_config(disable=None)
-
-        inputs = self.get_dummy_inputs()
-        image = pipe(**inputs).images
-        image_slice = image[0, -3:, -3:, -1]
-
-        assert image.shape == (1, 128, 128, 3)
-        expected_slice = np.array([0.53817, 0.60812, 0.47384, 0.49530, 0.51894, 0.49814, 0.47984, 0.38958, 0.44271])
-
-        assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-2
-
-    def test_pipeline_dpm_multistep(self):
-        pipe = OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint, provider="CPUExecutionProvider")
-        pipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
-        pipe.set_progress_bar_config(disable=None)
-
-        inputs = self.get_dummy_inputs()
-        image = pipe(**inputs).images
-        image_slice = image[0, -3:, -3:, -1]
-
-        assert image.shape == (1, 128, 128, 3)
-        expected_slice = np.array([0.53895, 0.60808, 0.47933, 0.49608, 0.51886, 0.49950, 0.48053, 0.38957, 0.44200])
-
-        assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-2
-
-    def test_stable_diffusion_prompt_embeds(self):
-        pipe = OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint, provider="CPUExecutionProvider")
-        pipe.set_progress_bar_config(disable=None)
-
-        inputs = self.get_dummy_inputs()
-        inputs["prompt"] = 3 * [inputs["prompt"]]
-
-        # forward
-        output = pipe(**inputs)
-        image_slice_1 = output.images[0, -3:, -3:, -1]
-
-        inputs = self.get_dummy_inputs()
-        prompt = 3 * [inputs.pop("prompt")]
-
-        text_inputs = pipe.tokenizer(
-            prompt,
-            padding="max_length",
-            max_length=pipe.tokenizer.model_max_length,
-            truncation=True,
-            return_tensors="np",
-        )
-        text_inputs = text_inputs["input_ids"]
-
-        prompt_embeds = pipe.text_encoder(input_ids=text_inputs.astype(np.int32))[0]
-
-        inputs["prompt_embeds"] = prompt_embeds
-
-        # forward
-        output = pipe(**inputs)
-        image_slice_2 = output.images[0, -3:, -3:, -1]
-
-        assert np.abs(image_slice_1.flatten() - image_slice_2.flatten()).max() < 1e-4
-
-    def test_stable_diffusion_negative_prompt_embeds(self):
-        pipe = OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint, provider="CPUExecutionProvider")
-        pipe.set_progress_bar_config(disable=None)
-
-        inputs = self.get_dummy_inputs()
-        negative_prompt = 3 * ["this is a negative prompt"]
-        inputs["negative_prompt"] = negative_prompt
-        inputs["prompt"] = 3 * [inputs["prompt"]]
-
-        # forward
-        output = pipe(**inputs)
-        image_slice_1 = output.images[0, -3:, -3:, -1]
-
-        inputs = self.get_dummy_inputs()
-        prompt = 3 * [inputs.pop("prompt")]
-
-        embeds = []
-        for p in [prompt, negative_prompt]:
-            text_inputs = pipe.tokenizer(
-                p,
-                padding="max_length",
-                max_length=pipe.tokenizer.model_max_length,
-                truncation=True,
-                return_tensors="np",
-            )
-            text_inputs = text_inputs["input_ids"]
-
-            embeds.append(pipe.text_encoder(input_ids=text_inputs.astype(np.int32))[0])
-
-        inputs["prompt_embeds"], inputs["negative_prompt_embeds"] = embeds
-
-        # forward
-        output = pipe(**inputs)
-        image_slice_2 = output.images[0, -3:, -3:, -1]
-
-        assert np.abs(image_slice_1.flatten() - image_slice_2.flatten()).max() < 1e-4
-
-
-@nightly
-@require_onnxruntime
-@require_torch_gpu
-class OnnxStableDiffusionPipelineIntegrationTests(unittest.TestCase):
-    @property
-    def gpu_provider(self):
-        return (
-            "CUDAExecutionProvider",
-            {
-                "gpu_mem_limit": "15000000000",  # 15GB
-                "arena_extend_strategy": "kSameAsRequested",
-            },
-        )
-
-    @property
-    def gpu_options(self):
-        options = ort.SessionOptions()
-        options.enable_mem_pattern = False
-        return options
-
-    def test_inference_default_pndm(self):
-        # using the PNDM scheduler by default
-        sd_pipe = OnnxStableDiffusionPipeline.from_pretrained(
-            "CompVis/stable-diffusion-v1-4",
-            revision="onnx",
-            safety_checker=None,
-            feature_extractor=None,
-            provider=self.gpu_provider,
-            sess_options=self.gpu_options,
-        )
-        sd_pipe.set_progress_bar_config(disable=None)
-
-        prompt = "A painting of a squirrel eating a burger"
-        np.random.seed(0)
-        output = sd_pipe([prompt], guidance_scale=6.0, num_inference_steps=10, output_type="np")
-        image = output.images
-
-        image_slice = image[0, -3:, -3:, -1]
-
-        assert image.shape == (1, 512, 512, 3)
-        expected_slice = np.array([0.0452, 0.0390, 0.0087, 0.0350, 0.0617, 0.0364, 0.0544, 0.0523, 0.0720])
-
-        assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-3
-
-    def test_inference_ddim(self):
-        ddim_scheduler = DDIMScheduler.from_pretrained(
-            "runwayml/stable-diffusion-v1-5", subfolder="scheduler", revision="onnx"
-        )
-        sd_pipe = OnnxStableDiffusionPipeline.from_pretrained(
-            "runwayml/stable-diffusion-v1-5",
-            revision="onnx",
-            scheduler=ddim_scheduler,
-            safety_checker=None,
-            feature_extractor=None,
-            provider=self.gpu_provider,
-            sess_options=self.gpu_options,
-        )
-        sd_pipe.set_progress_bar_config(disable=None)
-
-        prompt = "open neural network exchange"
-        generator = np.random.RandomState(0)
-        output = sd_pipe([prompt], guidance_scale=7.5, num_inference_steps=10, generator=generator, output_type="np")
-        image = output.images
-        image_slice = image[0, -3:, -3:, -1]
-
-        assert image.shape == (1, 512, 512, 3)
-        expected_slice = np.array([0.2867, 0.1974, 0.1481, 0.7294, 0.7251, 0.6667, 0.4194, 0.5642, 0.6486])
-
-        assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-3
-
-    def test_inference_k_lms(self):
-        lms_scheduler = LMSDiscreteScheduler.from_pretrained(
-            "runwayml/stable-diffusion-v1-5", subfolder="scheduler", revision="onnx"
-        )
-        sd_pipe = OnnxStableDiffusionPipeline.from_pretrained(
-            "runwayml/stable-diffusion-v1-5",
-            revision="onnx",
-            scheduler=lms_scheduler,
-            safety_checker=None,
-            feature_extractor=None,
-            provider=self.gpu_provider,
-            sess_options=self.gpu_options,
-        )
-        sd_pipe.set_progress_bar_config(disable=None)
-
-        prompt = "open neural network exchange"
-        generator = np.random.RandomState(0)
-        output = sd_pipe([prompt], guidance_scale=7.5, num_inference_steps=10, generator=generator, output_type="np")
-        image = output.images
-        image_slice = image[0, -3:, -3:, -1]
-
-        assert image.shape == (1, 512, 512, 3)
-        expected_slice = np.array([0.2306, 0.1959, 0.1593, 0.6549, 0.6394, 0.5408, 0.5065, 0.6010, 0.6161])
-
-        assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-3
-
-    def test_intermediate_state(self):
-        number_of_steps = 0
-
-        def test_callback_fn(step: int, timestep: int, latents: np.ndarray) -> None:
-            test_callback_fn.has_been_called = True
-            nonlocal number_of_steps
-            number_of_steps += 1
-            if step == 0:
-                assert latents.shape == (1, 4, 64, 64)
-                latents_slice = latents[0, -3:, -3:, -1]
-                expected_slice = np.array(
-                    [-0.6772, -0.3835, -1.2456, 0.1905, -1.0974, 0.6967, -1.9353, 0.0178, 1.0167]
-                )
-
-                assert np.abs(latents_slice.flatten() - expected_slice).max() < 1e-3
-            elif step == 5:
-                assert latents.shape == (1, 4, 64, 64)
-                latents_slice = latents[0, -3:, -3:, -1]
-                expected_slice = np.array(
-                    [-0.3351, 0.2241, -0.1837, -0.2325, -0.6577, 0.3393, -0.0241, 0.5899, 1.3875]
-                )
-
-                assert np.abs(latents_slice.flatten() - expected_slice).max() < 1e-3
-
-        test_callback_fn.has_been_called = False
-
-        pipe = OnnxStableDiffusionPipeline.from_pretrained(
-            "runwayml/stable-diffusion-v1-5",
-            revision="onnx",
-            safety_checker=None,
-            feature_extractor=None,
-            provider=self.gpu_provider,
-            sess_options=self.gpu_options,
-        )
-        pipe.set_progress_bar_config(disable=None)
-
-        prompt = "Andromeda galaxy in a bottle"
-
-        generator = np.random.RandomState(0)
-        pipe(
-            prompt=prompt,
-            num_inference_steps=5,
-            guidance_scale=7.5,
-            generator=generator,
-            callback=test_callback_fn,
-            callback_steps=1,
-        )
-        assert test_callback_fn.has_been_called
-        assert number_of_steps == 6
-
-    def test_stable_diffusion_no_safety_checker(self):
-        pipe = OnnxStableDiffusionPipeline.from_pretrained(
-            "runwayml/stable-diffusion-v1-5",
-            revision="onnx",
-            safety_checker=None,
-            feature_extractor=None,
-            provider=self.gpu_provider,
-            sess_options=self.gpu_options,
-        )
-        assert isinstance(pipe, OnnxStableDiffusionPipeline)
-        assert pipe.safety_checker is None
-
-        image = pipe("example prompt", num_inference_steps=2).images[0]
-        assert image is not None
-
-        # check that there's no error when saving a pipeline with one of the models being None
-        with tempfile.TemporaryDirectory() as tmpdirname:
-            pipe.save_pretrained(tmpdirname)
-            pipe = OnnxStableDiffusionPipeline.from_pretrained(tmpdirname)
-
-        # sanity check that the pipeline still works
-        assert pipe.safety_checker is None
-        image = pipe("example prompt", num_inference_steps=2).images[0]
-        assert image is not None

spaces/Andy1621/uniformer_image_detection/configs/regnet/mask_rcnn_regnetx-6.4GF_fpn_1x_coco.py

@@ -1,16 +0,0 @@
-_base_ = './mask_rcnn_regnetx-3.2GF_fpn_1x_coco.py'
-model = dict(
-    pretrained='open-mmlab://regnetx_6.4gf',
-    backbone=dict(
-        type='RegNet',
-        arch='regnetx_6.4gf',
-        out_indices=(0, 1, 2, 3),
-        frozen_stages=1,
-        norm_cfg=dict(type='BN', requires_grad=True),
-        norm_eval=True,
-        style='pytorch'),
-    neck=dict(
-        type='FPN',
-        in_channels=[168, 392, 784, 1624],
-        out_channels=256,
-        num_outs=5))

spaces/Andy1621/uniformer_image_detection/mmdet/utils/logger.py

@@ -1,19 +0,0 @@
-import logging
-
-from mmcv.utils import get_logger
-
-
-def get_root_logger(log_file=None, log_level=logging.INFO):
-    """Get root logger.
-
-    Args:
-        log_file (str, optional): File path of log. Defaults to None.
-        log_level (int, optional): The level of logger.
-            Defaults to logging.INFO.
-
-    Returns:
-        :obj:`logging.Logger`: The obtained logger
-    """
-    logger = get_logger(name='mmdet', log_file=log_file, log_level=log_level)
-
-    return logger

spaces/Andy1621/uniformer_light/transforms.py

@@ -1,443 +0,0 @@
-import torchvision
-import random
-from PIL import Image, ImageOps
-import numpy as np
-import numbers
-import math
-import torch
-
-
-class GroupRandomCrop(object):
-    def __init__(self, size):
-        if isinstance(size, numbers.Number):
-            self.size = (int(size), int(size))
-        else:
-            self.size = size
-
-    def __call__(self, img_group):
-
-        w, h = img_group[0].size
-        th, tw = self.size
-
-        out_images = list()
-
-        x1 = random.randint(0, w - tw)
-        y1 = random.randint(0, h - th)
-
-        for img in img_group:
-            assert(img.size[0] == w and img.size[1] == h)
-            if w == tw and h == th:
-                out_images.append(img)
-            else:
-                out_images.append(img.crop((x1, y1, x1 + tw, y1 + th)))
-
-        return out_images
-
-
-class MultiGroupRandomCrop(object):
-    def __init__(self, size, groups=1):
-        if isinstance(size, numbers.Number):
-            self.size = (int(size), int(size))
-        else:
-            self.size = size
-        self.groups = groups
-
-    def __call__(self, img_group):
-
-        w, h = img_group[0].size
-        th, tw = self.size
-
-        out_images = list()
-
-        for i in range(self.groups):
-            x1 = random.randint(0, w - tw)
-            y1 = random.randint(0, h - th)
-
-            for img in img_group:
-                assert(img.size[0] == w and img.size[1] == h)
-                if w == tw and h == th:
-                    out_images.append(img)
-                else:
-                    out_images.append(img.crop((x1, y1, x1 + tw, y1 + th)))
-
-        return out_images
-
-
-class GroupCenterCrop(object):
-    def __init__(self, size):
-        self.worker = torchvision.transforms.CenterCrop(size)
-
-    def __call__(self, img_group):
-        return [self.worker(img) for img in img_group]
-
-
-class GroupRandomHorizontalFlip(object):
-    """Randomly horizontally flips the given PIL.Image with a probability of 0.5
-    """
-
-    def __init__(self, is_flow=False):
-        self.is_flow = is_flow
-
-    def __call__(self, img_group, is_flow=False):
-        v = random.random()
-        if v < 0.5:
-            ret = [img.transpose(Image.FLIP_LEFT_RIGHT) for img in img_group]
-            if self.is_flow:
-                for i in range(0, len(ret), 2):
-                    # invert flow pixel values when flipping
-                    ret[i] = ImageOps.invert(ret[i])
-            return ret
-        else:
-            return img_group
-
-
-class GroupNormalize(object):
-    def __init__(self, mean, std):
-        self.mean = mean
-        self.std = std
-
-    def __call__(self, tensor):
-        rep_mean = self.mean * (tensor.size()[0] // len(self.mean))
-        rep_std = self.std * (tensor.size()[0] // len(self.std))
-
-        # TODO: make efficient
-        for t, m, s in zip(tensor, rep_mean, rep_std):
-            t.sub_(m).div_(s)
-
-        return tensor
-
-
-class GroupScale(object):
-    """ Rescales the input PIL.Image to the given 'size'.
-    'size' will be the size of the smaller edge.
-    For example, if height > width, then image will be
-    rescaled to (size * height / width, size)
-    size: size of the smaller edge
-    interpolation: Default: PIL.Image.BILINEAR
-    """
-
-    def __init__(self, size, interpolation=Image.BILINEAR):
-        self.worker = torchvision.transforms.Resize(size, interpolation)
-
-    def __call__(self, img_group):
-        return [self.worker(img) for img in img_group]
-
-
-class GroupOverSample(object):
-    def __init__(self, crop_size, scale_size=None, flip=True):
-        self.crop_size = crop_size if not isinstance(
-            crop_size, int) else (crop_size, crop_size)
-
-        if scale_size is not None:
-            self.scale_worker = GroupScale(scale_size)
-        else:
-            self.scale_worker = None
-        self.flip = flip
-
-    def __call__(self, img_group):
-
-        if self.scale_worker is not None:
-            img_group = self.scale_worker(img_group)
-
-        image_w, image_h = img_group[0].size
-        crop_w, crop_h = self.crop_size
-
-        offsets = GroupMultiScaleCrop.fill_fix_offset(
-            False, image_w, image_h, crop_w, crop_h)
-        oversample_group = list()
-        for o_w, o_h in offsets:
-            normal_group = list()
-            flip_group = list()
-            for i, img in enumerate(img_group):
-                crop = img.crop((o_w, o_h, o_w + crop_w, o_h + crop_h))
-                normal_group.append(crop)
-                flip_crop = crop.copy().transpose(Image.FLIP_LEFT_RIGHT)
-
-                if img.mode == 'L' and i % 2 == 0:
-                    flip_group.append(ImageOps.invert(flip_crop))
-                else:
-                    flip_group.append(flip_crop)
-
-            oversample_group.extend(normal_group)
-            if self.flip:
-                oversample_group.extend(flip_group)
-        return oversample_group
-
-
-class GroupFullResSample(object):
-    def __init__(self, crop_size, scale_size=None, flip=True):
-        self.crop_size = crop_size if not isinstance(
-            crop_size, int) else (crop_size, crop_size)
-
-        if scale_size is not None:
-            self.scale_worker = GroupScale(scale_size)
-        else:
-            self.scale_worker = None
-        self.flip = flip
-
-    def __call__(self, img_group):
-
-        if self.scale_worker is not None:
-            img_group = self.scale_worker(img_group)
-
-        image_w, image_h = img_group[0].size
-        crop_w, crop_h = self.crop_size
-
-        w_step = (image_w - crop_w) // 4
-        h_step = (image_h - crop_h) // 4
-
-        offsets = list()
-        offsets.append((0 * w_step, 2 * h_step))  # left
-        offsets.append((4 * w_step, 2 * h_step))  # right
-        offsets.append((2 * w_step, 2 * h_step))  # center
-
-        oversample_group = list()
-        for o_w, o_h in offsets:
-            normal_group = list()
-            flip_group = list()
-            for i, img in enumerate(img_group):
-                crop = img.crop((o_w, o_h, o_w + crop_w, o_h + crop_h))
-                normal_group.append(crop)
-                if self.flip:
-                    flip_crop = crop.copy().transpose(Image.FLIP_LEFT_RIGHT)
-
-                    if img.mode == 'L' and i % 2 == 0:
-                        flip_group.append(ImageOps.invert(flip_crop))
-                    else:
-                        flip_group.append(flip_crop)
-
-            oversample_group.extend(normal_group)
-            oversample_group.extend(flip_group)
-        return oversample_group
-
-
-class GroupMultiScaleCrop(object):
-
-    def __init__(self, input_size, scales=None, max_distort=1,
-                 fix_crop=True, more_fix_crop=True):
-        self.scales = scales if scales is not None else [1, .875, .75, .66]
-        self.max_distort = max_distort
-        self.fix_crop = fix_crop
-        self.more_fix_crop = more_fix_crop
-        self.input_size = input_size if not isinstance(input_size, int) else [
-            input_size, input_size]
-        self.interpolation = Image.BILINEAR
-
-    def __call__(self, img_group):
-
-        im_size = img_group[0].size
-
-        crop_w, crop_h, offset_w, offset_h = self._sample_crop_size(im_size)
-        crop_img_group = [
-            img.crop(
-                (offset_w,
-                 offset_h,
-                 offset_w +
-                 crop_w,
-                 offset_h +
-                 crop_h)) for img in img_group]
-        ret_img_group = [img.resize((self.input_size[0], self.input_size[1]), self.interpolation)
-                         for img in crop_img_group]
-        return ret_img_group
-
-    def _sample_crop_size(self, im_size):
-        image_w, image_h = im_size[0], im_size[1]
-
-        # find a crop size
-        base_size = min(image_w, image_h)
-        crop_sizes = [int(base_size * x) for x in self.scales]
-        crop_h = [
-            self.input_size[1] if abs(
-                x - self.input_size[1]) < 3 else x for x in crop_sizes]
-        crop_w = [
-            self.input_size[0] if abs(
-                x - self.input_size[0]) < 3 else x for x in crop_sizes]
-
-        pairs = []
-        for i, h in enumerate(crop_h):
-            for j, w in enumerate(crop_w):
-                if abs(i - j) <= self.max_distort:
-                    pairs.append((w, h))
-
-        crop_pair = random.choice(pairs)
-        if not self.fix_crop:
-            w_offset = random.randint(0, image_w - crop_pair[0])
-            h_offset = random.randint(0, image_h - crop_pair[1])
-        else:
-            w_offset, h_offset = self._sample_fix_offset(
-                image_w, image_h, crop_pair[0], crop_pair[1])
-
-        return crop_pair[0], crop_pair[1], w_offset, h_offset
-
-    def _sample_fix_offset(self, image_w, image_h, crop_w, crop_h):
-        offsets = self.fill_fix_offset(
-            self.more_fix_crop, image_w, image_h, crop_w, crop_h)
-        return random.choice(offsets)
-
-    @staticmethod
-    def fill_fix_offset(more_fix_crop, image_w, image_h, crop_w, crop_h):
-        w_step = (image_w - crop_w) // 4
-        h_step = (image_h - crop_h) // 4
-
-        ret = list()
-        ret.append((0, 0))  # upper left
-        ret.append((4 * w_step, 0))  # upper right
-        ret.append((0, 4 * h_step))  # lower left
-        ret.append((4 * w_step, 4 * h_step))  # lower right
-        ret.append((2 * w_step, 2 * h_step))  # center
-
-        if more_fix_crop:
-            ret.append((0, 2 * h_step))  # center left
-            ret.append((4 * w_step, 2 * h_step))  # center right
-            ret.append((2 * w_step, 4 * h_step))  # lower center
-            ret.append((2 * w_step, 0 * h_step))  # upper center
-
-            ret.append((1 * w_step, 1 * h_step))  # upper left quarter
-            ret.append((3 * w_step, 1 * h_step))  # upper right quarter
-            ret.append((1 * w_step, 3 * h_step))  # lower left quarter
-            ret.append((3 * w_step, 3 * h_step))  # lower righ quarter
-
-        return ret
-
-
-class GroupRandomSizedCrop(object):
-    """Random crop the given PIL.Image to a random size of (0.08 to 1.0) of the original size
-    and and a random aspect ratio of 3/4 to 4/3 of the original aspect ratio
-    This is popularly used to train the Inception networks
-    size: size of the smaller edge
-    interpolation: Default: PIL.Image.BILINEAR
-    """
-
-    def __init__(self, size, interpolation=Image.BILINEAR):
-        self.size = size
-        self.interpolation = interpolation
-
-    def __call__(self, img_group):
-        for attempt in range(10):
-            area = img_group[0].size[0] * img_group[0].size[1]
-            target_area = random.uniform(0.08, 1.0) * area
-            aspect_ratio = random.uniform(3. / 4, 4. / 3)
-
-            w = int(round(math.sqrt(target_area * aspect_ratio)))
-            h = int(round(math.sqrt(target_area / aspect_ratio)))
-
-            if random.random() < 0.5:
-                w, h = h, w
-
-            if w <= img_group[0].size[0] and h <= img_group[0].size[1]:
-                x1 = random.randint(0, img_group[0].size[0] - w)
-                y1 = random.randint(0, img_group[0].size[1] - h)
-                found = True
-                break
-        else:
-            found = False
-            x1 = 0
-            y1 = 0
-
-        if found:
-            out_group = list()
-            for img in img_group:
-                img = img.crop((x1, y1, x1 + w, y1 + h))
-                assert(img.size == (w, h))
-                out_group.append(
-                    img.resize(
-                        (self.size, self.size), self.interpolation))
-            return out_group
-        else:
-            # Fallback
-            scale = GroupScale(self.size, interpolation=self.interpolation)
-            crop = GroupRandomCrop(self.size)
-            return crop(scale(img_group))
-
-
-class ConvertDataFormat(object):
-    def __init__(self, model_type):
-        self.model_type = model_type
-
-    def __call__(self, images):
-        if self.model_type == '2D':
-            return images
-        tc, h, w = images.size()
-        t = tc // 3
-        images = images.view(t, 3, h, w)
-        images = images.permute(1, 0, 2, 3)
-        return images
-
-
-class Stack(object):
-
-    def __init__(self, roll=False):
-        self.roll = roll
-
-    def __call__(self, img_group):
-        if img_group[0].mode == 'L':
-            return np.concatenate([np.expand_dims(x, 2)
-                                   for x in img_group], axis=2)
-        elif img_group[0].mode == 'RGB':
-            if self.roll:
-                return np.concatenate([np.array(x)[:, :, ::-1]
-                                       for x in img_group], axis=2)
-            else:
-                #print(np.concatenate(img_group, axis=2).shape)
-                # print(img_group[0].shape)
-                return np.concatenate(img_group, axis=2)
-
-
-class ToTorchFormatTensor(object):
-    """ Converts a PIL.Image (RGB) or numpy.ndarray (H x W x C) in the range [0, 255]
-    to a torch.FloatTensor of shape (C x H x W) in the range [0.0, 1.0] """
-
-    def __init__(self, div=True):
-        self.div = div
-
-    def __call__(self, pic):
-        if isinstance(pic, np.ndarray):
-            # handle numpy array
-            img = torch.from_numpy(pic).permute(2, 0, 1).contiguous()
-        else:
-            # handle PIL Image
-            img = torch.ByteTensor(
-                torch.ByteStorage.from_buffer(
-                    pic.tobytes()))
-            img = img.view(pic.size[1], pic.size[0], len(pic.mode))
-            # put it from HWC to CHW format
-            # yikes, this transpose takes 80% of the loading time/CPU
-            img = img.transpose(0, 1).transpose(0, 2).contiguous()
-        return img.float().div(255) if self.div else img.float()
-
-
-class IdentityTransform(object):
-
-    def __call__(self, data):
-        return data
-
-
-if __name__ == "__main__":
-    trans = torchvision.transforms.Compose([
-        GroupScale(256),
-        GroupRandomCrop(224),
-        Stack(),
-        ToTorchFormatTensor(),
-        GroupNormalize(
-            mean=[.485, .456, .406],
-            std=[.229, .224, .225]
-        )]
-    )
-
-    im = Image.open('../tensorflow-model-zoo.torch/lena_299.png')
-
-    color_group = [im] * 3
-    rst = trans(color_group)
-
-    gray_group = [im.convert('L')] * 9
-    gray_rst = trans(gray_group)
-
-    trans2 = torchvision.transforms.Compose([
-        GroupRandomSizedCrop(256),
-        Stack(),
-        ToTorchFormatTensor(),
-        GroupNormalize(
-            mean=[.485, .456, .406],
-            std=[.229, .224, .225])
-    ])
-    print(trans2(color_group))

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

@@ -1,75 +0,0 @@
-import os
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-from transformers import BertModel, BertConfig, BertTokenizer
-
-
-class CharEmbedding(nn.Module):
-    def __init__(self, model_dir):
-        super().__init__()
-        self.tokenizer = BertTokenizer.from_pretrained(model_dir)
-        self.bert_config = BertConfig.from_pretrained(model_dir)
-        self.hidden_size = self.bert_config.hidden_size
-        self.bert = BertModel(self.bert_config)
-        self.proj = nn.Linear(self.hidden_size, 256)
-        self.linear = nn.Linear(256, 3)
-
-    def text2Token(self, text):
-        token = self.tokenizer.tokenize(text)
-        txtid = self.tokenizer.convert_tokens_to_ids(token)
-        return txtid
-
-    def forward(self, inputs_ids, inputs_masks, tokens_type_ids):
-        out_seq = self.bert(input_ids=inputs_ids,
-                            attention_mask=inputs_masks,
-                            token_type_ids=tokens_type_ids)[0]
-        out_seq = self.proj(out_seq)
-        return out_seq
-
-
-class TTSProsody(object):
-    def __init__(self, path, device):
-        self.device = device
-        self.char_model = CharEmbedding(path)
-        self.char_model.load_state_dict(
-            torch.load(
-                os.path.join(path, 'prosody_model.pt'),
-                map_location="cpu"
-            ),
-            strict=False
-        )
-        self.char_model.eval()
-        self.char_model.to(self.device)
-
-    def get_char_embeds(self, text):
-        input_ids = self.char_model.text2Token(text)
-        input_masks = [1] * len(input_ids)
-        type_ids = [0] * len(input_ids)
-        input_ids = torch.LongTensor([input_ids]).to(self.device)
-        input_masks = torch.LongTensor([input_masks]).to(self.device)
-        type_ids = torch.LongTensor([type_ids]).to(self.device)
-
-        with torch.no_grad():
-            char_embeds = self.char_model(
-                input_ids, input_masks, type_ids).squeeze(0).cpu()
-        return char_embeds
-
-    def expand_for_phone(self, char_embeds, length):  # length of phones for char
-        assert char_embeds.size(0) == len(length)
-        expand_vecs = list()
-        for vec, leng in zip(char_embeds, length):
-            vec = vec.expand(leng, -1)
-            expand_vecs.append(vec)
-        expand_embeds = torch.cat(expand_vecs, 0)
-        assert expand_embeds.size(0) == sum(length)
-        return expand_embeds.numpy()
-
-
-if __name__ == "__main__":
-    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    prosody = TTSProsody('./bert/', device)
-    while True:
-        text = input("请输入文本：")
-        prosody.get_char_embeds(text)

spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/resolvelib/compat/collections_abc.py

@@ -1,6 +0,0 @@
-__all__ = ["Mapping", "Sequence"]
-
-try:
-    from collections.abc import Mapping, Sequence
-except ImportError:
-    from collections import Mapping, Sequence

spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/setuptools/_distutils/file_util.py

@@ -1,249 +0,0 @@
-"""distutils.file_util
-
-Utility functions for operating on single files.
-"""
-
-import os
-from distutils.errors import DistutilsFileError
-from distutils import log
-
-# for generating verbose output in 'copy_file()'
-_copy_action = {None: 'copying', 'hard': 'hard linking', 'sym': 'symbolically linking'}
-
-
-def _copy_file_contents(src, dst, buffer_size=16 * 1024):  # noqa: C901
-    """Copy the file 'src' to 'dst'; both must be filenames.  Any error
-    opening either file, reading from 'src', or writing to 'dst', raises
-    DistutilsFileError.  Data is read/written in chunks of 'buffer_size'
-    bytes (default 16k).  No attempt is made to handle anything apart from
-    regular files.
-    """
-    # Stolen from shutil module in the standard library, but with
-    # custom error-handling added.
-    fsrc = None
-    fdst = None
-    try:
-        try:
-            fsrc = open(src, 'rb')
-        except OSError as e:
-            raise DistutilsFileError("could not open '{}': {}".format(src, e.strerror))
-
-        if os.path.exists(dst):
-            try:
-                os.unlink(dst)
-            except OSError as e:
-                raise DistutilsFileError(
-                    "could not delete '{}': {}".format(dst, e.strerror)
-                )
-
-        try:
-            fdst = open(dst, 'wb')
-        except OSError as e:
-            raise DistutilsFileError(
-                "could not create '{}': {}".format(dst, e.strerror)
-            )
-
-        while True:
-            try:
-                buf = fsrc.read(buffer_size)
-            except OSError as e:
-                raise DistutilsFileError(
-                    "could not read from '{}': {}".format(src, e.strerror)
-                )
-
-            if not buf:
-                break
-
-            try:
-                fdst.write(buf)
-            except OSError as e:
-                raise DistutilsFileError(
-                    "could not write to '{}': {}".format(dst, e.strerror)
-                )
-    finally:
-        if fdst:
-            fdst.close()
-        if fsrc:
-            fsrc.close()
-
-
-def copy_file(  # noqa: C901
-    src,
-    dst,
-    preserve_mode=1,
-    preserve_times=1,
-    update=0,
-    link=None,
-    verbose=1,
-    dry_run=0,
-):
-    """Copy a file 'src' to 'dst'.  If 'dst' is a directory, then 'src' is
-    copied there with the same name; otherwise, it must be a filename.  (If
-    the file exists, it will be ruthlessly clobbered.)  If 'preserve_mode'
-    is true (the default), the file's mode (type and permission bits, or
-    whatever is analogous on the current platform) is copied.  If
-    'preserve_times' is true (the default), the last-modified and
-    last-access times are copied as well.  If 'update' is true, 'src' will
-    only be copied if 'dst' does not exist, or if 'dst' does exist but is
-    older than 'src'.
-
-    'link' allows you to make hard links (os.link) or symbolic links
-    (os.symlink) instead of copying: set it to "hard" or "sym"; if it is
-    None (the default), files are copied.  Don't set 'link' on systems that
-    don't support it: 'copy_file()' doesn't check if hard or symbolic
-    linking is available. If hardlink fails, falls back to
-    _copy_file_contents().
-
-    Under Mac OS, uses the native file copy function in macostools; on
-    other systems, uses '_copy_file_contents()' to copy file contents.
-
-    Return a tuple (dest_name, copied): 'dest_name' is the actual name of
-    the output file, and 'copied' is true if the file was copied (or would
-    have been copied, if 'dry_run' true).
-    """
-    # XXX if the destination file already exists, we clobber it if
-    # copying, but blow up if linking.  Hmmm.  And I don't know what
-    # macostools.copyfile() does.  Should definitely be consistent, and
-    # should probably blow up if destination exists and we would be
-    # changing it (ie. it's not already a hard/soft link to src OR
-    # (not update) and (src newer than dst).
-
-    from distutils.dep_util import newer
-    from stat import ST_ATIME, ST_MTIME, ST_MODE, S_IMODE
-
-    if not os.path.isfile(src):
-        raise DistutilsFileError(
-            "can't copy '%s': doesn't exist or not a regular file" % src
-        )
-
-    if os.path.isdir(dst):
-        dir = dst
-        dst = os.path.join(dst, os.path.basename(src))
-    else:
-        dir = os.path.dirname(dst)
-
-    if update and not newer(src, dst):
-        if verbose >= 1:
-            log.debug("not copying %s (output up-to-date)", src)
-        return (dst, 0)
-
-    try:
-        action = _copy_action[link]
-    except KeyError:
-        raise ValueError("invalid value '%s' for 'link' argument" % link)
-
-    if verbose >= 1:
-        if os.path.basename(dst) == os.path.basename(src):
-            log.info("%s %s -> %s", action, src, dir)
-        else:
-            log.info("%s %s -> %s", action, src, dst)
-
-    if dry_run:
-        return (dst, 1)
-
-    # If linking (hard or symbolic), use the appropriate system call
-    # (Unix only, of course, but that's the caller's responsibility)
-    elif link == 'hard':
-        if not (os.path.exists(dst) and os.path.samefile(src, dst)):
-            try:
-                os.link(src, dst)
-                return (dst, 1)
-            except OSError:
-                # If hard linking fails, fall back on copying file
-                # (some special filesystems don't support hard linking
-                #  even under Unix, see issue #8876).
-                pass
-    elif link == 'sym':
-        if not (os.path.exists(dst) and os.path.samefile(src, dst)):
-            os.symlink(src, dst)
-            return (dst, 1)
-
-    # Otherwise (non-Mac, not linking), copy the file contents and
-    # (optionally) copy the times and mode.
-    _copy_file_contents(src, dst)
-    if preserve_mode or preserve_times:
-        st = os.stat(src)
-
-        # According to David Ascher <[email protected]>, utime() should be done
-        # before chmod() (at least under NT).
-        if preserve_times:
-            os.utime(dst, (st[ST_ATIME], st[ST_MTIME]))
-        if preserve_mode:
-            os.chmod(dst, S_IMODE(st[ST_MODE]))
-
-    return (dst, 1)
-
-
-# XXX I suspect this is Unix-specific -- need porting help!
-def move_file(src, dst, verbose=1, dry_run=0):  # noqa: C901
-
-    """Move a file 'src' to 'dst'.  If 'dst' is a directory, the file will
-    be moved into it with the same name; otherwise, 'src' is just renamed
-    to 'dst'.  Return the new full name of the file.
-
-    Handles cross-device moves on Unix using 'copy_file()'.  What about
-    other systems???
-    """
-    from os.path import exists, isfile, isdir, basename, dirname
-    import errno
-
-    if verbose >= 1:
-        log.info("moving %s -> %s", src, dst)
-
-    if dry_run:
-        return dst
-
-    if not isfile(src):
-        raise DistutilsFileError("can't move '%s': not a regular file" % src)
-
-    if isdir(dst):
-        dst = os.path.join(dst, basename(src))
-    elif exists(dst):
-        raise DistutilsFileError(
-            "can't move '{}': destination '{}' already exists".format(src, dst)
-        )
-
-    if not isdir(dirname(dst)):
-        raise DistutilsFileError(
-            "can't move '{}': destination '{}' not a valid path".format(src, dst)
-        )
-
-    copy_it = False
-    try:
-        os.rename(src, dst)
-    except OSError as e:
-        (num, msg) = e.args
-        if num == errno.EXDEV:
-            copy_it = True
-        else:
-            raise DistutilsFileError(
-                "couldn't move '{}' to '{}': {}".format(src, dst, msg)
-            )
-
-    if copy_it:
-        copy_file(src, dst, verbose=verbose)
-        try:
-            os.unlink(src)
-        except OSError as e:
-            (num, msg) = e.args
-            try:
-                os.unlink(dst)
-            except OSError:
-                pass
-            raise DistutilsFileError(
-                "couldn't move '%s' to '%s' by copy/delete: "
-                "delete '%s' failed: %s" % (src, dst, src, msg)
-            )
-    return dst
-
-
-def write_file(filename, contents):
-    """Create a file with the specified name and write 'contents' (a
-    sequence of strings without line terminators) to it.
-    """
-    f = open(filename, "w")
-    try:
-        for line in contents:
-            f.write(line + "\n")
-    finally:
-        f.close()

spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/setuptools/_distutils/filelist.py

@@ -1,371 +0,0 @@
-"""distutils.filelist
-
-Provides the FileList class, used for poking about the filesystem
-and building lists of files.
-"""
-
-import os
-import re
-import fnmatch
-import functools
-
-from distutils.util import convert_path
-from distutils.errors import DistutilsTemplateError, DistutilsInternalError
-from distutils import log
-
-
-class FileList:
-    """A list of files built by on exploring the filesystem and filtered by
-    applying various patterns to what we find there.
-
-    Instance attributes:
-      dir
-        directory from which files will be taken -- only used if
-        'allfiles' not supplied to constructor
-      files
-        list of filenames currently being built/filtered/manipulated
-      allfiles
-        complete list of files under consideration (ie. without any
-        filtering applied)
-    """
-
-    def __init__(self, warn=None, debug_print=None):
-        # ignore argument to FileList, but keep them for backwards
-        # compatibility
-        self.allfiles = None
-        self.files = []
-
-    def set_allfiles(self, allfiles):
-        self.allfiles = allfiles
-
-    def findall(self, dir=os.curdir):
-        self.allfiles = findall(dir)
-
-    def debug_print(self, msg):
-        """Print 'msg' to stdout if the global DEBUG (taken from the
-        DISTUTILS_DEBUG environment variable) flag is true.
-        """
-        from distutils.debug import DEBUG
-
-        if DEBUG:
-            print(msg)
-
-    # Collection methods
-
-    def append(self, item):
-        self.files.append(item)
-
-    def extend(self, items):
-        self.files.extend(items)
-
-    def sort(self):
-        # Not a strict lexical sort!
-        sortable_files = sorted(map(os.path.split, self.files))
-        self.files = []
-        for sort_tuple in sortable_files:
-            self.files.append(os.path.join(*sort_tuple))
-
-    # Other miscellaneous utility methods
-
-    def remove_duplicates(self):
-        # Assumes list has been sorted!
-        for i in range(len(self.files) - 1, 0, -1):
-            if self.files[i] == self.files[i - 1]:
-                del self.files[i]
-
-    # "File template" methods
-
-    def _parse_template_line(self, line):
-        words = line.split()
-        action = words[0]
-
-        patterns = dir = dir_pattern = None
-
-        if action in ('include', 'exclude', 'global-include', 'global-exclude'):
-            if len(words) < 2:
-                raise DistutilsTemplateError(
-                    "'%s' expects <pattern1> <pattern2> ..." % action
-                )
-            patterns = [convert_path(w) for w in words[1:]]
-        elif action in ('recursive-include', 'recursive-exclude'):
-            if len(words) < 3:
-                raise DistutilsTemplateError(
-                    "'%s' expects <dir> <pattern1> <pattern2> ..." % action
-                )
-            dir = convert_path(words[1])
-            patterns = [convert_path(w) for w in words[2:]]
-        elif action in ('graft', 'prune'):
-            if len(words) != 2:
-                raise DistutilsTemplateError(
-                    "'%s' expects a single <dir_pattern>" % action
-                )
-            dir_pattern = convert_path(words[1])
-        else:
-            raise DistutilsTemplateError("unknown action '%s'" % action)
-
-        return (action, patterns, dir, dir_pattern)
-
-    def process_template_line(self, line):  # noqa: C901
-        # Parse the line: split it up, make sure the right number of words
-        # is there, and return the relevant words.  'action' is always
-        # defined: it's the first word of the line.  Which of the other
-        # three are defined depends on the action; it'll be either
-        # patterns, (dir and patterns), or (dir_pattern).
-        (action, patterns, dir, dir_pattern) = self._parse_template_line(line)
-
-        # OK, now we know that the action is valid and we have the
-        # right number of words on the line for that action -- so we
-        # can proceed with minimal error-checking.
-        if action == 'include':
-            self.debug_print("include " + ' '.join(patterns))
-            for pattern in patterns:
-                if not self.include_pattern(pattern, anchor=1):
-                    log.warn("warning: no files found matching '%s'", pattern)
-
-        elif action == 'exclude':
-            self.debug_print("exclude " + ' '.join(patterns))
-            for pattern in patterns:
-                if not self.exclude_pattern(pattern, anchor=1):
-                    log.warn(
-                        (
-                            "warning: no previously-included files "
-                            "found matching '%s'"
-                        ),
-                        pattern,
-                    )
-
-        elif action == 'global-include':
-            self.debug_print("global-include " + ' '.join(patterns))
-            for pattern in patterns:
-                if not self.include_pattern(pattern, anchor=0):
-                    log.warn(
-                        (
-                            "warning: no files found matching '%s' "
-                            "anywhere in distribution"
-                        ),
-                        pattern,
-                    )
-
-        elif action == 'global-exclude':
-            self.debug_print("global-exclude " + ' '.join(patterns))
-            for pattern in patterns:
-                if not self.exclude_pattern(pattern, anchor=0):
-                    log.warn(
-                        (
-                            "warning: no previously-included files matching "
-                            "'%s' found anywhere in distribution"
-                        ),
-                        pattern,
-                    )
-
-        elif action == 'recursive-include':
-            self.debug_print("recursive-include {} {}".format(dir, ' '.join(patterns)))
-            for pattern in patterns:
-                if not self.include_pattern(pattern, prefix=dir):
-                    msg = (
-                        "warning: no files found matching '%s' " "under directory '%s'"
-                    )
-                    log.warn(msg, pattern, dir)
-
-        elif action == 'recursive-exclude':
-            self.debug_print("recursive-exclude {} {}".format(dir, ' '.join(patterns)))
-            for pattern in patterns:
-                if not self.exclude_pattern(pattern, prefix=dir):
-                    log.warn(
-                        (
-                            "warning: no previously-included files matching "
-                            "'%s' found under directory '%s'"
-                        ),
-                        pattern,
-                        dir,
-                    )
-
-        elif action == 'graft':
-            self.debug_print("graft " + dir_pattern)
-            if not self.include_pattern(None, prefix=dir_pattern):
-                log.warn("warning: no directories found matching '%s'", dir_pattern)
-
-        elif action == 'prune':
-            self.debug_print("prune " + dir_pattern)
-            if not self.exclude_pattern(None, prefix=dir_pattern):
-                log.warn(
-                    ("no previously-included directories found " "matching '%s'"),
-                    dir_pattern,
-                )
-        else:
-            raise DistutilsInternalError(
-                "this cannot happen: invalid action '%s'" % action
-            )
-
-    # Filtering/selection methods
-
-    def include_pattern(self, pattern, anchor=1, prefix=None, is_regex=0):
-        """Select strings (presumably filenames) from 'self.files' that
-        match 'pattern', a Unix-style wildcard (glob) pattern.  Patterns
-        are not quite the same as implemented by the 'fnmatch' module: '*'
-        and '?'  match non-special characters, where "special" is platform-
-        dependent: slash on Unix; colon, slash, and backslash on
-        DOS/Windows; and colon on Mac OS.
-
-        If 'anchor' is true (the default), then the pattern match is more
-        stringent: "*.py" will match "foo.py" but not "foo/bar.py".  If
-        'anchor' is false, both of these will match.
-
-        If 'prefix' is supplied, then only filenames starting with 'prefix'
-        (itself a pattern) and ending with 'pattern', with anything in between
-        them, will match.  'anchor' is ignored in this case.
-
-        If 'is_regex' is true, 'anchor' and 'prefix' are ignored, and
-        'pattern' is assumed to be either a string containing a regex or a
-        regex object -- no translation is done, the regex is just compiled
-        and used as-is.
-
-        Selected strings will be added to self.files.
-
-        Return True if files are found, False otherwise.
-        """
-        # XXX docstring lying about what the special chars are?
-        files_found = False
-        pattern_re = translate_pattern(pattern, anchor, prefix, is_regex)
-        self.debug_print("include_pattern: applying regex r'%s'" % pattern_re.pattern)
-
-        # delayed loading of allfiles list
-        if self.allfiles is None:
-            self.findall()
-
-        for name in self.allfiles:
-            if pattern_re.search(name):
-                self.debug_print(" adding " + name)
-                self.files.append(name)
-                files_found = True
-        return files_found
-
-    def exclude_pattern(self, pattern, anchor=1, prefix=None, is_regex=0):
-        """Remove strings (presumably filenames) from 'files' that match
-        'pattern'.  Other parameters are the same as for
-        'include_pattern()', above.
-        The list 'self.files' is modified in place.
-        Return True if files are found, False otherwise.
-        """
-        files_found = False
-        pattern_re = translate_pattern(pattern, anchor, prefix, is_regex)
-        self.debug_print("exclude_pattern: applying regex r'%s'" % pattern_re.pattern)
-        for i in range(len(self.files) - 1, -1, -1):
-            if pattern_re.search(self.files[i]):
-                self.debug_print(" removing " + self.files[i])
-                del self.files[i]
-                files_found = True
-        return files_found
-
-
-# Utility functions
-
-
-def _find_all_simple(path):
-    """
-    Find all files under 'path'
-    """
-    all_unique = _UniqueDirs.filter(os.walk(path, followlinks=True))
-    results = (
-        os.path.join(base, file) for base, dirs, files in all_unique for file in files
-    )
-    return filter(os.path.isfile, results)
-
-
-class _UniqueDirs(set):
-    """
-    Exclude previously-seen dirs from walk results,
-    avoiding infinite recursion.
-    Ref https://bugs.python.org/issue44497.
-    """
-
-    def __call__(self, walk_item):
-        """
-        Given an item from an os.walk result, determine
-        if the item represents a unique dir for this instance
-        and if not, prevent further traversal.
-        """
-        base, dirs, files = walk_item
-        stat = os.stat(base)
-        candidate = stat.st_dev, stat.st_ino
-        found = candidate in self
-        if found:
-            del dirs[:]
-        self.add(candidate)
-        return not found
-
-    @classmethod
-    def filter(cls, items):
-        return filter(cls(), items)
-
-
-def findall(dir=os.curdir):
-    """
-    Find all files under 'dir' and return the list of full filenames.
-    Unless dir is '.', return full filenames with dir prepended.
-    """
-    files = _find_all_simple(dir)
-    if dir == os.curdir:
-        make_rel = functools.partial(os.path.relpath, start=dir)
-        files = map(make_rel, files)
-    return list(files)
-
-
-def glob_to_re(pattern):
-    """Translate a shell-like glob pattern to a regular expression; return
-    a string containing the regex.  Differs from 'fnmatch.translate()' in
-    that '*' does not match "special characters" (which are
-    platform-specific).
-    """
-    pattern_re = fnmatch.translate(pattern)
-
-    # '?' and '*' in the glob pattern become '.' and '.*' in the RE, which
-    # IMHO is wrong -- '?' and '*' aren't supposed to match slash in Unix,
-    # and by extension they shouldn't match such "special characters" under
-    # any OS.  So change all non-escaped dots in the RE to match any
-    # character except the special characters (currently: just os.sep).
-    sep = os.sep
-    if os.sep == '\\':
-        # we're using a regex to manipulate a regex, so we need
-        # to escape the backslash twice
-        sep = r'\\\\'
-    escaped = r'\1[^%s]' % sep
-    pattern_re = re.sub(r'((?<!\\)(\\\\)*)\.', escaped, pattern_re)
-    return pattern_re
-
-
-def translate_pattern(pattern, anchor=1, prefix=None, is_regex=0):
-    """Translate a shell-like wildcard pattern to a compiled regular
-    expression.  Return the compiled regex.  If 'is_regex' true,
-    then 'pattern' is directly compiled to a regex (if it's a string)
-    or just returned as-is (assumes it's a regex object).
-    """
-    if is_regex:
-        if isinstance(pattern, str):
-            return re.compile(pattern)
-        else:
-            return pattern
-
-    # ditch start and end characters
-    start, _, end = glob_to_re('_').partition('_')
-
-    if pattern:
-        pattern_re = glob_to_re(pattern)
-        assert pattern_re.startswith(start) and pattern_re.endswith(end)
-    else:
-        pattern_re = ''
-
-    if prefix is not None:
-        prefix_re = glob_to_re(prefix)
-        assert prefix_re.startswith(start) and prefix_re.endswith(end)
-        prefix_re = prefix_re[len(start) : len(prefix_re) - len(end)]
-        sep = os.sep
-        if os.sep == '\\':
-            sep = r'\\'
-        pattern_re = pattern_re[len(start) : len(pattern_re) - len(end)]
-        pattern_re = r'{}\A{}{}.*{}{}'.format(start, prefix_re, sep, pattern_re, end)
-    else:  # no prefix -- respect anchor flag
-        if anchor:
-            pattern_re = r'{}\A{}'.format(start, pattern_re[len(start) :])
-
-    return re.compile(pattern_re)

spaces/Awesimo/jojogan/e4e/datasets/inference_dataset.py

@@ -1,25 +0,0 @@
-from torch.utils.data import Dataset
-from PIL import Image
-from utils import data_utils
-
-
-class InferenceDataset(Dataset):
-
-	def __init__(self, root, opts, transform=None, preprocess=None):
-		self.paths = sorted(data_utils.make_dataset(root))
-		self.transform = transform
-		self.preprocess = preprocess
-		self.opts = opts
-
-	def __len__(self):
-		return len(self.paths)
-
-	def __getitem__(self, index):
-		from_path = self.paths[index]
-		if self.preprocess is not None:
-			from_im = self.preprocess(from_path)
-		else:
-			from_im = Image.open(from_path).convert('RGB')
-		if self.transform:
-			from_im = self.transform(from_im)
-		return from_im

spaces/Benson/text-generation/Examples/Asesinato En Los Alpes Mod Apk An1.md

@@ -1,68 +0,0 @@
-<br />
-<h1>Asesinato en los Alpes Mod APK: Un juego de misterio oculto para Android</h1>
-<p>Si eres un fan de los juegos de misterio, aventura y romance, es posible que quieras echar un vistazo a <strong>Murder in the Alps</strong>, un juego de objetos ocultos que te llevará de vuelta a la década de 1930 en un hotel remoto en los Alpes. Actuarás como Anna Myers, una periodista que está investigando una serie de misteriosos asesinatos que ocurren en el hotel. Tendrás que explorar las escenas, encontrar pistas, resolver puzzles, interactuar con otros personajes y tomar decisiones que afecten el resultado de la historia. </p>
-<h2>asesinato en los Alpes mod apk an1</h2><br /><p><b><b>Download</b> &#10042; <a href="https://bltlly.com/2v6K3n">https://bltlly.com/2v6K3n</a></b></p><br /><br />
-<p>Pero lo que si quieres disfrutar del juego sin limitaciones o interrupciones? Ahí es donde <strong>Asesinato en los Alpes Mod APK</strong> entra en. Un apk mod es una versión modificada de una aplicación original que tiene algunas características añadidas o eliminadas para mejorar la experiencia del usuario. En este caso, Asesinato en los Alpes Mod APK tiene energía ilimitada, todos los capítulos desbloqueados, y no hay anuncios, por lo que puede jugar el juego tanto como quieras sin gastar dinero o esperar a que la energía para rellenar. </p>
-<p>Una de las fuentes donde se puede descargar Asesinato en los Alpes Mod APK es <strong>an1.co.in</strong>, un sitio web que proporciona apks mod gratis para varios juegos de Android. Usted puede encontrar asesinato en los Alpes Mod APK en este sitio web junto con otra información, tales como características, requisitos, pasos de instalación, capturas de pantalla, y comentarios. </p>
-<h2>Características de Asesinato en los Alpes Mod APK</h2>
-<p>Asesinato en los Alpes Mod APK tiene algunas características que lo hacen diferente del juego original. Estos son algunos de ellos:</p>
-<p></p>
-<h3>Energía ilimitada</h3>
-<p>En el juego original, necesitas energía para jugar cada escena. La energía se llena con el tiempo o viendo anuncios o comprándolo con dinero real. Sin embargo, con Asesinato en los Alpes Mod APK, usted no tiene que preocuparse por la energía en absoluto. Puedes reproducir tantas escenas como quieras sin ninguna restricción. </p>
-<h3>Todos los capítulos desbloqueados</h3>
-
-<h3>No hay anuncios</h3>
-<p>El juego original tiene anuncios que aparecen de vez en cuando o cuando quieres obtener energía adicional o sugerencias. Los anuncios pueden ser molestos y distraer cuando estás inmerso en el juego. Sin embargo, con Asesinato en los Alpes Mod APK, no tienes que ver ningún anuncio en absoluto. Puedes disfrutar del juego sin interrupciones. </p>
-<h2>Cómo descargar e instalar Asesinato en los Alpes Mod APK</h2>
-<p>Si desea probar Asesinato en los Alpes Mod APK, es necesario seguir estos pasos:</p>
-<h3>Requisitos</h3>
-<ul>
-<li>Un dispositivo Android con la versión 4.4 o superior</li>
-<li>Al menos 111 MB de espacio de almacenamiento libre</li>
-<li>Una conexión a Internet estable</li>
-<li>Permitir la instalación de fuentes desconocidas en la configuración del dispositivo</li>
-</ul>
-<h3>Pasos</h3>
-<ol>
-<li>Ir a <a href=">an1.co.in</a> y buscar Asesinato en los Alpes Mod APK</li>
-<li>Haga clic en el botón de descarga y espere a que el archivo se descargue</li>
-<li>Busque el archivo descargado en el administrador de archivos de su dispositivo y toque en él para instalarlo</li>
-<li>Iniciar el juego y disfrutar! </li>
-</ol>
-<h2>Cómo jugar Asesinato en los Alpes</h2>
-<p>Murder in the Alps es un juego de objetos ocultos que requiere que uses tus habilidades de observación, lógica y deducción para resolver el misterio. Aquí hay algunos consejos sobre cómo jugar el juego:</p>
-<h3>Elige tu personaje y la historia</h3>
-<p>Puedes elegir entre dos personajes: Anna Myers o Frank Miller. Cada personaje tiene una perspectiva y personalidad diferentes. También puede elegir entre seis historias: The Providence Express, The Heir, The Murder of Mrs. Miller, The Alchemist, The Curse of the Ancient One y The Final Showdown. Cada historia tiene una trama, un escenario y personajes diferentes. </p>
-<h3>Explora las escenas y encuentra pistas</h3>
-
-<h3>Resuelve puzzles y minijuegos</h3>
-<p>Además de encontrar pistas, también tendrás que resolver puzzles y minijuegos que desafiarán tu cerebro. Algunos rompecabezas requieren que uses habilidades de lógica, matemáticas o memoria, mientras que otros requieren que uses tus reflejos o coordinación. Puedes saltarte los puzzles si los encuentras demasiado difíciles o usar pistas si necesitas ayuda. </p>
-<h3>Interactuar con otros personajes y tomar decisiones</h3>
-<p>Encontrarás varios personajes en el juego, algunos de ellos amistosos, algunos de ellos sospechosos, y algunos de ellos peligrosos. Puedes hablar con ellos y aprender más sobre sus antecedentes, motivos y secretos. También puede tomar decisiones que afectarán el curso de la historia y las relaciones con otros personajes. Sin embargo, tenga cuidado, ya que algunas opciones pueden tener consecuencias más tarde. </p>
-<h2>Pros y contras de asesinato en los Alpes Mod APK</h2>
-<p>Asesinato en los Alpes Mod APK tiene algunas ventajas y desventajas que usted debe considerar antes de descargarlo. Aquí están algunos de ellos:</p>
-<h3>Pros</h3>
-<ul>
-<li><h4>Historia inmersiva y cautivadora</h4><p>El asesinato en los Alpes tiene una historia bien escrita y atractiva que te mantendrá enganchado hasta el final. Sentirás que eres parte de una novela clásica de detectives con giros y vueltas, suspense y romance, humor y drama. </p></li>
-<li><h4>Hermosos gráficos y efectos de sonido</h4><p>Murder in the Alps tiene gráficos impresionantes que te transportarán a la década de 1930 en los Alpes. Admirará las escenas realistas y detalladas, los personajes coloridos y expresivos, y la iluminación atmosférica y las sombras. También disfrutarás de los efectos de sonido auténticos que mejorarán tu inmersión en el juego. </p></li>
-
-</ul>
-<h3>Contras</h3>
-<ul>
-<li><h4>No es compatible con algunos dispositivos</h4><p>Asesinato en los Alpes Mod APK puede no funcionar correctamente en algunos dispositivos debido a diferentes especificaciones o problemas de compatibilidad. Puede experimentar bloqueos, congelaciones, retrasos o errores al jugar el juego. También es posible que no pueda guardar su progreso o acceder a algunas funciones. </p></li>
-<li><h4>Puede tener errores y problemas técnicos</h4><p>Asesinato en los Alpes Mod APK puede tener algunos errores y problemas técnicos que pueden afectar a su juego o el disfrute del juego. Por ejemplo, puede encontrar objetos que faltan, textos incorrectos, enlaces rotos o archivos dañados. También puede perder sus datos o ser expulsado del juego si es detectado por los desarrolladores. </p></li>
-<li><h4>Puede violar los términos de servicio del juego original</h4><p>Asesinato en los Alpes Mod APK no es una versión oficial del juego, pero uno modificado que ha sido creado por desarrolladores de terceros sin permiso de los desarrolladores del juego original. Esto puede violar los términos de servicio del juego original e infringir sus derechos de propiedad intelectual. Usted puede enfrentar acciones legales o sanciones si utiliza Asesinato en los Alpes Mod APK.</p></li>
-</ul>
-<h2>Conclusión</h2>
-<p>Asesinato en los Alpes Mod APK es un juego de misterio oculto para Android que le permite disfrutar del juego sin limitaciones o interrupciones. Puedes jugar con energía ilimitada, todos los capítulos desbloqueados y sin anuncios. También puede elegir su personaje y la historia, explorar las escenas y encontrar pistas, resolver puzzles y minijuegos, interactuar con otros personajes y tomar decisiones, y experimentar una historia inmersiva y cautivadora con hermosos gráficos y efectos de sonido. Sin embargo, Murder in the Alps Mod APK puede no ser compatible con algunos dispositivos, puede tener errores y problemas técnicos, y puede violar los términos de servicio del juego original. Usted debe descargar y utilizar asesinato en los Alpes Mod APK a su propio riesgo y discreción. </p>
-<h2>Preguntas frecuentes</h2>
-<p>Aquí hay algunas preguntas frecuentes sobre el asesinato en los Alpes Mod APK:</p>
-
-<tr><td><strong>Q: ¿Es el asesinato en los Alpes Mod APK seguro para descargar e instalar? </strong></td><td><strong>A: Asesinato en los Alpes Mod APK no es una versión oficial del juego, sino una versión modificada que ha sido creada por desarrolladores de terceros sin permiso de los desarrolladores del juego original. Por lo tanto, puede no ser seguro descargar e instalar, ya que puede contener virus, malware o spyware que pueden dañar su dispositivo o robar su información personal. Usted debe descargar e instalar Asesinato en los Alpes Mod APK de una fuente de confianza y escanear con un antivirus antes de instalarlo. </strong></td></tr>
-<tr><td><strong>Q: ¿Cómo puedo actualizar Asesinato en los Alpes Mod APK? </strong></td><td><strong>A: Asesinato en los Alpes Mod APK no se puede actualizar automáticamente ya que no está conectado al servidor del juego original. Es posible que tenga que comprobar si hay actualizaciones manualmente en el sitio web desde el que lo descargó o buscar una nueva versión de la apk mod en línea. También puede necesitar desinstalar la versión anterior del apk mod antes de instalar el nuevo. </strong></td></tr>
-<tr><td><strong>Q: ¿Puedo jugar Asesinato en los Alpes Mod APK fuera de línea? </strong></td><td><strong>A: Asesinato en los Alpes Mod APK requiere una conexión a Internet para descargar e instalar. Sin embargo, una vez que lo haya instalado, puede jugar sin conexión sin ningún problema. No necesitas conectarte a Internet para acceder a las características o contenido del juego. </strong></td></tr>
-<tr><td><strong>Q: ¿Puedo jugar Asesinato en los Alpes Mod APK con mis amigos? </strong></td><td><strong>A: Asesinato en los Alpes Mod APK es un juego para un solo jugador que no tiene un modo multijugador o característica. Solo puedes jugar por ti mismo y seguir tu propia historia. Sin embargo, puedes compartir tu progreso y logros con tus amigos en las redes sociales o chatear con ellos sobre el juego. </strong></td></tr>
-
-</table></p> 64aa2da5cf<br />
-<br />
-<br />

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

@@ -1,146 +0,0 @@
-from __future__ import absolute_import
-
-from base64 import b64encode
-
-from ..exceptions import UnrewindableBodyError
-from ..packages.six import b, integer_types
-
-# Pass as a value within ``headers`` to skip
-# emitting some HTTP headers that are added automatically.
-# The only headers that are supported are ``Accept-Encoding``,
-# ``Host``, and ``User-Agent``.
-SKIP_HEADER = "@@@SKIP_HEADER@@@"
-SKIPPABLE_HEADERS = frozenset(["accept-encoding", "host", "user-agent"])
-
-ACCEPT_ENCODING = "gzip,deflate"
-try:
-    try:
-        import brotlicffi as _unused_module_brotli  # noqa: F401
-    except ImportError:
-        import brotli as _unused_module_brotli  # noqa: F401
-except ImportError:
-    pass
-else:
-    ACCEPT_ENCODING += ",br"
-
-_FAILEDTELL = object()
-
-
-def make_headers(
-    keep_alive=None,
-    accept_encoding=None,
-    user_agent=None,
-    basic_auth=None,
-    proxy_basic_auth=None,
-    disable_cache=None,
-):
-    """
-    Shortcuts for generating request headers.
-
-    :param keep_alive:
-        If ``True``, adds 'connection: keep-alive' header.
-
-    :param accept_encoding:
-        Can be a boolean, list, or string.
-        ``True`` translates to 'gzip,deflate'.
-        List will get joined by comma.
-        String will be used as provided.
-
-    :param user_agent:
-        String representing the user-agent you want, such as
-        "python-urllib3/0.6"
-
-    :param basic_auth:
-        Colon-separated username:password string for 'authorization: basic ...'
-        auth header.
-
-    :param proxy_basic_auth:
-        Colon-separated username:password string for 'proxy-authorization: basic ...'
-        auth header.
-
-    :param disable_cache:
-        If ``True``, adds 'cache-control: no-cache' header.
-
-    Example::
-
-        >>> make_headers(keep_alive=True, user_agent="Batman/1.0")
-        {'connection': 'keep-alive', 'user-agent': 'Batman/1.0'}
-        >>> make_headers(accept_encoding=True)
-        {'accept-encoding': 'gzip,deflate'}
-    """
-    headers = {}
-    if accept_encoding:
-        if isinstance(accept_encoding, str):
-            pass
-        elif isinstance(accept_encoding, list):
-            accept_encoding = ",".join(accept_encoding)
-        else:
-            accept_encoding = ACCEPT_ENCODING
-        headers["accept-encoding"] = accept_encoding
-
-    if user_agent:
-        headers["user-agent"] = user_agent
-
-    if keep_alive:
-        headers["connection"] = "keep-alive"
-
-    if basic_auth:
-        headers["authorization"] = "Basic " + b64encode(b(basic_auth)).decode("utf-8")
-
-    if proxy_basic_auth:
-        headers["proxy-authorization"] = "Basic " + b64encode(
-            b(proxy_basic_auth)
-        ).decode("utf-8")
-
-    if disable_cache:
-        headers["cache-control"] = "no-cache"
-
-    return headers
-
-
-def set_file_position(body, pos):
-    """
-    If a position is provided, move file to that point.
-    Otherwise, we'll attempt to record a position for future use.
-    """
-    if pos is not None:
-        rewind_body(body, pos)
-    elif getattr(body, "tell", None) is not None:
-        try:
-            pos = body.tell()
-        except (IOError, OSError):
-            # This differentiates from None, allowing us to catch
-            # a failed `tell()` later when trying to rewind the body.
-            pos = _FAILEDTELL
-
-    return pos
-
-
-def rewind_body(body, body_pos):
-    """
-    Attempt to rewind body to a certain position.
-    Primarily used for request redirects and retries.
-
-    :param body:
-        File-like object that supports seek.
-
-    :param int pos:
-        Position to seek to in file.
-    """
-    body_seek = getattr(body, "seek", None)
-    if body_seek is not None and isinstance(body_pos, integer_types):
-        try:
-            body_seek(body_pos)
-        except (IOError, OSError):
-            raise UnrewindableBodyError(
-                "An error occurred when rewinding request body for redirect/retry."
-            )
-    elif body_pos is _FAILEDTELL:
-        raise UnrewindableBodyError(
-            "Unable to record file position for rewinding "
-            "request body during a redirect/retry."
-        )
-    else:
-        raise ValueError(
-            "body_pos must be of type integer, instead it was %s." % type(body_pos)
-        )

spaces/BradSegal/Literature-Rating/README.md

@@ -1,37 +0,0 @@
----
-title: Literature Rating
-emoji: 📊
-colorFrom: gray
-colorTo: indigo
-sdk: gradio
-app_file: app.py
-pinned: false
----
-
-# Configuration
-
-`title`: _string_  
-Display title for the Space
-
-`emoji`: _string_  
-Space emoji (emoji-only character allowed)
-
-`colorFrom`: _string_  
-Color for Thumbnail gradient (red, yellow, green, blue, indigo, purple, pink, gray)
-
-`colorTo`: _string_  
-Color for Thumbnail gradient (red, yellow, green, blue, indigo, purple, pink, gray)
-
-`sdk`: _string_  
-Can be either `gradio` or `streamlit`
-
-`sdk_version` : _string_  
-Only applicable for `streamlit` SDK.  
-See [doc](https://hf.co/docs/hub/spaces) for more info on supported versions.
-
-`app_file`: _string_  
-Path to your main application file (which contains either `gradio` or `streamlit` Python code).  
-Path is relative to the root of the repository.
-
-`pinned`: _boolean_  
-Whether the Space stays on top of your list.

spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/detectron2/utils/collect_env.py

@@ -1,153 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-import importlib
-import numpy as np
-import os
-import re
-import subprocess
-import sys
-from collections import defaultdict
-import PIL
-import torch
-import torchvision
-from tabulate import tabulate
-
-__all__ = ["collect_env_info"]
-
-
-def collect_torch_env():
-    try:
-        import torch.__config__
-
-        return torch.__config__.show()
-    except ImportError:
-        # compatible with older versions of pytorch
-        from torch.utils.collect_env import get_pretty_env_info
-
-        return get_pretty_env_info()
-
-
-def get_env_module():
-    var_name = "DETECTRON2_ENV_MODULE"
-    return var_name, os.environ.get(var_name, "<not set>")
-
-
-def detect_compute_compatibility(CUDA_HOME, so_file):
-    try:
-        cuobjdump = os.path.join(CUDA_HOME, "bin", "cuobjdump")
-        if os.path.isfile(cuobjdump):
-            output = subprocess.check_output(
-                "'{}' --list-elf '{}'".format(cuobjdump, so_file), shell=True
-            )
-            output = output.decode("utf-8").strip().split("\n")
-            sm = []
-            for line in output:
-                line = re.findall(r"\.sm_[0-9]*\.", line)[0]
-                sm.append(line.strip("."))
-            sm = sorted(set(sm))
-            return ", ".join(sm)
-        else:
-            return so_file + "; cannot find cuobjdump"
-    except Exception:
-        # unhandled failure
-        return so_file
-
-
-def collect_env_info():
-    has_cuda = torch.cuda.is_available()
-    # NOTE: the use of CUDA_HOME requires the CUDA build deps, though in
-    # theory detectron2 should be made runnable with only the CUDA runtime
-    from torch.utils.cpp_extension import CUDA_HOME
-
-    data = []
-    data.append(("sys.platform", sys.platform))
-    data.append(("Python", sys.version.replace("\n", "")))
-    data.append(("numpy", np.__version__))
-
-    try:
-        import detectron2  # noqa
-
-        data.append(
-            ("detectron2", detectron2.__version__ + " @" + os.path.dirname(detectron2.__file__))
-        )
-    except ImportError:
-        data.append(("detectron2", "failed to import"))
-    else:
-        try:
-            from detectron2 import _C
-        except ImportError:
-            data.append(("detectron2._C", "failed to import"))
-        else:
-            data.append(("detectron2 compiler", _C.get_compiler_version()))
-            data.append(("detectron2 CUDA compiler", _C.get_cuda_version()))
-            if has_cuda:
-                data.append(
-                    ("detectron2 arch flags", detect_compute_compatibility(CUDA_HOME, _C.__file__))
-                )
-
-    data.append(get_env_module())
-    data.append(("PyTorch", torch.__version__ + " @" + os.path.dirname(torch.__file__)))
-    data.append(("PyTorch debug build", torch.version.debug))
-
-    data.append(("CUDA available", has_cuda))
-    if has_cuda:
-        devices = defaultdict(list)
-        for k in range(torch.cuda.device_count()):
-            devices[torch.cuda.get_device_name(k)].append(str(k))
-        for name, devids in devices.items():
-            data.append(("GPU " + ",".join(devids), name))
-
-        from torch.utils.cpp_extension import CUDA_HOME
-
-        data.append(("CUDA_HOME", str(CUDA_HOME)))
-
-        if CUDA_HOME is not None and os.path.isdir(CUDA_HOME):
-            try:
-                nvcc = os.path.join(CUDA_HOME, "bin", "nvcc")
-                nvcc = subprocess.check_output("'{}' -V | tail -n1".format(nvcc), shell=True)
-                nvcc = nvcc.decode("utf-8").strip()
-            except subprocess.SubprocessError:
-                nvcc = "Not Available"
-            data.append(("NVCC", nvcc))
-
-        cuda_arch_list = os.environ.get("TORCH_CUDA_ARCH_LIST", None)
-        if cuda_arch_list:
-            data.append(("TORCH_CUDA_ARCH_LIST", cuda_arch_list))
-    data.append(("Pillow", PIL.__version__))
-
-    try:
-        data.append(
-            (
-                "torchvision",
-                str(torchvision.__version__) + " @" + os.path.dirname(torchvision.__file__),
-            )
-        )
-        if has_cuda:
-            try:
-                torchvision_C = importlib.util.find_spec("torchvision._C").origin
-                msg = detect_compute_compatibility(CUDA_HOME, torchvision_C)
-                data.append(("torchvision arch flags", msg))
-            except ImportError:
-                data.append(("torchvision._C", "failed to find"))
-    except AttributeError:
-        data.append(("torchvision", "unknown"))
-
-    try:
-        import cv2
-
-        data.append(("cv2", cv2.__version__))
-    except ImportError:
-        pass
-    env_str = tabulate(data) + "\n"
-    env_str += collect_torch_env()
-    return env_str
-
-
-if __name__ == "__main__":
-    try:
-        import detectron2  # noqa
-    except ImportError:
-        print(collect_env_info())
-    else:
-        from detectron2.utils.collect_env import collect_env_info
-
-        print(collect_env_info())

spaces/CVPR/LIVE/pybind11/tests/conftest.py

@@ -1,200 +0,0 @@
-# -*- coding: utf-8 -*-
-"""pytest configuration
-
-Extends output capture as needed by pybind11: ignore constructors, optional unordered lines.
-Adds docstring and exceptions message sanitizers: ignore Python 2 vs 3 differences.
-"""
-
-import contextlib
-import difflib
-import gc
-import re
-import textwrap
-
-import pytest
-
-import env
-
-# Early diagnostic for failed imports
-import pybind11_tests  # noqa: F401
-
-_unicode_marker = re.compile(r'u(\'[^\']*\')')
-_long_marker = re.compile(r'([0-9])L')
-_hexadecimal = re.compile(r'0x[0-9a-fA-F]+')
-
-# Avoid collecting Python3 only files
-collect_ignore = []
-if env.PY2:
-    collect_ignore.append("test_async.py")
-
-
-def _strip_and_dedent(s):
-    """For triple-quote strings"""
-    return textwrap.dedent(s.lstrip('\n').rstrip())
-
-
-def _split_and_sort(s):
-    """For output which does not require specific line order"""
-    return sorted(_strip_and_dedent(s).splitlines())
-
-
-def _make_explanation(a, b):
-    """Explanation for a failed assert -- the a and b arguments are List[str]"""
-    return ["--- actual / +++ expected"] + [line.strip('\n') for line in difflib.ndiff(a, b)]
-
-
-class Output(object):
-    """Basic output post-processing and comparison"""
-    def __init__(self, string):
-        self.string = string
-        self.explanation = []
-
-    def __str__(self):
-        return self.string
-
-    def __eq__(self, other):
-        # Ignore constructor/destructor output which is prefixed with "###"
-        a = [line for line in self.string.strip().splitlines() if not line.startswith("###")]
-        b = _strip_and_dedent(other).splitlines()
-        if a == b:
-            return True
-        else:
-            self.explanation = _make_explanation(a, b)
-            return False
-
-
-class Unordered(Output):
-    """Custom comparison for output without strict line ordering"""
-    def __eq__(self, other):
-        a = _split_and_sort(self.string)
-        b = _split_and_sort(other)
-        if a == b:
-            return True
-        else:
-            self.explanation = _make_explanation(a, b)
-            return False
-
-
-class Capture(object):
-    def __init__(self, capfd):
-        self.capfd = capfd
-        self.out = ""
-        self.err = ""
-
-    def __enter__(self):
-        self.capfd.readouterr()
-        return self
-
-    def __exit__(self, *args):
-        self.out, self.err = self.capfd.readouterr()
-
-    def __eq__(self, other):
-        a = Output(self.out)
-        b = other
-        if a == b:
-            return True
-        else:
-            self.explanation = a.explanation
-            return False
-
-    def __str__(self):
-        return self.out
-
-    def __contains__(self, item):
-        return item in self.out
-
-    @property
-    def unordered(self):
-        return Unordered(self.out)
-
-    @property
-    def stderr(self):
-        return Output(self.err)
-
-
-@pytest.fixture
-def capture(capsys):
-    """Extended `capsys` with context manager and custom equality operators"""
-    return Capture(capsys)
-
-
-class SanitizedString(object):
-    def __init__(self, sanitizer):
-        self.sanitizer = sanitizer
-        self.string = ""
-        self.explanation = []
-
-    def __call__(self, thing):
-        self.string = self.sanitizer(thing)
-        return self
-
-    def __eq__(self, other):
-        a = self.string
-        b = _strip_and_dedent(other)
-        if a == b:
-            return True
-        else:
-            self.explanation = _make_explanation(a.splitlines(), b.splitlines())
-            return False
-
-
-def _sanitize_general(s):
-    s = s.strip()
-    s = s.replace("pybind11_tests.", "m.")
-    s = s.replace("unicode", "str")
-    s = _long_marker.sub(r"\1", s)
-    s = _unicode_marker.sub(r"\1", s)
-    return s
-
-
-def _sanitize_docstring(thing):
-    s = thing.__doc__
-    s = _sanitize_general(s)
-    return s
-
-
-@pytest.fixture
-def doc():
-    """Sanitize docstrings and add custom failure explanation"""
-    return SanitizedString(_sanitize_docstring)
-
-
-def _sanitize_message(thing):
-    s = str(thing)
-    s = _sanitize_general(s)
-    s = _hexadecimal.sub("0", s)
-    return s
-
-
-@pytest.fixture
-def msg():
-    """Sanitize messages and add custom failure explanation"""
-    return SanitizedString(_sanitize_message)
-
-
-# noinspection PyUnusedLocal
-def pytest_assertrepr_compare(op, left, right):
-    """Hook to insert custom failure explanation"""
-    if hasattr(left, 'explanation'):
-        return left.explanation
-
-
-@contextlib.contextmanager
-def suppress(exception):
-    """Suppress the desired exception"""
-    try:
-        yield
-    except exception:
-        pass
-
-
-def gc_collect():
-    ''' Run the garbage collector twice (needed when running
-    reference counting tests with PyPy) '''
-    gc.collect()
-    gc.collect()
-
-
-def pytest_configure():
-    pytest.suppress = suppress
-    pytest.gc_collect = gc_collect

spaces/CVPR/LIVE/pybind11/tests/test_embed/external_module.cpp

@@ -1,23 +0,0 @@
-#include <pybind11/pybind11.h>
-
-namespace py = pybind11;
-
-/* Simple test module/test class to check that the referenced internals data of external pybind11
- * modules aren't preserved over a finalize/initialize.
- */
-
-PYBIND11_MODULE(external_module, m) {
-    class A {
-    public:
-        A(int value) : v{value} {};
-        int v;
-    };
-
-    py::class_<A>(m, "A")
-        .def(py::init<int>())
-        .def_readwrite("value", &A::v);
-
-    m.def("internals_at", []() {
-        return reinterpret_cast<uintptr_t>(&py::detail::get_internals());
-    });
-}

spaces/CVPR/LIVE/thrust/thrust/detail/range/head_flags.h

@@ -1,230 +0,0 @@
-/*
- *  Copyright 2008-2013 NVIDIA Corporation
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-#pragma once
-
-#include <thrust/detail/config.h>
-#include <thrust/iterator/transform_iterator.h>
-#include <thrust/iterator/zip_iterator.h>
-#include <thrust/iterator/counting_iterator.h>
-#include <thrust/tuple.h>
-#include <thrust/functional.h>
-
-
-namespace thrust
-{
-namespace detail
-{
-
-
-template<typename RandomAccessIterator,
-         typename BinaryPredicate = thrust::equal_to<typename thrust::iterator_value<RandomAccessIterator>::type>,
-         typename ValueType = bool,
-         typename IndexType = typename thrust::iterator_difference<RandomAccessIterator>::type>
-  class head_flags_with_init
-{
-  typedef typename thrust::iterator_value<RandomAccessIterator>::type init_type;
-
-  // XXX WAR cudafe issue
-  //private:
-  public:
-    struct head_flag_functor
-    {
-      BinaryPredicate binary_pred; // this must be the first member for performance reasons
-      init_type init;
-      IndexType n;
-
-      typedef ValueType result_type;
-
-      __host__ __device__
-      head_flag_functor(init_type init, IndexType n)
-        : binary_pred(), init(init), n(n)
-      {}
-
-      __host__ __device__
-      head_flag_functor(init_type init, IndexType n, BinaryPredicate binary_pred)
-        : binary_pred(binary_pred), init(init), n(n)
-      {}
-
-      template<typename Tuple>
-      __host__ __device__ __thrust_forceinline__
-      result_type operator()(const Tuple &t)
-      {
-        const IndexType i = thrust::get<0>(t);
-
-        if(i == 0)
-        {
-          return !binary_pred(init, thrust::get<1>(t));
-        }
-
-        return !binary_pred(thrust::get<1>(t), thrust::get<2>(t));
-      }
-    };
-
-    typedef thrust::counting_iterator<IndexType> counting_iterator;
-
-  public:
-    typedef thrust::transform_iterator<
-      head_flag_functor,
-      thrust::zip_iterator<thrust::tuple<counting_iterator,RandomAccessIterator,RandomAccessIterator> >
-    > iterator;
-
-    __thrust_exec_check_disable__
-    __host__ __device__
-    head_flags_with_init(RandomAccessIterator first, RandomAccessIterator last, init_type init)
-      : m_begin(thrust::make_transform_iterator(thrust::make_zip_iterator(thrust::make_tuple(thrust::counting_iterator<IndexType>(0), first, first - 1)),
-                                                head_flag_functor(init, last - first))),
-        m_end(m_begin + (last - first))
-    {}
-
-    __thrust_exec_check_disable__
-    __host__ __device__
-    head_flags_with_init(RandomAccessIterator first, RandomAccessIterator last, init_type init, BinaryPredicate binary_pred)
-      : m_begin(thrust::make_transform_iterator(thrust::make_zip_iterator(thrust::make_tuple(thrust::counting_iterator<IndexType>(0), first, first - 1)),
-                                                head_flag_functor(init, last - first, binary_pred))),
-        m_end(m_begin + (last - first))
-    {}
-
-    __host__ __device__
-    iterator begin() const
-    {
-      return m_begin;
-    }
-
-    __host__ __device__
-    iterator end() const
-    {
-      return m_end;
-    }
-
-    template<typename OtherIndex>
-    __host__ __device__
-    typename iterator::reference operator[](OtherIndex i)
-    {
-      return *(begin() + i);
-    }
-
-  private:
-    iterator m_begin, m_end;
-};
-
-
-
-template<typename RandomAccessIterator,
-         typename BinaryPredicate = thrust::equal_to<typename thrust::iterator_value<RandomAccessIterator>::type>,
-         typename ValueType = bool,
-         typename IndexType = typename thrust::iterator_difference<RandomAccessIterator>::type>
-  class head_flags
-{
-  // XXX WAR cudafe issue
-  //private:
-  public:
-    struct head_flag_functor
-    {
-      BinaryPredicate binary_pred; // this must be the first member for performance reasons
-      IndexType n;
-
-      typedef ValueType result_type;
-
-      __host__ __device__
-      head_flag_functor(IndexType n)
-        : binary_pred(), n(n)
-      {}
-
-      __host__ __device__
-      head_flag_functor(IndexType n, BinaryPredicate binary_pred)
-        : binary_pred(binary_pred), n(n)
-      {}
-
-      template<typename Tuple>
-      __host__ __device__ __thrust_forceinline__
-      result_type operator()(const Tuple &t)
-      {
-        const IndexType i = thrust::get<0>(t);
-
-        // note that we do not dereference the tuple's 2nd element when i <= 0
-        // and therefore do not dereference a bad location at the boundary
-        return (i == 0 || !binary_pred(thrust::get<1>(t), thrust::get<2>(t)));
-      }
-    };
-
-    typedef thrust::counting_iterator<IndexType> counting_iterator;
-
-  public:
-    typedef thrust::transform_iterator<
-      head_flag_functor,
-      thrust::zip_iterator<thrust::tuple<counting_iterator,RandomAccessIterator,RandomAccessIterator> >
-    > iterator;
-
-    __host__ __device__
-    head_flags(RandomAccessIterator first, RandomAccessIterator last)
-      : m_begin(thrust::make_transform_iterator(thrust::make_zip_iterator(thrust::make_tuple(thrust::counting_iterator<IndexType>(0), first, first - 1)),
-                                                head_flag_functor(last - first))),
-        m_end(m_begin + (last - first))
-    {}
-
-    __host__ __device__
-    head_flags(RandomAccessIterator first, RandomAccessIterator last, BinaryPredicate binary_pred)
-      : m_begin(thrust::make_transform_iterator(thrust::make_zip_iterator(thrust::make_tuple(thrust::counting_iterator<IndexType>(0), first, first - 1)),
-                                                head_flag_functor(last - first, binary_pred))),
-        m_end(m_begin + (last - first))
-    {}
-
-    __host__ __device__
-    iterator begin() const
-    {
-      return m_begin;
-    }
-
-    __host__ __device__
-    iterator end() const
-    {
-      return m_end;
-    }
-
-    template<typename OtherIndex>
-    __host__ __device__
-    typename iterator::reference operator[](OtherIndex i)
-    {
-      return *(begin() + i);
-    }
-
-  private:
-    iterator m_begin, m_end;
-};
-
-
-template<typename RandomAccessIterator, typename BinaryPredicate>
-__host__ __device__
-head_flags<RandomAccessIterator, BinaryPredicate>
-  make_head_flags(RandomAccessIterator first, RandomAccessIterator last, BinaryPredicate binary_pred)
-{
-  return head_flags<RandomAccessIterator, BinaryPredicate>(first, last, binary_pred);
-}
-
-
-template<typename RandomAccessIterator>
-__host__ __device__
-head_flags<RandomAccessIterator>
-  make_head_flags(RandomAccessIterator first, RandomAccessIterator last)
-{
-  return head_flags<RandomAccessIterator>(first, last);
-}
-
-
-} // end detail
-} // end thrust
-

spaces/CVPR/LIVE/thrust/thrust/random/xor_combine_engine.h

@@ -1,271 +0,0 @@
-/*
- *  Copyright 2008-2013 NVIDIA Corporation
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-/*! \file xor_combine_engine.h
- *  \brief A pseudorandom number generator which produces pseudorandom
- *         numbers from two integer base engines by merging their
- *         pseudorandom numbers with bitwise exclusive-or.
- */
-
-#pragma once
-
-#include <thrust/detail/config.h>
-#include <thrust/detail/type_traits.h>
-#include <thrust/random/detail/xor_combine_engine_max.h>
-#include <thrust/random/detail/random_core_access.h>
-#include <iostream>
-#include <cstddef> // for size_t
-
-namespace thrust
-{
-
-namespace random
-{
-
-/*! \addtogroup random_number_engine_adaptors
- *  \{
- */
-
-/*! \class xor_combine_engine
- *  \brief An \p xor_combine_engine adapts two existing base random number engines and
- *         produces random values by combining the values produced by each.
- *
- *  \tparam Engine1 The type of the first base random number engine to adapt.
- *  \tparam s1 The size of the first shift to use in the generation algorithm.
- *  \tparam Engine2 The type of the second base random number engine to adapt.
- *  \tparam s2 The second of the second shift to use in the generation algorithm. Defaults to \c 0.
- *
- *  The following code snippet shows an example of using an \p xor_combine_engine instance:
- *
- *  \code
- *  #include <thrust/random/linear_congruential_engine.h>
- *  #include <thrust/random/xor_combine_engine.h>
- *  #include <iostream>
- *
- *  int main(void)
- *  {
- *    // create an xor_combine_engine from minstd_rand and minstd_rand0
- *    // use a shift of 0 for each
- *    thrust::xor_combine_engine<thrust::minstd_rand,0,thrust::minstd_rand0,0> rng;
- *
- *    // print a random number to standard output
- *    std::cout << rng() << std::endl;
- *
- *    return 0;
- *  }
- *  \endcode
- */
-template<typename Engine1, size_t s1,
-         typename Engine2, size_t s2=0u>
-  class xor_combine_engine
-{
-  public:
-    // types
-
-    /*! \typedef base1_type
-     *  \brief The type of the first adapted base random number engine.
-     */
-    typedef Engine1 base1_type;
-
-    /*! \typedef base2_type
-     *  \brief The type of the second adapted base random number engine.
-     */
-    typedef Engine2 base2_type;
-
-    /*! \typedef result_type
-     *  \brief The type of the unsigned integer produced by this \p xor_combine_engine.
-     */
-    typedef typename thrust::detail::eval_if<
-      (sizeof(typename base2_type::result_type) > sizeof(typename base1_type::result_type)),
-      thrust::detail::identity_<typename base2_type::result_type>,
-      thrust::detail::identity_<typename base1_type::result_type>
-    >::type result_type;
-    
-    /*! The size of the first shift used in the generation algorithm.
-     */
-    static const size_t shift1 = s1;
-
-    /*! The size of the second shift used in the generation algorithm.
-     */
-    static const size_t shift2 = s2;
-
-    /*! The smallest value this \p xor_combine_engine may potentially produce.
-     */
-    static const result_type min = 0;
-
-    /*! The largest value this \p xor_combine_engine may potentially produce.
-     */
-    static const result_type max =
-      detail::xor_combine_engine_max<
-        Engine1, s1, Engine2, s2, result_type
-      >::value;
-
-    // constructors and seeding functions
-
-    /*! This constructor constructs a new \p xor_combine_engine and constructs
-     *  its adapted engines using their null constructors.
-     */
-    __host__ __device__
-    xor_combine_engine(void);
-
-    /*! This constructor constructs a new \p xor_combine_engine using
-     *  given \p base1_type and \p base2_type engines to initialize its adapted base engines.
-     *
-     *  \param urng1 A \p base1_type to use to initialize this \p xor_combine_engine's
-     *         first adapted base engine.
-     *  \param urng2 A \p base2_type to use to initialize this \p xor_combine_engine's
-     *         first adapted base engine.
-     */
-    __host__ __device__
-    xor_combine_engine(const base1_type &urng1, const base2_type &urng2);
-
-    /*! This constructor initializes a new \p xor_combine_engine with a given seed.
-     *  
-     *  \param s The seed used to intialize this \p xor_combine_engine's adapted base engines.
-     */
-    __host__ __device__
-    xor_combine_engine(result_type s);
-
-    /*! This method initializes the state of this \p xor_combine_engine's adapted base engines
-     *  by using their \p default_seed values.
-     */
-    __host__ __device__
-    void seed(void);
-
-    /*! This method initializes the state of this \p xor_combine_engine's adapted base engines
-     *  by using the given seed.
-     *
-     *  \param s The seed with which to intialize this \p xor_combine_engine's adapted base engines.
-     */
-    __host__ __device__
-    void seed(result_type s);
-
-    // generating functions
-
-    /*! This member function produces a new random value and updates this \p xor_combine_engine's state.
-     *  \return A new random number.
-     */
-    __host__ __device__
-    result_type operator()(void);
-
-    /*! This member function advances this \p xor_combine_engine's state a given number of times
-     *  and discards the results.
-     *
-     *  \param z The number of random values to discard.
-     *  \note This function is provided because an implementation may be able to accelerate it.
-     */
-    __host__ __device__
-    void discard(unsigned long long z);
-
-    // property functions
-
-    /*! This member function returns a const reference to this \p xor_combine_engine's
-     *  first adapted base engine.
-     *
-     *  \return A const reference to the first base engine this \p xor_combine_engine adapts.
-     */
-    __host__ __device__
-    const base1_type &base1(void) const;
-
-    /*! This member function returns a const reference to this \p xor_combine_engine's
-     *  second adapted base engine.
-     *
-     *  \return A const reference to the second base engine this \p xor_combine_engine adapts.
-     */
-    __host__ __device__
-    const base2_type &base2(void) const;
-
-    /*! \cond
-     */
-  private:
-    base1_type m_b1;
-    base2_type m_b2;
-
-    friend struct thrust::random::detail::random_core_access;
-
-    __host__ __device__
-    bool equal(const xor_combine_engine &rhs) const;
-
-    template<typename CharT, typename Traits>
-    std::basic_istream<CharT,Traits>& stream_in(std::basic_istream<CharT,Traits> &is);
-
-    template<typename CharT, typename Traits>
-    std::basic_ostream<CharT,Traits>& stream_out(std::basic_ostream<CharT,Traits> &os) const;
-
-    /*! \endcond
-     */
-}; // end xor_combine_engine
-
-
-/*! This function checks two \p xor_combine_engines for equality.
- *  \param lhs The first \p xor_combine_engine to test.
- *  \param rhs The second \p xor_combine_engine to test.
- *  \return \c true if \p lhs is equal to \p rhs; \c false, otherwise.
- */
-template<typename Engine1_, size_t s1_, typename Engine2_, size_t s2_>
-__host__ __device__
-bool operator==(const xor_combine_engine<Engine1_,s1_,Engine2_,s2_> &lhs,
-                const xor_combine_engine<Engine1_,s1_,Engine2_,s2_> &rhs);
-
-
-/*! This function checks two \p xor_combine_engines for inequality.
- *  \param lhs The first \p xor_combine_engine to test.
- *  \param rhs The second \p xor_combine_engine to test.
- *  \return \c true if \p lhs is not equal to \p rhs; \c false, otherwise.
- */
-template<typename Engine1_, size_t s1_, typename Engine2_, size_t s2_>
-__host__ __device__
-bool operator!=(const xor_combine_engine<Engine1_,s1_,Engine2_,s2_> &lhs,
-                const xor_combine_engine<Engine1_,s1_,Engine2_,s2_> &rhs);
-
-
-/*! This function streams a xor_combine_engine to a \p std::basic_ostream.
- *  \param os The \p basic_ostream to stream out to.
- *  \param e The \p xor_combine_engine to stream out.
- *  \return \p os
- */
-template<typename Engine1_, size_t s1_, typename Engine2_, size_t s2_,
-         typename CharT, typename Traits>
-std::basic_ostream<CharT,Traits>&
-operator<<(std::basic_ostream<CharT,Traits> &os,
-           const xor_combine_engine<Engine1_,s1_,Engine2_,s2_> &e);
-
-
-/*! This function streams a xor_combine_engine in from a std::basic_istream.
- *  \param is The \p basic_istream to stream from.
- *  \param e The \p xor_combine_engine to stream in.
- *  \return \p is
- */
-template<typename Engine1_, size_t s1_, typename Engine2_, size_t s2_,
-         typename CharT, typename Traits>
-std::basic_istream<CharT,Traits>&
-operator>>(std::basic_istream<CharT,Traits> &is,
-           xor_combine_engine<Engine1_,s1_,Engine2_,s2_> &e);
-
-
-/*! \} // end random_number_engine_adaptors
- */
-
-
-} // end random
-
-// import names into thrust::
-using random::xor_combine_engine;
-
-} // end thrust
-
-#include <thrust/random/detail/xor_combine_engine.inl>
-

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

@@ -1,60 +0,0 @@
-/*
- *  Copyright 2008-2013 NVIDIA Corporation
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-#pragma once
-
-#include <thrust/detail/config.h>
-#include <thrust/system/detail/sequential/execution_policy.h>
-
-namespace thrust
-{
-namespace system
-{
-namespace detail
-{
-namespace sequential
-{
-
-
-template<typename DerivedPolicy,
-         typename RandomAccessIterator,
-         typename StrictWeakOrdering>
-__host__ __device__
-void stable_merge_sort(sequential::execution_policy<DerivedPolicy> &exec,
-                       RandomAccessIterator begin,
-                       RandomAccessIterator end,
-                       StrictWeakOrdering comp);
-
-
-template<typename DerivedPolicy,
-         typename RandomAccessIterator1,
-         typename RandomAccessIterator2,
-         typename StrictWeakOrdering>
-__host__ __device__
-void stable_merge_sort_by_key(sequential::execution_policy<DerivedPolicy> &exec,
-                              RandomAccessIterator1 keys_begin,
-                              RandomAccessIterator1 keys_end,
-                              RandomAccessIterator2 values_begin,
-                              StrictWeakOrdering comp);
-
-
-} // end namespace sequential
-} // end namespace detail
-} // end namespace system
-} // end namespace thrust
-
-#include <thrust/system/detail/sequential/stable_merge_sort.inl>
-

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

@@ -1,292 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import torch.utils.checkpoint as cp
-from mmcv.cnn import build_conv_layer, build_norm_layer, kaiming_init
-from torch.nn.modules.utils import _pair
-
-from mmdet.models.backbones.resnet import Bottleneck, ResNet
-from mmdet.models.builder import BACKBONES
-
-
-class TridentConv(nn.Module):
-    """Trident Convolution Module.
-
-    Args:
-        in_channels (int): Number of channels in input.
-        out_channels (int): Number of channels in output.
-        kernel_size (int): Size of convolution kernel.
-        stride (int, optional): Convolution stride. Default: 1.
-        trident_dilations (tuple[int, int, int], optional): Dilations of
-            different trident branch. Default: (1, 2, 3).
-        test_branch_idx (int, optional): In inference, all 3 branches will
-            be used if `test_branch_idx==-1`, otherwise only branch with
-            index `test_branch_idx` will be used. Default: 1.
-        bias (bool, optional): Whether to use bias in convolution or not.
-            Default: False.
-    """
-
-    def __init__(self,
-                 in_channels,
-                 out_channels,
-                 kernel_size,
-                 stride=1,
-                 trident_dilations=(1, 2, 3),
-                 test_branch_idx=1,
-                 bias=False):
-        super(TridentConv, self).__init__()
-        self.num_branch = len(trident_dilations)
-        self.with_bias = bias
-        self.test_branch_idx = test_branch_idx
-        self.stride = _pair(stride)
-        self.kernel_size = _pair(kernel_size)
-        self.paddings = _pair(trident_dilations)
-        self.dilations = trident_dilations
-        self.in_channels = in_channels
-        self.out_channels = out_channels
-        self.bias = bias
-
-        self.weight = nn.Parameter(
-            torch.Tensor(out_channels, in_channels, *self.kernel_size))
-        if bias:
-            self.bias = nn.Parameter(torch.Tensor(out_channels))
-        else:
-            self.bias = None
-        self.init_weights()
-
-    def init_weights(self):
-        kaiming_init(self, distribution='uniform', mode='fan_in')
-
-    def extra_repr(self):
-        tmpstr = f'in_channels={self.in_channels}'
-        tmpstr += f', out_channels={self.out_channels}'
-        tmpstr += f', kernel_size={self.kernel_size}'
-        tmpstr += f', num_branch={self.num_branch}'
-        tmpstr += f', test_branch_idx={self.test_branch_idx}'
-        tmpstr += f', stride={self.stride}'
-        tmpstr += f', paddings={self.paddings}'
-        tmpstr += f', dilations={self.dilations}'
-        tmpstr += f', bias={self.bias}'
-        return tmpstr
-
-    def forward(self, inputs):
-        if self.training or self.test_branch_idx == -1:
-            outputs = [
-                F.conv2d(input, self.weight, self.bias, self.stride, padding,
-                         dilation) for input, dilation, padding in zip(
-                             inputs, self.dilations, self.paddings)
-            ]
-        else:
-            assert len(inputs) == 1
-            outputs = [
-                F.conv2d(inputs[0], self.weight, self.bias, self.stride,
-                         self.paddings[self.test_branch_idx],
-                         self.dilations[self.test_branch_idx])
-            ]
-
-        return outputs
-
-
-# Since TridentNet is defined over ResNet50 and ResNet101, here we
-# only support TridentBottleneckBlock.
-class TridentBottleneck(Bottleneck):
-    """BottleBlock for TridentResNet.
-
-    Args:
-        trident_dilations (tuple[int, int, int]): Dilations of different
-            trident branch.
-        test_branch_idx (int): In inference, all 3 branches will be used
-            if `test_branch_idx==-1`, otherwise only branch with index
-            `test_branch_idx` will be used.
-        concat_output (bool): Whether to concat the output list to a Tensor.
-            `True` only in the last Block.
-    """
-
-    def __init__(self, trident_dilations, test_branch_idx, concat_output,
-                 **kwargs):
-
-        super(TridentBottleneck, self).__init__(**kwargs)
-        self.trident_dilations = trident_dilations
-        self.num_branch = len(trident_dilations)
-        self.concat_output = concat_output
-        self.test_branch_idx = test_branch_idx
-        self.conv2 = TridentConv(
-            self.planes,
-            self.planes,
-            kernel_size=3,
-            stride=self.conv2_stride,
-            bias=False,
-            trident_dilations=self.trident_dilations,
-            test_branch_idx=test_branch_idx)
-
-    def forward(self, x):
-
-        def _inner_forward(x):
-            num_branch = (
-                self.num_branch
-                if self.training or self.test_branch_idx == -1 else 1)
-            identity = x
-            if not isinstance(x, list):
-                x = (x, ) * num_branch
-                identity = x
-                if self.downsample is not None:
-                    identity = [self.downsample(b) for b in x]
-
-            out = [self.conv1(b) for b in x]
-            out = [self.norm1(b) for b in out]
-            out = [self.relu(b) for b in out]
-
-            if self.with_plugins:
-                for k in range(len(out)):
-                    out[k] = self.forward_plugin(out[k],
-                                                 self.after_conv1_plugin_names)
-
-            out = self.conv2(out)
-            out = [self.norm2(b) for b in out]
-            out = [self.relu(b) for b in out]
-            if self.with_plugins:
-                for k in range(len(out)):
-                    out[k] = self.forward_plugin(out[k],
-                                                 self.after_conv2_plugin_names)
-
-            out = [self.conv3(b) for b in out]
-            out = [self.norm3(b) for b in out]
-
-            if self.with_plugins:
-                for k in range(len(out)):
-                    out[k] = self.forward_plugin(out[k],
-                                                 self.after_conv3_plugin_names)
-
-            out = [
-                out_b + identity_b for out_b, identity_b in zip(out, identity)
-            ]
-            return out
-
-        if self.with_cp and x.requires_grad:
-            out = cp.checkpoint(_inner_forward, x)
-        else:
-            out = _inner_forward(x)
-
-        out = [self.relu(b) for b in out]
-        if self.concat_output:
-            out = torch.cat(out, dim=0)
-        return out
-
-
-def make_trident_res_layer(block,
-                           inplanes,
-                           planes,
-                           num_blocks,
-                           stride=1,
-                           trident_dilations=(1, 2, 3),
-                           style='pytorch',
-                           with_cp=False,
-                           conv_cfg=None,
-                           norm_cfg=dict(type='BN'),
-                           dcn=None,
-                           plugins=None,
-                           test_branch_idx=-1):
-    """Build Trident Res Layers."""
-
-    downsample = None
-    if stride != 1 or inplanes != planes * block.expansion:
-        downsample = []
-        conv_stride = stride
-        downsample.extend([
-            build_conv_layer(
-                conv_cfg,
-                inplanes,
-                planes * block.expansion,
-                kernel_size=1,
-                stride=conv_stride,
-                bias=False),
-            build_norm_layer(norm_cfg, planes * block.expansion)[1]
-        ])
-        downsample = nn.Sequential(*downsample)
-
-    layers = []
-    for i in range(num_blocks):
-        layers.append(
-            block(
-                inplanes=inplanes,
-                planes=planes,
-                stride=stride if i == 0 else 1,
-                trident_dilations=trident_dilations,
-                downsample=downsample if i == 0 else None,
-                style=style,
-                with_cp=with_cp,
-                conv_cfg=conv_cfg,
-                norm_cfg=norm_cfg,
-                dcn=dcn,
-                plugins=plugins,
-                test_branch_idx=test_branch_idx,
-                concat_output=True if i == num_blocks - 1 else False))
-        inplanes = planes * block.expansion
-    return nn.Sequential(*layers)
-
-
-@BACKBONES.register_module()
-class TridentResNet(ResNet):
-    """The stem layer, stage 1 and stage 2 in Trident ResNet are identical to
-    ResNet, while in stage 3, Trident BottleBlock is utilized to replace the
-    normal BottleBlock to yield trident output. Different branch shares the
-    convolution weight but uses different dilations to achieve multi-scale
-    output.
-
-                               / stage3(b0) \
-    x - stem - stage1 - stage2 - stage3(b1) - output
-                               \ stage3(b2) /
-
-    Args:
-        depth (int): Depth of resnet, from {50, 101, 152}.
-        num_branch (int): Number of branches in TridentNet.
-        test_branch_idx (int): In inference, all 3 branches will be used
-            if `test_branch_idx==-1`, otherwise only branch with index
-            `test_branch_idx` will be used.
-        trident_dilations (tuple[int]): Dilations of different trident branch.
-            len(trident_dilations) should be equal to num_branch.
-    """  # noqa
-
-    def __init__(self, depth, num_branch, test_branch_idx, trident_dilations,
-                 **kwargs):
-
-        assert num_branch == len(trident_dilations)
-        assert depth in (50, 101, 152)
-        super(TridentResNet, self).__init__(depth, **kwargs)
-        assert self.num_stages == 3
-        self.test_branch_idx = test_branch_idx
-        self.num_branch = num_branch
-
-        last_stage_idx = self.num_stages - 1
-        stride = self.strides[last_stage_idx]
-        dilation = trident_dilations
-        dcn = self.dcn if self.stage_with_dcn[last_stage_idx] else None
-        if self.plugins is not None:
-            stage_plugins = self.make_stage_plugins(self.plugins,
-                                                    last_stage_idx)
-        else:
-            stage_plugins = None
-        planes = self.base_channels * 2**last_stage_idx
-        res_layer = make_trident_res_layer(
-            TridentBottleneck,
-            inplanes=(self.block.expansion * self.base_channels *
-                      2**(last_stage_idx - 1)),
-            planes=planes,
-            num_blocks=self.stage_blocks[last_stage_idx],
-            stride=stride,
-            trident_dilations=dilation,
-            style=self.style,
-            with_cp=self.with_cp,
-            conv_cfg=self.conv_cfg,
-            norm_cfg=self.norm_cfg,
-            dcn=dcn,
-            plugins=stage_plugins,
-            test_branch_idx=self.test_branch_idx)
-
-        layer_name = f'layer{last_stage_idx + 1}'
-
-        self.__setattr__(layer_name, res_layer)
-        self.res_layers.pop(last_stage_idx)
-        self.res_layers.insert(last_stage_idx, layer_name)
-
-        self._freeze_stages()

spaces/CVPR/regionclip-demo/detectron2/data/samplers/distributed_sampler.py

@@ -1,200 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import itertools
-import math
-from collections import defaultdict
-from typing import Optional
-import torch
-from torch.utils.data.sampler import Sampler
-
-from detectron2.utils import comm
-
-
-class TrainingSampler(Sampler):
-    """
-    In training, we only care about the "infinite stream" of training data.
-    So this sampler produces an infinite stream of indices and
-    all workers cooperate to correctly shuffle the indices and sample different indices.
-
-    The samplers in each worker effectively produces `indices[worker_id::num_workers]`
-    where `indices` is an infinite stream of indices consisting of
-    `shuffle(range(size)) + shuffle(range(size)) + ...` (if shuffle is True)
-    or `range(size) + range(size) + ...` (if shuffle is False)
-    """
-
-    def __init__(self, size: int, shuffle: bool = True, seed: Optional[int] = None):
-        """
-        Args:
-            size (int): the total number of data of the underlying dataset to sample from
-            shuffle (bool): whether to shuffle the indices or not
-            seed (int): the initial seed of the shuffle. Must be the same
-                across all workers. If None, will use a random seed shared
-                among workers (require synchronization among all workers).
-        """
-        self._size = size
-        assert size > 0
-        self._shuffle = shuffle
-        if seed is None:
-            seed = comm.shared_random_seed()
-        self._seed = int(seed)
-
-        self._rank = comm.get_rank()
-        self._world_size = comm.get_world_size()
-
-    def __iter__(self):
-        start = self._rank
-        yield from itertools.islice(self._infinite_indices(), start, None, self._world_size)
-
-    def _infinite_indices(self):
-        g = torch.Generator()
-        g.manual_seed(self._seed)
-        while True:
-            if self._shuffle:
-                yield from torch.randperm(self._size, generator=g).tolist()
-            else:
-                yield from torch.arange(self._size).tolist()
-
-
-class RepeatFactorTrainingSampler(Sampler):
-    """
-    Similar to TrainingSampler, but a sample may appear more times than others based
-    on its "repeat factor". This is suitable for training on class imbalanced datasets like LVIS.
-    """
-
-    def __init__(self, repeat_factors, *, shuffle=True, seed=None):
-        """
-        Args:
-            repeat_factors (Tensor): a float vector, the repeat factor for each indice. When it's
-                full of ones, it is equivalent to ``TrainingSampler(len(repeat_factors), ...)``.
-            shuffle (bool): whether to shuffle the indices or not
-            seed (int): the initial seed of the shuffle. Must be the same
-                across all workers. If None, will use a random seed shared
-                among workers (require synchronization among all workers).
-        """
-        self._shuffle = shuffle
-        if seed is None:
-            seed = comm.shared_random_seed()
-        self._seed = int(seed)
-
-        self._rank = comm.get_rank()
-        self._world_size = comm.get_world_size()
-
-        # Split into whole number (_int_part) and fractional (_frac_part) parts.
-        self._int_part = torch.trunc(repeat_factors)
-        self._frac_part = repeat_factors - self._int_part
-
-    @staticmethod
-    def repeat_factors_from_category_frequency(dataset_dicts, repeat_thresh):
-        """
-        Compute (fractional) per-image repeat factors based on category frequency.
-        The repeat factor for an image is a function of the frequency of the rarest
-        category labeled in that image. The "frequency of category c" in [0, 1] is defined
-        as the fraction of images in the training set (without repeats) in which category c
-        appears.
-        See :paper:`lvis` (>= v2) Appendix B.2.
-
-        Args:
-            dataset_dicts (list[dict]): annotations in Detectron2 dataset format.
-            repeat_thresh (float): frequency threshold below which data is repeated.
-                If the frequency is half of `repeat_thresh`, the image will be
-                repeated twice.
-
-        Returns:
-            torch.Tensor:
-                the i-th element is the repeat factor for the dataset image at index i.
-        """
-        # 1. For each category c, compute the fraction of images that contain it: f(c)
-        category_freq = defaultdict(int)
-        for dataset_dict in dataset_dicts:  # For each image (without repeats)
-            cat_ids = {ann["category_id"] for ann in dataset_dict["annotations"]}
-            for cat_id in cat_ids:
-                category_freq[cat_id] += 1
-        num_images = len(dataset_dicts)
-        for k, v in category_freq.items():
-            category_freq[k] = v / num_images
-
-        # 2. For each category c, compute the category-level repeat factor:
-        #    r(c) = max(1, sqrt(t / f(c)))
-        category_rep = {
-            cat_id: max(1.0, math.sqrt(repeat_thresh / cat_freq))
-            for cat_id, cat_freq in category_freq.items()
-        }
-
-        # 3. For each image I, compute the image-level repeat factor:
-        #    r(I) = max_{c in I} r(c)
-        rep_factors = []
-        for dataset_dict in dataset_dicts:
-            cat_ids = {ann["category_id"] for ann in dataset_dict["annotations"]}
-            rep_factor = max({category_rep[cat_id] for cat_id in cat_ids}, default=1.0)
-            rep_factors.append(rep_factor)
-
-        return torch.tensor(rep_factors, dtype=torch.float32)
-
-    def _get_epoch_indices(self, generator):
-        """
-        Create a list of dataset indices (with repeats) to use for one epoch.
-
-        Args:
-            generator (torch.Generator): pseudo random number generator used for
-                stochastic rounding.
-
-        Returns:
-            torch.Tensor: list of dataset indices to use in one epoch. Each index
-                is repeated based on its calculated repeat factor.
-        """
-        # Since repeat factors are fractional, we use stochastic rounding so
-        # that the target repeat factor is achieved in expectation over the
-        # course of training
-        rands = torch.rand(len(self._frac_part), generator=generator)
-        rep_factors = self._int_part + (rands < self._frac_part).float()
-        # Construct a list of indices in which we repeat images as specified
-        indices = []
-        for dataset_index, rep_factor in enumerate(rep_factors):
-            indices.extend([dataset_index] * int(rep_factor.item()))
-        return torch.tensor(indices, dtype=torch.int64)
-
-    def __iter__(self):
-        start = self._rank
-        yield from itertools.islice(self._infinite_indices(), start, None, self._world_size)
-
-    def _infinite_indices(self):
-        g = torch.Generator()
-        g.manual_seed(self._seed)
-        while True:
-            # Sample indices with repeats determined by stochastic rounding; each
-            # "epoch" may have a slightly different size due to the rounding.
-            indices = self._get_epoch_indices(g)
-            if self._shuffle:
-                randperm = torch.randperm(len(indices), generator=g)
-                yield from indices[randperm].tolist()
-            else:
-                yield from indices.tolist()
-
-
-class InferenceSampler(Sampler):
-    """
-    Produce indices for inference across all workers.
-    Inference needs to run on the __exact__ set of samples,
-    therefore when the total number of samples is not divisible by the number of workers,
-    this sampler produces different number of samples on different workers.
-    """
-
-    def __init__(self, size: int):
-        """
-        Args:
-            size (int): the total number of data of the underlying dataset to sample from
-        """
-        self._size = size
-        assert size > 0
-        self._rank = comm.get_rank()
-        self._world_size = comm.get_world_size()
-
-        shard_size = (self._size - 1) // self._world_size + 1
-        begin = shard_size * self._rank
-        end = min(shard_size * (self._rank + 1), self._size)
-        self._local_indices = range(begin, end)
-
-    def __iter__(self):
-        yield from self._local_indices
-
-    def __len__(self):
-        return len(self._local_indices)

spaces/CVPR/regionclip-demo/detectron2/utils/memory.py

@@ -1,84 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-
-import logging
-from contextlib import contextmanager
-from functools import wraps
-import torch
-
-__all__ = ["retry_if_cuda_oom"]
-
-
-@contextmanager
-def _ignore_torch_cuda_oom():
-    """
-    A context which ignores CUDA OOM exception from pytorch.
-    """
-    try:
-        yield
-    except RuntimeError as e:
-        # NOTE: the string may change?
-        if "CUDA out of memory. " in str(e):
-            pass
-        else:
-            raise
-
-
-def retry_if_cuda_oom(func):
-    """
-    Makes a function retry itself after encountering
-    pytorch's CUDA OOM error.
-    It will first retry after calling `torch.cuda.empty_cache()`.
-
-    If that still fails, it will then retry by trying to convert inputs to CPUs.
-    In this case, it expects the function to dispatch to CPU implementation.
-    The return values may become CPU tensors as well and it's user's
-    responsibility to convert it back to CUDA tensor if needed.
-
-    Args:
-        func: a stateless callable that takes tensor-like objects as arguments
-
-    Returns:
-        a callable which retries `func` if OOM is encountered.
-
-    Examples:
-    ::
-        output = retry_if_cuda_oom(some_torch_function)(input1, input2)
-        # output may be on CPU even if inputs are on GPU
-
-    Note:
-        1. When converting inputs to CPU, it will only look at each argument and check
-           if it has `.device` and `.to` for conversion. Nested structures of tensors
-           are not supported.
-
-        2. Since the function might be called more than once, it has to be
-           stateless.
-    """
-
-    def maybe_to_cpu(x):
-        try:
-            like_gpu_tensor = x.device.type == "cuda" and hasattr(x, "to")
-        except AttributeError:
-            like_gpu_tensor = False
-        if like_gpu_tensor:
-            return x.to(device="cpu")
-        else:
-            return x
-
-    @wraps(func)
-    def wrapped(*args, **kwargs):
-        with _ignore_torch_cuda_oom():
-            return func(*args, **kwargs)
-
-        # Clear cache and retry
-        torch.cuda.empty_cache()
-        with _ignore_torch_cuda_oom():
-            return func(*args, **kwargs)
-
-        # Try on CPU. This slows down the code significantly, therefore print a notice.
-        logger = logging.getLogger(__name__)
-        logger.info("Attempting to copy inputs of {} to CPU due to CUDA OOM".format(str(func)))
-        new_args = (maybe_to_cpu(x) for x in args)
-        new_kwargs = {k: maybe_to_cpu(v) for k, v in kwargs.items()}
-        return func(*new_args, **new_kwargs)
-
-    return wrapped

spaces/CVPR/time/app.py

@@ -1,38 +0,0 @@
-import gradio as gr
-import cv2
-import numpy as np
-import torch
-import torch.nn as nn
-import torchvision.models as models
-import einops
-
-def predict(img):
-    device = 'cuda' if torch.cuda.is_available() else 'cpu'
-    model = models.resnet50()
-    model.fc = nn.Linear(2048, 720)
-    resume_path = 'full+++++.pth'
-    model.load_state_dict(torch.load(resume_path, map_location=torch.device(device)))
-    model.to(device)
-    with torch.no_grad():
-        model.eval()
-        img = cv2.resize(img, (224, 224))/255.
-        img = np.stack([einops.rearrange(img, 'h w c -> c h w')], 0)
-        img = torch.Tensor(img).float().to(device)
-        pred = model(img)  
-        max_pred = torch.argsort(pred, dim=1, descending=True)
-        max_h = (max_pred[0][0] // 60).item()
-        max_m = (max_pred[0][0] % 60).item()
-    return '{}:{}'.format(str(max_h), str(max_m).zfill(2))
-
-inputs = gr.inputs.Image()
-
-io = gr.Interface(
-    fn=predict,
-    description='Note that this model ingests clocks that are already cropped, i.e. we do not run object detection.',
-    title='It\'s About Time: Analog Clock Reading in the Wild',
-    inputs=inputs,
-    examples=['d1.png', 'd2.png'],
-    outputs="text",
-)
-
-io.launch(share=True)

spaces/CikeyQI/Yunzai/Yunzai/plugins/ws-plugin/model/index.js

@@ -1,21 +0,0 @@
-import { lifecycle, heartbeat } from './meta.js'
-import { makeOneBotReportMsg, makeGSUidReportMsg, makeGSUidSendMsg } from './makeMsg.js'
-import { getApiData } from './api.js'
-import { setGuildLatestMsgId, getGuildLatestMsgId, setMsgMap } from './msgMap.js'
-import { TMP_DIR, sleep, mimeTypes, decodeHtml } from './tool.js'
-
-export {
-    lifecycle,
-    heartbeat,
-    makeOneBotReportMsg,
-    makeGSUidReportMsg,
-    getApiData,
-    makeGSUidSendMsg,
-    setGuildLatestMsgId,
-    getGuildLatestMsgId,
-    setMsgMap,
-    TMP_DIR,
-    sleep,
-    mimeTypes,
-    decodeHtml
-}

spaces/Cyril666/ContourNet-ABI/maskrcnn_benchmark/csrc/ROIPool.h

@@ -1,48 +0,0 @@
-// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
-#pragma once
-
-#include "cpu/vision.h"
-
-#ifdef WITH_CUDA
-#include "cuda/vision.h"
-#endif
-
-
-std::tuple<at::Tensor, at::Tensor> ROIPool_forward(const at::Tensor& input,
-                                const at::Tensor& rois,
-                                const float spatial_scale,
-                                const int pooled_height,
-                                const int pooled_width) {
-  if (input.type().is_cuda()) {
-#ifdef WITH_CUDA
-    return ROIPool_forward_cuda(input, rois, spatial_scale, pooled_height, pooled_width);
-#else
-    AT_ERROR("Not compiled with GPU support");
-#endif
-  }
-  AT_ERROR("Not implemented on the CPU");
-}
-
-at::Tensor ROIPool_backward(const at::Tensor& grad,
-                                 const at::Tensor& input,
-                                 const at::Tensor& rois,
-                                 const at::Tensor& argmax,
-                                 const float spatial_scale,
-                                 const int pooled_height,
-                                 const int pooled_width,
-                                 const int batch_size,
-                                 const int channels,
-                                 const int height,
-                                 const int width) {
-  if (grad.type().is_cuda()) {
-#ifdef WITH_CUDA
-    return ROIPool_backward_cuda(grad, input, rois, argmax, spatial_scale, pooled_height, pooled_width, batch_size, channels, height, width);
-#else
-    AT_ERROR("Not compiled with GPU support");
-#endif
-  }
-  AT_ERROR("Not implemented on the CPU");
-}
-
-
-

spaces/DarkyMan/OrangeMixes/README.md

@@ -1,14 +0,0 @@
----
-title: Open Journey V4
-emoji: 💻
-colorFrom: red
-colorTo: indigo
-sdk: gradio
-sdk_version: 3.23.0
-app_file: app.py
-pinned: false
-license: mit
-duplicated_from: DarkyMan/URPM
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/DeclK/pose/tools/manager.py

@@ -1,72 +0,0 @@
-import mim
-from pathlib import Path
-from mim.utils import get_installed_path, echo_success
-from mmengine.config import Config
-
-class Manager:
-
-    def __init__(self, path=None) -> None:
-        """ 
-        Params:
-            - path: root path of projects to save checkpoints and configs
-        """
-        if path:
-            self.path = Path(path)
-        else:
-            self.path = Path(__file__).parents[1]   
-        self.keys = ['weight', 'config', 'model', 'training_data']
-
-    def get_model_infos(self, package_name, keyword: str=None):
-        """ because mim search is too strict,
-        I want to search by keyword, not a strict match
-        """
-        model_infos = mim.get_model_info(package_name)
-        model_names = model_infos.index
-        info_keys = model_infos.columns.tolist()
-        keys = self.intersect_keys(info_keys,
-                                   self.keys)
-        if keyword is None:
-            return model_infos[:, keys]
-        # get valid names, which contains the keyword
-        valid_names = [name for name in model_names
-                                 if keyword in name]
-        filter_infos = model_infos.loc[valid_names, keys]
-        return filter_infos
-
-    def intersect_keys(self, keys1 , keys2):
-        return list(set(keys1) & set(keys2))
-
-    def download(self, package, model, config_only=False):
-        """ Use model names to download checkpoints and configs.
-        Args:
-            - package: package name, e.g. mmdet
-            - model: model name, e.g. faster_rcnn or faster_rcnn_r50_fpn_1x_coco
-            - config_only: only download configs, which is helpful when you 
-                            already download checkpoints fast through other ways.
-        """
-        infos = self.get_model_infos(package, model)
-        
-        for model, info in infos.iterrows():
-            # get destination path
-            hyper_name = info['model']
-            dst_path = self.path / 'model_zoo' / hyper_name / model
-            dst_path.mkdir(parents=True, exist_ok=True)
-
-            if config_only:
-                # get config path of the package
-                installed_path = Path(get_installed_path(package))
-                config_path = info['config']
-                config_path = installed_path / '.mim' / config_path
-                # build and dump config
-                config_obj = Config.fromfile(config_path)
-                saved_config_path = dst_path / f'{model}.py'
-                config_obj.dump(saved_config_path)
-                echo_success(
-                    f'Successfully dumped {model}.py to {dst_path}')
-            else:
-                mim.download(package, [model], dest_root=dst_path)
-
-if __name__ == '__main__':
-    m = Manager()
-    print(m.get_model_infos('mmdet', 'det'))
-    # m.download('mmpose', 'rtmpose-t_8xb256-420e_aic-coco-256x192', config_only=True)