Update parquet files (step 30 of 476)

spaces/101-5/gpt4free/g4f/.v1/gpt4free/quora/tests/test_api.py

@@ -1,38 +0,0 @@
-import unittest
-import requests
-from unittest.mock import MagicMock
-from gpt4free.quora.api import retry_request
-
-
-class TestRetryRequest(unittest.TestCase):
-    def test_successful_request(self):
-        # Mock a successful request with a 200 status code
-        mock_response = MagicMock()
-        mock_response.status_code = 200
-        requests.get = MagicMock(return_value=mock_response)
-
-        # Call the function and assert that it returns the response
-        response = retry_request(requests.get, "http://example.com", max_attempts=3)
-        self.assertEqual(response.status_code, 200)
-
-    def test_exponential_backoff(self):
-        # Mock a failed request that succeeds after two retries
-        mock_response = MagicMock()
-        mock_response.status_code = 200
-        requests.get = MagicMock(side_effect=[requests.exceptions.RequestException] * 2 + [mock_response])
-
-        # Call the function and assert that it retries with exponential backoff
-        with self.assertLogs() as logs:
-            response = retry_request(requests.get, "http://example.com", max_attempts=3, delay=1)
-            self.assertEqual(response.status_code, 200)
-            self.assertGreaterEqual(len(logs.output), 2)
-            self.assertIn("Retrying in 1 seconds...", logs.output[0])
-            self.assertIn("Retrying in 2 seconds...", logs.output[1])
-
-    def test_too_many_attempts(self):
-        # Mock a failed request that never succeeds
-        requests.get = MagicMock(side_effect=requests.exceptions.RequestException)
-
-        # Call the function and assert that it raises an exception after the maximum number of attempts
-        with self.assertRaises(RuntimeError):
-            retry_request(requests.get, "http://example.com", max_attempts=3)

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Adobe Photoshop CC 2014 [32 64 Bit] Activation Multilanguage How to Get the Most Out of It.md

@@ -1,101 +0,0 @@
-
-<h1>Adobe Photoshop CC 2014 [32 64 Bit] Activation Multilanguage: A Comprehensive Guide</h1>
- <p>Adobe Photoshop is the most popular and powerful image editing software in the world. It allows you to create, edit, and enhance photos, graphics, and designs with a variety of tools and features. Whether you are a professional designer, photographer, or hobbyist, Adobe Photoshop can help you achieve your creative vision.</p>
- <p>In this article, we will introduce you to Adobe Photoshop CC 2014, the latest version of the software that was released in June 2014. We will explain what Adobe Photoshop CC 2014 is, what are its main features, how to install and activate it, and how to use it for design and photography. By the end of this article, you will have a better understanding of Adobe Photoshop CC 2014 and how to make the most of it.</p>
-<h2>Adobe Photoshop CC 2014 [32 64 Bit] Activation Multilanguagel</h2><br /><p><b><b>DOWNLOAD</b> ===== <a href="https://byltly.com/2uKze0">https://byltly.com/2uKze0</a></b></p><br /><br />
- <h2>What is Adobe Photoshop CC 2014?</h2>
- <p>Adobe Photoshop CC 2014 is the fourteenth major release of Adobe Photoshop, which is part of the Adobe Creative Cloud subscription service. It is also known as Adobe Photoshop 15 or Adobe Photoshop 2014. It is available for Windows and Mac OS X operating systems, and it supports both 32-bit and 64-bit architectures.</p>
- <h3>The main features of Adobe Photoshop CC 2014</h3>
- <p>Adobe Photoshop CC 2014 introduces several new features and enhancements that improve the performance, functionality, and usability of the software. Some of the most notable new features are:</p>
- <ul>
-<li><b>Editing images directly in Adobe Camera Raw.</b> This means that you no longer have to convert your raw files into Photoshop format before you can start editing them. Adobe Camera Raw is a powerful image editing tool that gives you complete control over your raw files.</li>
-<li><b>Applying blur effects with Blur Gallery.</b> This feature allows you to create realistic motion blur, spin blur, and path blur effects with ease. You can also use multiple blurs in one image and adjust them individually.</li>
-<li><b>Enhancing typography with new controls and fonts.</b> This feature gives you more options to customize your text, such as font size variations, font matching, smart quotes, hyphenation, and more. You can also access over 900 fonts from Typekit, a library of high-quality fonts that are integrated with Creative Cloud.</li>
-<li><b>Creating and managing assets with Creative Cloud Libraries.</b> This feature lets you create, categorize, and store your favorite colors, brushes, text styles, graphics, and vector images in one easily accessible place. Then you can access them anywhere: Assets you create under the same Adobe ID will be visible across different computers—in a variety of applications like Photoshop CC—wherever you sign in.</li>
-</ul>
- <h3>The system requirements for Adobe Photoshop CC 2014</h3>
- <p>To run Adobe Photoshop CC 2014 smoothly on your computer, you need to meet the following minimum system requirements:</p>
- <table>
-<tr>
-<th>Operating system</th>
-<th>Processor</th>
-<th>RAM</th>
-<th>Hard disk space</th>
-<th>Graphics card</th>
-</tr>
-<tr>
-<td>Windows 7 SP1 or later (32-bit or 64-bit)</td>
-<td>Intel Pentium 4 or AMD Athlon 64 processor (2 GHz or faster)</td>
-<td>2 GB (8 GB recommended)</td>
-<td>2 GB of available hard-disk space for installation; additional free space required during installation (cannot install on removable flash storage devices)</td>
-<td>1024 x 768 display (1280 x 800 recommended) with OpenGL® 2.0–capable system</td>
-</tr>
-<tr>
-<td>Mac OS X v10.7 or later (64-bit only)</td>
-<td>Multicore Intel processor with 64-bit support</td>
-<td>2 GB (8 GB recommended)</td>
-<td>3.2 GB of available hard-disk space for installation; additional free space required during installation (cannot install on a volume that uses a case-sensitive file system or on removable flash storage devices)</td>
-<td>1024 x 768 display (1280 x 800 recommended) with OpenGL® 2.0–capable system</td>
-</tr>
-</table>
- <h2>How to install and activate Adobe Photoshop CC 2014?</h2>
- <p>To install and activate Adobe Photoshop CC 2014 on your computer, you need to follow these steps:</p>
-<p>Adobe Photoshop CC 2014 crack download<br />
-Adobe Photoshop CC 2014 multilingual portable<br />
-Adobe Photoshop CC 2014 serial number<br />
-Adobe Photoshop CC 2014 offline installer<br />
-Adobe Photoshop CC 2014 free trial<br />
-Adobe Photoshop CC 2014 full version<br />
-Adobe Photoshop CC 2014 keygen<br />
-Adobe Photoshop CC 2014 system requirements<br />
-Adobe Photoshop CC 2014 tutorial<br />
-Adobe Photoshop CC 2014 update<br />
-Adobe Photoshop CC 2014 features<br />
-Adobe Photoshop CC 2014 license key<br />
-Adobe Photoshop CC 2014 activation code<br />
-Adobe Photoshop CC 2014 patch<br />
-Adobe Photoshop CC 2014 direct download link<br />
-Adobe Photoshop CC 2014 torrent<br />
-Adobe Photoshop CC 2014 mac<br />
-Adobe Photoshop CC 2014 windows<br />
-Adobe Photoshop CC 2014 x64 bit<br />
-Adobe Photoshop CC 2014 x32 bit<br />
-Adobe Photoshop CC 2014 latest version<br />
-Adobe Photoshop CC 2014 review<br />
-Adobe Photoshop CC 2014 tips and tricks<br />
-Adobe Photoshop CC 2014 plugins<br />
-Adobe Photoshop CC 2014 brushes<br />
-Adobe Photoshop CC 2014 presets<br />
-Adobe Photoshop CC 2014 filters<br />
-Adobe Photoshop CC 2014 actions<br />
-Adobe Photoshop CC 2014 fonts<br />
-Adobe Photoshop CC 2014 tools<br />
-Adobe Photoshop CC 2014 shortcuts<br />
-Adobe Photoshop CC 2014 layers<br />
-Adobe Photoshop CC 2014 masks<br />
-Adobe Photoshop CC 2014 smart objects<br />
-Adobe Photoshop CC 2014 adjustment layers<br />
-Adobe Photoshop CC 2014 blending modes<br />
-Adobe Photoshop CC 2014 selection tools<br />
-Adobe Photoshop CC 2014 transform tools<br />
-Adobe Photoshop CC 2014 crop tool<br />
-Adobe Photoshop CC 2014 healing tools<br />
-Adobe Photoshop CC 2014 clone stamp tool<br />
-Adobe Photoshop CC 2014 pen tool<br />
-Adobe Photoshop CC 2014 text tool<br />
-Adobe Photoshop CC 2014 shape tool<br />
-Adobe Photoshop CC 2014 gradient tool<br />
-Adobe Photoshop CC 2014 paint bucket tool<br />
-Adobe Photoshop CC 2014 eraser tool<br />
-Adobe Photoshop CC 2014 dodge and burn tools<br />
-Adobe Photoshop CC 2014 sponge tool</p>
- <h3>Downloading the setup files</h3>
- <p>You can download the setup files for Adobe Photoshop CC 2014 from the official website of Adobe or from other trusted sources online. Make sure you download the correct version for your operating system and architecture (32-bit or 64-bit). The setup files are usually compressed in ZIP or RAR format, so you need to extract them before installing.</p>
- <h3>Installing Adobe Photoshop CC 2014</h3>
- <p>To install Adobe Photoshop CC 2014 on your computer, you need to run the setup.exe file that you extracted from the downloaded file. Follow the instructions on the screen to complete the installation process. You may need to restart your computer after the installation is finished.</p>
- <h3>Activating Adobe Photoshop CC 2014 with a serial number or a patch</h3>
- <p>To activate Adobe Photoshop CC 2014 on your computer, you need to have a valid serial number or a patch that can bypass the activation process. A serial number is a unique code that identifies your license for using the software. A patch is a small program that modifies the original software code to remove the activation requirement.</p>
- <p>You can obtain a serial number or a patch from various sources online, such as forums, blogs, or websites that offer cracked software. However, be careful when downloading these files as they may contain viruses or malware that can harm your computer. Also, using cracked software is illegal and unethical as it violates the terms and conditions of Adobe.</p>
- <p>If you have a serial number for Adobe Photoshop CC 2014, you can enter it when prompted during the installation process or after launching the software for the first time. If you have a patch for Adobe Photoshop CC</p> 0a6ba089eb<br />
-<br />
-<br />

spaces/1gistliPinn/ChatGPT4/Examples/E Elio Le Story Tese Torrent.md

@@ -1,94 +0,0 @@
-<br />
-<h1>E Elio Le Story Tese Torrent: How to Download Their Music for Free</h1>
-
-<p>Elio e le Storie Tese is an Italian comedy rock band that was formed in 1980. The band is known for their humorous and satirical lyrics, their eclectic musical style, and their live performances. The band has released 14 studio albums, 5 live albums, and several singles and compilations. Some of their most popular songs are "La terra dei cachi", "Mio cuggino", "Born to Be Abramo", and "La canzone mononota".</p>
-
-<p>If you are a fan of Elio e le Storie Tese and you want to download their music for free, you might be tempted to use a torrent site or a file-sharing platform that hosts pirated copies of their albums. However, this is not a legal or safe way to get their music. You might be breaking the law, violating the rights of the band and their record label, exposing yourself to malware or viruses, or risking legal troubles or penalties.</p>
-<h2>E Elio Le Story Tese Torrent</h2><br /><p><b><b>Download</b> &ndash;&ndash;&ndash;&ndash;&ndash;>>> <a href="https://imgfil.com/2uxYMw">https://imgfil.com/2uxYMw</a></b></p><br /><br />
-
-<p>The best way to download E Elio Le Story Tese Torrent legally and safely is to use a streaming service that offers their music in your preferred language and region. Some of the popular streaming platforms that have Elio e le Storie Tese in their library are:</p>
-
-<ul>
-<li>Spotify: You can listen to Elio e le Storie Tese on Spotify for free with ads, or you can upgrade to Spotify Premium for ad-free listening, offline mode, and other features.</li>
-<li>Apple Music: You can listen to Elio e le Storie Tese on Apple Music with a subscription fee, or you can try it for free for three months.</li>
-<li>Deezer: You can listen to Elio e le Storie Tese on Deezer for free with ads, or you can upgrade to Deezer Premium for ad-free listening, offline mode, and other features.</li>
-<li>YouTube Music: You can listen to Elio e le Storie Tese on YouTube Music for free with ads, or you can upgrade to YouTube Music Premium for ad-free listening, offline mode, and other features.</li>
-<li>Amazon Music: You can listen to Elio e le Storie Tese on Amazon Music with a subscription fee, or you can try it for free for 30 days.</li>
-</ul>
-
-<p>All these streaming services offer high-quality audio, as well as various payment options and customer support. However, they may not be available in all countries or regions, so you should check their availability and pricing before choosing one.</p>
-
-<h2>How to Download E Elio Le Story Tese Torrent Illegally</h2>
-
-<p>If you still want to download E Elio Le Story Tese Torrent illegally, you should be aware of the risks and consequences involved. Some of the notorious websites that offer Elio e le Storie Tese torrents are:</p>
-
-<ul>
-<li>RuTracker.org: This is a Russian torrent site that has a large collection of music torrents, including Elio e le Storie Tese albums in FLAC format.</li>
-<li>Marok.org: This is an Italian torrent site that has some videos of Elio e le Storie Tese live performances.</li>
-<li>Archive.org: This is a digital library that hosts various media files, including some audio files of Elio e le Storie Tese songs.</li>
-<li>Direct-Download.com: This is a file-sharing platform that has a link to download Elio e le Storie Tese discography in RAR format.</li>
-</ul>
-
-<p>These websites claim to provide free and fast downloads of E Elio Le Story Tese Torrent files in various formats and resolutions. However, they are not authorized by the original creators or distributors of the music, and they violate the copyright laws and intellectual property rights of the music industry. Moreover, they are risky and unsafe to use, as they may contain malware or viruses that can infect your device or steal your personal information. They may also expose you to legal troubles or penalties if you are caught downloading or sharing pirated content.</p>
-
-<h2>Conclusion</h2>
-
-<p>Elio e le Storie Tese is a band that will appeal to fans of comedy rock and Italian music. If you want to download their music for free, you have several options online, but not all of them are legal or safe. The best way to download E Elio Le Story Tese Torrent legally and safely is to use a streaming service that offers their music in your preferred language and region. However, if you choose to download E Elio Le Story Tese Torrent illegally, you should be aware of the risks and consequences involved.</p>
-
-<p>In this article, we have provided you with some information and tips on how to download E Elio Le Story Tese Torrent legally or illegally. We hope you have enjoyed reading this article and found it useful. Now go ahead and download E Elio Le Story Tese Torrent and enjoy their music!</p>
-<p></p>
-<h2>Why Elio e le Storie Tese is a Unique Band</h2>
-
-<p>Elio e le Storie Tese is not just a comedy rock band, but also a cultural phenomenon in Italy. The band has been praised for their originality, creativity, and versatility. They have experimented with various genres and styles, such as pop, rock, jazz, funk, metal, classical, folk, rap, and more. They have also collaborated with many famous artists and personalities, such as Luciano Pavarotti, Ennio Morricone, Giorgio Moroder, Renato Zero, Jovanotti, and Fabio Fazio.</p>
-
-<p>Elio e le Storie Tese is also known for their social and political satire, their parody of Italian stereotypes and clichés, and their criticism of the Italian society and media. The band has often used irony, sarcasm, absurdity, and nonsense to convey their messages and opinions. They have also created many fictional characters and alter egos, such as Rocco Tanica, Faso, Cesareo, Mangoni, Feiez, Elio Samaga Hukapan Kariyana Turu (the Sri Lankan version of Elio), and Il Complesso Misterioso (a fake band that competed in the Sanremo Music Festival).</p>
-
-<p>Elio e le Storie Tese is a band that has influenced many other artists and comedians in Italy and abroad. They have also received many awards and recognitions for their music and career. They have been nominated for several MTV Europe Music Awards and Italian Music Awards. They have also won the Critics' Award at the Sanremo Music Festival twice (in 1996 and 2013). In 2016, they announced their farewell tour, which ended in 2018 with a final concert in Milan.</p>
-
-<h2>How to Support Elio e le Storie Tese</h2>
-
-<p>If you love Elio e le Storie Tese and you want to support them, you can do so in various ways. Here are some suggestions:</p>
-
-<ul>
-<li>Buy their music: You can buy their albums, singles, compilations, or special editions from their official website or from online stores such as Amazon or iTunes.</li>
-<li>Watch their videos: You can watch their music videos, live performances, interviews, documentaries, or sketches on their official YouTube channel or on other platforms such as Vimeo or Dailymotion.</li>
-<li>Follow them on social media: You can follow them on Facebook, Twitter, Instagram, or other social networks to get updates on their news, events, projects, or personal lives.</li>
-<li>Join their fan club: You can join their official fan club "Elii" to get access to exclusive content, merchandise, discounts, contests, or meet-and-greets.</li>
-<li>Donate to their causes: You can donate to their charitable causes or initiatives that they support or promote. For example, you can donate to the Fondazione Umberto Veronesi (a foundation that supports scientific research on cancer), to the Emergency (a humanitarian organization that provides medical care to victims of war and poverty), or to the Lega del Filo d'Oro (an association that helps deafblind people).</li>
-</ul>
-
-<p>By supporting Elio e le Storie Tese, you are not only showing your appreciation for their music and artistry but also contributing to their legacy and impact on the Italian culture and society.</p>
-<h2>How to Discover More About Elio e le Storie Tese</h2>
-
-<p>If you are curious about Elio e le Storie Tese and you want to discover more about their music and history, you can do so in various ways. Here are some suggestions:</p>
-
-<ul>
-<li>Read their books: You can read their books that contain their lyrics, stories, anecdotes, illustrations, or photos. Some of their books are "Elio Samaga Hukapan Kariyana Turu", "Gli Occhi del Cuore", "Il Mistero dei Bulli", and "La Risposta è Nelle Stelle".</li>
-<li>Watch their movies: You can watch their movies that feature their songs, sketches, or appearances. Some of their movies are "Tutti Gli Uomini del Deficiente", "La Febbre del Sabato Sera", "Fuga da Reuma Park", and "Boris Il Film".</li>
-<li>Listen to their podcasts: You can listen to their podcasts that cover various topics, such as music, cinema, literature, or current affairs. Some of their podcasts are "Elio e le Storie Tese Show", "Elio e le Storie Tese Radio Show", and "Elio e le Storie Tese Podcast".</li>
-<li>Visit their website: You can visit their official website that contains their news, biography, discography, tour dates, merchandise, or contacts.</li>
-<li>Subscribe to their newsletter: You can subscribe to their official newsletter that will send you updates on their activities, projects, or offers.</li>
-</ul>
-
-<p>By discovering more about Elio e le Storie Tese, you are not only enriching your knowledge and appreciation for their music and artistry but also joining their loyal and passionate fan community.</p>
-
-<h2>How to Share E Elio Le Story Tese Torrent with Others</h2>
-
-<p>If you love E Elio Le Story Tese Torrent and you want to share it with others, you can do so in various ways. Here are some suggestions:</p>
-
-<ul>
-<li>Create a playlist: You can create a playlist of your favorite Elio e le Storie Tese songs and share it with your friends or family on social media or streaming platforms.</li>
-<li>Write a review: You can write a review of your favorite Elio e le Storie Tese album or song and share it with other fans or music lovers on blogs or forums.</li>
-<li>Make a tribute: You can make a tribute to Elio e le Storie Tese by covering their songs, making a fan art, writing a fan fiction, or cosplaying their characters.</li>
-<li>Attend a concert: You can attend one of their live concerts and enjoy their music and performance with other fans. You can also take photos or videos and share them online.</li>
-<li>Recommend them: You can recommend Elio e le Storie Tese to someone who might like their music or style. You can also introduce them to some of their songs or albums that suit their taste or mood.</li>
-</ul>
-
-<p>By sharing E Elio Le Story Tese Torrent with others, you are not only spreading your love and enthusiasm for their music and artistry but also supporting their career and success.</p>
-<h2>Conclusion</h2>
-
-<p>E Elio Le Story Tese Torrent is a keyword that refers to the illegal and unsafe way of downloading the music of Elio e le Storie Tese, an Italian comedy rock band that has been entertaining audiences since 1980. The band is known for their witty and satirical lyrics, their eclectic musical style, and their energetic live performances. The band has released 14 studio albums, 5 live albums, and several singles and compilations.</p>
-
-<p>In this article, we have provided you with some information and tips on how to download E Elio Le Story Tese Torrent legally and safely, how to discover more about Elio e le Storie Tese, and how to share their music with others. We hope you have enjoyed reading this article and found it useful. Now go ahead and enjoy E Elio Le Story Tese Torrent online!</p> 3cee63e6c2<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Download attack on titan mod APK for Android - Free and Easy.md

@@ -1,126 +0,0 @@
-<br />
-<h1>Attack on Titan Mod Free Download in APKPure</h1>
-<p>If you are a fan of the popular anime and manga series Attack on Titan, you might be interested in playing the game based on it. However, if you want to enjoy some extra features and enhancements, you might want to try the mod version of the game. In this article, we will show you how to download and install Attack on Titan mod free from APKPure, one of the best sources for Android apps and games.</p>
-<h2>attack on titan mod free download in apkpure</h2><br /><p><b><b>Download Zip</b> &#9675; <a href="https://jinyurl.com/2uNMLd">https://jinyurl.com/2uNMLd</a></b></p><br /><br />
- <h2>What is Attack on Titan?</h2>
-<p>Attack on Titan is a Japanese manga series written and illustrated by Hajime Isayama. It is set in a world where humanity lives inside cities surrounded by three enormous walls that protect them from gigantic man-eating humanoids referred to as Titans. The story follows Eren Yeager, who vows to exterminate the Titans after they bring about the destruction of his hometown and the death of his mother.</p>
-<p>The manga series has been adapted into an anime television series, which has four seasons so far. The anime series has received critical acclaim and commercial success, winning several awards and becoming one of the best-selling manga series of all time.</p>
-<p>The game based on the anime series is called Attack on Titan / A.O.T. Wings of Freedom. It is an action hack and slash game that lets you play as one of the beloved characters from the series. You can use the Three Dimensional Maneuver Gear to fly around and fight against the Titans. You can also discover the story from the anime, with some original twists, and experience the thrill of being in the anime.</p>
-<p>attack on titan mod apk download for android<br />
-attack on titan mod minecraft pe free download<br />
-attack on titan mod apk unlimited money and gems<br />
-attack on titan mod menu apk download latest version<br />
-attack on titan mod for gta san andreas free download<br />
-attack on titan mod apk offline no root<br />
-attack on titan mod pack for minecraft java edition<br />
-attack on titan mod apk rexdl<br />
-attack on titan mod among us free download<br />
-attack on titan mod apk obb highly compressed<br />
-attack on titan mod for roblox free download<br />
-attack on titan mod apk unlimited everything<br />
-attack on titan mod for skyrim special edition<br />
-attack on titan mod apk happymod<br />
-attack on titan mod for gta 5 pc free download<br />
-attack on titan mod apk revdl<br />
-attack on titan mod for sims 4 free download<br />
-attack on titan mod apk all characters unlocked<br />
-attack on titan mod for fallout 4 xbox one<br />
-attack on titan mod apk android 1<br />
-attack on titan mod for terraria free download<br />
-attack on titan mod apk god mode<br />
-attack on titan mod for left 4 dead 2 free download<br />
-attack on titan mod apk unlimited coins and diamonds<br />
-attack on titan mod for stardew valley free download<br />
-attack on titan mod apk no ads<br />
-attack on titan mod for ark survival evolved free download<br />
-attack on titan mod apk unlimited health and stamina<br />
-attack on titan mod for subnautica free download<br />
-attack on titan mod apk latest update<br />
-attack on titan mod for starbound free download<br />
-attack on titan mod apk no verification<br />
-attack on titan mod for mount and blade warband free download<br />
-attack on titan mod apk unlimited blades and gas<br />
-attack on titan mod for rimworld free download<br />
-attack on titan mod apk no human verification<br />
-attack on titan mod for dragon age inquisition free download<br />
-attack on titan mod apk unlimited skills and items<br />
-attack on titan mod for xcom 2 free download<br />
-attack on titan mod apk one hit kill<br />
-attack on titan mod for witcher 3 free download<br />
-attack on titan mod apk online multiplayer<br />
-attack on titan mod for dark souls 3 free download<br />
-attack on titan mod apk all episodes unlocked<br />
-attack on titan mod for dying light free download<br />
-attack on titan mod apk original version<br />
-attack on titan mod for just cause 3 free download</p>
-<p>Some of the main features and characters of the game are:</p>
-<ul>
-<li>Play as Eren, Mikasa, Armin, Levi, Erwin, and more</li>
-<li>Use various weapons and skills to defeat different types of Titans</li>
-<li>Explore various locations from the anime, such as Shiganshina, Trost, Forest of Giant Trees, etc.</li>
-<li>Enjoy stunning graphics and sound effects that match the anime style</li>
-<li>Play solo or in cooperation with up to four players online</li>
-</ul>
- <h2>What is APKPure?</h2>
-<p>APKPure is a website that offers APK files for Android apps and games. APK stands for Android Package Kit, which is a file format that contains all the elements needed to install an app or game on your Android device. Normally, you would download apps and games from Google Play Store, which is the official source for Android apps. However, there are some reasons why you might want to use APKPure instead.</p>
-<p>Some of the benefits of using APKPure are:</p>
-<ul>
-<li>You can download apps and games that are not available in your country or region</li>
-<li>You can download apps and games that are not compatible with your device or Android version</li>
-<li>You can download apps and games that have been removed from Google Play Store</li>
-<li>You can download older versions of apps and games that work better for you</li>
-<li>You can download modded versions of apps and games that have extra features or enhancements</li>
-</ul>
-<p>However, there are also some risks of using APKPure that you should be aware of:</p>
-<ul>
-<li>You might download malicious or harmful files that can damage your device or steal your data</li>
-<li>You might violate the terms and conditions of the app or game developers and face legal consequences</li>
-<li>You might miss out on the updates and bug fixes that are provided by Google Play Store</li>
-<li>You might encounter compatibility or performance issues with some apps or games</li>
-</ul>
-<p>Therefore, you should always be careful and cautious when using APKPure or any other third-party source for Android apps and games. You should always check the ratings, reviews, and permissions of the files before downloading them. You should also scan the files with a reliable antivirus software before installing them. And you should always backup your data and device before trying any new app or game.</p>
- <h2>How to download and install Attack on Titan mod in APKPure?</h2>
-<p>If you want to try the mod version of Attack on Titan / A.O.T. Wings of Freedom, which has some extra features such as unlimited money, unlocked characters, and more, you can download it from APKPure website. Here are the steps to download and install Attack on Titan mod in APKPure:</p>
-<ol>
-<li>Go to the APKPure website and search for Attack on Titan mod or click on this link: [Attack on Titan Mod APK 1.1.2.12 - Download Attack on Titan Mod for Android]</li>
-<li>Click on the green Download APK button and wait for the file to be downloaded to your device</li>
-<li>Once the file is downloaded, go to your device settings and enable the option to install apps from unknown sources. This will allow you to install apps that are not from Google Play Store</li>
-<li>Locate the downloaded APK file in your device storage and tap on it to start the installation process</li>
-<li>Follow the instructions on the screen and grant the necessary permissions to the app</li>
-<li>Wait for the installation to finish and then launch the app from your app drawer or home screen</li>
-</ol>
-<p>Congratulations! You have successfully downloaded and installed Attack on Titan mod in APKPure. You can now enjoy playing the game with some extra features and enhancements.</p>
- <h2>Conclusion</h2>
-<p>In this article, we have shown you how to download and install Attack on Titan mod free from APKPure, one of the best sources for Android apps and games. We have also explained what is Attack on Titan, what is APKPure, and what are the benefits and risks of using APKPure. We hope you found this article helpful and informative. If you have any questions or feedback, please feel free to leave a comment below.</p>
-<p>If you liked this article, please share it with your friends and family who might be interested in playing Attack on Titan mod. And if you want to read more articles like this, please subscribe to our newsletter or follow us on social media. Thank you for reading!</p>
- <h2>FAQs</h2>
-<h3>What is an APK file and why do I need it?</h3>
-<p>An APK file is a file format that contains all the elements needed to install an app or game on your Android device. You need an APK file when you want to download an app or game that is not available in Google Play Store or that is not compatible with your device or Android version.</p>
- <h3>Is APKPure safe and reliable?</h3>
-<p>APKPure is one of the most popular and trusted websites that offers APK files for Android apps and games. It has millions of users and thousands of positive reviews. However, like any other third-party source, it also has some risks of downloading malicious or harmful files that can damage your device or steal your data. Therefore, you should always be careful and cautious when using APKPure or any other third-party source for Android apps and games.</p>
- <h3>What are the requirements and compatibility of Attack on Titan mod?</h3>
-<p>The requirements and compatibility of Attack on Titan mod are as follows:</p>
-<ul>
-<li>The minimum Android version required is 4.0.3 (Ice Cream Sandwich) or higher</li>
-<li>The minimum RAM required is 1 GB or higher</li>
-<li>The minimum storage space required is 500 MB or higher</li>
-<li>The app supports English, Japanese, Chinese, Korean, French, German, Spanish, Italian, Portuguese, Russian, Turkish, Arabic, Indonesian, Thai, Vietnamese languages</li>
-<li>The app is compatible with most Android devices such as Samsung, Huawei, Xiaomi, LG, Sony, Motorola, etc.</li>
-</ul>
- <h3>What are the features and advantages of Attack on Titan mod?</h3>
-<p>The features and advantages of Attack on Titan mod are as follows:</p>
-<ul>
-<li>You can get unlimited money to buy weapons, items, upgrades, etc.</li>
-<li>You can unlock all the characters and skills to play as your favorite character</li>
-<li>You can enjoy the game without any ads or interruptions</li>
-<li>You can customize the game settings to suit your preferences and device performance</li>
-<li>You can experience the game with some extra enhancements and improvements</li>
-</ul>
- <h3>How can I update or uninstall Attack on Titan mod?</h3>
-<p>If you want to update or uninstall Attack on Titan mod, you can follow these steps:</p>
-<ol>
-<li>To update the app, you need to download the latest version of the APK file from APKPure website and install it over the existing app. You don't need to uninstall the previous version, but you should backup your data before updating</li>
-<li>To uninstall the app, you need to go to your device settings and find the app in the list of installed apps. Then, you need to tap on the app and select the option to uninstall it. You should also delete the APK file from your device storage</li>
-</ol></p> 401be4b1e0<br />
-<br />
-<br />

spaces/AIGC-Audio/AudioGPT/text_to_speech/data_gen/tts/txt_processors/zh.py

@@ -1,117 +0,0 @@
-import re
-import jieba
-from pypinyin import pinyin, Style
-from text_to_speech.utils.text.text_norm import NSWNormalizer
-from text_to_speech.data_gen.tts.txt_processors.base_text_processor import BaseTxtProcessor, register_txt_processors
-from text_to_speech.utils.text.text_encoder import PUNCS, is_sil_phoneme
-
-ALL_SHENMU = ['zh', 'ch', 'sh', 'b', 'p', 'm', 'f', 'd', 't', 'n', 'l', 'g', 'k', 'h', 'j',
-              'q', 'x', 'r', 'z', 'c', 's', 'y', 'w']
-
-
-@register_txt_processors('zh')
-class TxtProcessor(BaseTxtProcessor):
-    table = {ord(f): ord(t) for f, t in zip(
-        u'：，。！？【】（）％＃＠＆１２３４５６７８９０',
-        u':,.!?[]()%#@&1234567890')}
-
-    @staticmethod
-    def sp_phonemes():
-        return ['|', '#']
-
-    @staticmethod
-    def preprocess_text(text):
-        text = text.translate(TxtProcessor.table)
-        text = NSWNormalizer(text).normalize(remove_punc=False).lower()
-        text = re.sub("[\'\"()]+", "", text)
-        text = re.sub("[-]+", " ", text)
-        text = re.sub(f"[^ A-Za-z\u4e00-\u9fff{PUNCS}]", "", text)
-        text = re.sub(f"([{PUNCS}])+", r"\1", text)  # !! -> !
-        text = re.sub(f"([{PUNCS}])", r" \1 ", text)
-        text = re.sub(rf"\s+", r"", text)
-        text = re.sub(rf"[A-Za-z]+", r"$", text)
-        return text
-
-    @classmethod
-    def pinyin_with_en(cls, txt, style):
-        x = pinyin(txt, style)
-        x = [t[0] for t in x]
-        x_ = []
-        for t in x:
-            if '$' not in t:
-                x_.append(t)
-            else:
-                x_ += list(t)
-        x_ = [t if t != '$' else 'ENG' for t in x_]
-        return x_
-
-    @classmethod
-    def process(cls, txt, pre_align_args):
-        txt = cls.preprocess_text(txt)
-        txt = txt.replace("嗯", "蒽") # pypin会把嗯的声母韵母识别为''，导致ph2word出现错位。
-        # https://blog.csdn.net/zhoulei124/article/details/89055403
-        
-        shengmu = cls.pinyin_with_en(txt, style=Style.INITIALS)
-        yunmu = cls.pinyin_with_en(txt, style=
-        Style.FINALS_TONE3 if pre_align_args['use_tone'] else Style.FINALS)
-        assert len(shengmu) == len(yunmu)
-        for i in range(len(shengmu)):
-            if shengmu[i] == '' and yunmu[i] == '':
-                print(f"发现了一个声母韵母都是空的文字:{txt[i]}")
-        ph_list = []
-        for a, b in zip(shengmu, yunmu):
-            if a == b:
-                ph_list += [a]
-            else:
-                ph_list += [a + "%" + b]
-        seg_list = '#'.join(jieba.cut(txt))
-        assert len(ph_list) == len([s for s in seg_list if s != '#']), (ph_list, seg_list)
-
-        # 加入词边界'#'
-        ph_list_ = []
-        seg_idx = 0
-        for p in ph_list:
-            if seg_list[seg_idx] == '#':
-                ph_list_.append('#')
-                seg_idx += 1
-            elif len(ph_list_) > 0:
-                ph_list_.append("|")
-            seg_idx += 1
-            finished = False
-            if not finished:
-                ph_list_ += [x for x in p.split("%") if x != '']
-
-        ph_list = ph_list_
-
-        # 去除静音符号周围的词边界标记 [..., '#', ',', '#', ...]
-        sil_phonemes = list(PUNCS) + TxtProcessor.sp_phonemes()
-        ph_list_ = []
-        for i in range(0, len(ph_list), 1):
-            if ph_list[i] != '#' or (ph_list[i - 1] not in sil_phonemes and ph_list[i + 1] not in sil_phonemes):
-                ph_list_.append(ph_list[i])
-        ph_list = ph_list_
-
-        txt_struct = [[w, []] for w in txt]
-        i = 0
-        for ph in ph_list:
-            if ph == '|' or ph == '#':
-                i += 1
-                continue
-            # elif ph in [',', '.']:
-            elif ph in [',', '.', '?', '!', ':']:
-                i += 1
-                txt_struct[i][1].append(ph)
-                i += 1
-                continue
-            txt_struct[i][1].append(ph)
-        # return ph_list, txt
-        txt_struct.insert(0, ['<BOS>', ['<BOS>']])
-        txt_struct.append(['<EOS>', ['<EOS>']])
-        return txt_struct, txt
-
-
-if __name__ == '__main__':
-    # t = 'simon演唱过后，simon还进行了simon精彩的文艺演出simon.'
-    t = '你当我傻啊？脑子那么大怎么塞进去？?？'
-    phs, txt = TxtProcessor.process(t, {'use_tone': True})
-    print(phs, txt)

spaces/AIGC-Audio/Make_An_Audio/ldm/modules/x_transformer.py

@@ -1,641 +0,0 @@
-"""shout-out to https://github.com/lucidrains/x-transformers/tree/main/x_transformers"""
-import torch
-from torch import nn, einsum
-import torch.nn.functional as F
-from functools import partial
-from inspect import isfunction
-from collections import namedtuple
-from einops import rearrange, repeat, reduce
-
-# constants
-
-DEFAULT_DIM_HEAD = 64
-
-Intermediates = namedtuple('Intermediates', [
-    'pre_softmax_attn',
-    'post_softmax_attn'
-])
-
-LayerIntermediates = namedtuple('Intermediates', [
-    'hiddens',
-    'attn_intermediates'
-])
-
-
-class AbsolutePositionalEmbedding(nn.Module):
-    def __init__(self, dim, max_seq_len):
-        super().__init__()
-        self.emb = nn.Embedding(max_seq_len, dim)
-        self.init_()
-
-    def init_(self):
-        nn.init.normal_(self.emb.weight, std=0.02)
-
-    def forward(self, x):
-        n = torch.arange(x.shape[1], device=x.device)
-        return self.emb(n)[None, :, :]
-
-
-class FixedPositionalEmbedding(nn.Module):
-    def __init__(self, dim):
-        super().__init__()
-        inv_freq = 1. / (10000 ** (torch.arange(0, dim, 2).float() / dim))
-        self.register_buffer('inv_freq', inv_freq)
-
-    def forward(self, x, seq_dim=1, offset=0):
-        t = torch.arange(x.shape[seq_dim], device=x.device).type_as(self.inv_freq) + offset
-        sinusoid_inp = torch.einsum('i , j -> i j', t, self.inv_freq)
-        emb = torch.cat((sinusoid_inp.sin(), sinusoid_inp.cos()), dim=-1)
-        return emb[None, :, :]
-
-
-# helpers
-
-def exists(val):
-    return val is not None
-
-
-def default(val, d):
-    if exists(val):
-        return val
-    return d() if isfunction(d) else d
-
-
-def always(val):
-    def inner(*args, **kwargs):
-        return val
-    return inner
-
-
-def not_equals(val):
-    def inner(x):
-        return x != val
-    return inner
-
-
-def equals(val):
-    def inner(x):
-        return x == val
-    return inner
-
-
-def max_neg_value(tensor):
-    return -torch.finfo(tensor.dtype).max
-
-
-# keyword argument helpers
-
-def pick_and_pop(keys, d):
-    values = list(map(lambda key: d.pop(key), keys))
-    return dict(zip(keys, values))
-
-
-def group_dict_by_key(cond, d):
-    return_val = [dict(), dict()]
-    for key in d.keys():
-        match = bool(cond(key))
-        ind = int(not match)
-        return_val[ind][key] = d[key]
-    return (*return_val,)
-
-
-def string_begins_with(prefix, str):
-    return str.startswith(prefix)
-
-
-def group_by_key_prefix(prefix, d):
-    return group_dict_by_key(partial(string_begins_with, prefix), d)
-
-
-def groupby_prefix_and_trim(prefix, d):
-    kwargs_with_prefix, kwargs = group_dict_by_key(partial(string_begins_with, prefix), d)
-    kwargs_without_prefix = dict(map(lambda x: (x[0][len(prefix):], x[1]), tuple(kwargs_with_prefix.items())))
-    return kwargs_without_prefix, kwargs
-
-
-# classes
-class Scale(nn.Module):
-    def __init__(self, value, fn):
-        super().__init__()
-        self.value = value
-        self.fn = fn
-
-    def forward(self, x, **kwargs):
-        x, *rest = self.fn(x, **kwargs)
-        return (x * self.value, *rest)
-
-
-class Rezero(nn.Module):
-    def __init__(self, fn):
-        super().__init__()
-        self.fn = fn
-        self.g = nn.Parameter(torch.zeros(1))
-
-    def forward(self, x, **kwargs):
-        x, *rest = self.fn(x, **kwargs)
-        return (x * self.g, *rest)
-
-
-class ScaleNorm(nn.Module):
-    def __init__(self, dim, eps=1e-5):
-        super().__init__()
-        self.scale = dim ** -0.5
-        self.eps = eps
-        self.g = nn.Parameter(torch.ones(1))
-
-    def forward(self, x):
-        norm = torch.norm(x, dim=-1, keepdim=True) * self.scale
-        return x / norm.clamp(min=self.eps) * self.g
-
-
-class RMSNorm(nn.Module):
-    def __init__(self, dim, eps=1e-8):
-        super().__init__()
-        self.scale = dim ** -0.5
-        self.eps = eps
-        self.g = nn.Parameter(torch.ones(dim))
-
-    def forward(self, x):
-        norm = torch.norm(x, dim=-1, keepdim=True) * self.scale
-        return x / norm.clamp(min=self.eps) * self.g
-
-
-class Residual(nn.Module):
-    def forward(self, x, residual):
-        return x + residual
-
-
-class GRUGating(nn.Module):
-    def __init__(self, dim):
-        super().__init__()
-        self.gru = nn.GRUCell(dim, dim)
-
-    def forward(self, x, residual):
-        gated_output = self.gru(
-            rearrange(x, 'b n d -> (b n) d'),
-            rearrange(residual, 'b n d -> (b n) d')
-        )
-
-        return gated_output.reshape_as(x)
-
-
-# feedforward
-
-class GEGLU(nn.Module):
-    def __init__(self, dim_in, dim_out):
-        super().__init__()
-        self.proj = nn.Linear(dim_in, dim_out * 2)
-
-    def forward(self, x):
-        x, gate = self.proj(x).chunk(2, dim=-1)
-        return x * F.gelu(gate)
-
-
-class FeedForward(nn.Module):
-    def __init__(self, dim, dim_out=None, mult=4, glu=False, dropout=0.):
-        super().__init__()
-        inner_dim = int(dim * mult)
-        dim_out = default(dim_out, dim)
-        project_in = nn.Sequential(
-            nn.Linear(dim, inner_dim),
-            nn.GELU()
-        ) if not glu else GEGLU(dim, inner_dim)
-
-        self.net = nn.Sequential(
-            project_in,
-            nn.Dropout(dropout),
-            nn.Linear(inner_dim, dim_out)
-        )
-
-    def forward(self, x):
-        return self.net(x)
-
-
-# attention.
-class Attention(nn.Module):
-    def __init__(
-            self,
-            dim,
-            dim_head=DEFAULT_DIM_HEAD,
-            heads=8,
-            causal=False,
-            mask=None,
-            talking_heads=False,
-            sparse_topk=None,
-            use_entmax15=False,
-            num_mem_kv=0,
-            dropout=0.,
-            on_attn=False
-    ):
-        super().__init__()
-        if use_entmax15:
-            raise NotImplementedError("Check out entmax activation instead of softmax activation!")
-        self.scale = dim_head ** -0.5
-        self.heads = heads
-        self.causal = causal
-        self.mask = mask
-
-        inner_dim = dim_head * heads
-
-        self.to_q = nn.Linear(dim, inner_dim, bias=False)
-        self.to_k = nn.Linear(dim, inner_dim, bias=False)
-        self.to_v = nn.Linear(dim, inner_dim, bias=False)
-        self.dropout = nn.Dropout(dropout)
-
-        # talking heads
-        self.talking_heads = talking_heads
-        if talking_heads:
-            self.pre_softmax_proj = nn.Parameter(torch.randn(heads, heads))
-            self.post_softmax_proj = nn.Parameter(torch.randn(heads, heads))
-
-        # explicit topk sparse attention
-        self.sparse_topk = sparse_topk
-
-        # entmax
-        #self.attn_fn = entmax15 if use_entmax15 else F.softmax
-        self.attn_fn = F.softmax
-
-        # add memory key / values
-        self.num_mem_kv = num_mem_kv
-        if num_mem_kv > 0:
-            self.mem_k = nn.Parameter(torch.randn(heads, num_mem_kv, dim_head))
-            self.mem_v = nn.Parameter(torch.randn(heads, num_mem_kv, dim_head))
-
-        # attention on attention
-        self.attn_on_attn = on_attn
-        self.to_out = nn.Sequential(nn.Linear(inner_dim, dim * 2), nn.GLU()) if on_attn else nn.Linear(inner_dim, dim)
-
-    def forward(
-            self,
-            x,
-            context=None,
-            mask=None,
-            context_mask=None,
-            rel_pos=None,
-            sinusoidal_emb=None,
-            prev_attn=None,
-            mem=None
-    ):
-        b, n, _, h, talking_heads, device = *x.shape, self.heads, self.talking_heads, x.device
-        kv_input = default(context, x)
-
-        q_input = x
-        k_input = kv_input
-        v_input = kv_input
-
-        if exists(mem):
-            k_input = torch.cat((mem, k_input), dim=-2)
-            v_input = torch.cat((mem, v_input), dim=-2)
-
-        if exists(sinusoidal_emb):
-            # in shortformer, the query would start at a position offset depending on the past cached memory
-            offset = k_input.shape[-2] - q_input.shape[-2]
-            q_input = q_input + sinusoidal_emb(q_input, offset=offset)
-            k_input = k_input + sinusoidal_emb(k_input)
-
-        q = self.to_q(q_input)
-        k = self.to_k(k_input)
-        v = self.to_v(v_input)
-
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h=h), (q, k, v))
-
-        input_mask = None
-        if any(map(exists, (mask, context_mask))):
-            q_mask = default(mask, lambda: torch.ones((b, n), device=device).bool())
-            k_mask = q_mask if not exists(context) else context_mask
-            k_mask = default(k_mask, lambda: torch.ones((b, k.shape[-2]), device=device).bool())
-            q_mask = rearrange(q_mask, 'b i -> b () i ()')
-            k_mask = rearrange(k_mask, 'b j -> b () () j')
-            input_mask = q_mask * k_mask
-
-        if self.num_mem_kv > 0:
-            mem_k, mem_v = map(lambda t: repeat(t, 'h n d -> b h n d', b=b), (self.mem_k, self.mem_v))
-            k = torch.cat((mem_k, k), dim=-2)
-            v = torch.cat((mem_v, v), dim=-2)
-            if exists(input_mask):
-                input_mask = F.pad(input_mask, (self.num_mem_kv, 0), value=True)
-
-        dots = einsum('b h i d, b h j d -> b h i j', q, k) * self.scale
-        mask_value = max_neg_value(dots)
-
-        if exists(prev_attn):
-            dots = dots + prev_attn
-
-        pre_softmax_attn = dots
-
-        if talking_heads:
-            dots = einsum('b h i j, h k -> b k i j', dots, self.pre_softmax_proj).contiguous()
-
-        if exists(rel_pos):
-            dots = rel_pos(dots)
-
-        if exists(input_mask):
-            dots.masked_fill_(~input_mask, mask_value)
-            del input_mask
-
-        if self.causal:
-            i, j = dots.shape[-2:]
-            r = torch.arange(i, device=device)
-            mask = rearrange(r, 'i -> () () i ()') < rearrange(r, 'j -> () () () j')
-            mask = F.pad(mask, (j - i, 0), value=False)
-            dots.masked_fill_(mask, mask_value)
-            del mask
-
-        if exists(self.sparse_topk) and self.sparse_topk < dots.shape[-1]:
-            top, _ = dots.topk(self.sparse_topk, dim=-1)
-            vk = top[..., -1].unsqueeze(-1).expand_as(dots)
-            mask = dots < vk
-            dots.masked_fill_(mask, mask_value)
-            del mask
-
-        attn = self.attn_fn(dots, dim=-1)
-        post_softmax_attn = attn
-
-        attn = self.dropout(attn)
-
-        if talking_heads:
-            attn = einsum('b h i j, h k -> b k i j', attn, self.post_softmax_proj).contiguous()
-
-        out = einsum('b h i j, b h j d -> b h i d', attn, v)
-        out = rearrange(out, 'b h n d -> b n (h d)')
-
-        intermediates = Intermediates(
-            pre_softmax_attn=pre_softmax_attn,
-            post_softmax_attn=post_softmax_attn
-        )
-
-        return self.to_out(out), intermediates
-
-
-class AttentionLayers(nn.Module):
-    def __init__(
-            self,
-            dim,
-            depth,
-            heads=8,
-            causal=False,
-            cross_attend=False,
-            only_cross=False,
-            use_scalenorm=False,
-            use_rmsnorm=False,
-            use_rezero=False,
-            rel_pos_num_buckets=32,
-            rel_pos_max_distance=128,
-            position_infused_attn=False,
-            custom_layers=None,
-            sandwich_coef=None,
-            par_ratio=None,
-            residual_attn=False,
-            cross_residual_attn=False,
-            macaron=False,
-            pre_norm=True,
-            gate_residual=False,
-            **kwargs
-    ):
-        super().__init__()
-        ff_kwargs, kwargs = groupby_prefix_and_trim('ff_', kwargs)
-        attn_kwargs, _ = groupby_prefix_and_trim('attn_', kwargs)
-
-        dim_head = attn_kwargs.get('dim_head', DEFAULT_DIM_HEAD)
-
-        self.dim = dim
-        self.depth = depth
-        self.layers = nn.ModuleList([])
-
-        self.has_pos_emb = position_infused_attn
-        self.pia_pos_emb = FixedPositionalEmbedding(dim) if position_infused_attn else None
-        self.rotary_pos_emb = always(None)
-
-        assert rel_pos_num_buckets <= rel_pos_max_distance, 'number of relative position buckets must be less than the relative position max distance'
-        self.rel_pos = None
-
-        self.pre_norm = pre_norm
-
-        self.residual_attn = residual_attn
-        self.cross_residual_attn = cross_residual_attn
-
-        norm_class = ScaleNorm if use_scalenorm else nn.LayerNorm
-        norm_class = RMSNorm if use_rmsnorm else norm_class
-        norm_fn = partial(norm_class, dim)
-
-        norm_fn = nn.Identity if use_rezero else norm_fn
-        branch_fn = Rezero if use_rezero else None
-
-        if cross_attend and not only_cross:
-            default_block = ('a', 'c', 'f')
-        elif cross_attend and only_cross:
-            default_block = ('c', 'f')
-        else:
-            default_block = ('a', 'f')
-
-        if macaron:
-            default_block = ('f',) + default_block
-
-        if exists(custom_layers):
-            layer_types = custom_layers
-        elif exists(par_ratio):
-            par_depth = depth * len(default_block)
-            assert 1 < par_ratio <= par_depth, 'par ratio out of range'
-            default_block = tuple(filter(not_equals('f'), default_block))
-            par_attn = par_depth // par_ratio
-            depth_cut = par_depth * 2 // 3  # 2 / 3 attention layer cutoff suggested by PAR paper
-            par_width = (depth_cut + depth_cut // par_attn) // par_attn
-            assert len(default_block) <= par_width, 'default block is too large for par_ratio'
-            par_block = default_block + ('f',) * (par_width - len(default_block))
-            par_head = par_block * par_attn
-            layer_types = par_head + ('f',) * (par_depth - len(par_head))
-        elif exists(sandwich_coef):
-            assert sandwich_coef > 0 and sandwich_coef <= depth, 'sandwich coefficient should be less than the depth'
-            layer_types = ('a',) * sandwich_coef + default_block * (depth - sandwich_coef) + ('f',) * sandwich_coef
-        else:
-            layer_types = default_block * depth
-
-        self.layer_types = layer_types
-        self.num_attn_layers = len(list(filter(equals('a'), layer_types)))
-
-        for layer_type in self.layer_types:
-            if layer_type == 'a':
-                layer = Attention(dim, heads=heads, causal=causal, **attn_kwargs)
-            elif layer_type == 'c':
-                layer = Attention(dim, heads=heads, **attn_kwargs)
-            elif layer_type == 'f':
-                layer = FeedForward(dim, **ff_kwargs)
-                layer = layer if not macaron else Scale(0.5, layer)
-            else:
-                raise Exception(f'invalid layer type {layer_type}')
-
-            if isinstance(layer, Attention) and exists(branch_fn):
-                layer = branch_fn(layer)
-
-            if gate_residual:
-                residual_fn = GRUGating(dim)
-            else:
-                residual_fn = Residual()
-
-            self.layers.append(nn.ModuleList([
-                norm_fn(),
-                layer,
-                residual_fn
-            ]))
-
-    def forward(
-            self,
-            x,
-            context=None,
-            mask=None,
-            context_mask=None,
-            mems=None,
-            return_hiddens=False
-    ):
-        hiddens = []
-        intermediates = []
-        prev_attn = None
-        prev_cross_attn = None
-
-        mems = mems.copy() if exists(mems) else [None] * self.num_attn_layers
-
-        for ind, (layer_type, (norm, block, residual_fn)) in enumerate(zip(self.layer_types, self.layers)):
-            is_last = ind == (len(self.layers) - 1)
-
-            if layer_type == 'a':
-                hiddens.append(x)
-                layer_mem = mems.pop(0)
-
-            residual = x
-
-            if self.pre_norm:
-                x = norm(x)
-
-            if layer_type == 'a':
-                out, inter = block(x, mask=mask, sinusoidal_emb=self.pia_pos_emb, rel_pos=self.rel_pos,
-                                   prev_attn=prev_attn, mem=layer_mem)
-            elif layer_type == 'c':
-                out, inter = block(x, context=context, mask=mask, context_mask=context_mask, prev_attn=prev_cross_attn)
-            elif layer_type == 'f':
-                out = block(x)
-
-            x = residual_fn(out, residual)
-
-            if layer_type in ('a', 'c'):
-                intermediates.append(inter)
-
-            if layer_type == 'a' and self.residual_attn:
-                prev_attn = inter.pre_softmax_attn
-            elif layer_type == 'c' and self.cross_residual_attn:
-                prev_cross_attn = inter.pre_softmax_attn
-
-            if not self.pre_norm and not is_last:
-                x = norm(x)
-
-        if return_hiddens:
-            intermediates = LayerIntermediates(
-                hiddens=hiddens,
-                attn_intermediates=intermediates
-            )
-
-            return x, intermediates
-
-        return x
-
-
-class Encoder(AttentionLayers):
-    def __init__(self, **kwargs):
-        assert 'causal' not in kwargs, 'cannot set causality on encoder'
-        super().__init__(causal=False, **kwargs)
-
-
-
-class TransformerWrapper(nn.Module):
-    def __init__(
-            self,
-            *,
-            num_tokens,
-            max_seq_len,
-            attn_layers,
-            emb_dim=None,
-            max_mem_len=0.,
-            emb_dropout=0.,
-            num_memory_tokens=None,
-            tie_embedding=False,
-            use_pos_emb=True
-    ):
-        super().__init__()
-        assert isinstance(attn_layers, AttentionLayers), 'attention layers must be one of Encoder or Decoder'
-
-        dim = attn_layers.dim
-        emb_dim = default(emb_dim, dim)
-
-        self.max_seq_len = max_seq_len
-        self.max_mem_len = max_mem_len
-        self.num_tokens = num_tokens
-
-        self.token_emb = nn.Embedding(num_tokens, emb_dim)
-        self.pos_emb = AbsolutePositionalEmbedding(emb_dim, max_seq_len) if (
-                    use_pos_emb and not attn_layers.has_pos_emb) else always(0)
-        self.emb_dropout = nn.Dropout(emb_dropout)
-
-        self.project_emb = nn.Linear(emb_dim, dim) if emb_dim != dim else nn.Identity()
-        self.attn_layers = attn_layers
-        self.norm = nn.LayerNorm(dim)
-
-        self.init_()
-
-        self.to_logits = nn.Linear(dim, num_tokens) if not tie_embedding else lambda t: t @ self.token_emb.weight.t()
-
-        # memory tokens (like [cls]) from Memory Transformers paper
-        num_memory_tokens = default(num_memory_tokens, 0)
-        self.num_memory_tokens = num_memory_tokens
-        if num_memory_tokens > 0:
-            self.memory_tokens = nn.Parameter(torch.randn(num_memory_tokens, dim))
-
-            # let funnel encoder know number of memory tokens, if specified
-            if hasattr(attn_layers, 'num_memory_tokens'):
-                attn_layers.num_memory_tokens = num_memory_tokens
-
-    def init_(self):
-        nn.init.normal_(self.token_emb.weight, std=0.02)
-
-    def forward(
-            self,
-            x,
-            return_embeddings=False,
-            mask=None,
-            return_mems=False,
-            return_attn=False,
-            mems=None,
-            **kwargs
-    ):
-        b, n, device, num_mem = *x.shape, x.device, self.num_memory_tokens
-        x = self.token_emb(x)
-        x += self.pos_emb(x)
-        x = self.emb_dropout(x)
-
-        x = self.project_emb(x)
-
-        if num_mem > 0:
-            mem = repeat(self.memory_tokens, 'n d -> b n d', b=b)
-            x = torch.cat((mem, x), dim=1)
-
-            # auto-handle masking after appending memory tokens
-            if exists(mask):
-                mask = F.pad(mask, (num_mem, 0), value=True)
-
-        x, intermediates = self.attn_layers(x, mask=mask, mems=mems, return_hiddens=True, **kwargs)
-        x = self.norm(x)
-
-        mem, x = x[:, :num_mem], x[:, num_mem:]
-
-        out = self.to_logits(x) if not return_embeddings else x
-
-        if return_mems:
-            hiddens = intermediates.hiddens
-            new_mems = list(map(lambda pair: torch.cat(pair, dim=-2), zip(mems, hiddens))) if exists(mems) else hiddens
-            new_mems = list(map(lambda t: t[..., -self.max_mem_len:, :].detach(), new_mems))
-            return out, new_mems
-
-        if return_attn:
-            attn_maps = list(map(lambda t: t.post_softmax_attn, intermediates.attn_intermediates))
-            return out, attn_maps
-
-        return out
-

spaces/AIGText/GlyphControl/annotator/render_images.py

@@ -1,95 +0,0 @@
-from PIL import Image, ImageFont, ImageDraw
-import random
-
-# resize height to image_height first, then shrink or pad to image_width
-def resize_and_pad_image(pil_image, image_size):
-
-    if isinstance(image_size, (tuple, list)) and len(image_size) == 2:
-        image_width, image_height = image_size
-    elif isinstance(image_size, int):
-        image_width  = image_height = image_size
-    else:
-        raise ValueError(f"Image size should be int or list/tuple of int not {image_size}")
-
-    while pil_image.size[1] >= 2 * image_height:
-        pil_image = pil_image.resize(
-            tuple(x // 2 for x in pil_image.size), resample=Image.BOX
-        )
-    
-    scale = image_height / pil_image.size[1]
-    pil_image = pil_image.resize(tuple(round(x * scale) for x in pil_image.size),resample=Image.BICUBIC)
-
-    # shrink
-    if pil_image.size[0] > image_width:
-        pil_image = pil_image.resize((image_width, image_height),resample=Image.BICUBIC)
-    
-    # padding
-    if pil_image.size[0] < image_width:
-        img = Image.new(mode="RGB",size=(image_width,image_height), color="white")
-        width, _ = pil_image.size
-        img.paste(pil_image,((image_width - width)//2, 0))
-        pil_image = img
-
-    return pil_image
-
-def render_text_image_custom(image_size, bboxes, rendered_txt_values, num_rows_values, align = "center"):
-    # aligns = ["center", "left", "right"]
-    """Render text image based on the list of bbox called  `bboxes`.
-        Support font that can be choosed.
-    """
-    print(image_size, bboxes, rendered_txt_values, num_rows_values, align)
-    background = Image.new("RGB", image_size, "white")
-    font = ImageFont.truetype("calibri.ttf", encoding='utf-8', size=512)
-    
-    for text, bbox, num_rows in zip(rendered_txt_values, bboxes, num_rows_values):
-        
-        if len(text) == 0:
-            continue
-        
-        text = text.strip()
-        if num_rows != 1:
-            word_tokens = text.split()
-            num_tokens = len(word_tokens)
-            index_list = range(1, num_tokens + 1)
-            if num_tokens > num_rows:
-                index_list = random.sample(index_list, num_rows)
-                index_list.sort()
-            line_list = []
-            start_idx = 0
-            for index in index_list: 
-                line_list.append(
-                    " ".join(word_tokens
-                    [start_idx: index]
-                    )
-                )
-                start_idx = index
-            text = "\n".join(line_list)
-        
-        if 'ratio' not in bbox or bbox['ratio'] == 0 or bbox['ratio'] < 1e-4:
-            image4ratio = Image.new("RGB", (512, 512), "white")
-            draw = ImageDraw.Draw(image4ratio)
-            _, _ , w, h = draw.textbbox(xy=(0,0),text = text, font=font)
-            ratio = w / h
-        else:
-            ratio = bbox['ratio']
-        
-        width = int(bbox['width'] * image_size[1])
-        height = int(width / ratio)
-        top_left_x = int(bbox['top_left_x'] * image_size[0])
-        top_left_y = int(bbox['top_left_y'] * image_size[1])
-        yaw = bbox['yaw']
-        
-        text_image = Image.new("RGB", (512, 512), "white")
-        draw = ImageDraw.Draw(text_image)
-        x,y,w,h = draw.textbbox(xy=(0,0),text = text, font=font)   
-        text_image = Image.new("RGB", (w, h), "white")
-        draw = ImageDraw.Draw(text_image)
-        draw.text((-x/2,-y/2), text, "black", font=font, align=align)
-        text_image = resize_and_pad_image(text_image, (width, height))
-        text_image = text_image.rotate(angle=-yaw, expand=True, fillcolor="white")
-        # image = Image.new("RGB", (w, h), "white")
-        # draw = ImageDraw.Draw(image)
-        
-        background.paste(text_image, (top_left_x, top_left_y))
-    
-    return background

spaces/Abhilashvj/planogram-compliance/classify/train.py

@@ -1,537 +0,0 @@
-# YOLOv5 🚀 by Ultralytics, GPL-3.0 license
-"""
-Train a YOLOv5 classifier model on a classification dataset
-
-Usage - Single-GPU training:
-    $ python classify/train.py --model yolov5s-cls.pt --data imagenette160 --epochs 5 --img 224
-
-Usage - Multi-GPU DDP training:
-    $ python -m torch.distributed.run --nproc_per_node 4 --master_port 2022 classify/train.py --model yolov5s-cls.pt --data imagenet --epochs 5 --img 224 --device 0,1,2,3
-
-Datasets:           --data mnist, fashion-mnist, cifar10, cifar100, imagenette, imagewoof, imagenet, or 'path/to/data'
-YOLOv5-cls models:  --model yolov5n-cls.pt, yolov5s-cls.pt, yolov5m-cls.pt, yolov5l-cls.pt, yolov5x-cls.pt
-Torchvision models: --model resnet50, efficientnet_b0, etc. See https://pytorch.org/vision/stable/models.html
-"""
-
-import argparse
-import os
-import subprocess
-import sys
-import time
-from copy import deepcopy
-from datetime import datetime
-from pathlib import Path
-
-import torch
-import torch.distributed as dist
-import torch.hub as hub
-import torch.optim.lr_scheduler as lr_scheduler
-import torchvision
-from torch.cuda import amp
-from tqdm import tqdm
-
-FILE = Path(__file__).resolve()
-ROOT = FILE.parents[1]  # YOLOv5 root directory
-if str(ROOT) not in sys.path:
-    sys.path.append(str(ROOT))  # add ROOT to PATH
-ROOT = Path(os.path.relpath(ROOT, Path.cwd()))  # relative
-
-from classify import val as validate
-from models.experimental import attempt_load
-from models.yolo import ClassificationModel, DetectionModel
-from utils.dataloaders import create_classification_dataloader
-from utils.general import (
-    DATASETS_DIR,
-    LOGGER,
-    TQDM_BAR_FORMAT,
-    WorkingDirectory,
-    check_git_info,
-    check_git_status,
-    check_requirements,
-    colorstr,
-    download,
-    increment_path,
-    init_seeds,
-    print_args,
-    yaml_save,
-)
-from utils.loggers import GenericLogger
-from utils.plots import imshow_cls
-from utils.torch_utils import (
-    ModelEMA,
-    model_info,
-    reshape_classifier_output,
-    select_device,
-    smart_DDP,
-    smart_optimizer,
-    smartCrossEntropyLoss,
-    torch_distributed_zero_first,
-)
-
-LOCAL_RANK = int(
-    os.getenv("LOCAL_RANK", -1)
-)  # https://pytorch.org/docs/stable/elastic/run.html
-RANK = int(os.getenv("RANK", -1))
-WORLD_SIZE = int(os.getenv("WORLD_SIZE", 1))
-GIT_INFO = check_git_info()
-
-
-def train(opt, device):
-    init_seeds(opt.seed + 1 + RANK, deterministic=True)
-    save_dir, data, bs, epochs, nw, imgsz, pretrained = (
-        opt.save_dir,
-        Path(opt.data),
-        opt.batch_size,
-        opt.epochs,
-        min(os.cpu_count() - 1, opt.workers),
-        opt.imgsz,
-        str(opt.pretrained).lower() == "true",
-    )
-    cuda = device.type != "cpu"
-
-    # Directories
-    wdir = save_dir / "weights"
-    wdir.mkdir(parents=True, exist_ok=True)  # make dir
-    last, best = wdir / "last.pt", wdir / "best.pt"
-
-    # Save run settings
-    yaml_save(save_dir / "opt.yaml", vars(opt))
-
-    # Logger
-    logger = (
-        GenericLogger(opt=opt, console_logger=LOGGER)
-        if RANK in {-1, 0}
-        else None
-    )
-
-    # Download Dataset
-    with torch_distributed_zero_first(LOCAL_RANK), WorkingDirectory(ROOT):
-        data_dir = data if data.is_dir() else (DATASETS_DIR / data)
-        if not data_dir.is_dir():
-            LOGGER.info(
-                f"\nDataset not found ⚠️, missing path {data_dir}, attempting download..."
-            )
-            t = time.time()
-            if str(data) == "imagenet":
-                subprocess.run(
-                    f"bash {ROOT / 'data/scripts/get_imagenet.sh'}",
-                    shell=True,
-                    check=True,
-                )
-            else:
-                url = f"https://github.com/ultralytics/yolov5/releases/download/v1.0/{data}.zip"
-                download(url, dir=data_dir.parent)
-            s = f"Dataset download success ✅ ({time.time() - t:.1f}s), saved to {colorstr('bold', data_dir)}\n"
-            LOGGER.info(s)
-
-    # Dataloaders
-    nc = len(
-        [x for x in (data_dir / "train").glob("*") if x.is_dir()]
-    )  # number of classes
-    trainloader = create_classification_dataloader(
-        path=data_dir / "train",
-        imgsz=imgsz,
-        batch_size=bs // WORLD_SIZE,
-        augment=True,
-        cache=opt.cache,
-        rank=LOCAL_RANK,
-        workers=nw,
-    )
-
-    test_dir = (
-        data_dir / "test" if (data_dir / "test").exists() else data_dir / "val"
-    )  # data/test or data/val
-    if RANK in {-1, 0}:
-        testloader = create_classification_dataloader(
-            path=test_dir,
-            imgsz=imgsz,
-            batch_size=bs // WORLD_SIZE * 2,
-            augment=False,
-            cache=opt.cache,
-            rank=-1,
-            workers=nw,
-        )
-
-    # Model
-    with torch_distributed_zero_first(LOCAL_RANK), WorkingDirectory(ROOT):
-        if Path(opt.model).is_file() or opt.model.endswith(".pt"):
-            model = attempt_load(opt.model, device="cpu", fuse=False)
-        elif (
-            opt.model in torchvision.models.__dict__
-        ):  # TorchVision models i.e. resnet50, efficientnet_b0
-            model = torchvision.models.__dict__[opt.model](
-                weights="IMAGENET1K_V1" if pretrained else None
-            )
-        else:
-            m = hub.list(
-                "ultralytics/yolov5"
-            )  # + hub.list('pytorch/vision')  # models
-            raise ModuleNotFoundError(
-                f"--model {opt.model} not found. Available models are: \n"
-                + "\n".join(m)
-            )
-        if isinstance(model, DetectionModel):
-            LOGGER.warning(
-                "WARNING ⚠️ pass YOLOv5 classifier model with '-cls' suffix, i.e. '--model yolov5s-cls.pt'"
-            )
-            model = ClassificationModel(
-                model=model, nc=nc, cutoff=opt.cutoff or 10
-            )  # convert to classification model
-        reshape_classifier_output(model, nc)  # update class count
-    for m in model.modules():
-        if not pretrained and hasattr(m, "reset_parameters"):
-            m.reset_parameters()
-        if isinstance(m, torch.nn.Dropout) and opt.dropout is not None:
-            m.p = opt.dropout  # set dropout
-    for p in model.parameters():
-        p.requires_grad = True  # for training
-    model = model.to(device)
-
-    # Info
-    if RANK in {-1, 0}:
-        model.names = trainloader.dataset.classes  # attach class names
-        model.transforms = (
-            testloader.dataset.torch_transforms
-        )  # attach inference transforms
-        model_info(model)
-        if opt.verbose:
-            LOGGER.info(model)
-        images, labels = next(iter(trainloader))
-        file = imshow_cls(
-            images[:25],
-            labels[:25],
-            names=model.names,
-            f=save_dir / "train_images.jpg",
-        )
-        logger.log_images(file, name="Train Examples")
-        logger.log_graph(model, imgsz)  # log model
-
-    # Optimizer
-    optimizer = smart_optimizer(
-        model, opt.optimizer, opt.lr0, momentum=0.9, decay=opt.decay
-    )
-
-    # Scheduler
-    lrf = 0.01  # final lr (fraction of lr0)
-    # lf = lambda x: ((1 + math.cos(x * math.pi / epochs)) / 2) * (1 - lrf) + lrf  # cosine
-    lf = lambda x: (1 - x / epochs) * (1 - lrf) + lrf  # linear
-    scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda=lf)
-    # scheduler = lr_scheduler.OneCycleLR(optimizer, max_lr=lr0, total_steps=epochs, pct_start=0.1,
-    #                                    final_div_factor=1 / 25 / lrf)
-
-    # EMA
-    ema = ModelEMA(model) if RANK in {-1, 0} else None
-
-    # DDP mode
-    if cuda and RANK != -1:
-        model = smart_DDP(model)
-
-    # Train
-    t0 = time.time()
-    criterion = smartCrossEntropyLoss(
-        label_smoothing=opt.label_smoothing
-    )  # loss function
-    best_fitness = 0.0
-    scaler = amp.GradScaler(enabled=cuda)
-    val = test_dir.stem  # 'val' or 'test'
-    LOGGER.info(
-        f"Image sizes {imgsz} train, {imgsz} test\n"
-        f"Using {nw * WORLD_SIZE} dataloader workers\n"
-        f"Logging results to {colorstr('bold', save_dir)}\n"
-        f"Starting {opt.model} training on {data} dataset with {nc} classes for {epochs} epochs...\n\n"
-        f"{'Epoch':>10}{'GPU_mem':>10}{'train_loss':>12}{f'{val}_loss':>12}{'top1_acc':>12}{'top5_acc':>12}"
-    )
-    for epoch in range(epochs):  # loop over the dataset multiple times
-        tloss, vloss, fitness = 0.0, 0.0, 0.0  # train loss, val loss, fitness
-        model.train()
-        if RANK != -1:
-            trainloader.sampler.set_epoch(epoch)
-        pbar = enumerate(trainloader)
-        if RANK in {-1, 0}:
-            pbar = tqdm(
-                enumerate(trainloader),
-                total=len(trainloader),
-                bar_format=TQDM_BAR_FORMAT,
-            )
-        for i, (images, labels) in pbar:  # progress bar
-            images, labels = images.to(device, non_blocking=True), labels.to(
-                device
-            )
-
-            # Forward
-            with amp.autocast(enabled=cuda):  # stability issues when enabled
-                loss = criterion(model(images), labels)
-
-            # Backward
-            scaler.scale(loss).backward()
-
-            # Optimize
-            scaler.unscale_(optimizer)  # unscale gradients
-            torch.nn.utils.clip_grad_norm_(
-                model.parameters(), max_norm=10.0
-            )  # clip gradients
-            scaler.step(optimizer)
-            scaler.update()
-            optimizer.zero_grad()
-            if ema:
-                ema.update(model)
-
-            if RANK in {-1, 0}:
-                # Print
-                tloss = (tloss * i + loss.item()) / (
-                    i + 1
-                )  # update mean losses
-                mem = "%.3gG" % (
-                    torch.cuda.memory_reserved() / 1e9
-                    if torch.cuda.is_available()
-                    else 0
-                )  # (GB)
-                pbar.desc = (
-                    f"{f'{epoch + 1}/{epochs}':>10}{mem:>10}{tloss:>12.3g}"
-                    + " " * 36
-                )
-
-                # Test
-                if i == len(pbar) - 1:  # last batch
-                    top1, top5, vloss = validate.run(
-                        model=ema.ema,
-                        dataloader=testloader,
-                        criterion=criterion,
-                        pbar=pbar,
-                    )  # test accuracy, loss
-                    fitness = top1  # define fitness as top1 accuracy
-
-        # Scheduler
-        scheduler.step()
-
-        # Log metrics
-        if RANK in {-1, 0}:
-            # Best fitness
-            if fitness > best_fitness:
-                best_fitness = fitness
-
-            # Log
-            metrics = {
-                "train/loss": tloss,
-                f"{val}/loss": vloss,
-                "metrics/accuracy_top1": top1,
-                "metrics/accuracy_top5": top5,
-                "lr/0": optimizer.param_groups[0]["lr"],
-            }  # learning rate
-            logger.log_metrics(metrics, epoch)
-
-            # Save model
-            final_epoch = epoch + 1 == epochs
-            if (not opt.nosave) or final_epoch:
-                ckpt = {
-                    "epoch": epoch,
-                    "best_fitness": best_fitness,
-                    "model": deepcopy(
-                        ema.ema
-                    ).half(),  # deepcopy(de_parallel(model)).half(),
-                    "ema": None,  # deepcopy(ema.ema).half(),
-                    "updates": ema.updates,
-                    "optimizer": None,  # optimizer.state_dict(),
-                    "opt": vars(opt),
-                    "git": GIT_INFO,  # {remote, branch, commit} if a git repo
-                    "date": datetime.now().isoformat(),
-                }
-
-                # Save last, best and delete
-                torch.save(ckpt, last)
-                if best_fitness == fitness:
-                    torch.save(ckpt, best)
-                del ckpt
-
-    # Train complete
-    if RANK in {-1, 0} and final_epoch:
-        LOGGER.info(
-            f"\nTraining complete ({(time.time() - t0) / 3600:.3f} hours)"
-            f"\nResults saved to {colorstr('bold', save_dir)}"
-            f"\nPredict:         python classify/predict.py --weights {best} --source im.jpg"
-            f"\nValidate:        python classify/val.py --weights {best} --data {data_dir}"
-            f"\nExport:          python export.py --weights {best} --include onnx"
-            f"\nPyTorch Hub:     model = torch.hub.load('ultralytics/yolov5', 'custom', '{best}')"
-            f"\nVisualize:       https://netron.app\n"
-        )
-
-        # Plot examples
-        images, labels = (
-            x[:25] for x in next(iter(testloader))
-        )  # first 25 images and labels
-        pred = torch.max(ema.ema(images.to(device)), 1)[1]
-        file = imshow_cls(
-            images,
-            labels,
-            pred,
-            model.names,
-            verbose=False,
-            f=save_dir / "test_images.jpg",
-        )
-
-        # Log results
-        meta = {
-            "epochs": epochs,
-            "top1_acc": best_fitness,
-            "date": datetime.now().isoformat(),
-        }
-        logger.log_images(
-            file, name="Test Examples (true-predicted)", epoch=epoch
-        )
-        logger.log_model(best, epochs, metadata=meta)
-
-
-def parse_opt(known=False):
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--model",
-        type=str,
-        default="yolov5s-cls.pt",
-        help="initial weights path",
-    )
-    parser.add_argument(
-        "--data",
-        type=str,
-        default="imagenette160",
-        help="cifar10, cifar100, mnist, imagenet, ...",
-    )
-    parser.add_argument(
-        "--epochs", type=int, default=10, help="total training epochs"
-    )
-    parser.add_argument(
-        "--batch-size",
-        type=int,
-        default=64,
-        help="total batch size for all GPUs",
-    )
-    parser.add_argument(
-        "--imgsz",
-        "--img",
-        "--img-size",
-        type=int,
-        default=224,
-        help="train, val image size (pixels)",
-    )
-    parser.add_argument(
-        "--nosave", action="store_true", help="only save final checkpoint"
-    )
-    parser.add_argument(
-        "--cache",
-        type=str,
-        nargs="?",
-        const="ram",
-        help='--cache images in "ram" (default) or "disk"',
-    )
-    parser.add_argument(
-        "--device", default="", help="cuda device, i.e. 0 or 0,1,2,3 or cpu"
-    )
-    parser.add_argument(
-        "--workers",
-        type=int,
-        default=8,
-        help="max dataloader workers (per RANK in DDP mode)",
-    )
-    parser.add_argument(
-        "--project",
-        default=ROOT / "runs/train-cls",
-        help="save to project/name",
-    )
-    parser.add_argument("--name", default="exp", help="save to project/name")
-    parser.add_argument(
-        "--exist-ok",
-        action="store_true",
-        help="existing project/name ok, do not increment",
-    )
-    parser.add_argument(
-        "--pretrained",
-        nargs="?",
-        const=True,
-        default=True,
-        help="start from i.e. --pretrained False",
-    )
-    parser.add_argument(
-        "--optimizer",
-        choices=["SGD", "Adam", "AdamW", "RMSProp"],
-        default="Adam",
-        help="optimizer",
-    )
-    parser.add_argument(
-        "--lr0", type=float, default=0.001, help="initial learning rate"
-    )
-    parser.add_argument(
-        "--decay", type=float, default=5e-5, help="weight decay"
-    )
-    parser.add_argument(
-        "--label-smoothing",
-        type=float,
-        default=0.1,
-        help="Label smoothing epsilon",
-    )
-    parser.add_argument(
-        "--cutoff",
-        type=int,
-        default=None,
-        help="Model layer cutoff index for Classify() head",
-    )
-    parser.add_argument(
-        "--dropout", type=float, default=None, help="Dropout (fraction)"
-    )
-    parser.add_argument("--verbose", action="store_true", help="Verbose mode")
-    parser.add_argument(
-        "--seed", type=int, default=0, help="Global training seed"
-    )
-    parser.add_argument(
-        "--local_rank",
-        type=int,
-        default=-1,
-        help="Automatic DDP Multi-GPU argument, do not modify",
-    )
-    return parser.parse_known_args()[0] if known else parser.parse_args()
-
-
-def main(opt):
-    # Checks
-    if RANK in {-1, 0}:
-        print_args(vars(opt))
-        check_git_status()
-        check_requirements()
-
-    # DDP mode
-    device = select_device(opt.device, batch_size=opt.batch_size)
-    if LOCAL_RANK != -1:
-        assert (
-            opt.batch_size != -1
-        ), "AutoBatch is coming soon for classification, please pass a valid --batch-size"
-        assert (
-            opt.batch_size % WORLD_SIZE == 0
-        ), f"--batch-size {opt.batch_size} must be multiple of WORLD_SIZE"
-        assert (
-            torch.cuda.device_count() > LOCAL_RANK
-        ), "insufficient CUDA devices for DDP command"
-        torch.cuda.set_device(LOCAL_RANK)
-        device = torch.device("cuda", LOCAL_RANK)
-        dist.init_process_group(
-            backend="nccl" if dist.is_nccl_available() else "gloo"
-        )
-
-    # Parameters
-    opt.save_dir = increment_path(
-        Path(opt.project) / opt.name, exist_ok=opt.exist_ok
-    )  # increment run
-
-    # Train
-    train(opt, device)
-
-
-def run(**kwargs):
-    # Usage: from yolov5 import classify; classify.train.run(data=mnist, imgsz=320, model='yolov5m')
-    opt = parse_opt(True)
-    for k, v in kwargs.items():
-        setattr(opt, k, v)
-    main(opt)
-    return opt
-
-
-if __name__ == "__main__":
-    opt = parse_opt()
-    main(opt)

spaces/AchyuthGamer/OpenGPT/g4f/Provider/deprecated/Equing.py

@@ -1,81 +0,0 @@
-from __future__ import annotations
-
-import json
-from abc import ABC, abstractmethod
-
-import requests
-
-from ...typing import Any, CreateResult
-from ..base_provider import BaseProvider
-
-
-class Equing(BaseProvider):
-    url: str              = 'https://next.eqing.tech/'
-    working               = False
-    supports_stream       = True
-    supports_gpt_35_turbo = True
-    supports_gpt_4        = False
-
-    @staticmethod
-    @abstractmethod
-    def create_completion(
-        model: str,
-        messages: list[dict[str, str]],
-        stream: bool, **kwargs: Any) -> CreateResult:
-
-        headers = {
-            'authority'         : 'next.eqing.tech',
-            'accept'            : 'text/event-stream',
-            'accept-language'   : 'en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3',
-            'cache-control'     : 'no-cache',
-            'content-type'      : 'application/json',
-            'origin'            : 'https://next.eqing.tech',
-            'plugins'           : '0',
-            'pragma'            : 'no-cache',
-            'referer'           : 'https://next.eqing.tech/',
-            'sec-ch-ua'         : '"Not/A)Brand";v="99", "Google Chrome";v="115", "Chromium";v="115"',
-            'sec-ch-ua-mobile'  : '?0',
-            'sec-ch-ua-platform': '"macOS"',
-            'sec-fetch-dest'    : 'empty',
-            'sec-fetch-mode'    : 'cors',
-            'sec-fetch-site'    : 'same-origin',
-            'user-agent'        : 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36',
-            'usesearch'         : 'false',
-            'x-requested-with'  : 'XMLHttpRequest'
-        }
-
-        json_data = {
-            'messages'          : messages,
-            'stream'            : stream,
-            'model'             : model,
-            'temperature'       : kwargs.get('temperature', 0.5),
-            'presence_penalty'  : kwargs.get('presence_penalty', 0),
-            'frequency_penalty' : kwargs.get('frequency_penalty', 0),
-            'top_p'             : kwargs.get('top_p', 1),
-        }
-
-        response = requests.post('https://next.eqing.tech/api/openai/v1/chat/completions',
-            headers=headers, json=json_data, stream=stream)
-        
-        if not stream:
-            yield response.json()["choices"][0]["message"]["content"]
-            return
-        
-        for line in response.iter_content(chunk_size=1024):
-            if line:
-                if b'content' in line:
-                        line_json = json.loads(line.decode('utf-8').split('data: ')[1])
-                        token = line_json['choices'][0]['delta'].get('content')
-                        if token:
-                            yield token
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"

spaces/Aditya9790/yolo7-object-tracking/models/experimental.py

@@ -1,272 +0,0 @@
-import numpy as np
-import random
-import torch
-import torch.nn as nn
-
-from models.common import Conv, DWConv
-from utils.google_utils import attempt_download
-
-
-class CrossConv(nn.Module):
-    # Cross Convolution Downsample
-    def __init__(self, c1, c2, k=3, s=1, g=1, e=1.0, shortcut=False):
-        # ch_in, ch_out, kernel, stride, groups, expansion, shortcut
-        super(CrossConv, self).__init__()
-        c_ = int(c2 * e)  # hidden channels
-        self.cv1 = Conv(c1, c_, (1, k), (1, s))
-        self.cv2 = Conv(c_, c2, (k, 1), (s, 1), g=g)
-        self.add = shortcut and c1 == c2
-
-    def forward(self, x):
-        return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x))
-
-
-class Sum(nn.Module):
-    # Weighted sum of 2 or more layers https://arxiv.org/abs/1911.09070
-    def __init__(self, n, weight=False):  # n: number of inputs
-        super(Sum, self).__init__()
-        self.weight = weight  # apply weights boolean
-        self.iter = range(n - 1)  # iter object
-        if weight:
-            self.w = nn.Parameter(-torch.arange(1., n) / 2, requires_grad=True)  # layer weights
-
-    def forward(self, x):
-        y = x[0]  # no weight
-        if self.weight:
-            w = torch.sigmoid(self.w) * 2
-            for i in self.iter:
-                y = y + x[i + 1] * w[i]
-        else:
-            for i in self.iter:
-                y = y + x[i + 1]
-        return y
-
-
-class MixConv2d(nn.Module):
-    # Mixed Depthwise Conv https://arxiv.org/abs/1907.09595
-    def __init__(self, c1, c2, k=(1, 3), s=1, equal_ch=True):
-        super(MixConv2d, self).__init__()
-        groups = len(k)
-        if equal_ch:  # equal c_ per group
-            i = torch.linspace(0, groups - 1E-6, c2).floor()  # c2 indices
-            c_ = [(i == g).sum() for g in range(groups)]  # intermediate channels
-        else:  # equal weight.numel() per group
-            b = [c2] + [0] * groups
-            a = np.eye(groups + 1, groups, k=-1)
-            a -= np.roll(a, 1, axis=1)
-            a *= np.array(k) ** 2
-            a[0] = 1
-            c_ = np.linalg.lstsq(a, b, rcond=None)[0].round()  # solve for equal weight indices, ax = b
-
-        self.m = nn.ModuleList([nn.Conv2d(c1, int(c_[g]), k[g], s, k[g] // 2, bias=False) for g in range(groups)])
-        self.bn = nn.BatchNorm2d(c2)
-        self.act = nn.LeakyReLU(0.1, inplace=True)
-
-    def forward(self, x):
-        return x + self.act(self.bn(torch.cat([m(x) for m in self.m], 1)))
-
-
-class Ensemble(nn.ModuleList):
-    # Ensemble of models
-    def __init__(self):
-        super(Ensemble, self).__init__()
-
-    def forward(self, x, augment=False):
-        y = []
-        for module in self:
-            y.append(module(x, augment)[0])
-        # y = torch.stack(y).max(0)[0]  # max ensemble
-        # y = torch.stack(y).mean(0)  # mean ensemble
-        y = torch.cat(y, 1)  # nms ensemble
-        return y, None  # inference, train output
-
-
-
-
-
-class ORT_NMS(torch.autograd.Function):
-    '''ONNX-Runtime NMS operation'''
-    @staticmethod
-    def forward(ctx,
-                boxes,
-                scores,
-                max_output_boxes_per_class=torch.tensor([100]),
-                iou_threshold=torch.tensor([0.45]),
-                score_threshold=torch.tensor([0.25])):
-        device = boxes.device
-        batch = scores.shape[0]
-        num_det = random.randint(0, 100)
-        batches = torch.randint(0, batch, (num_det,)).sort()[0].to(device)
-        idxs = torch.arange(100, 100 + num_det).to(device)
-        zeros = torch.zeros((num_det,), dtype=torch.int64).to(device)
-        selected_indices = torch.cat([batches[None], zeros[None], idxs[None]], 0).T.contiguous()
-        selected_indices = selected_indices.to(torch.int64)
-        return selected_indices
-
-    @staticmethod
-    def symbolic(g, boxes, scores, max_output_boxes_per_class, iou_threshold, score_threshold):
-        return g.op("NonMaxSuppression", boxes, scores, max_output_boxes_per_class, iou_threshold, score_threshold)
-
-
-class TRT_NMS(torch.autograd.Function):
-    '''TensorRT NMS operation'''
-    @staticmethod
-    def forward(
-        ctx,
-        boxes,
-        scores,
-        background_class=-1,
-        box_coding=1,
-        iou_threshold=0.45,
-        max_output_boxes=100,
-        plugin_version="1",
-        score_activation=0,
-        score_threshold=0.25,
-    ):
-        batch_size, num_boxes, num_classes = scores.shape
-        num_det = torch.randint(0, max_output_boxes, (batch_size, 1), dtype=torch.int32)
-        det_boxes = torch.randn(batch_size, max_output_boxes, 4)
-        det_scores = torch.randn(batch_size, max_output_boxes)
-        det_classes = torch.randint(0, num_classes, (batch_size, max_output_boxes), dtype=torch.int32)
-        return num_det, det_boxes, det_scores, det_classes
-
-    @staticmethod
-    def symbolic(g,
-                 boxes,
-                 scores,
-                 background_class=-1,
-                 box_coding=1,
-                 iou_threshold=0.45,
-                 max_output_boxes=100,
-                 plugin_version="1",
-                 score_activation=0,
-                 score_threshold=0.25):
-        out = g.op("TRT::EfficientNMS_TRT",
-                   boxes,
-                   scores,
-                   background_class_i=background_class,
-                   box_coding_i=box_coding,
-                   iou_threshold_f=iou_threshold,
-                   max_output_boxes_i=max_output_boxes,
-                   plugin_version_s=plugin_version,
-                   score_activation_i=score_activation,
-                   score_threshold_f=score_threshold,
-                   outputs=4)
-        nums, boxes, scores, classes = out
-        return nums, boxes, scores, classes
-
-
-class ONNX_ORT(nn.Module):
-    '''onnx module with ONNX-Runtime NMS operation.'''
-    def __init__(self, max_obj=100, iou_thres=0.45, score_thres=0.25, max_wh=640, device=None, n_classes=80):
-        super().__init__()
-        self.device = device if device else torch.device("cpu")
-        self.max_obj = torch.tensor([max_obj]).to(device)
-        self.iou_threshold = torch.tensor([iou_thres]).to(device)
-        self.score_threshold = torch.tensor([score_thres]).to(device)
-        self.max_wh = max_wh # if max_wh != 0 : non-agnostic else : agnostic
-        self.convert_matrix = torch.tensor([[1, 0, 1, 0], [0, 1, 0, 1], [-0.5, 0, 0.5, 0], [0, -0.5, 0, 0.5]],
-                                           dtype=torch.float32,
-                                           device=self.device)
-        self.n_classes=n_classes
-
-    def forward(self, x):
-        boxes = x[:, :, :4]
-        conf = x[:, :, 4:5]
-        scores = x[:, :, 5:]
-        if self.n_classes == 1:
-            scores = conf # for models with one class, cls_loss is 0 and cls_conf is always 0.5,
-                                 # so there is no need to multiplicate.
-        else:
-            scores *= conf  # conf = obj_conf * cls_conf
-        boxes @= self.convert_matrix
-        max_score, category_id = scores.max(2, keepdim=True)
-        dis = category_id.float() * self.max_wh
-        nmsbox = boxes + dis
-        max_score_tp = max_score.transpose(1, 2).contiguous()
-        selected_indices = ORT_NMS.apply(nmsbox, max_score_tp, self.max_obj, self.iou_threshold, self.score_threshold)
-        X, Y = selected_indices[:, 0], selected_indices[:, 2]
-        selected_boxes = boxes[X, Y, :]
-        selected_categories = category_id[X, Y, :].float()
-        selected_scores = max_score[X, Y, :]
-        X = X.unsqueeze(1).float()
-        return torch.cat([X, selected_boxes, selected_categories, selected_scores], 1)
-
-class ONNX_TRT(nn.Module):
-    '''onnx module with TensorRT NMS operation.'''
-    def __init__(self, max_obj=100, iou_thres=0.45, score_thres=0.25, max_wh=None ,device=None, n_classes=80):
-        super().__init__()
-        assert max_wh is None
-        self.device = device if device else torch.device('cpu')
-        self.background_class = -1,
-        self.box_coding = 1,
-        self.iou_threshold = iou_thres
-        self.max_obj = max_obj
-        self.plugin_version = '1'
-        self.score_activation = 0
-        self.score_threshold = score_thres
-        self.n_classes=n_classes
-
-    def forward(self, x):
-        boxes = x[:, :, :4]
-        conf = x[:, :, 4:5]
-        scores = x[:, :, 5:]
-        if self.n_classes == 1:
-            scores = conf # for models with one class, cls_loss is 0 and cls_conf is always 0.5,
-                                 # so there is no need to multiplicate.
-        else:
-            scores *= conf  # conf = obj_conf * cls_conf
-        num_det, det_boxes, det_scores, det_classes = TRT_NMS.apply(boxes, scores, self.background_class, self.box_coding,
-                                                                    self.iou_threshold, self.max_obj,
-                                                                    self.plugin_version, self.score_activation,
-                                                                    self.score_threshold)
-        return num_det, det_boxes, det_scores, det_classes
-
-
-class End2End(nn.Module):
-    '''export onnx or tensorrt model with NMS operation.'''
-    def __init__(self, model, max_obj=100, iou_thres=0.45, score_thres=0.25, max_wh=None, device=None, n_classes=80):
-        super().__init__()
-        device = device if device else torch.device('cpu')
-        assert isinstance(max_wh,(int)) or max_wh is None
-        self.model = model.to(device)
-        self.model.model[-1].end2end = True
-        self.patch_model = ONNX_TRT if max_wh is None else ONNX_ORT
-        self.end2end = self.patch_model(max_obj, iou_thres, score_thres, max_wh, device, n_classes)
-        self.end2end.eval()
-
-    def forward(self, x):
-        x = self.model(x)
-        x = self.end2end(x)
-        return x
-
-
-
-
-
-def attempt_load(weights, map_location=None):
-    # Loads an ensemble of models weights=[a,b,c] or a single model weights=[a] or weights=a
-    model = Ensemble()
-    for w in weights if isinstance(weights, list) else [weights]:
-        attempt_download(w)
-        ckpt = torch.load(w, map_location=map_location)  # load
-        model.append(ckpt['ema' if ckpt.get('ema') else 'model'].float().fuse().eval())  # FP32 model
-    
-    # Compatibility updates
-    for m in model.modules():
-        if type(m) in [nn.Hardswish, nn.LeakyReLU, nn.ReLU, nn.ReLU6, nn.SiLU]:
-            m.inplace = True  # pytorch 1.7.0 compatibility
-        elif type(m) is nn.Upsample:
-            m.recompute_scale_factor = None  # torch 1.11.0 compatibility
-        elif type(m) is Conv:
-            m._non_persistent_buffers_set = set()  # pytorch 1.6.0 compatibility
-    
-    if len(model) == 1:
-        return model[-1]  # return model
-    else:
-        print('Ensemble created with %s\n' % weights)
-        for k in ['names', 'stride']:
-            setattr(model, k, getattr(model[-1], k))
-        return model  # return ensemble
-
-

spaces/Al-Chan/Vits_League_of_Legends_Yuumi_TTS/text/ngu_dialect.py

@@ -1,30 +0,0 @@
-import re
-import opencc
-
-
-dialects = {'SZ': 'suzhou', 'WX': 'wuxi', 'CZ': 'changzhou', 'HZ': 'hangzhou',
-            'SX': 'shaoxing', 'NB': 'ningbo', 'JJ': 'jingjiang', 'YX': 'yixing',
-            'JD': 'jiading', 'ZR': 'zhenru', 'PH': 'pinghu', 'TX': 'tongxiang',
-            'JS': 'jiashan', 'HN': 'xiashi', 'LP': 'linping', 'XS': 'xiaoshan',
-            'FY': 'fuyang', 'RA': 'ruao', 'CX': 'cixi', 'SM': 'sanmen',
-            'TT': 'tiantai', 'WZ': 'wenzhou', 'SC': 'suichang', 'YB': 'youbu'}
-
-converters = {}
-
-for dialect in dialects.values():
-    try:
-        converters[dialect] = opencc.OpenCC(dialect)
-    except:
-        pass
-
-
-def ngu_dialect_to_ipa(text, dialect):
-    dialect = dialects[dialect]
-    text = converters[dialect].convert(text).replace('-','').replace('$',' ')
-    text = re.sub(r'[、；：]', '，', text)
-    text = re.sub(r'\s*，\s*', ', ', text)
-    text = re.sub(r'\s*。\s*', '. ', text)
-    text = re.sub(r'\s*？\s*', '? ', text)
-    text = re.sub(r'\s*！\s*', '! ', text)
-    text = re.sub(r'\s*$', '', text)
-    return text

spaces/AlexWang/lama/bin/predict_inner_features.py

@@ -1,119 +0,0 @@
-#!/usr/bin/env python3
-
-# Example command:
-# ./bin/predict.py \
-#       model.path=<path to checkpoint, prepared by make_checkpoint.py> \
-#       indir=<path to input data> \
-#       outdir=<where to store predicts>
-
-import logging
-import os
-import sys
-import traceback
-
-from saicinpainting.evaluation.utils import move_to_device
-
-os.environ['OMP_NUM_THREADS'] = '1'
-os.environ['OPENBLAS_NUM_THREADS'] = '1'
-os.environ['MKL_NUM_THREADS'] = '1'
-os.environ['VECLIB_MAXIMUM_THREADS'] = '1'
-os.environ['NUMEXPR_NUM_THREADS'] = '1'
-
-import cv2
-import hydra
-import numpy as np
-import torch
-import tqdm
-import yaml
-from omegaconf import OmegaConf
-from torch.utils.data._utils.collate import default_collate
-
-from saicinpainting.training.data.datasets import make_default_val_dataset
-from saicinpainting.training.trainers import load_checkpoint, DefaultInpaintingTrainingModule
-from saicinpainting.utils import register_debug_signal_handlers, get_shape
-
-LOGGER = logging.getLogger(__name__)
-
-
-@hydra.main(config_path='../configs/prediction', config_name='default_inner_features.yaml')
-def main(predict_config: OmegaConf):
-    try:
-        register_debug_signal_handlers()  # kill -10 <pid> will result in traceback dumped into log
-
-        device = torch.device(predict_config.device)
-
-        train_config_path = os.path.join(predict_config.model.path, 'config.yaml')
-        with open(train_config_path, 'r') as f:
-            train_config = OmegaConf.create(yaml.safe_load(f))
-
-        checkpoint_path = os.path.join(predict_config.model.path, 'models', predict_config.model.checkpoint)
-        model = load_checkpoint(train_config, checkpoint_path, strict=False)
-        model.freeze()
-        model.to(device)
-
-        assert isinstance(model, DefaultInpaintingTrainingModule), 'Only DefaultInpaintingTrainingModule is supported'
-        assert isinstance(getattr(model.generator, 'model', None), torch.nn.Sequential)
-
-        if not predict_config.indir.endswith('/'):
-            predict_config.indir += '/'
-
-        dataset = make_default_val_dataset(predict_config.indir, **predict_config.dataset)
-
-        max_level = max(predict_config.levels)
-
-        with torch.no_grad():
-            for img_i in tqdm.trange(len(dataset)):
-                mask_fname = dataset.mask_filenames[img_i]
-                cur_out_fname = os.path.join(predict_config.outdir, os.path.splitext(mask_fname[len(predict_config.indir):])[0])
-                os.makedirs(os.path.dirname(cur_out_fname), exist_ok=True)
-
-                batch = move_to_device(default_collate([dataset[img_i]]), device)
-
-                img = batch['image']
-                mask = batch['mask']
-                mask[:] = 0
-                mask_h, mask_w = mask.shape[-2:]
-                mask[:, :,
-                    mask_h // 2 - predict_config.hole_radius : mask_h // 2 + predict_config.hole_radius,
-                    mask_w // 2 - predict_config.hole_radius : mask_w // 2 + predict_config.hole_radius] = 1
-
-                masked_img = torch.cat([img * (1 - mask), mask], dim=1)
-
-                feats = masked_img
-                for level_i, level in enumerate(model.generator.model):
-                    feats = level(feats)
-                    if level_i in predict_config.levels:
-                        cur_feats = torch.cat([f for f in feats if torch.is_tensor(f)], dim=1) \
-                            if isinstance(feats, tuple) else feats
-
-                        if predict_config.slice_channels:
-                            cur_feats = cur_feats[:, slice(*predict_config.slice_channels)]
-
-                        cur_feat = cur_feats.pow(2).mean(1).pow(0.5).clone()
-                        cur_feat -= cur_feat.min()
-                        cur_feat /= cur_feat.std()
-                        cur_feat = cur_feat.clamp(0, 1) / 1
-                        cur_feat = cur_feat.cpu().numpy()[0]
-                        cur_feat *= 255
-                        cur_feat = np.clip(cur_feat, 0, 255).astype('uint8')
-                        cv2.imwrite(cur_out_fname + f'_lev{level_i:02d}_norm.png', cur_feat)
-
-                        # for channel_i in predict_config.channels:
-                        #
-                        #     cur_feat = cur_feats[0, channel_i].clone().detach().cpu().numpy()
-                        #     cur_feat -= cur_feat.min()
-                        #     cur_feat /= cur_feat.max()
-                        #     cur_feat *= 255
-                        #     cur_feat = np.clip(cur_feat, 0, 255).astype('uint8')
-                        #     cv2.imwrite(cur_out_fname + f'_lev{level_i}_ch{channel_i}.png', cur_feat)
-                    elif level_i >= max_level:
-                        break
-    except KeyboardInterrupt:
-        LOGGER.warning('Interrupted by user')
-    except Exception as ex:
-        LOGGER.critical(f'Prediction failed due to {ex}:\n{traceback.format_exc()}')
-        sys.exit(1)
-
-
-if __name__ == '__main__':
-    main()

spaces/Ame42/rwms/local_utils.py

@@ -1,344 +0,0 @@
-import math
-import re
-import numpy
-import pandas
-from sklearn.ensemble import RandomForestRegressor
-from sklearn.tree import export_graphviz
-import pickle as pkl
-
-l2 = "2L"
-l1 = "1L"
-s2 = "2S"
-s1 = "1S"
-date_time_col = "Date Time (GMT+01)"
-time_col = "Time (GMT+01)"
-dur_col = "Daylight duration (SEC)"
-date_col = "Date"
-id_col = "id"
-well_col = "Well index"
-blind_col = "THP BLIND (PSI)"
-temp_col = "TEMP (°F)"
-flp_col = "FLP (PSI)"
-ro_col = "THP R/O (PSI)"
-man_col = "Manifold Pressure (PSI)"
-sim_col = f'Predicted {ro_col}'
-ql_col = 'Liquid production (BBL/D)'
-out_folder = "output/"
-well_key = "wellhead"
-flow_key = "flowstation"
-
-model_file = "rf-AWNW"
-scaler_file = "ss-AWNW"
-
-day_mode = '22-11-2020'
-all_mode = 'All'
-train_mode = 'Train'
-test_mode = 'Test'
-
-
-def round_to_n(x, n):
-    x = x if x % 10 != 5 else x + 1
-    n = n if x > 9 else n - 1
-    return x if x == 0 else round(x, -int(math.floor(math.log10(abs(x)))) + (n - 1))
-
-
-def to_sec(h, m, s):
-    return (int(h) * 60 * 60) + (int(m) * 60) + int(s)
-
-
-def from_sec(t):
-    return f"{t // (60 * 60):0>2}:{(t % (60 * 60)) // 60:0>2}:{(t % (60 * 60)) % 60:0>2}"
-
-
-def column_matcher(title):
-    if re.search("#", string=title) is not None:
-        found = id_col
-    elif re.search(".*(Date|DATE).*(Time|TIME).*GMT.*", string=title) is not None:
-        found = date_time_col
-    elif re.search("THP.*R/O.*(PSI|units)", string=title) is not None:
-        found = ro_col
-    elif re.search(".*TEMP.*(F|units)", string=title) is not None:
-        found = temp_col
-    elif re.search(".*FLP.*(PSI|units)", string=title) is not None:
-        found = flp_col
-    elif re.search("THP.*BLIND.*(PSI|units)", string=title) is not None:
-        found = blind_col
-    elif re.search("THP.*(PSI|units)", string=title) is not None:
-        found = blind_col
-    elif re.search(".*1S.*PSI.*", string=title) is not None:
-        found = s1
-    elif re.search(".*2S.*PSI.*", string=title) is not None:
-        found = s2
-    elif re.search(".*1L.*PSI.*", string=title) is not None:
-        found = l1
-    elif re.search(".*2L.*PSI.*", string=title) is not None:
-        found = l2
-    else:
-        found = False
-
-    return found
-
-
-def file_matcher(name: str):
-    if re.search("\\d+-\\d+-\\d+.*flow.*man.*", string=name.lower()) is not None:
-        flowstation = True
-    else:
-        flowstation = False
-
-    return flowstation
-
-
-def file_matcher2(name: str):
-    if re.search(".*1s.*", string=name.lower()) is not None:
-        well = s1
-    elif re.search(".*1l.*", string=name.lower()) is not None:
-        well = l1
-    elif re.search(".*2s.*", string=name.lower()) is not None:
-        well = s2
-    else:
-        well = l2
-
-    return well
-
-
-def restructure(data, count, duration, times, dates):
-    for datetime in data[date_time_col]:
-        try:
-            date_time = re.sub("\\.0(?=\\s)", "", datetime)
-            datetime_array = date_time.split()
-            date = datetime_array[0].split("/")
-
-            time_array = datetime_array[1].split(":")
-
-            if datetime_array[2] == "PM" and time_array[0] != "12":
-                hour = int(time_array[0]) + 12
-            elif datetime_array[2] == "AM" and time_array[0] == "12":
-                hour = int(time_array[0]) - 12
-            else:
-                hour = time_array[0]
-
-            minutes = time_array[1]
-            sec = round_to_n(int(time_array[2]), 1)
-
-            if sec == 60:
-                sec = "00"
-                minutes = int(minutes) + 1
-
-            if minutes == 60:
-                minutes = "00"
-                hour = int(hour) + 1
-
-            if hour == 24:
-                hour = "00"
-                date[1] = int(date[1]) + 1
-
-            duration.append(to_sec(hour, minutes, sec))
-            times.append(f"{hour}:{minutes}:{sec}")
-            dates.append(f"{date[1]}/{date[0]}/{date[2]}")
-            date_time = f"{date[1]}/{date[0]}/{date[2]} {datetime_array[1]} {datetime_array[2]}"
-
-            data.loc[count, date_time_col] = date_time
-            count += 1
-        except IndexError:
-            print(f"\n\n{datetime}", flush=True)
-            raise
-
-    data.insert(1, dur_col, numpy.array(duration), True)
-    data.insert(2, time_col, numpy.array(times), True)
-    data.insert(3, date_col, numpy.array(dates), True)
-    return data.drop(axis=1, columns="index", errors='ignore')
-
-
-def try_key(temp, key):
-    try:
-        temp[f"{key}"]
-    except KeyError:
-        temp[f"{key}"] = dict()
-
-
-def find_data(index, wlhd):
-    for w in wlhd:
-        if index == w[0]:
-            return w[1]
-
-    return None
-
-
-def split_join(flowstation: pandas.DataFrame, wellhead: pandas.DataFrame, offset):
-    joined = []
-    info = [s1, l1, s2, l2]
-    for i, o in zip(info, offset):
-        # print(f'\n\nNow working on {i} column\n')
-        data = flowstation.drop(flowstation.columns.difference([i, 'Daylight duration (SEC)']),
-                                axis=1)
-        data.rename(columns={i: man_col}, inplace=True)
-        data.insert(2, well_col, [i for _ in range(data.shape[0])], True)
-
-        # print(f"{data.shape[0]} rows before drop and merge")
-        data_well = find_data(i, wellhead)
-        if data_well is not None:
-            data_well.drop_duplicates(inplace=True, subset=[time_col])
-            data = data.merge(data_well, how='inner', on=[dur_col])
-
-            # print(f"{data.shape[0]} rows after drop and merge")
-            # offset the rows by the required amount 'o'
-            data_y = data.drop(data.columns.difference([ro_col, id_col]), axis=1, errors="ignore").iloc[o:]
-            data_x = data.drop(columns=[ro_col], axis=1, errors="ignore").iloc[:(data.shape[0] - 1 - o)]
-            data_y.reset_index(inplace=True)
-            data_x.reset_index(inplace=True)
-            data_y.drop(columns=["index"], axis=1, inplace=True)
-            data_x.drop(columns=["index"], axis=1, inplace=True)
-            data = data_y.merge(data_x, how='inner', on=[id_col])
-            joined.append((i, data))
-
-    return joined
-
-
-class WellDataPoint:
-
-    def __init__(self, thp, day_sec, man_pres, temp, _l1=0, _s1=1, _l2=0, _s2=0):
-        self.thp = thp
-        self.day_sec = day_sec
-        self.man_pres = man_pres
-        self.temp = temp
-        self.l1 = _l1
-        self.s1 = _s1
-        self.l2 = _l2
-        self.s2 = _s2
-
-    def __str__(self):
-        day_sec, deli, i, man_pres, temp, well, well_titles = self.fields()
-        return f"""\033[1;31mTesting data\033[0m
-{day_sec:>20}{deli:3}{self.day_sec} seconds
-{man_pres:>20}{deli:3}{self.man_pres} psi
-{temp:>20}{deli:3}{self.temp} °F
-{well:>20}{deli:3}{well_titles[i]}
-"""
-
-    def fields(self):
-        deli = ' '
-        day_sec = "Day duration:"
-        man_pres = "Manifold Pressure:"
-        temp = "Temperature:"
-        well = "Well Name:"
-        wells = [self.l1, self.l2, self.s1, self.s2]
-        well_titles = ["Awoba NW 1L", "Awoba NW 2L", "Awoba NW 1S", "Awoba NW 2S"]  # List of well titles
-        i = 0
-        # Find the well with dummy value 1
-        while not (wells[i]):  # not(0) yields true and not(anything else) yields false
-            i += 1
-        return day_sec, deli, i, man_pres, temp, well, well_titles
-
-    def __plain__(self):
-        day_sec, deli, i, man_pres, temp, well, well_titles = self.fields()
-        space = '40'
-        d_space = '3'
-        return f"""Testing data
-{day_sec:>{space}}{deli:{d_space}}{self.day_sec} seconds
-{man_pres:>{space}}{deli:{d_space}}{self.man_pres} psi
-{temp:>{space}}{deli:{d_space}}{self.temp} °F
-{well:>{space}}{deli:{d_space}}{well_titles[i]}
-"""
-
-    def __repr__(self):
-        return f"Practice([{self.day_sec}, {self.man_pres}, {self.temp}, {self.l1}, {self.s1}, {self.l2}, {self.s2}])"
-
-    def get_x(self):
-        return [self.day_sec, self.man_pres, self.temp, self.l1, self.s1, self.l2, self.s2]
-
-    def get_y(self):
-        return self.thp
-
-
-def oversample_balance(data: pandas.DataFrame):
-    # get buckets for control column
-    data = data.astype(float, errors='ignore')
-    mx = data[ro_col].max(axis=0, skipna=True)
-    mn = data[ro_col].min(axis=0, skipna=True)
-    rng = mx - mn
-    bucket = rng / 10
-
-    # shuffle data into buckets
-    max_count = 0
-    counter = mn
-    temp = []
-    results = []
-
-    while counter < mx:
-
-        sub_data = data[data[ro_col].between(counter, counter + bucket, inclusive='right')]
-        if sub_data.shape[0] > 0 and float(sub_data[ro_col].min(axis=0, skipna=True)) > 0:
-            temp.append(sub_data)
-
-        max_count = max_count if sub_data.shape[0] < max_count else sub_data.shape[0]
-
-        counter += bucket
-
-    for r in temp:
-        counter = 0
-        pumped_data = r
-        print(r.shape, "\n", r.head())
-        # add elements of r to pumped_data
-        while pumped_data.shape[0] < max_count:
-            new_row = r.iloc[[counter % r.shape[0]]]
-
-            pumped_data = pandas.concat([pumped_data, new_row], ignore_index=True)
-
-        # add final results to results series
-        results.append(pumped_data)
-
-    return pandas.concat(results, ignore_index=True)
-
-
-def parse_well_id(well_id):
-    return f"Awoba NW {well_id}"
-
-
-def parse_well_id_2(well_id):
-    return f"Abura {well_id}"
-
-
-def print_graph(model: RandomForestRegressor, x):
-    for est, idx in zip(model.estimators_, len(model.estimators_)):
-        file = f'tree_{idx}.dot'
-        export_graphviz(model, out_file=file, feature_names=x.columns,
-                        class_names=['extreme', 'moderate', 'vulnerable', 'non-vulnerable'],
-                        rounded=True, proportion=False, precision=4, filled=True)
-
-
-def write_state_files(model, scaler):
-    pkl.dump(model, open(f"{model_file}.mdl", "wb"))
-    pkl.dump(scaler, open(f"{scaler_file}.sts", "wb"))
-
-
-def keep_useful_cols(data, columns=None):
-    if columns is None:
-        columns = [ro_col, dur_col, man_col, well_col, time_col, date_col, blind_col, flp_col, temp_col]
-    return data.drop(data.columns.difference(columns), axis=1)
-
-
-def read_state_files(mdl, scl):
-    mdl = pkl.load(open(f"{mdl}.mdl", "rb"))
-    scl = pkl.load(open(f"{scl}.sts", "rb"))
-    return mdl, scl
-
-
-def change_well_to_dummy(wl):
-    _l1, _l2, _s1, _s2 = 0, 0, 0, 0
-
-    if wl == parse_well_id(l1):
-        _l1 = 1
-    elif wl == parse_well_id(s1):
-        _s1 = 1
-    elif wl == parse_well_id(l2):
-        _l2 = 1
-    elif wl == parse_well_id(s2):
-        _s2 = 1
-
-    return _l1, _l2, _s1, _s2
-
-
-def calc_excel(pres):
-    # from well Abura 2S
-    return pres + 624, pres * 31.88
-

spaces/Ameaou/academic-chatgpt3.1/crazy_functions/test_project/cpp/cppipc/policy.h

@@ -1,25 +0,0 @@
-#pragma once
-
-#include <type_traits>
-
-#include "libipc/def.h"
-#include "libipc/prod_cons.h"
-
-#include "libipc/circ/elem_array.h"
-
-namespace ipc {
-namespace policy {
-
-template <template <typename, std::size_t...> class Elems, typename Flag>
-struct choose;
-
-template <typename Flag>
-struct choose<circ::elem_array, Flag> {
-    using flag_t = Flag;
-
-    template <std::size_t DataSize, std::size_t AlignSize>
-    using elems_t = circ::elem_array<ipc::prod_cons_impl<flag_t>, DataSize, AlignSize>;
-};
-
-} // namespace policy
-} // namespace ipc

spaces/Amrrs/DragGan-Inversion/stylegan_human/torch_utils/models.py

@@ -1,770 +0,0 @@
-# Copyright (c) SenseTime Research. All rights reserved.
-
-# https://github.com/rosinality/stylegan2-pytorch/blob/master/model.py
-
-import math
-import random
-import functools
-import operator
-
-import torch
-from torch import nn
-from torch.nn import functional as F
-import torch.nn.init as init
-from torch.autograd import Function
-
-from .op_edit import FusedLeakyReLU, fused_leaky_relu, upfirdn2d
-
-
-class PixelNorm(nn.Module):
-    def __init__(self):
-        super().__init__()
-
-    def forward(self, input):
-        return input * torch.rsqrt(torch.mean(input ** 2, dim=1, keepdim=True) + 1e-8)
-
-
-def make_kernel(k):
-    k = torch.tensor(k, dtype=torch.float32)
-    if k.ndim == 1:
-        k = k[None, :] * k[:, None]
-    k /= k.sum()
-    return k
-
-
-class Upsample(nn.Module):
-    def __init__(self, kernel, factor=2):
-        super().__init__()
-
-        self.factor = factor
-        kernel = make_kernel(kernel) * (factor ** 2)
-        self.register_buffer("kernel", kernel)
-
-        p = kernel.shape[0] - factor
-
-        pad0 = (p + 1) // 2 + factor - 1
-        pad1 = p // 2
-
-        self.pad = (pad0, pad1)
-
-    def forward(self, input):
-        out = upfirdn2d(input, self.kernel, up=self.factor,
-                        down=1, pad=self.pad)
-        return out
-
-
-class Downsample(nn.Module):
-    def __init__(self, kernel, factor=2):
-        super().__init__()
-
-        self.factor = factor
-        kernel = make_kernel(kernel)
-        self.register_buffer("kernel", kernel)
-
-        p = kernel.shape[0] - factor
-
-        pad0 = (p + 1) // 2
-        pad1 = p // 2
-
-        self.pad = (pad0, pad1)
-
-    def forward(self, input):
-        out = upfirdn2d(input, self.kernel, up=1,
-                        down=self.factor, pad=self.pad)
-        return out
-
-
-class Blur(nn.Module):
-    def __init__(self, kernel, pad, upsample_factor=1):
-        super().__init__()
-
-        kernel = make_kernel(kernel)
-
-        if upsample_factor > 1:
-            kernel = kernel * (upsample_factor ** 2)
-
-        self.register_buffer("kernel", kernel)
-
-        self.pad = pad
-
-    def forward(self, input):
-        out = upfirdn2d(input, self.kernel, pad=self.pad)
-        return out
-
-
-class EqualConv2d(nn.Module):
-    def __init__(
-        self, in_channel, out_channel, kernel_size, stride=1, padding=0, bias=True
-    ):
-        super().__init__()
-
-        self.weight = nn.Parameter(
-            torch.randn(out_channel, in_channel, kernel_size, kernel_size)
-        )
-        self.scale = 1 / math.sqrt(in_channel * kernel_size ** 2)
-
-        self.stride = stride
-        self.padding = padding
-
-        if bias:
-            self.bias = nn.Parameter(torch.zeros(out_channel))
-
-        else:
-            self.bias = None
-
-    def forward(self, input):
-        out = F.conv2d(
-            input,
-            self.weight * self.scale,
-            bias=self.bias,
-            stride=self.stride,
-            padding=self.padding,
-        )
-        return out
-
-    def __repr__(self):
-        return (
-            f"{self.__class__.__name__}({self.weight.shape[1]}, {self.weight.shape[0]},"
-            f" {self.weight.shape[2]}, stride={self.stride}, padding={self.padding})"
-        )
-
-
-class EqualLinear(nn.Module):
-    def __init__(
-        self, in_dim, out_dim, bias=True, bias_init=0, lr_mul=1, activation=None
-    ):
-        super().__init__()
-
-        self.weight = nn.Parameter(torch.randn(out_dim, in_dim).div_(lr_mul))
-
-        if bias:
-            self.bias = nn.Parameter(torch.zeros(out_dim).fill_(bias_init))
-        else:
-            self.bias = None
-
-        self.activation = activation
-
-        self.scale = (1 / math.sqrt(in_dim)) * lr_mul
-        self.lr_mul = lr_mul
-
-    def forward(self, input):
-        if self.activation:
-            out = F.linear(input, self.weight * self.scale)
-            out = fused_leaky_relu(out, self.bias * self.lr_mul)
-        else:
-            out = F.linear(
-                input, self.weight * self.scale, bias=self.bias * self.lr_mul
-            )
-        return out
-
-    def __repr__(self):
-        return (
-            f"{self.__class__.__name__}({self.weight.shape[1]}, {self.weight.shape[0]})"
-        )
-
-
-class ScaledLeakyReLU(nn.Module):
-    def __init__(self, negative_slope=0.2):
-        super().__init__()
-        self.negative_slope = negative_slope
-
-    def forward(self, input):
-        out = F.leaky_relu(input, negative_slope=self.negative_slope)
-        return out * math.sqrt(2)
-
-
-class ModulatedConv2d(nn.Module):
-    def __init__(
-        self,
-        in_channel,
-        out_channel,
-        kernel_size,
-        style_dim,
-        demodulate=True,
-        upsample=False,
-        downsample=False,
-        blur_kernel=[1, 3, 3, 1],
-    ):
-        super().__init__()
-
-        self.eps = 1e-8
-        self.kernel_size = kernel_size
-        self.in_channel = in_channel
-        self.out_channel = out_channel
-        self.upsample = upsample
-        self.downsample = downsample
-
-        if upsample:
-            factor = 2
-            p = (len(blur_kernel) - factor) - (kernel_size - 1)
-            pad0 = (p + 1) // 2 + factor - 1
-            pad1 = p // 2 + 1
-            self.blur = Blur(blur_kernel, pad=(
-                pad0, pad1), upsample_factor=factor)
-
-        if downsample:
-            factor = 2
-            p = (len(blur_kernel) - factor) + (kernel_size - 1)
-            pad0 = (p + 1) // 2
-            pad1 = p // 2
-            self.blur = Blur(blur_kernel, pad=(pad0, pad1))
-
-        fan_in = in_channel * kernel_size ** 2
-        self.scale = 1 / math.sqrt(fan_in)
-        self.padding = kernel_size // 2
-        self.weight = nn.Parameter(
-            torch.randn(1, out_channel, in_channel, kernel_size, kernel_size)
-        )
-        self.modulation = EqualLinear(style_dim, in_channel, bias_init=1)
-        self.demodulate = demodulate
-
-    def __repr__(self):
-        return (
-            f"{self.__class__.__name__}({self.in_channel}, {self.out_channel}, {self.kernel_size}, "
-            f"upsample={self.upsample}, downsample={self.downsample})"
-        )
-
-    def forward(self, input, style):
-        batch, in_channel, height, width = input.shape
-
-        style = self.modulation(style).view(batch, 1, in_channel, 1, 1)
-        weight = self.scale * self.weight * style
-
-        if self.demodulate:
-            demod = torch.rsqrt(weight.pow(2).sum([2, 3, 4]) + 1e-8)
-            weight = weight * demod.view(batch, self.out_channel, 1, 1, 1)
-
-        weight = weight.view(
-            batch * self.out_channel, in_channel, self.kernel_size, self.kernel_size
-        )
-
-        if self.upsample:
-            input = input.view(1, batch * in_channel, height, width)
-            weight = weight.view(
-                batch, self.out_channel, in_channel, self.kernel_size, self.kernel_size
-            )
-            weight = weight.transpose(1, 2).reshape(
-                batch * in_channel, self.out_channel, self.kernel_size, self.kernel_size
-            )
-            out = F.conv_transpose2d(
-                input, weight, padding=0, stride=2, groups=batch)
-            _, _, height, width = out.shape
-            out = out.view(batch, self.out_channel, height, width)
-            out = self.blur(out)
-
-        elif self.downsample:
-            input = self.blur(input)
-            _, _, height, width = input.shape
-            input = input.view(1, batch * in_channel, height, width)
-            out = F.conv2d(input, weight, padding=0, stride=2, groups=batch)
-            _, _, height, width = out.shape
-            out = out.view(batch, self.out_channel, height, width)
-
-        else:
-            input = input.view(1, batch * in_channel, height, width)
-            out = F.conv2d(input, weight, padding=self.padding, groups=batch)
-            _, _, height, width = out.shape
-            out = out.view(batch, self.out_channel, height, width)
-
-        return out
-
-
-class NoiseInjection(nn.Module):
-    def __init__(self):
-        super().__init__()
-        self.weight = nn.Parameter(torch.zeros(1))
-
-    def forward(self, image, noise=None):
-        if noise is None:
-            batch, _, height, width = image.shape
-            noise = image.new_empty(batch, 1, height, width).normal_()
-        return image + self.weight * noise
-
-
-class ConstantInput(nn.Module):
-    def __init__(self, channel, size=4):
-        super().__init__()
-        self.input = nn.Parameter(torch.randn(1, channel, size, size // 2))
-
-    def forward(self, input):
-        batch = input.shape[0]
-        out = self.input.repeat(batch, 1, 1, 1)
-        return out
-
-
-class StyledConv(nn.Module):
-    def __init__(
-        self,
-        in_channel,
-        out_channel,
-        kernel_size,
-        style_dim,
-        upsample=False,
-        blur_kernel=[1, 3, 3, 1],
-        demodulate=True,
-    ):
-        super().__init__()
-        self.conv = ModulatedConv2d(
-            in_channel,
-            out_channel,
-            kernel_size,
-            style_dim,
-            upsample=upsample,
-            blur_kernel=blur_kernel,
-            demodulate=demodulate,
-        )
-        self.noise = NoiseInjection()
-        self.activate = FusedLeakyReLU(out_channel)
-
-    def forward(self, input, style, noise=None):
-        out = self.conv(input, style)
-        out = self.noise(out, noise=noise)
-        out = self.activate(out)
-        return out
-
-
-class ToRGB(nn.Module):
-    def __init__(self, in_channel, style_dim, upsample=True, blur_kernel=[1, 3, 3, 1]):
-        super().__init__()
-        if upsample:
-            self.upsample = Upsample(blur_kernel)
-
-        self.conv = ModulatedConv2d(
-            in_channel, 3, 1, style_dim, demodulate=False)
-        self.bias = nn.Parameter(torch.zeros(1, 3, 1, 1))
-
-    def forward(self, input, style, skip=None):
-        out = self.conv(input, style)
-        out = out + self.bias
-
-        if skip is not None:
-            skip = self.upsample(skip)
-            out = out + skip
-
-        return out
-
-
-class Generator(nn.Module):
-    def __init__(
-        self,
-        size,
-        style_dim,
-        n_mlp,
-        channel_multiplier=1,
-        blur_kernel=[1, 3, 3, 1],
-        lr_mlp=0.01,
-        small=False,
-        small_isaac=False,
-    ):
-        super().__init__()
-
-        self.size = size
-
-        if small and size > 64:
-            raise ValueError("small only works for sizes <= 64")
-
-        self.style_dim = style_dim
-        layers = [PixelNorm()]
-
-        for i in range(n_mlp):
-            layers.append(
-                EqualLinear(
-                    style_dim, style_dim, lr_mul=lr_mlp, activation="fused_lrelu"
-                )
-            )
-
-        self.style = nn.Sequential(*layers)
-
-        if small:
-            self.channels = {
-                4: 64 * channel_multiplier,
-                8: 64 * channel_multiplier,
-                16: 64 * channel_multiplier,
-                32: 64 * channel_multiplier,
-                64: 64 * channel_multiplier,
-            }
-        elif small_isaac:
-            self.channels = {4: 256, 8: 256,
-                             16: 256, 32: 256, 64: 128, 128: 128}
-        else:
-            self.channels = {
-                4: 512,
-                8: 512,
-                16: 512,
-                32: 512,
-                64: 256 * channel_multiplier,
-                128: 128 * channel_multiplier,
-                256: 64 * channel_multiplier,
-                512: 32 * channel_multiplier,
-                1024: 16 * channel_multiplier,
-            }
-
-        self.input = ConstantInput(self.channels[4])
-        self.conv1 = StyledConv(
-            self.channels[4], self.channels[4], 3, style_dim, blur_kernel=blur_kernel
-        )
-        self.to_rgb1 = ToRGB(self.channels[4], style_dim, upsample=False)
-
-        self.log_size = int(math.log(size, 2))
-        self.num_layers = (self.log_size - 2) * 2 + 1
-
-        self.convs = nn.ModuleList()
-        self.upsamples = nn.ModuleList()
-        self.to_rgbs = nn.ModuleList()
-        self.noises = nn.Module()
-
-        in_channel = self.channels[4]
-
-        for layer_idx in range(self.num_layers):
-            res = (layer_idx + 5) // 2
-            shape = [1, 1, 2 ** res, 2 ** res // 2]
-            self.noises.register_buffer(
-                "noise_{}".format(layer_idx), torch.randn(*shape)
-            )
-
-        for i in range(3, self.log_size + 1):
-            out_channel = self.channels[2 ** i]
-
-            self.convs.append(
-                StyledConv(
-                    in_channel,
-                    out_channel,
-                    3,
-                    style_dim,
-                    upsample=True,
-                    blur_kernel=blur_kernel,
-                )
-            )
-
-            self.convs.append(
-                StyledConv(
-                    out_channel, out_channel, 3, style_dim, blur_kernel=blur_kernel
-                )
-            )
-
-            self.to_rgbs.append(ToRGB(out_channel, style_dim))
-            in_channel = out_channel
-
-        self.n_latent = self.log_size * 2 - 2
-
-    def make_noise(self):
-        device = self.input.input.device
-
-        noises = [torch.randn(1, 1, 2 ** 2, 2 ** 2 // 2, device=device)]
-
-        for i in range(3, self.log_size + 1):
-            for _ in range(2):
-                noises.append(torch.randn(
-                    1, 1, 2 ** i, 2 ** i // 2, device=device))
-
-        return noises
-
-    def mean_latent(self, n_latent):
-        latent_in = torch.randn(
-            n_latent, self.style_dim, device=self.input.input.device
-        )
-        latent = self.style(latent_in).mean(0, keepdim=True)
-
-        return latent
-
-    def get_latent(self, input):
-        return self.style(input)
-
-    def forward(
-        self,
-        styles,
-        return_latents=False,
-        return_features=False,
-        inject_index=None,
-        truncation=1,
-        truncation_latent=None,
-        input_is_latent=False,
-        noise=None,
-        randomize_noise=True,
-        real=False,
-    ):
-        if not input_is_latent:
-            styles = [self.style(s) for s in styles]
-        if noise is None:
-            if randomize_noise:
-                noise = [None] * self.num_layers
-            else:
-                noise = [
-                    getattr(self.noises, "noise_{}".format(i))
-                    for i in range(self.num_layers)
-                ]
-
-        if truncation < 1:
-            # print('truncation_latent: ', truncation_latent.shape)
-            if not real:  # if type(styles) == list:
-                style_t = []
-                for style in styles:
-                    style_t.append(
-                        truncation_latent + truncation *
-                        (style - truncation_latent)
-                    )  # (-1.1162e-03-(-1.0914e-01))*0.8+(-1.0914e-01)
-                styles = style_t
-            else:  # styles are latent (tensor: 1,18,512), for real PTI output
-                truncation_latent = truncation_latent.repeat(
-                    18, 1).unsqueeze(0)  # (1,512) --> (1,18,512)
-                styles = torch.add(truncation_latent, torch.mul(
-                    torch.sub(styles, truncation_latent), truncation))
-                # print('now styles after truncation : ', styles)
-        # if type(styles) == list and len(styles) < 2: # this if for input as list of [(1,512)]
-        if not real:
-            if len(styles) < 2:
-                inject_index = self.n_latent
-                if styles[0].ndim < 3:
-                    latent = styles[0].unsqueeze(1).repeat(1, inject_index, 1)
-                else:
-                    latent = styles[0]
-            elif type(styles) == list:
-                if inject_index is None:
-                    inject_index = 4
-
-                latent = styles[0].unsqueeze(0)
-                if latent.shape[1] == 1:
-                    latent = latent.repeat(1, inject_index, 1)
-                else:
-                    latent = latent[:, :inject_index, :]
-                latent2 = styles[1].unsqueeze(1).repeat(
-                    1, self.n_latent - inject_index, 1)
-                latent = torch.cat([latent, latent2], 1)
-        # input is tensor of size with torch.Size([1, 18, 512]), for real PTI output
-        else:
-            latent = styles
-
-        # print(f'processed latent: {latent.shape}')
-
-        features = {}
-        out = self.input(latent)
-        features["out_0"] = out
-        out = self.conv1(out, latent[:, 0], noise=noise[0])
-        features["conv1_0"] = out
-
-        skip = self.to_rgb1(out, latent[:, 1])
-        features["skip_0"] = skip
-        i = 1
-        for conv1, conv2, noise1, noise2, to_rgb in zip(
-            self.convs[::2], self.convs[1::2], noise[1::2], noise[2::2], self.to_rgbs
-        ):
-            out = conv1(out, latent[:, i], noise=noise1)
-            features["conv1_{}".format(i)] = out
-            out = conv2(out, latent[:, i + 1], noise=noise2)
-            features["conv2_{}".format(i)] = out
-            skip = to_rgb(out, latent[:, i + 2], skip)
-            features["skip_{}".format(i)] = skip
-
-            i += 2
-
-        image = skip
-
-        if return_latents:
-            return image, latent
-        elif return_features:
-            return image, features
-        else:
-            return image, None
-
-
-class ConvLayer(nn.Sequential):
-    def __init__(
-        self,
-        in_channel,
-        out_channel,
-        kernel_size,
-        downsample=False,
-        blur_kernel=[1, 3, 3, 1],
-        bias=True,
-        activate=True,
-    ):
-        layers = []
-
-        if downsample:
-            factor = 2
-            p = (len(blur_kernel) - factor) + (kernel_size - 1)
-            pad0 = (p + 1) // 2
-            pad1 = p // 2
-
-            layers.append(Blur(blur_kernel, pad=(pad0, pad1)))
-
-            stride = 2
-            self.padding = 0
-
-        else:
-            stride = 1
-            self.padding = kernel_size // 2
-
-        layers.append(
-            EqualConv2d(
-                in_channel,
-                out_channel,
-                kernel_size,
-                padding=self.padding,
-                stride=stride,
-                bias=bias and not activate,
-            )
-        )
-
-        if activate:
-            if bias:
-                layers.append(FusedLeakyReLU(out_channel))
-            else:
-                layers.append(ScaledLeakyReLU(0.2))
-
-        super().__init__(*layers)
-
-
-class ResBlock(nn.Module):
-    def __init__(self, in_channel, out_channel, blur_kernel=[1, 3, 3, 1]):
-        super().__init__()
-
-        self.conv1 = ConvLayer(in_channel, in_channel, 3)
-        self.conv2 = ConvLayer(in_channel, out_channel, 3, downsample=True)
-
-        self.skip = ConvLayer(
-            in_channel, out_channel, 1, downsample=True, activate=False, bias=False
-        )
-
-    def forward(self, input):
-        out = self.conv1(input)
-        out = self.conv2(out)
-
-        skip = self.skip(input)
-        out = (out + skip) / math.sqrt(2)
-
-        return out
-
-
-class StyleDiscriminator(nn.Module):
-    def __init__(
-        self, size, channel_multiplier=2, blur_kernel=[1, 3, 3, 1], small=False
-    ):
-        super().__init__()
-
-        if small:
-            channels = {4: 64, 8: 64, 16: 64, 32: 64, 64: 64}
-
-        else:
-            channels = {
-                4: 512,
-                8: 512,
-                16: 512,
-                32: 512,
-                64: 256 * channel_multiplier,
-                128: 128 * channel_multiplier,
-                256: 64 * channel_multiplier,
-                512: 32 * channel_multiplier,
-                1024: 16 * channel_multiplier,
-            }
-
-        convs = [ConvLayer(3, channels[size], 1)]
-
-        log_size = int(math.log(size, 2))
-        in_channel = channels[size]
-
-        for i in range(log_size, 2, -1):
-            out_channel = channels[2 ** (i - 1)]
-
-            convs.append(ResBlock(in_channel, out_channel, blur_kernel))
-
-            in_channel = out_channel
-
-        self.convs = nn.Sequential(*convs)
-
-        self.stddev_group = 4
-        self.stddev_feat = 1
-
-        self.final_conv = ConvLayer(in_channel + 1, channels[4], 3)
-        self.final_linear = nn.Sequential(
-            EqualLinear(channels[4] * 4 * 4, channels[4],
-                        activation="fused_lrelu"),
-            EqualLinear(channels[4], 1),
-        )
-
-    def forward(self, input):
-        h = input
-        h_list = []
-
-        for index, blocklist in enumerate(self.convs):
-            h = blocklist(h)
-            h_list.append(h)
-
-        out = h
-        batch, channel, height, width = out.shape
-        group = min(batch, self.stddev_group)
-        stddev = out.view(
-            group, -1, self.stddev_feat, channel // self.stddev_feat, height, width
-        )
-        stddev = torch.sqrt(stddev.var(0, unbiased=False) + 1e-8)
-        stddev = stddev.mean([2, 3, 4], keepdims=True).squeeze(2)
-        stddev = stddev.repeat(group, 1, height, width)
-        out = torch.cat([out, stddev], 1)
-
-        out = self.final_conv(out)
-        h_list.append(out)
-
-        out = out.view(batch, -1)
-        out = self.final_linear(out)
-
-        return out, h_list
-
-
-class StyleEncoder(nn.Module):
-    def __init__(self, size, w_dim=512):
-        super().__init__()
-
-        channels = {
-            4: 512,
-            8: 512,
-            16: 512,
-            32: 512,
-            64: 256,
-            128: 128,
-            256: 64,
-            512: 32,
-            1024: 16
-        }
-
-        self.w_dim = w_dim
-        log_size = int(math.log(size, 2))
-        convs = [ConvLayer(3, channels[size], 1)]
-
-        in_channel = channels[size]
-        for i in range(log_size, 2, -1):
-            out_channel = channels[2 ** (i - 1)]
-            convs.append(ResBlock(in_channel, out_channel))
-            in_channel = out_channel
-
-        convs.append(EqualConv2d(
-            in_channel, 2*self.w_dim, 4, padding=0, bias=False))
-
-        self.convs = nn.Sequential(*convs)
-
-    def forward(self, input):
-        out = self.convs(input)
-        # return out.view(len(input), self.n_latents, self.w_dim)
-        reshaped = out.view(len(input), 2*self.w_dim)
-        return reshaped[:, :self.w_dim], reshaped[:, self.w_dim:]
-
-
-def kaiming_init(m):
-    if isinstance(m, (nn.Linear, nn.Conv2d)):
-        init.kaiming_normal_(m.weight)
-        if m.bias is not None:
-            m.bias.data.fill_(0)
-    elif isinstance(m, (nn.BatchNorm1d, nn.BatchNorm2d)):
-        m.weight.data.fill_(1)
-        if m.bias is not None:
-            m.bias.data.fill_(0)
-
-
-def normal_init(m):
-    if isinstance(m, (nn.Linear, nn.Conv2d)):
-        init.normal_(m.weight, 0, 0.02)
-        if m.bias is not None:
-            m.bias.data.fill_(0)
-    elif isinstance(m, (nn.BatchNorm1d, nn.BatchNorm2d)):
-        m.weight.data.fill_(1)
-        if m.bias is not None:
-            m.bias.data.fill_(0)

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/docs/source/en/api/models/autoencoderkl.md

@@ -1,43 +0,0 @@
-# AutoencoderKL
-
-The variational autoencoder (VAE) model with KL loss was introduced in [Auto-Encoding Variational Bayes](https://arxiv.org/abs/1312.6114v11) by Diederik P. Kingma and Max Welling. The model is used in 🤗 Diffusers to encode images into latents and to decode latent representations into images.
-
-The abstract from the paper is:
-
-*How can we perform efficient inference and learning in directed probabilistic models, in the presence of continuous latent variables with intractable posterior distributions, and large datasets? We introduce a stochastic variational inference and learning algorithm that scales to large datasets and, under some mild differentiability conditions, even works in the intractable case. Our contributions are two-fold. First, we show that a reparameterization of the variational lower bound yields a lower bound estimator that can be straightforwardly optimized using standard stochastic gradient methods. Second, we show that for i.i.d. datasets with continuous latent variables per datapoint, posterior inference can be made especially efficient by fitting an approximate inference model (also called a recognition model) to the intractable posterior using the proposed lower bound estimator. Theoretical advantages are reflected in experimental results.*
-
-## Loading from the original format
-
-By default the [`AutoencoderKL`] should be loaded with [`~ModelMixin.from_pretrained`], but it can also be loaded
-from the original format using [`FromOriginalVAEMixin.from_single_file`] as follows:
-
-```py
-from diffusers import AutoencoderKL
-
-url = "https://huggingface.co/stabilityai/sd-vae-ft-mse-original/blob/main/vae-ft-mse-840000-ema-pruned.safetensors"  # can also be local file
-model = AutoencoderKL.from_single_file(url)
-```
-
-## AutoencoderKL
-
-[[autodoc]] AutoencoderKL
-
-## AutoencoderKLOutput
-
-[[autodoc]] models.autoencoder_kl.AutoencoderKLOutput
-
-## DecoderOutput
-
-[[autodoc]] models.vae.DecoderOutput
-
-## FlaxAutoencoderKL
-
-[[autodoc]] FlaxAutoencoderKL
-
-## FlaxAutoencoderKLOutput
-
-[[autodoc]] models.vae_flax.FlaxAutoencoderKLOutput
-
-## FlaxDecoderOutput
-
-[[autodoc]] models.vae_flax.FlaxDecoderOutput

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

@@ -1,33 +0,0 @@
-<!--Copyright 2023 The HuggingFace Team. All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
-an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
-specific language governing permissions and limitations under the License.
--->
-
-# Cycle Diffusion
-
-Cycle Diffusion is a text guided image-to-image generation model proposed in [Unifying Diffusion Models' Latent Space, with Applications to CycleDiffusion and Guidance](https://huggingface.co/papers/2210.05559) by Chen Henry Wu, Fernando De la Torre.
-
-The abstract from the paper is:
-
-*Diffusion models have achieved unprecedented performance in generative modeling. The commonly-adopted formulation of the latent code of diffusion models is a sequence of gradually denoised samples, as opposed to the simpler (e.g., Gaussian) latent space of GANs, VAEs, and normalizing flows. This paper provides an alternative, Gaussian formulation of the latent space of various diffusion models, as well as an invertible DPM-Encoder that maps images into the latent space. While our formulation is purely based on the definition of diffusion models, we demonstrate several intriguing consequences. (1) Empirically, we observe that a common latent space emerges from two diffusion models trained independently on related domains. In light of this finding, we propose CycleDiffusion, which uses DPM-Encoder for unpaired image-to-image translation. Furthermore, applying CycleDiffusion to text-to-image diffusion models, we show that large-scale text-to-image diffusion models can be used as zero-shot image-to-image editors. (2) One can guide pre-trained diffusion models and GANs by controlling the latent codes in a unified, plug-and-play formulation based on energy-based models. Using the CLIP model and a face recognition model as guidance, we demonstrate that diffusion models have better coverage of low-density sub-populations and individuals than GANs.*
-
-<Tip>
-
-Make sure to check out the Schedulers [guide](/using-diffusers/schedulers) to learn how to explore the tradeoff between scheduler speed and quality, and see the [reuse components across pipelines](/using-diffusers/loading#reuse-components-across-pipelines) section to learn how to efficiently load the same components into multiple pipelines.
-
-</Tip>
-
-## CycleDiffusionPipeline
-[[autodoc]] CycleDiffusionPipeline
-	- all
-	- __call__
-
-## StableDiffusionPiplineOutput
-[[autodoc]] pipelines.stable_diffusion.StableDiffusionPipelineOutput

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/tests/schedulers/test_scheduler_lms.py

@@ -1,140 +0,0 @@
-import torch
-
-from diffusers import LMSDiscreteScheduler
-from diffusers.utils import torch_device
-
-from .test_schedulers import SchedulerCommonTest
-
-
-class LMSDiscreteSchedulerTest(SchedulerCommonTest):
-    scheduler_classes = (LMSDiscreteScheduler,)
-    num_inference_steps = 10
-
-    def get_scheduler_config(self, **kwargs):
-        config = {
-            "num_train_timesteps": 1100,
-            "beta_start": 0.0001,
-            "beta_end": 0.02,
-            "beta_schedule": "linear",
-        }
-
-        config.update(**kwargs)
-        return config
-
-    def test_timesteps(self):
-        for timesteps in [10, 50, 100, 1000]:
-            self.check_over_configs(num_train_timesteps=timesteps)
-
-    def test_betas(self):
-        for beta_start, beta_end in zip([0.00001, 0.0001, 0.001], [0.0002, 0.002, 0.02]):
-            self.check_over_configs(beta_start=beta_start, beta_end=beta_end)
-
-    def test_schedules(self):
-        for schedule in ["linear", "scaled_linear"]:
-            self.check_over_configs(beta_schedule=schedule)
-
-    def test_prediction_type(self):
-        for prediction_type in ["epsilon", "v_prediction"]:
-            self.check_over_configs(prediction_type=prediction_type)
-
-    def test_time_indices(self):
-        for t in [0, 500, 800]:
-            self.check_over_forward(time_step=t)
-
-    def test_full_loop_no_noise(self):
-        scheduler_class = self.scheduler_classes[0]
-        scheduler_config = self.get_scheduler_config()
-        scheduler = scheduler_class(**scheduler_config)
-
-        scheduler.set_timesteps(self.num_inference_steps)
-
-        model = self.dummy_model()
-        sample = self.dummy_sample_deter * scheduler.init_noise_sigma
-
-        for i, t in enumerate(scheduler.timesteps):
-            sample = scheduler.scale_model_input(sample, t)
-
-            model_output = model(sample, t)
-
-            output = scheduler.step(model_output, t, sample)
-            sample = output.prev_sample
-
-        result_sum = torch.sum(torch.abs(sample))
-        result_mean = torch.mean(torch.abs(sample))
-
-        assert abs(result_sum.item() - 1006.388) < 1e-2
-        assert abs(result_mean.item() - 1.31) < 1e-3
-
-    def test_full_loop_with_v_prediction(self):
-        scheduler_class = self.scheduler_classes[0]
-        scheduler_config = self.get_scheduler_config(prediction_type="v_prediction")
-        scheduler = scheduler_class(**scheduler_config)
-
-        scheduler.set_timesteps(self.num_inference_steps)
-
-        model = self.dummy_model()
-        sample = self.dummy_sample_deter * scheduler.init_noise_sigma
-
-        for i, t in enumerate(scheduler.timesteps):
-            sample = scheduler.scale_model_input(sample, t)
-
-            model_output = model(sample, t)
-
-            output = scheduler.step(model_output, t, sample)
-            sample = output.prev_sample
-
-        result_sum = torch.sum(torch.abs(sample))
-        result_mean = torch.mean(torch.abs(sample))
-
-        assert abs(result_sum.item() - 0.0017) < 1e-2
-        assert abs(result_mean.item() - 2.2676e-06) < 1e-3
-
-    def test_full_loop_device(self):
-        scheduler_class = self.scheduler_classes[0]
-        scheduler_config = self.get_scheduler_config()
-        scheduler = scheduler_class(**scheduler_config)
-
-        scheduler.set_timesteps(self.num_inference_steps, device=torch_device)
-
-        model = self.dummy_model()
-        sample = self.dummy_sample_deter * scheduler.init_noise_sigma.cpu()
-        sample = sample.to(torch_device)
-
-        for i, t in enumerate(scheduler.timesteps):
-            sample = scheduler.scale_model_input(sample, t)
-
-            model_output = model(sample, t)
-
-            output = scheduler.step(model_output, t, sample)
-            sample = output.prev_sample
-
-        result_sum = torch.sum(torch.abs(sample))
-        result_mean = torch.mean(torch.abs(sample))
-
-        assert abs(result_sum.item() - 1006.388) < 1e-2
-        assert abs(result_mean.item() - 1.31) < 1e-3
-
-    def test_full_loop_device_karras_sigmas(self):
-        scheduler_class = self.scheduler_classes[0]
-        scheduler_config = self.get_scheduler_config()
-        scheduler = scheduler_class(**scheduler_config, use_karras_sigmas=True)
-
-        scheduler.set_timesteps(self.num_inference_steps, device=torch_device)
-
-        model = self.dummy_model()
-        sample = self.dummy_sample_deter.to(torch_device) * scheduler.init_noise_sigma
-        sample = sample.to(torch_device)
-
-        for t in scheduler.timesteps:
-            sample = scheduler.scale_model_input(sample, t)
-
-            model_output = model(sample, t)
-
-            output = scheduler.step(model_output, t, sample)
-            sample = output.prev_sample
-
-        result_sum = torch.sum(torch.abs(sample))
-        result_mean = torch.mean(torch.abs(sample))
-
-        assert abs(result_sum.item() - 3812.9927) < 2e-2
-        assert abs(result_mean.item() - 4.9648) < 1e-3

spaces/Andy1621/uniformer_image_detection/configs/cascade_rcnn/cascade_mask_rcnn_r101_fpn_1x_coco.py

@@ -1,2 +0,0 @@
-_base_ = './cascade_mask_rcnn_r50_fpn_1x_coco.py'
-model = dict(pretrained='torchvision://resnet101', backbone=dict(depth=101))

spaces/Andy1621/uniformer_image_detection/mmdet/models/dense_heads/pisa_ssd_head.py

@@ -1,139 +0,0 @@
-import torch
-
-from mmdet.core import multi_apply
-from ..builder import HEADS
-from ..losses import CrossEntropyLoss, SmoothL1Loss, carl_loss, isr_p
-from .ssd_head import SSDHead
-
-
-# TODO: add loss evaluator for SSD
-@HEADS.register_module()
-class PISASSDHead(SSDHead):
-
-    def loss(self,
-             cls_scores,
-             bbox_preds,
-             gt_bboxes,
-             gt_labels,
-             img_metas,
-             gt_bboxes_ignore=None):
-        """Compute losses of the head.
-
-        Args:
-            cls_scores (list[Tensor]): Box scores for each scale level
-                Has shape (N, num_anchors * num_classes, H, W)
-            bbox_preds (list[Tensor]): Box energies / deltas for each scale
-                level with shape (N, num_anchors * 4, H, W)
-            gt_bboxes (list[Tensor]): Ground truth bboxes of each image
-                with shape (num_obj, 4).
-            gt_labels (list[Tensor]): Ground truth labels of each image
-                with shape (num_obj, 4).
-            img_metas (list[dict]): Meta information of each image, e.g.,
-                image size, scaling factor, etc.
-            gt_bboxes_ignore (list[Tensor]): Ignored gt bboxes of each image.
-                Default: None.
-
-        Returns:
-            dict: Loss dict, comprise classification loss regression loss and
-                carl loss.
-        """
-        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
-        assert len(featmap_sizes) == self.anchor_generator.num_levels
-
-        device = cls_scores[0].device
-
-        anchor_list, valid_flag_list = self.get_anchors(
-            featmap_sizes, img_metas, device=device)
-        cls_reg_targets = self.get_targets(
-            anchor_list,
-            valid_flag_list,
-            gt_bboxes,
-            img_metas,
-            gt_bboxes_ignore_list=gt_bboxes_ignore,
-            gt_labels_list=gt_labels,
-            label_channels=1,
-            unmap_outputs=False,
-            return_sampling_results=True)
-        if cls_reg_targets is None:
-            return None
-        (labels_list, label_weights_list, bbox_targets_list, bbox_weights_list,
-         num_total_pos, num_total_neg, sampling_results_list) = cls_reg_targets
-
-        num_images = len(img_metas)
-        all_cls_scores = torch.cat([
-            s.permute(0, 2, 3, 1).reshape(
-                num_images, -1, self.cls_out_channels) for s in cls_scores
-        ], 1)
-        all_labels = torch.cat(labels_list, -1).view(num_images, -1)
-        all_label_weights = torch.cat(label_weights_list,
-                                      -1).view(num_images, -1)
-        all_bbox_preds = torch.cat([
-            b.permute(0, 2, 3, 1).reshape(num_images, -1, 4)
-            for b in bbox_preds
-        ], -2)
-        all_bbox_targets = torch.cat(bbox_targets_list,
-                                     -2).view(num_images, -1, 4)
-        all_bbox_weights = torch.cat(bbox_weights_list,
-                                     -2).view(num_images, -1, 4)
-
-        # concat all level anchors to a single tensor
-        all_anchors = []
-        for i in range(num_images):
-            all_anchors.append(torch.cat(anchor_list[i]))
-
-        isr_cfg = self.train_cfg.get('isr', None)
-        all_targets = (all_labels.view(-1), all_label_weights.view(-1),
-                       all_bbox_targets.view(-1,
-                                             4), all_bbox_weights.view(-1, 4))
-        # apply ISR-P
-        if isr_cfg is not None:
-            all_targets = isr_p(
-                all_cls_scores.view(-1, all_cls_scores.size(-1)),
-                all_bbox_preds.view(-1, 4),
-                all_targets,
-                torch.cat(all_anchors),
-                sampling_results_list,
-                loss_cls=CrossEntropyLoss(),
-                bbox_coder=self.bbox_coder,
-                **self.train_cfg.isr,
-                num_class=self.num_classes)
-            (new_labels, new_label_weights, new_bbox_targets,
-             new_bbox_weights) = all_targets
-            all_labels = new_labels.view(all_labels.shape)
-            all_label_weights = new_label_weights.view(all_label_weights.shape)
-            all_bbox_targets = new_bbox_targets.view(all_bbox_targets.shape)
-            all_bbox_weights = new_bbox_weights.view(all_bbox_weights.shape)
-
-        # add CARL loss
-        carl_loss_cfg = self.train_cfg.get('carl', None)
-        if carl_loss_cfg is not None:
-            loss_carl = carl_loss(
-                all_cls_scores.view(-1, all_cls_scores.size(-1)),
-                all_targets[0],
-                all_bbox_preds.view(-1, 4),
-                all_targets[2],
-                SmoothL1Loss(beta=1.),
-                **self.train_cfg.carl,
-                avg_factor=num_total_pos,
-                num_class=self.num_classes)
-
-        # check NaN and Inf
-        assert torch.isfinite(all_cls_scores).all().item(), \
-            'classification scores become infinite or NaN!'
-        assert torch.isfinite(all_bbox_preds).all().item(), \
-            'bbox predications become infinite or NaN!'
-
-        losses_cls, losses_bbox = multi_apply(
-            self.loss_single,
-            all_cls_scores,
-            all_bbox_preds,
-            all_anchors,
-            all_labels,
-            all_label_weights,
-            all_bbox_targets,
-            all_bbox_weights,
-            num_total_samples=num_total_pos)
-        loss_dict = dict(loss_cls=losses_cls, loss_bbox=losses_bbox)
-        if carl_loss_cfg is not None:
-            loss_dict.update(loss_carl)
-        return loss_dict

spaces/Andy1621/uniformer_image_segmentation/configs/deeplabv3/deeplabv3_r101-d8_512x512_40k_voc12aug.py

@@ -1,2 +0,0 @@
-_base_ = './deeplabv3_r50-d8_512x512_40k_voc12aug.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))

spaces/AnishKumbhar/ChatBot/text-generation-webui-main/modules/exllamav2.py

@@ -1,133 +0,0 @@
-import random
-from pathlib import Path
-
-import torch
-from exllamav2 import (
-    ExLlamaV2,
-    ExLlamaV2Cache,
-    ExLlamaV2Config,
-    ExLlamaV2Tokenizer
-)
-from exllamav2.generator import ExLlamaV2BaseGenerator, ExLlamaV2Sampler
-
-from modules import shared
-from modules.logging_colors import logger
-from modules.text_generation import get_max_prompt_length
-
-try:
-    import flash_attn
-except ModuleNotFoundError:
-    logger.warning(
-        'You are running ExLlamaV2 without flash-attention. This will cause the VRAM usage '
-        'to be a lot higher than it could be.\n'
-        'Try installing flash-attention following the instructions here: '
-        'https://github.com/Dao-AILab/flash-attention#installation-and-features'
-    )
-    pass
-
-
-class Exllamav2Model:
-    def __init__(self):
-        pass
-
-    @classmethod
-    def from_pretrained(self, path_to_model):
-
-        path_to_model = Path(f'{shared.args.model_dir}') / Path(path_to_model)
-
-        config = ExLlamaV2Config()
-        config.model_dir = str(path_to_model)
-        config.prepare()
-
-        config.max_seq_len = shared.args.max_seq_len
-        config.scale_pos_emb = shared.args.compress_pos_emb
-        config.scale_alpha_value = shared.args.alpha_value
-
-        model = ExLlamaV2(config)
-
-        split = None
-        if shared.args.gpu_split:
-            split = [float(alloc) for alloc in shared.args.gpu_split.split(",")]
-
-        model.load(split)
-
-        tokenizer = ExLlamaV2Tokenizer(config)
-        cache = ExLlamaV2Cache(model)
-        generator = ExLlamaV2BaseGenerator(model, cache, tokenizer)
-
-        result = self()
-        result.model = model
-        result.cache = cache
-        result.tokenizer = tokenizer
-        result.generator = generator
-        return result, result
-
-    def encode(self, string, **kwargs):
-        return self.tokenizer.encode(string, add_bos=True)
-
-    def decode(self, ids, **kwargs):
-        if isinstance(ids, list):
-            ids = torch.tensor([ids])
-        elif isinstance(ids, torch.Tensor) and ids.numel() == 1:
-            ids = ids.view(1, -1)
-
-        return self.tokenizer.decode(ids)[0]
-
-    def get_logits(self, token_ids, **kwargs):
-        self.cache.current_seq_len = 0
-        self.model.forward(token_ids[:, :-1], self.cache, input_mask=None, preprocess_only=True)
-        return self.model.forward(token_ids[:, -1:], self.cache, input_mask=None, **kwargs).float().cpu()
-
-    def generate_with_streaming(self, prompt, state):
-        settings = ExLlamaV2Sampler.Settings()
-        settings.temperature = state['temperature']
-        settings.top_k = state['top_k']
-        settings.top_p = state['top_p']
-        settings.typical = state['typical_p']
-        settings.token_repetition_penalty = state['repetition_penalty']
-        settings.token_repetition_range = -1 if state['repetition_penalty_range'] <= 0 else state['repetition_penalty_range']
-        if state['ban_eos_token']:
-            settings.disallow_tokens(self.tokenizer, [self.tokenizer.eos_token_id])
-
-        if state['custom_token_bans']:
-            to_ban = [int(x) for x in state['custom_token_bans'].split(',')]
-            if len(to_ban) > 0:
-                settings.disallow_tokens(self.tokenizer, to_ban)
-
-        ids = self.tokenizer.encode(prompt, add_bos=state['add_bos_token'])
-        ids = ids[:, -get_max_prompt_length(state):]
-        initial_len = ids.shape[-1]
-
-        if state['auto_max_new_tokens']:
-            max_new_tokens = state['truncation_length'] - ids.shape[-1]
-        else:
-            max_new_tokens = state['max_new_tokens']
-
-        # _gen_begin_base
-        self.cache.current_seq_len = 0
-        self.model.forward(ids[:, :-1], self.cache, input_mask=None, preprocess_only=True)
-
-        has_leading_space = False
-        for i in range(max_new_tokens):
-            logits = self.model.forward(ids[:, -1:], self.cache, input_mask=None).float().cpu()
-            token, _, _= ExLlamaV2Sampler.sample(logits, settings, ids, random.random(), self.tokenizer)
-            ids = torch.cat([ids, token], dim=1)
-
-            if i == 0 and self.tokenizer.tokenizer.IdToPiece(int(token)).startswith('▁'):
-                has_leading_space = True
-
-            decoded_text = self.tokenizer.decode(ids[:, initial_len:])[0]
-            if has_leading_space:
-                decoded_text = ' ' + decoded_text
-
-            yield decoded_text
-
-            if token.item() == self.tokenizer.eos_token_id or shared.stop_everything:
-                break
-
-    def generate(self, prompt, state):
-        output = ''
-        for output in self.generate_with_streaming(prompt, state):
-            pass
-
-        return output

spaces/Anonymous-123/ImageNet-Editing/editing_diffusion/guided_diffusion/guided_diffusion/unet.py

@@ -1,894 +0,0 @@
-from abc import abstractmethod
-
-import math
-
-import numpy as np
-import torch as th
-import torch.nn as nn
-import torch.nn.functional as F
-
-from .fp16_util import convert_module_to_f16, convert_module_to_f32
-from .nn import (
-    checkpoint,
-    conv_nd,
-    linear,
-    avg_pool_nd,
-    zero_module,
-    normalization,
-    timestep_embedding,
-)
-
-
-class AttentionPool2d(nn.Module):
-    """
-    Adapted from CLIP: https://github.com/openai/CLIP/blob/main/clip/model.py
-    """
-
-    def __init__(
-        self,
-        spacial_dim: int,
-        embed_dim: int,
-        num_heads_channels: int,
-        output_dim: int = None,
-    ):
-        super().__init__()
-        self.positional_embedding = nn.Parameter(
-            th.randn(embed_dim, spacial_dim ** 2 + 1) / embed_dim ** 0.5
-        )
-        self.qkv_proj = conv_nd(1, embed_dim, 3 * embed_dim, 1)
-        self.c_proj = conv_nd(1, embed_dim, output_dim or embed_dim, 1)
-        self.num_heads = embed_dim // num_heads_channels
-        self.attention = QKVAttention(self.num_heads)
-
-    def forward(self, x):
-        b, c, *_spatial = x.shape
-        x = x.reshape(b, c, -1)  # NC(HW)
-        x = th.cat([x.mean(dim=-1, keepdim=True), x], dim=-1)  # NC(HW+1)
-        x = x + self.positional_embedding[None, :, :].to(x.dtype)  # NC(HW+1)
-        x = self.qkv_proj(x)
-        x = self.attention(x)
-        x = self.c_proj(x)
-        return x[:, :, 0]
-
-
-class TimestepBlock(nn.Module):
-    """
-    Any module where forward() takes timestep embeddings as a second argument.
-    """
-
-    @abstractmethod
-    def forward(self, x, emb):
-        """
-        Apply the module to `x` given `emb` timestep embeddings.
-        """
-
-
-class TimestepEmbedSequential(nn.Sequential, TimestepBlock):
-    """
-    A sequential module that passes timestep embeddings to the children that
-    support it as an extra input.
-    """
-
-    def forward(self, x, emb):
-        for layer in self:
-            if isinstance(layer, TimestepBlock):
-                x = layer(x, emb)
-            else:
-                x = layer(x)
-        return x
-
-
-class Upsample(nn.Module):
-    """
-    An upsampling layer with an optional convolution.
-
-    :param channels: channels in the inputs and outputs.
-    :param use_conv: a bool determining if a convolution is applied.
-    :param dims: determines if the signal is 1D, 2D, or 3D. If 3D, then
-                 upsampling occurs in the inner-two dimensions.
-    """
-
-    def __init__(self, channels, use_conv, dims=2, out_channels=None):
-        super().__init__()
-        self.channels = channels
-        self.out_channels = out_channels or channels
-        self.use_conv = use_conv
-        self.dims = dims
-        if use_conv:
-            self.conv = conv_nd(dims, self.channels, self.out_channels, 3, padding=1)
-
-    def forward(self, x):
-        assert x.shape[1] == self.channels
-        if self.dims == 3:
-            x = F.interpolate(
-                x, (x.shape[2], x.shape[3] * 2, x.shape[4] * 2), mode="nearest"
-            )
-        else:
-            x = F.interpolate(x, scale_factor=2, mode="nearest")
-        if self.use_conv:
-            x = self.conv(x)
-        return x
-
-
-class Downsample(nn.Module):
-    """
-    A downsampling layer with an optional convolution.
-
-    :param channels: channels in the inputs and outputs.
-    :param use_conv: a bool determining if a convolution is applied.
-    :param dims: determines if the signal is 1D, 2D, or 3D. If 3D, then
-                 downsampling occurs in the inner-two dimensions.
-    """
-
-    def __init__(self, channels, use_conv, dims=2, out_channels=None):
-        super().__init__()
-        self.channels = channels
-        self.out_channels = out_channels or channels
-        self.use_conv = use_conv
-        self.dims = dims
-        stride = 2 if dims != 3 else (1, 2, 2)
-        if use_conv:
-            self.op = conv_nd(
-                dims, self.channels, self.out_channels, 3, stride=stride, padding=1
-            )
-        else:
-            assert self.channels == self.out_channels
-            self.op = avg_pool_nd(dims, kernel_size=stride, stride=stride)
-
-    def forward(self, x):
-        assert x.shape[1] == self.channels
-        return self.op(x)
-
-
-class ResBlock(TimestepBlock):
-    """
-    A residual block that can optionally change the number of channels.
-
-    :param channels: the number of input channels.
-    :param emb_channels: the number of timestep embedding channels.
-    :param dropout: the rate of dropout.
-    :param out_channels: if specified, the number of out channels.
-    :param use_conv: if True and out_channels is specified, use a spatial
-        convolution instead of a smaller 1x1 convolution to change the
-        channels in the skip connection.
-    :param dims: determines if the signal is 1D, 2D, or 3D.
-    :param use_checkpoint: if True, use gradient checkpointing on this module.
-    :param up: if True, use this block for upsampling.
-    :param down: if True, use this block for downsampling.
-    """
-
-    def __init__(
-        self,
-        channels,
-        emb_channels,
-        dropout,
-        out_channels=None,
-        use_conv=False,
-        use_scale_shift_norm=False,
-        dims=2,
-        use_checkpoint=False,
-        up=False,
-        down=False,
-    ):
-        super().__init__()
-        self.channels = channels
-        self.emb_channels = emb_channels
-        self.dropout = dropout
-        self.out_channels = out_channels or channels
-        self.use_conv = use_conv
-        self.use_checkpoint = use_checkpoint
-        self.use_scale_shift_norm = use_scale_shift_norm
-
-        self.in_layers = nn.Sequential(
-            normalization(channels),
-            nn.SiLU(),
-            conv_nd(dims, channels, self.out_channels, 3, padding=1),
-        )
-
-        self.updown = up or down
-
-        if up:
-            self.h_upd = Upsample(channels, False, dims)
-            self.x_upd = Upsample(channels, False, dims)
-        elif down:
-            self.h_upd = Downsample(channels, False, dims)
-            self.x_upd = Downsample(channels, False, dims)
-        else:
-            self.h_upd = self.x_upd = nn.Identity()
-
-        self.emb_layers = nn.Sequential(
-            nn.SiLU(),
-            linear(
-                emb_channels,
-                2 * self.out_channels if use_scale_shift_norm else self.out_channels,
-            ),
-        )
-        self.out_layers = nn.Sequential(
-            normalization(self.out_channels),
-            nn.SiLU(),
-            nn.Dropout(p=dropout),
-            zero_module(
-                conv_nd(dims, self.out_channels, self.out_channels, 3, padding=1)
-            ),
-        )
-
-        if self.out_channels == channels:
-            self.skip_connection = nn.Identity()
-        elif use_conv:
-            self.skip_connection = conv_nd(
-                dims, channels, self.out_channels, 3, padding=1
-            )
-        else:
-            self.skip_connection = conv_nd(dims, channels, self.out_channels, 1)
-
-    def forward(self, x, emb):
-        """
-        Apply the block to a Tensor, conditioned on a timestep embedding.
-
-        :param x: an [N x C x ...] Tensor of features.
-        :param emb: an [N x emb_channels] Tensor of timestep embeddings.
-        :return: an [N x C x ...] Tensor of outputs.
-        """
-        return checkpoint(
-            self._forward, (x, emb), self.parameters(), self.use_checkpoint
-        )
-
-    def _forward(self, x, emb):
-        if self.updown:
-            in_rest, in_conv = self.in_layers[:-1], self.in_layers[-1]
-            h = in_rest(x)
-            h = self.h_upd(h)
-            x = self.x_upd(x)
-            h = in_conv(h)
-        else:
-            h = self.in_layers(x)
-        emb_out = self.emb_layers(emb).type(h.dtype)
-        while len(emb_out.shape) < len(h.shape):
-            emb_out = emb_out[..., None]
-        if self.use_scale_shift_norm:
-            out_norm, out_rest = self.out_layers[0], self.out_layers[1:]
-            scale, shift = th.chunk(emb_out, 2, dim=1)
-            h = out_norm(h) * (1 + scale) + shift
-            h = out_rest(h)
-        else:
-            h = h + emb_out
-            h = self.out_layers(h)
-        return self.skip_connection(x) + h
-
-
-class AttentionBlock(nn.Module):
-    """
-    An attention block that allows spatial positions to attend to each other.
-
-    Originally ported from here, but adapted to the N-d case.
-    https://github.com/hojonathanho/diffusion/blob/1e0dceb3b3495bbe19116a5e1b3596cd0706c543/diffusion_tf/models/unet.py#L66.
-    """
-
-    def __init__(
-        self,
-        channels,
-        num_heads=1,
-        num_head_channels=-1,
-        use_checkpoint=False,
-        use_new_attention_order=False,
-    ):
-        super().__init__()
-        self.channels = channels
-        if num_head_channels == -1:
-            self.num_heads = num_heads
-        else:
-            assert (
-                channels % num_head_channels == 0
-            ), f"q,k,v channels {channels} is not divisible by num_head_channels {num_head_channels}"
-            self.num_heads = channels // num_head_channels
-        self.use_checkpoint = use_checkpoint
-        self.norm = normalization(channels)
-        self.qkv = conv_nd(1, channels, channels * 3, 1)
-        if use_new_attention_order:
-            # split qkv before split heads
-            self.attention = QKVAttention(self.num_heads)
-        else:
-            # split heads before split qkv
-            self.attention = QKVAttentionLegacy(self.num_heads)
-
-        self.proj_out = zero_module(conv_nd(1, channels, channels, 1))
-
-    def forward(self, x):
-        return checkpoint(self._forward, (x,), self.parameters(), True)
-
-    def _forward(self, x):
-        b, c, *spatial = x.shape
-        x = x.reshape(b, c, -1)
-        qkv = self.qkv(self.norm(x))
-        h = self.attention(qkv)
-        h = self.proj_out(h)
-        return (x + h).reshape(b, c, *spatial)
-
-
-def count_flops_attn(model, _x, y):
-    """
-    A counter for the `thop` package to count the operations in an
-    attention operation.
-    Meant to be used like:
-        macs, params = thop.profile(
-            model,
-            inputs=(inputs, timestamps),
-            custom_ops={QKVAttention: QKVAttention.count_flops},
-        )
-    """
-    b, c, *spatial = y[0].shape
-    num_spatial = int(np.prod(spatial))
-    # We perform two matmuls with the same number of ops.
-    # The first computes the weight matrix, the second computes
-    # the combination of the value vectors.
-    matmul_ops = 2 * b * (num_spatial ** 2) * c
-    model.total_ops += th.DoubleTensor([matmul_ops])
-
-
-class QKVAttentionLegacy(nn.Module):
-    """
-    A module which performs QKV attention. Matches legacy QKVAttention + input/ouput heads shaping
-    """
-
-    def __init__(self, n_heads):
-        super().__init__()
-        self.n_heads = n_heads
-
-    def forward(self, qkv):
-        """
-        Apply QKV attention.
-
-        :param qkv: an [N x (H * 3 * C) x T] tensor of Qs, Ks, and Vs.
-        :return: an [N x (H * C) x T] tensor after attention.
-        """
-        bs, width, length = qkv.shape
-        assert width % (3 * self.n_heads) == 0
-        ch = width // (3 * self.n_heads)
-        q, k, v = qkv.reshape(bs * self.n_heads, ch * 3, length).split(ch, dim=1)
-        scale = 1 / math.sqrt(math.sqrt(ch))
-        weight = th.einsum(
-            "bct,bcs->bts", q * scale, k * scale
-        )  # More stable with f16 than dividing afterwards
-        weight = th.softmax(weight.float(), dim=-1).type(weight.dtype)
-        a = th.einsum("bts,bcs->bct", weight, v)
-        return a.reshape(bs, -1, length)
-
-    @staticmethod
-    def count_flops(model, _x, y):
-        return count_flops_attn(model, _x, y)
-
-
-class QKVAttention(nn.Module):
-    """
-    A module which performs QKV attention and splits in a different order.
-    """
-
-    def __init__(self, n_heads):
-        super().__init__()
-        self.n_heads = n_heads
-
-    def forward(self, qkv):
-        """
-        Apply QKV attention.
-
-        :param qkv: an [N x (3 * H * C) x T] tensor of Qs, Ks, and Vs.
-        :return: an [N x (H * C) x T] tensor after attention.
-        """
-        bs, width, length = qkv.shape
-        assert width % (3 * self.n_heads) == 0
-        ch = width // (3 * self.n_heads)
-        q, k, v = qkv.chunk(3, dim=1)
-        scale = 1 / math.sqrt(math.sqrt(ch))
-        weight = th.einsum(
-            "bct,bcs->bts",
-            (q * scale).view(bs * self.n_heads, ch, length),
-            (k * scale).view(bs * self.n_heads, ch, length),
-        )  # More stable with f16 than dividing afterwards
-        weight = th.softmax(weight.float(), dim=-1).type(weight.dtype)
-        a = th.einsum("bts,bcs->bct", weight, v.reshape(bs * self.n_heads, ch, length))
-        return a.reshape(bs, -1, length)
-
-    @staticmethod
-    def count_flops(model, _x, y):
-        return count_flops_attn(model, _x, y)
-
-
-class UNetModel(nn.Module):
-    """
-    The full UNet model with attention and timestep embedding.
-
-    :param in_channels: channels in the input Tensor.
-    :param model_channels: base channel count for the model.
-    :param out_channels: channels in the output Tensor.
-    :param num_res_blocks: number of residual blocks per downsample.
-    :param attention_resolutions: a collection of downsample rates at which
-        attention will take place. May be a set, list, or tuple.
-        For example, if this contains 4, then at 4x downsampling, attention
-        will be used.
-    :param dropout: the dropout probability.
-    :param channel_mult: channel multiplier for each level of the UNet.
-    :param conv_resample: if True, use learned convolutions for upsampling and
-        downsampling.
-    :param dims: determines if the signal is 1D, 2D, or 3D.
-    :param num_classes: if specified (as an int), then this model will be
-        class-conditional with `num_classes` classes.
-    :param use_checkpoint: use gradient checkpointing to reduce memory usage.
-    :param num_heads: the number of attention heads in each attention layer.
-    :param num_heads_channels: if specified, ignore num_heads and instead use
-                               a fixed channel width per attention head.
-    :param num_heads_upsample: works with num_heads to set a different number
-                               of heads for upsampling. Deprecated.
-    :param use_scale_shift_norm: use a FiLM-like conditioning mechanism.
-    :param resblock_updown: use residual blocks for up/downsampling.
-    :param use_new_attention_order: use a different attention pattern for potentially
-                                    increased efficiency.
-    """
-
-    def __init__(
-        self,
-        image_size,
-        in_channels,
-        model_channels,
-        out_channels,
-        num_res_blocks,
-        attention_resolutions,
-        dropout=0,
-        channel_mult=(1, 2, 4, 8),
-        conv_resample=True,
-        dims=2,
-        num_classes=None,
-        use_checkpoint=False,
-        use_fp16=False,
-        num_heads=1,
-        num_head_channels=-1,
-        num_heads_upsample=-1,
-        use_scale_shift_norm=False,
-        resblock_updown=False,
-        use_new_attention_order=False,
-    ):
-        super().__init__()
-
-        if num_heads_upsample == -1:
-            num_heads_upsample = num_heads
-
-        self.image_size = image_size
-        self.in_channels = in_channels
-        self.model_channels = model_channels
-        self.out_channels = out_channels
-        self.num_res_blocks = num_res_blocks
-        self.attention_resolutions = attention_resolutions
-        self.dropout = dropout
-        self.channel_mult = channel_mult
-        self.conv_resample = conv_resample
-        self.num_classes = num_classes
-        self.use_checkpoint = use_checkpoint
-        self.dtype = th.float16 if use_fp16 else th.float32
-        self.num_heads = num_heads
-        self.num_head_channels = num_head_channels
-        self.num_heads_upsample = num_heads_upsample
-
-        time_embed_dim = model_channels * 4
-        self.time_embed = nn.Sequential(
-            linear(model_channels, time_embed_dim),
-            nn.SiLU(),
-            linear(time_embed_dim, time_embed_dim),
-        )
-
-        if self.num_classes is not None:
-            self.label_emb = nn.Embedding(num_classes, time_embed_dim)
-
-        ch = input_ch = int(channel_mult[0] * model_channels)
-        self.input_blocks = nn.ModuleList(
-            [TimestepEmbedSequential(conv_nd(dims, in_channels, ch, 3, padding=1))]
-        )
-        self._feature_size = ch
-        input_block_chans = [ch]
-        ds = 1
-        for level, mult in enumerate(channel_mult):
-            for _ in range(num_res_blocks):
-                layers = [
-                    ResBlock(
-                        ch,
-                        time_embed_dim,
-                        dropout,
-                        out_channels=int(mult * model_channels),
-                        dims=dims,
-                        use_checkpoint=use_checkpoint,
-                        use_scale_shift_norm=use_scale_shift_norm,
-                    )
-                ]
-                ch = int(mult * model_channels)
-                if ds in attention_resolutions:
-                    layers.append(
-                        AttentionBlock(
-                            ch,
-                            use_checkpoint=use_checkpoint,
-                            num_heads=num_heads,
-                            num_head_channels=num_head_channels,
-                            use_new_attention_order=use_new_attention_order,
-                        )
-                    )
-                self.input_blocks.append(TimestepEmbedSequential(*layers))
-                self._feature_size += ch
-                input_block_chans.append(ch)
-            if level != len(channel_mult) - 1:
-                out_ch = ch
-                self.input_blocks.append(
-                    TimestepEmbedSequential(
-                        ResBlock(
-                            ch,
-                            time_embed_dim,
-                            dropout,
-                            out_channels=out_ch,
-                            dims=dims,
-                            use_checkpoint=use_checkpoint,
-                            use_scale_shift_norm=use_scale_shift_norm,
-                            down=True,
-                        )
-                        if resblock_updown
-                        else Downsample(
-                            ch, conv_resample, dims=dims, out_channels=out_ch
-                        )
-                    )
-                )
-                ch = out_ch
-                input_block_chans.append(ch)
-                ds *= 2
-                self._feature_size += ch
-
-        self.middle_block = TimestepEmbedSequential(
-            ResBlock(
-                ch,
-                time_embed_dim,
-                dropout,
-                dims=dims,
-                use_checkpoint=use_checkpoint,
-                use_scale_shift_norm=use_scale_shift_norm,
-            ),
-            AttentionBlock(
-                ch,
-                use_checkpoint=use_checkpoint,
-                num_heads=num_heads,
-                num_head_channels=num_head_channels,
-                use_new_attention_order=use_new_attention_order,
-            ),
-            ResBlock(
-                ch,
-                time_embed_dim,
-                dropout,
-                dims=dims,
-                use_checkpoint=use_checkpoint,
-                use_scale_shift_norm=use_scale_shift_norm,
-            ),
-        )
-        self._feature_size += ch
-
-        self.output_blocks = nn.ModuleList([])
-        for level, mult in list(enumerate(channel_mult))[::-1]:
-            for i in range(num_res_blocks + 1):
-                ich = input_block_chans.pop()
-                layers = [
-                    ResBlock(
-                        ch + ich,
-                        time_embed_dim,
-                        dropout,
-                        out_channels=int(model_channels * mult),
-                        dims=dims,
-                        use_checkpoint=use_checkpoint,
-                        use_scale_shift_norm=use_scale_shift_norm,
-                    )
-                ]
-                ch = int(model_channels * mult)
-                if ds in attention_resolutions:
-                    layers.append(
-                        AttentionBlock(
-                            ch,
-                            use_checkpoint=use_checkpoint,
-                            num_heads=num_heads_upsample,
-                            num_head_channels=num_head_channels,
-                            use_new_attention_order=use_new_attention_order,
-                        )
-                    )
-                if level and i == num_res_blocks:
-                    out_ch = ch
-                    layers.append(
-                        ResBlock(
-                            ch,
-                            time_embed_dim,
-                            dropout,
-                            out_channels=out_ch,
-                            dims=dims,
-                            use_checkpoint=use_checkpoint,
-                            use_scale_shift_norm=use_scale_shift_norm,
-                            up=True,
-                        )
-                        if resblock_updown
-                        else Upsample(ch, conv_resample, dims=dims, out_channels=out_ch)
-                    )
-                    ds //= 2
-                self.output_blocks.append(TimestepEmbedSequential(*layers))
-                self._feature_size += ch
-
-        self.out = nn.Sequential(
-            normalization(ch),
-            nn.SiLU(),
-            zero_module(conv_nd(dims, input_ch, out_channels, 3, padding=1)),
-        )
-
-    def convert_to_fp16(self):
-        """
-        Convert the torso of the model to float16.
-        """
-        self.input_blocks.apply(convert_module_to_f16)
-        self.middle_block.apply(convert_module_to_f16)
-        self.output_blocks.apply(convert_module_to_f16)
-
-    def convert_to_fp32(self):
-        """
-        Convert the torso of the model to float32.
-        """
-        self.input_blocks.apply(convert_module_to_f32)
-        self.middle_block.apply(convert_module_to_f32)
-        self.output_blocks.apply(convert_module_to_f32)
-
-    def forward(self, x, timesteps, y=None):
-        """
-        Apply the model to an input batch.
-
-        :param x: an [N x C x ...] Tensor of inputs.
-        :param timesteps: a 1-D batch of timesteps.
-        :param y: an [N] Tensor of labels, if class-conditional.
-        :return: an [N x C x ...] Tensor of outputs.
-        """
-        assert (y is not None) == (
-            self.num_classes is not None
-        ), "must specify y if and only if the model is class-conditional"
-
-        hs = []
-        emb = self.time_embed(timestep_embedding(timesteps, self.model_channels))
-
-        if self.num_classes is not None:
-            assert y.shape == (x.shape[0],)
-            emb = emb + self.label_emb(y)
-
-        h = x.type(self.dtype)
-        for module in self.input_blocks:
-            h = module(h, emb)
-            hs.append(h)
-        h = self.middle_block(h, emb)
-        for module in self.output_blocks:
-            h = th.cat([h, hs.pop()], dim=1)
-            h = module(h, emb)
-        h = h.type(x.dtype)
-        return self.out(h)
-
-
-class SuperResModel(UNetModel):
-    """
-    A UNetModel that performs super-resolution.
-
-    Expects an extra kwarg `low_res` to condition on a low-resolution image.
-    """
-
-    def __init__(self, image_size, in_channels, *args, **kwargs):
-        super().__init__(image_size, in_channels * 2, *args, **kwargs)
-
-    def forward(self, x, timesteps, low_res=None, **kwargs):
-        _, _, new_height, new_width = x.shape
-        upsampled = F.interpolate(low_res, (new_height, new_width), mode="bilinear")
-        x = th.cat([x, upsampled], dim=1)
-        return super().forward(x, timesteps, **kwargs)
-
-
-class EncoderUNetModel(nn.Module):
-    """
-    The half UNet model with attention and timestep embedding.
-
-    For usage, see UNet.
-    """
-
-    def __init__(
-        self,
-        image_size,
-        in_channels,
-        model_channels,
-        out_channels,
-        num_res_blocks,
-        attention_resolutions,
-        dropout=0,
-        channel_mult=(1, 2, 4, 8),
-        conv_resample=True,
-        dims=2,
-        use_checkpoint=False,
-        use_fp16=False,
-        num_heads=1,
-        num_head_channels=-1,
-        num_heads_upsample=-1,
-        use_scale_shift_norm=False,
-        resblock_updown=False,
-        use_new_attention_order=False,
-        pool="adaptive",
-    ):
-        super().__init__()
-
-        if num_heads_upsample == -1:
-            num_heads_upsample = num_heads
-
-        self.in_channels = in_channels
-        self.model_channels = model_channels
-        self.out_channels = out_channels
-        self.num_res_blocks = num_res_blocks
-        self.attention_resolutions = attention_resolutions
-        self.dropout = dropout
-        self.channel_mult = channel_mult
-        self.conv_resample = conv_resample
-        self.use_checkpoint = use_checkpoint
-        self.dtype = th.float16 if use_fp16 else th.float32
-        self.num_heads = num_heads
-        self.num_head_channels = num_head_channels
-        self.num_heads_upsample = num_heads_upsample
-
-        time_embed_dim = model_channels * 4
-        self.time_embed = nn.Sequential(
-            linear(model_channels, time_embed_dim),
-            nn.SiLU(),
-            linear(time_embed_dim, time_embed_dim),
-        )
-
-        ch = int(channel_mult[0] * model_channels)
-        self.input_blocks = nn.ModuleList(
-            [TimestepEmbedSequential(conv_nd(dims, in_channels, ch, 3, padding=1))]
-        )
-        self._feature_size = ch
-        input_block_chans = [ch]
-        ds = 1
-        for level, mult in enumerate(channel_mult):
-            for _ in range(num_res_blocks):
-                layers = [
-                    ResBlock(
-                        ch,
-                        time_embed_dim,
-                        dropout,
-                        out_channels=int(mult * model_channels),
-                        dims=dims,
-                        use_checkpoint=use_checkpoint,
-                        use_scale_shift_norm=use_scale_shift_norm,
-                    )
-                ]
-                ch = int(mult * model_channels)
-                if ds in attention_resolutions:
-                    layers.append(
-                        AttentionBlock(
-                            ch,
-                            use_checkpoint=use_checkpoint,
-                            num_heads=num_heads,
-                            num_head_channels=num_head_channels,
-                            use_new_attention_order=use_new_attention_order,
-                        )
-                    )
-                self.input_blocks.append(TimestepEmbedSequential(*layers))
-                self._feature_size += ch
-                input_block_chans.append(ch)
-            if level != len(channel_mult) - 1:
-                out_ch = ch
-                self.input_blocks.append(
-                    TimestepEmbedSequential(
-                        ResBlock(
-                            ch,
-                            time_embed_dim,
-                            dropout,
-                            out_channels=out_ch,
-                            dims=dims,
-                            use_checkpoint=use_checkpoint,
-                            use_scale_shift_norm=use_scale_shift_norm,
-                            down=True,
-                        )
-                        if resblock_updown
-                        else Downsample(
-                            ch, conv_resample, dims=dims, out_channels=out_ch
-                        )
-                    )
-                )
-                ch = out_ch
-                input_block_chans.append(ch)
-                ds *= 2
-                self._feature_size += ch
-
-        self.middle_block = TimestepEmbedSequential(
-            ResBlock(
-                ch,
-                time_embed_dim,
-                dropout,
-                dims=dims,
-                use_checkpoint=use_checkpoint,
-                use_scale_shift_norm=use_scale_shift_norm,
-            ),
-            AttentionBlock(
-                ch,
-                use_checkpoint=use_checkpoint,
-                num_heads=num_heads,
-                num_head_channels=num_head_channels,
-                use_new_attention_order=use_new_attention_order,
-            ),
-            ResBlock(
-                ch,
-                time_embed_dim,
-                dropout,
-                dims=dims,
-                use_checkpoint=use_checkpoint,
-                use_scale_shift_norm=use_scale_shift_norm,
-            ),
-        )
-        self._feature_size += ch
-        self.pool = pool
-        if pool == "adaptive":
-            self.out = nn.Sequential(
-                normalization(ch),
-                nn.SiLU(),
-                nn.AdaptiveAvgPool2d((1, 1)),
-                zero_module(conv_nd(dims, ch, out_channels, 1)),
-                nn.Flatten(),
-            )
-        elif pool == "attention":
-            assert num_head_channels != -1
-            self.out = nn.Sequential(
-                normalization(ch),
-                nn.SiLU(),
-                AttentionPool2d(
-                    (image_size // ds), ch, num_head_channels, out_channels
-                ),
-            )
-        elif pool == "spatial":
-            self.out = nn.Sequential(
-                nn.Linear(self._feature_size, 2048),
-                nn.ReLU(),
-                nn.Linear(2048, self.out_channels),
-            )
-        elif pool == "spatial_v2":
-            self.out = nn.Sequential(
-                nn.Linear(self._feature_size, 2048),
-                normalization(2048),
-                nn.SiLU(),
-                nn.Linear(2048, self.out_channels),
-            )
-        else:
-            raise NotImplementedError(f"Unexpected {pool} pooling")
-
-    def convert_to_fp16(self):
-        """
-        Convert the torso of the model to float16.
-        """
-        self.input_blocks.apply(convert_module_to_f16)
-        self.middle_block.apply(convert_module_to_f16)
-
-    def convert_to_fp32(self):
-        """
-        Convert the torso of the model to float32.
-        """
-        self.input_blocks.apply(convert_module_to_f32)
-        self.middle_block.apply(convert_module_to_f32)
-
-    def forward(self, x, timesteps):
-        """
-        Apply the model to an input batch.
-
-        :param x: an [N x C x ...] Tensor of inputs.
-        :param timesteps: a 1-D batch of timesteps.
-        :return: an [N x K] Tensor of outputs.
-        """
-        emb = self.time_embed(timestep_embedding(timesteps, self.model_channels))
-
-        results = []
-        h = x.type(self.dtype)
-        for module in self.input_blocks:
-            h = module(h, emb)
-            if self.pool.startswith("spatial"):
-                results.append(h.type(x.dtype).mean(dim=(2, 3)))
-        h = self.middle_block(h, emb)
-        if self.pool.startswith("spatial"):
-            results.append(h.type(x.dtype).mean(dim=(2, 3)))
-            h = th.cat(results, axis=-1)
-            return self.out(h)
-        else:
-            h = h.type(x.dtype)
-            return self.out(h)

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

@@ -1,662 +0,0 @@
-"""Light wrapper around the Win32 Console API - this module should only be imported on Windows
-
-The API that this module wraps is documented at https://docs.microsoft.com/en-us/windows/console/console-functions
-"""
-import ctypes
-import sys
-from typing import Any
-
-windll: Any = None
-if sys.platform == "win32":
-    windll = ctypes.LibraryLoader(ctypes.WinDLL)
-else:
-    raise ImportError(f"{__name__} can only be imported on Windows")
-
-import time
-from ctypes import Structure, byref, wintypes
-from typing import IO, NamedTuple, Type, cast
-
-from pip._vendor.rich.color import ColorSystem
-from pip._vendor.rich.style import Style
-
-STDOUT = -11
-ENABLE_VIRTUAL_TERMINAL_PROCESSING = 4
-
-COORD = wintypes._COORD
-
-
-class LegacyWindowsError(Exception):
-    pass
-
-
-class WindowsCoordinates(NamedTuple):
-    """Coordinates in the Windows Console API are (y, x), not (x, y).
-    This class is intended to prevent that confusion.
-    Rows and columns are indexed from 0.
-    This class can be used in place of wintypes._COORD in arguments and argtypes.
-    """
-
-    row: int
-    col: int
-
-    @classmethod
-    def from_param(cls, value: "WindowsCoordinates") -> COORD:
-        """Converts a WindowsCoordinates into a wintypes _COORD structure.
-        This classmethod is internally called by ctypes to perform the conversion.
-
-        Args:
-            value (WindowsCoordinates): The input coordinates to convert.
-
-        Returns:
-            wintypes._COORD: The converted coordinates struct.
-        """
-        return COORD(value.col, value.row)
-
-
-class CONSOLE_SCREEN_BUFFER_INFO(Structure):
-    _fields_ = [
-        ("dwSize", COORD),
-        ("dwCursorPosition", COORD),
-        ("wAttributes", wintypes.WORD),
-        ("srWindow", wintypes.SMALL_RECT),
-        ("dwMaximumWindowSize", COORD),
-    ]
-
-
-class CONSOLE_CURSOR_INFO(ctypes.Structure):
-    _fields_ = [("dwSize", wintypes.DWORD), ("bVisible", wintypes.BOOL)]
-
-
-_GetStdHandle = windll.kernel32.GetStdHandle
-_GetStdHandle.argtypes = [
-    wintypes.DWORD,
-]
-_GetStdHandle.restype = wintypes.HANDLE
-
-
-def GetStdHandle(handle: int = STDOUT) -> wintypes.HANDLE:
-    """Retrieves a handle to the specified standard device (standard input, standard output, or standard error).
-
-    Args:
-        handle (int): Integer identifier for the handle. Defaults to -11 (stdout).
-
-    Returns:
-        wintypes.HANDLE: The handle
-    """
-    return cast(wintypes.HANDLE, _GetStdHandle(handle))
-
-
-_GetConsoleMode = windll.kernel32.GetConsoleMode
-_GetConsoleMode.argtypes = [wintypes.HANDLE, wintypes.LPDWORD]
-_GetConsoleMode.restype = wintypes.BOOL
-
-
-def GetConsoleMode(std_handle: wintypes.HANDLE) -> int:
-    """Retrieves the current input mode of a console's input buffer
-    or the current output mode of a console screen buffer.
-
-    Args:
-        std_handle (wintypes.HANDLE): A handle to the console input buffer or the console screen buffer.
-
-    Raises:
-        LegacyWindowsError: If any error occurs while calling the Windows console API.
-
-    Returns:
-        int: Value representing the current console mode as documented at
-            https://docs.microsoft.com/en-us/windows/console/getconsolemode#parameters
-    """
-
-    console_mode = wintypes.DWORD()
-    success = bool(_GetConsoleMode(std_handle, console_mode))
-    if not success:
-        raise LegacyWindowsError("Unable to get legacy Windows Console Mode")
-    return console_mode.value
-
-
-_FillConsoleOutputCharacterW = windll.kernel32.FillConsoleOutputCharacterW
-_FillConsoleOutputCharacterW.argtypes = [
-    wintypes.HANDLE,
-    ctypes.c_char,
-    wintypes.DWORD,
-    cast(Type[COORD], WindowsCoordinates),
-    ctypes.POINTER(wintypes.DWORD),
-]
-_FillConsoleOutputCharacterW.restype = wintypes.BOOL
-
-
-def FillConsoleOutputCharacter(
-    std_handle: wintypes.HANDLE,
-    char: str,
-    length: int,
-    start: WindowsCoordinates,
-) -> int:
-    """Writes a character to the console screen buffer a specified number of times, beginning at the specified coordinates.
-
-    Args:
-        std_handle (wintypes.HANDLE): A handle to the console input buffer or the console screen buffer.
-        char (str): The character to write. Must be a string of length 1.
-        length (int): The number of times to write the character.
-        start (WindowsCoordinates): The coordinates to start writing at.
-
-    Returns:
-        int: The number of characters written.
-    """
-    character = ctypes.c_char(char.encode())
-    num_characters = wintypes.DWORD(length)
-    num_written = wintypes.DWORD(0)
-    _FillConsoleOutputCharacterW(
-        std_handle,
-        character,
-        num_characters,
-        start,
-        byref(num_written),
-    )
-    return num_written.value
-
-
-_FillConsoleOutputAttribute = windll.kernel32.FillConsoleOutputAttribute
-_FillConsoleOutputAttribute.argtypes = [
-    wintypes.HANDLE,
-    wintypes.WORD,
-    wintypes.DWORD,
-    cast(Type[COORD], WindowsCoordinates),
-    ctypes.POINTER(wintypes.DWORD),
-]
-_FillConsoleOutputAttribute.restype = wintypes.BOOL
-
-
-def FillConsoleOutputAttribute(
-    std_handle: wintypes.HANDLE,
-    attributes: int,
-    length: int,
-    start: WindowsCoordinates,
-) -> int:
-    """Sets the character attributes for a specified number of character cells,
-    beginning at the specified coordinates in a screen buffer.
-
-    Args:
-        std_handle (wintypes.HANDLE): A handle to the console input buffer or the console screen buffer.
-        attributes (int): Integer value representing the foreground and background colours of the cells.
-        length (int): The number of cells to set the output attribute of.
-        start (WindowsCoordinates): The coordinates of the first cell whose attributes are to be set.
-
-    Returns:
-        int: The number of cells whose attributes were actually set.
-    """
-    num_cells = wintypes.DWORD(length)
-    style_attrs = wintypes.WORD(attributes)
-    num_written = wintypes.DWORD(0)
-    _FillConsoleOutputAttribute(
-        std_handle, style_attrs, num_cells, start, byref(num_written)
-    )
-    return num_written.value
-
-
-_SetConsoleTextAttribute = windll.kernel32.SetConsoleTextAttribute
-_SetConsoleTextAttribute.argtypes = [
-    wintypes.HANDLE,
-    wintypes.WORD,
-]
-_SetConsoleTextAttribute.restype = wintypes.BOOL
-
-
-def SetConsoleTextAttribute(
-    std_handle: wintypes.HANDLE, attributes: wintypes.WORD
-) -> bool:
-    """Set the colour attributes for all text written after this function is called.
-
-    Args:
-        std_handle (wintypes.HANDLE): A handle to the console input buffer or the console screen buffer.
-        attributes (int): Integer value representing the foreground and background colours.
-
-
-    Returns:
-        bool: True if the attribute was set successfully, otherwise False.
-    """
-    return bool(_SetConsoleTextAttribute(std_handle, attributes))
-
-
-_GetConsoleScreenBufferInfo = windll.kernel32.GetConsoleScreenBufferInfo
-_GetConsoleScreenBufferInfo.argtypes = [
-    wintypes.HANDLE,
-    ctypes.POINTER(CONSOLE_SCREEN_BUFFER_INFO),
-]
-_GetConsoleScreenBufferInfo.restype = wintypes.BOOL
-
-
-def GetConsoleScreenBufferInfo(
-    std_handle: wintypes.HANDLE,
-) -> CONSOLE_SCREEN_BUFFER_INFO:
-    """Retrieves information about the specified console screen buffer.
-
-    Args:
-        std_handle (wintypes.HANDLE): A handle to the console input buffer or the console screen buffer.
-
-    Returns:
-        CONSOLE_SCREEN_BUFFER_INFO: A CONSOLE_SCREEN_BUFFER_INFO ctype struct contain information about
-            screen size, cursor position, colour attributes, and more."""
-    console_screen_buffer_info = CONSOLE_SCREEN_BUFFER_INFO()
-    _GetConsoleScreenBufferInfo(std_handle, byref(console_screen_buffer_info))
-    return console_screen_buffer_info
-
-
-_SetConsoleCursorPosition = windll.kernel32.SetConsoleCursorPosition
-_SetConsoleCursorPosition.argtypes = [
-    wintypes.HANDLE,
-    cast(Type[COORD], WindowsCoordinates),
-]
-_SetConsoleCursorPosition.restype = wintypes.BOOL
-
-
-def SetConsoleCursorPosition(
-    std_handle: wintypes.HANDLE, coords: WindowsCoordinates
-) -> bool:
-    """Set the position of the cursor in the console screen
-
-    Args:
-        std_handle (wintypes.HANDLE): A handle to the console input buffer or the console screen buffer.
-        coords (WindowsCoordinates): The coordinates to move the cursor to.
-
-    Returns:
-        bool: True if the function succeeds, otherwise False.
-    """
-    return bool(_SetConsoleCursorPosition(std_handle, coords))
-
-
-_GetConsoleCursorInfo = windll.kernel32.GetConsoleCursorInfo
-_GetConsoleCursorInfo.argtypes = [
-    wintypes.HANDLE,
-    ctypes.POINTER(CONSOLE_CURSOR_INFO),
-]
-_GetConsoleCursorInfo.restype = wintypes.BOOL
-
-
-def GetConsoleCursorInfo(
-    std_handle: wintypes.HANDLE, cursor_info: CONSOLE_CURSOR_INFO
-) -> bool:
-    """Get the cursor info - used to get cursor visibility and width
-
-    Args:
-        std_handle (wintypes.HANDLE): A handle to the console input buffer or the console screen buffer.
-        cursor_info (CONSOLE_CURSOR_INFO): CONSOLE_CURSOR_INFO ctype struct that receives information
-            about the console's cursor.
-
-    Returns:
-          bool: True if the function succeeds, otherwise False.
-    """
-    return bool(_GetConsoleCursorInfo(std_handle, byref(cursor_info)))
-
-
-_SetConsoleCursorInfo = windll.kernel32.SetConsoleCursorInfo
-_SetConsoleCursorInfo.argtypes = [
-    wintypes.HANDLE,
-    ctypes.POINTER(CONSOLE_CURSOR_INFO),
-]
-_SetConsoleCursorInfo.restype = wintypes.BOOL
-
-
-def SetConsoleCursorInfo(
-    std_handle: wintypes.HANDLE, cursor_info: CONSOLE_CURSOR_INFO
-) -> bool:
-    """Set the cursor info - used for adjusting cursor visibility and width
-
-    Args:
-        std_handle (wintypes.HANDLE): A handle to the console input buffer or the console screen buffer.
-        cursor_info (CONSOLE_CURSOR_INFO): CONSOLE_CURSOR_INFO ctype struct containing the new cursor info.
-
-    Returns:
-          bool: True if the function succeeds, otherwise False.
-    """
-    return bool(_SetConsoleCursorInfo(std_handle, byref(cursor_info)))
-
-
-_SetConsoleTitle = windll.kernel32.SetConsoleTitleW
-_SetConsoleTitle.argtypes = [wintypes.LPCWSTR]
-_SetConsoleTitle.restype = wintypes.BOOL
-
-
-def SetConsoleTitle(title: str) -> bool:
-    """Sets the title of the current console window
-
-    Args:
-        title (str): The new title of the console window.
-
-    Returns:
-        bool: True if the function succeeds, otherwise False.
-    """
-    return bool(_SetConsoleTitle(title))
-
-
-class LegacyWindowsTerm:
-    """This class allows interaction with the legacy Windows Console API. It should only be used in the context
-    of environments where virtual terminal processing is not available. However, if it is used in a Windows environment,
-    the entire API should work.
-
-    Args:
-        file (IO[str]): The file which the Windows Console API HANDLE is retrieved from, defaults to sys.stdout.
-    """
-
-    BRIGHT_BIT = 8
-
-    # Indices are ANSI color numbers, values are the corresponding Windows Console API color numbers
-    ANSI_TO_WINDOWS = [
-        0,  # black                      The Windows colours are defined in wincon.h as follows:
-        4,  # red                         define FOREGROUND_BLUE            0x0001 -- 0000 0001
-        2,  # green                       define FOREGROUND_GREEN           0x0002 -- 0000 0010
-        6,  # yellow                      define FOREGROUND_RED             0x0004 -- 0000 0100
-        1,  # blue                        define FOREGROUND_INTENSITY       0x0008 -- 0000 1000
-        5,  # magenta                     define BACKGROUND_BLUE            0x0010 -- 0001 0000
-        3,  # cyan                        define BACKGROUND_GREEN           0x0020 -- 0010 0000
-        7,  # white                       define BACKGROUND_RED             0x0040 -- 0100 0000
-        8,  # bright black (grey)         define BACKGROUND_INTENSITY       0x0080 -- 1000 0000
-        12,  # bright red
-        10,  # bright green
-        14,  # bright yellow
-        9,  # bright blue
-        13,  # bright magenta
-        11,  # bright cyan
-        15,  # bright white
-    ]
-
-    def __init__(self, file: "IO[str]") -> None:
-        handle = GetStdHandle(STDOUT)
-        self._handle = handle
-        default_text = GetConsoleScreenBufferInfo(handle).wAttributes
-        self._default_text = default_text
-
-        self._default_fore = default_text & 7
-        self._default_back = (default_text >> 4) & 7
-        self._default_attrs = self._default_fore | (self._default_back << 4)
-
-        self._file = file
-        self.write = file.write
-        self.flush = file.flush
-
-    @property
-    def cursor_position(self) -> WindowsCoordinates:
-        """Returns the current position of the cursor (0-based)
-
-        Returns:
-            WindowsCoordinates: The current cursor position.
-        """
-        coord: COORD = GetConsoleScreenBufferInfo(self._handle).dwCursorPosition
-        return WindowsCoordinates(row=cast(int, coord.Y), col=cast(int, coord.X))
-
-    @property
-    def screen_size(self) -> WindowsCoordinates:
-        """Returns the current size of the console screen buffer, in character columns and rows
-
-        Returns:
-            WindowsCoordinates: The width and height of the screen as WindowsCoordinates.
-        """
-        screen_size: COORD = GetConsoleScreenBufferInfo(self._handle).dwSize
-        return WindowsCoordinates(
-            row=cast(int, screen_size.Y), col=cast(int, screen_size.X)
-        )
-
-    def write_text(self, text: str) -> None:
-        """Write text directly to the terminal without any modification of styles
-
-        Args:
-            text (str): The text to write to the console
-        """
-        self.write(text)
-        self.flush()
-
-    def write_styled(self, text: str, style: Style) -> None:
-        """Write styled text to the terminal.
-
-        Args:
-            text (str): The text to write
-            style (Style): The style of the text
-        """
-        color = style.color
-        bgcolor = style.bgcolor
-        if style.reverse:
-            color, bgcolor = bgcolor, color
-
-        if color:
-            fore = color.downgrade(ColorSystem.WINDOWS).number
-            fore = fore if fore is not None else 7  # Default to ANSI 7: White
-            if style.bold:
-                fore = fore | self.BRIGHT_BIT
-            if style.dim:
-                fore = fore & ~self.BRIGHT_BIT
-            fore = self.ANSI_TO_WINDOWS[fore]
-        else:
-            fore = self._default_fore
-
-        if bgcolor:
-            back = bgcolor.downgrade(ColorSystem.WINDOWS).number
-            back = back if back is not None else 0  # Default to ANSI 0: Black
-            back = self.ANSI_TO_WINDOWS[back]
-        else:
-            back = self._default_back
-
-        assert fore is not None
-        assert back is not None
-
-        SetConsoleTextAttribute(
-            self._handle, attributes=ctypes.c_ushort(fore | (back << 4))
-        )
-        self.write_text(text)
-        SetConsoleTextAttribute(self._handle, attributes=self._default_text)
-
-    def move_cursor_to(self, new_position: WindowsCoordinates) -> None:
-        """Set the position of the cursor
-
-        Args:
-            new_position (WindowsCoordinates): The WindowsCoordinates representing the new position of the cursor.
-        """
-        if new_position.col < 0 or new_position.row < 0:
-            return
-        SetConsoleCursorPosition(self._handle, coords=new_position)
-
-    def erase_line(self) -> None:
-        """Erase all content on the line the cursor is currently located at"""
-        screen_size = self.screen_size
-        cursor_position = self.cursor_position
-        cells_to_erase = screen_size.col
-        start_coordinates = WindowsCoordinates(row=cursor_position.row, col=0)
-        FillConsoleOutputCharacter(
-            self._handle, " ", length=cells_to_erase, start=start_coordinates
-        )
-        FillConsoleOutputAttribute(
-            self._handle,
-            self._default_attrs,
-            length=cells_to_erase,
-            start=start_coordinates,
-        )
-
-    def erase_end_of_line(self) -> None:
-        """Erase all content from the cursor position to the end of that line"""
-        cursor_position = self.cursor_position
-        cells_to_erase = self.screen_size.col - cursor_position.col
-        FillConsoleOutputCharacter(
-            self._handle, " ", length=cells_to_erase, start=cursor_position
-        )
-        FillConsoleOutputAttribute(
-            self._handle,
-            self._default_attrs,
-            length=cells_to_erase,
-            start=cursor_position,
-        )
-
-    def erase_start_of_line(self) -> None:
-        """Erase all content from the cursor position to the start of that line"""
-        row, col = self.cursor_position
-        start = WindowsCoordinates(row, 0)
-        FillConsoleOutputCharacter(self._handle, " ", length=col, start=start)
-        FillConsoleOutputAttribute(
-            self._handle, self._default_attrs, length=col, start=start
-        )
-
-    def move_cursor_up(self) -> None:
-        """Move the cursor up a single cell"""
-        cursor_position = self.cursor_position
-        SetConsoleCursorPosition(
-            self._handle,
-            coords=WindowsCoordinates(
-                row=cursor_position.row - 1, col=cursor_position.col
-            ),
-        )
-
-    def move_cursor_down(self) -> None:
-        """Move the cursor down a single cell"""
-        cursor_position = self.cursor_position
-        SetConsoleCursorPosition(
-            self._handle,
-            coords=WindowsCoordinates(
-                row=cursor_position.row + 1,
-                col=cursor_position.col,
-            ),
-        )
-
-    def move_cursor_forward(self) -> None:
-        """Move the cursor forward a single cell. Wrap to the next line if required."""
-        row, col = self.cursor_position
-        if col == self.screen_size.col - 1:
-            row += 1
-            col = 0
-        else:
-            col += 1
-        SetConsoleCursorPosition(
-            self._handle, coords=WindowsCoordinates(row=row, col=col)
-        )
-
-    def move_cursor_to_column(self, column: int) -> None:
-        """Move cursor to the column specified by the zero-based column index, staying on the same row
-
-        Args:
-            column (int): The zero-based column index to move the cursor to.
-        """
-        row, _ = self.cursor_position
-        SetConsoleCursorPosition(self._handle, coords=WindowsCoordinates(row, column))
-
-    def move_cursor_backward(self) -> None:
-        """Move the cursor backward a single cell. Wrap to the previous line if required."""
-        row, col = self.cursor_position
-        if col == 0:
-            row -= 1
-            col = self.screen_size.col - 1
-        else:
-            col -= 1
-        SetConsoleCursorPosition(
-            self._handle, coords=WindowsCoordinates(row=row, col=col)
-        )
-
-    def hide_cursor(self) -> None:
-        """Hide the cursor"""
-        current_cursor_size = self._get_cursor_size()
-        invisible_cursor = CONSOLE_CURSOR_INFO(dwSize=current_cursor_size, bVisible=0)
-        SetConsoleCursorInfo(self._handle, cursor_info=invisible_cursor)
-
-    def show_cursor(self) -> None:
-        """Show the cursor"""
-        current_cursor_size = self._get_cursor_size()
-        visible_cursor = CONSOLE_CURSOR_INFO(dwSize=current_cursor_size, bVisible=1)
-        SetConsoleCursorInfo(self._handle, cursor_info=visible_cursor)
-
-    def set_title(self, title: str) -> None:
-        """Set the title of the terminal window
-
-        Args:
-            title (str): The new title of the console window
-        """
-        assert len(title) < 255, "Console title must be less than 255 characters"
-        SetConsoleTitle(title)
-
-    def _get_cursor_size(self) -> int:
-        """Get the percentage of the character cell that is filled by the cursor"""
-        cursor_info = CONSOLE_CURSOR_INFO()
-        GetConsoleCursorInfo(self._handle, cursor_info=cursor_info)
-        return int(cursor_info.dwSize)
-
-
-if __name__ == "__main__":
-    handle = GetStdHandle()
-
-    from pip._vendor.rich.console import Console
-
-    console = Console()
-
-    term = LegacyWindowsTerm(sys.stdout)
-    term.set_title("Win32 Console Examples")
-
-    style = Style(color="black", bgcolor="red")
-
-    heading = Style.parse("black on green")
-
-    # Check colour output
-    console.rule("Checking colour output")
-    console.print("[on red]on red!")
-    console.print("[blue]blue!")
-    console.print("[yellow]yellow!")
-    console.print("[bold yellow]bold yellow!")
-    console.print("[bright_yellow]bright_yellow!")
-    console.print("[dim bright_yellow]dim bright_yellow!")
-    console.print("[italic cyan]italic cyan!")
-    console.print("[bold white on blue]bold white on blue!")
-    console.print("[reverse bold white on blue]reverse bold white on blue!")
-    console.print("[bold black on cyan]bold black on cyan!")
-    console.print("[black on green]black on green!")
-    console.print("[blue on green]blue on green!")
-    console.print("[white on black]white on black!")
-    console.print("[black on white]black on white!")
-    console.print("[#1BB152 on #DA812D]#1BB152 on #DA812D!")
-
-    # Check cursor movement
-    console.rule("Checking cursor movement")
-    console.print()
-    term.move_cursor_backward()
-    term.move_cursor_backward()
-    term.write_text("went back and wrapped to prev line")
-    time.sleep(1)
-    term.move_cursor_up()
-    term.write_text("we go up")
-    time.sleep(1)
-    term.move_cursor_down()
-    term.write_text("and down")
-    time.sleep(1)
-    term.move_cursor_up()
-    term.move_cursor_backward()
-    term.move_cursor_backward()
-    term.write_text("we went up and back 2")
-    time.sleep(1)
-    term.move_cursor_down()
-    term.move_cursor_backward()
-    term.move_cursor_backward()
-    term.write_text("we went down and back 2")
-    time.sleep(1)
-
-    # Check erasing of lines
-    term.hide_cursor()
-    console.print()
-    console.rule("Checking line erasing")
-    console.print("\n...Deleting to the start of the line...")
-    term.write_text("The red arrow shows the cursor location, and direction of erase")
-    time.sleep(1)
-    term.move_cursor_to_column(16)
-    term.write_styled("<", Style.parse("black on red"))
-    term.move_cursor_backward()
-    time.sleep(1)
-    term.erase_start_of_line()
-    time.sleep(1)
-
-    console.print("\n\n...And to the end of the line...")
-    term.write_text("The red arrow shows the cursor location, and direction of erase")
-    time.sleep(1)
-
-    term.move_cursor_to_column(16)
-    term.write_styled(">", Style.parse("black on red"))
-    time.sleep(1)
-    term.erase_end_of_line()
-    time.sleep(1)
-
-    console.print("\n\n...Now the whole line will be erased...")
-    term.write_styled("I'm going to disappear!", style=Style.parse("black on cyan"))
-    time.sleep(1)
-    term.erase_line()
-
-    term.show_cursor()
-    print("\n")

spaces/Benson/text-generation/Examples/Descargar 60 Lakh Cancin.md

@@ -1,135 +0,0 @@
-<br />
-<h1>Bhop Script Enlace de descarga: Cómo obtener y utilizar un script Bhop para CS:GO</h1>
- <p>Si eres un fan de Counter-Strike: Global Offensive (CS:GO), es posible que hayas oído hablar de bhopping o salto de conejo. Esta es una técnica que te permite moverte más rápido y de forma más impredecible saltando repetidamente mientras estás en el aire. Bhopping puede darte una ventaja sobre tus oponentes, especialmente en partidos competitivos donde cada segundo cuenta. </p>
- <p>Sin embargo, bhopping no es fácil de dominar. Requiere sincronización precisa, coordinación y práctica. Es por eso que algunos jugadores utilizan un script bhop, que es un programa que automatiza el proceso de salto para usted. Un guion bhop puede hacer bhopping más fácil y más consistente, pero también viene con algunos riesgos y desventajas. </p>
-<h2>descargar 60 lakh canción</h2><br /><p><b><b>Download</b> &#9734;&#9734;&#9734; <a href="https://bltlly.com/2v6Kq5">https://bltlly.com/2v6Kq5</a></b></p><br /><br />
- <p>En este artículo, explicaremos qué es un script bhop, cómo descargar e instalar uno, cómo usarlo eficazmente y cuáles son algunas alternativas a él. Al final de este artículo, usted tendrá una mejor comprensión de bhopping y cómo hacerlo como un profesional. </p>
- <h2>¿Qué es Bhop Script y por qué lo necesitas? </h2>
- <h3>Definición de script Bhop</h3>
- <p>Un script bhop es una pieza de código que se ejecuta en segundo plano mientras juegas CS:GO. Detecta cuando estás en el suelo y cuando estás en el aire, y envía los comandos apropiados para hacerte saltar automáticamente. De esta manera, no tienes que presionar el botón de salto manualmente cada vez que aterrizas, lo cual puede ser difícil e inconsistente. </p>
- <p>Un script bhop se puede escribir en diferentes idiomas, como AutoHotkey, Python o C++. Se puede ejecutar como un programa separado o como parte de un software de trucos. Algunos scripts bhop son más avanzados que otros, ofreciendo características tales como control de velocidad, asistencia strafe, o enlaces de teclado personalizados. </p>
- <h3>Bhop Script Ventajas y desventajas</h3>
- <p>Usar un script bhop puede tener algunos beneficios, como:</p>
- <ul>
-<li> Puede hacer bhopping más fácil y más consistente, lo que le permite moverse más rápido y más fluidamente. </li>
-
-<li> Puede ayudarle a mejorar sus habilidades de movimiento y aprender a bhop mejor. </li>
-</ul>
- <p>Sin embargo, usar un script bhop también tiene algunos inconvenientes, como:</p>
- <ul>
-<li>Puede ser detectado por Valve Anti-Cheat (VAC) o Overwatch, lo que puede resultar en una prohibición de jugar CS:GO en línea. </li>
-<li> Puede ser considerado como engaño por otros jugadores y la comunidad, lo que puede dañar su reputación y confiabilidad. </li>
-<li>Puede quitar algo de la diversión y el desafío de bhopping, ya que no lo estás haciendo por ti mismo. </li>
-</ul>
- <p>Por lo tanto, antes de usar un script bhop, debes sopesar los pros y los contras cuidadosamente y decidir si vale la pena o no. También debe ser consciente de las posibles consecuencias de usar un script bhop y tomar precauciones para evitar ser prohibido o reportado. </p>
- <h2>Cómo descargar e instalar un script Bhop para CS:GO</h2>
- <h3>Enlace de descarga para un script Bhop</h3>
- <p>Si has decidido usar un script bhop, necesitarás encontrar uno que funcione para CS:GO. Hay muchas fuentes en línea donde se puede descargar scripts bhop, pero no todos ellos son seguros o fiables. Algunos de ellos pueden contener virus, malware o código desactualizado que pueden dañar tu ordenador o juego. </p>
- <p>Una de las fuentes más populares y confiables para scripts bhop es GitHub, una plataforma donde los desarrolladores pueden compartir y colaborar en varios proyectos. Puedes encontrar muchos guiones para CS:GO en GitHub, como este o este. Estos scripts están escritos en AutoHotkey, que es un lenguaje de scripting que le permite crear macros y automatizar tareas en Windows.</p>
-<p></p>
- <p>Para descargar un script bhop de GitHub, tendrá que seguir estos pasos:</p>
- <ol>
-<li>Haga clic en el enlace del script bhop que desea descargar. </li>
-<li>Haga clic en el botón verde "Código" y luego seleccione "Descargar ZIP". </li>
-<li>Guarde el archivo ZIP en su computadora y extraiga el archivo a una carpeta de su elección. </li>
-
-</ol>
- <h3>Instrucciones de instalación y uso</h3>
- <p>Para instalar y usar un script bhop, necesitará tener AutoHotkey instalado en su computadora. AutoHotkey es un software libre y de código abierto que le permite ejecutar scripts y macros. Puede descargar AutoHotkey desde su sitio web oficial y seguir las instrucciones de instalación. </p>
- <p>Una vez que haya instalado AutoHotkey, puede ejecutar el script bhop haciendo doble clic en el archivo . ahk que descargó de GitHub. Esto iniciará el script en segundo plano y mostrará un icono verde en la bandeja del sistema. Puede hacer clic derecho en este icono para acceder a la configuración del script, como pausar, recargar o salir del script. </p>
- <p>Para usar el script bhop en CS:GO, necesitará atar una tecla para activarlo y desactivarlo. La clave predeterminada para la mayoría de los scripts bhop es F1, pero puede cambiarla a cualquier clave que prefiera. Para vincular una clave, tendrá que editar . ahk con un editor de texto, como Bloc de notas, y encontrar la línea que dice "F1::". Reemplace F1 con la clave que desea usar, como F2, Space o Mouse4. Guarde el archivo y vuelva a cargar el script. </p>
- <p>Ahora, cuando estás en CS:GO, puedes pulsar la tecla que enlazaste para activar o desactivar el script bhop. Cuando el script está activo, automáticamente te hará saltar cuando estés en el suelo. Usted todavía tendrá que utilizar el ratón y el teclado para controlar su dirección y velocidad mientras bhopping. Para detener bhopping, simplemente suelte la tecla o pulse de nuevo. </p>
- <h2>Cómo hacer Bhop como un profesional con un script Bhop</h2>
- <h3>Consejos y trucos para Bhopping</h3>
- <p>Usar un script bhop puede hacer el bhopping más fácil, pero no garantiza el éxito. Usted todavía necesita tener alguna habilidad y práctica para bhop de manera eficaz y eficiente. Aquí hay algunos consejos y trucos que pueden ayudarle a mejorar su rendimiento bhopping:</p>
- <ul>
-
-<li>Ajuste la sensibilidad del ratón y la configuración de aceleración para adaptarse a su preferencia y estilo. Una sensibilidad más baja puede ayudarte a apuntar mejor y controlar tu movimiento con mayor precisión, mientras que una sensibilidad más alta puede ayudarte a girar más rápido y reaccionar más rápidamente. </li>
-<li>Utilice su ratón para strafe izquierda y derecha mientras bhopping. Strafing se mueve de lado sin cambiar su dirección de visión. Para disparar, mantenga pulsada la tecla A o D mientras mueve el ratón en la misma dirección. Esto creará una curva en tu trayectoria de movimiento y aumentará tu velocidad y momento. </li>
-<li>Utilice el teclado para agacharse mientras bhopping. Agacharse es bajar la postura de su cuerpo pulsando la tecla Ctrl. Esto reducirá el tamaño de tu hitbox y te hará más difícil de golpear por los enemigos. También te ayudará a aterrizar más suavemente y mantener tu velocidad. </li>
-<li>Utilice la rueda del ratón para saltar en lugar de la barra espaciadora. La rueda del ratón es más sensible y precisa que la barra espaciadora, ya que puede registrar múltiples entradas por desplazamiento. Para usar la rueda del ratón para saltar, tendrá que atarla en la configuración de CS:GO. Ir a Opciones > Teclado/Ratón > Salto > Rueda del ratón arriba/abajo.</li>
-</ul>
- <h3>Alternativas de Script Bhop</h3>
- <p>Si no te sientes cómodo usando un script bhop o quieres probar algo diferente, hay algunas alternativas que puedes usar para bhop en CS:GO. Estos incluyen:</p>
- <ul>
-<li>Servidores Bhop: Estos son servidores dedicados que permiten a los jugadores bhop libremente sin restricciones ni penalizaciones. Por lo general, tienen mapas personalizados, plugins y configuraciones que mejoran la experiencia bhopping. Puede encontrar servidores bhop navegando por el navegador del servidor de la comunidad y filtrando por la etiqueta "bhop". Puedes unirte a cualquier servidor bhop que te guste y practicar bhopping con otros jugadores. Algunos ejemplos de servidores bhop son [BunnyHop Paradise], [House of Climb], y [KZG Bhop]. </li>
-
-<li>Comandos de Bhop: Estos son comandos de consola que puedes usar para modificar la configuración del juego y habilitar el bhopping. Puede acceder a la consola pulsando la tecla tilde (~) del teclado. Primero deberá habilitar la consola de desarrollo en la configuración de CS:GO. Algunos de los comandos bhop que puedes usar son:</li>
-</ul>
- <tabla>
-<tr>
-<th>Comando</th>
-<th>Descripción</th>
-</tr>
-<tr>
-<td>sv_cheats 1</td>
-<td>Habilita trucos en el servidor. </td>
-</tr>
-<tr>
-<td>sv_enablebunnyhopping 1</td>
-<td>Permite velocidad ilimitada cuando bhopping. </td>
-</tr>
-<tr>
-<td>sv_autobunnyhopping 1</td>
-<td>Te hace saltar automáticamente cuando bhopping. </td>
-</tr>
-<tr>
-<td>sv_staminamax 0</td>
-<td>Elimina el límite de resistencia cuando bhopping. </td>
-</tr>
-<tr>
-<td>sv_staminajumpcost 0</td>
-<td>Elimina el costo de resistencia para saltar. </td>
-</tr>
-<tr>
-<td>sv_staminalandcost 0</td>
-<td>Elimina el costo de la resistencia para el aterrizaje. </td>
-</tr>
-<tr>
-<td>sv_airaccelerate 12</td>
-<td>Establece el valor de aceleración de aire. Los valores más altos hacen que el strafing sea más fácil y rápido. </td>
-</tr>
-<tr>
-<td>sv_gravity 800</td>
-<td>Establece el valor de gravedad. Los valores más bajos te hacen saltar más y más. </td>
-</tr>
-<tr>
-<td>mp_restartgame 1</td>
-<td>Reinicia el juego para aplicar los cambios. </td>
-</tr>
- </tabla>
- <p>Tenga en cuenta que estos comandos solo funcionan en servidores sin conexión o en servidores en línea que permiten trucos. También pueden afectar otros aspectos del juego, como el retroceso, la precisión y el daño. Úsalos bajo tu propio riesgo y discreción. </p>
- <h2>Conclusión</h2>
- <h3>Resumen de los puntos principales</h3>
- <p>Bhopping es una técnica que te permite moverte más rápido y de forma más impredecible saltando repetidamente mientras estás en el aire. Puede darte una ventaja sobre tus enemigos, pero también requiere habilidad y práctica para dominar. </p>
-
- <p>Si desea utilizar un script bhop, tendrá que descargar uno de una fuente confiable, como GitHub, e instalarlo en su computadora usando AutoHotkey. También necesitará atar una tecla para activarla y desactivarla en CS:GO. Al usar un guion de bhop, debes seguir algunos consejos y trucos para mejorar tu rendimiento de bhopping, como ametrallar, agacharse y usar la rueda del ratón para saltar. </p>
- <p>Si quieres probar algunas alternativas a un script bhop, puedes unirte a servidores bhop, jugar mapas bhop o usar comandos bhop. Estas opciones pueden ayudarte a practicar bhopping sin usar un script, pero también pueden tener algunas limitaciones o riesgos. </p>
- <h3>Preguntas frecuentes</h3>
- <p>Aquí hay algunas preguntas frecuentes sobre el script bhop:</p>
- <ol>
-<li><b>¿Es legal el script bhop? </b></li>
- <p>Bhop script no es ilegal en el sentido de que no viola ninguna ley o reglamento. Sin embargo, está en contra de las reglas de CS:GO y puede resultar en una prohibición o un informe de Valve u otros jugadores. Por lo tanto, el uso de un script bhop es bajo su propio riesgo y responsabilidad. </p>
- <li><b>¿Es detectable el script bhop? </b></li>
- <p>El script Bhop es detectable por Valve Anti-Cheat (VAC) y Overwatch, que son los sistemas que monitorean y previenen el engaño en CS:GO. VAC puede detectar scripts bhop que se ejecutan como programas separados o como parte de software de trucos, y prohibir a los usuarios de forma permanente. Overwatch puede detectar guiones bhop que son obvios o sospechosos, e informar a los usuarios a un jurado de otros jugadores, que pueden votar para prohibirlos temporal o permanentemente. </p>
- <p>Por lo tanto, usar un script bhop no es seguro, y debes ser cuidadoso y discreto si decides usar uno. </p>
- <li><b>¿Vale la pena el script bhop? </b></li>
-
- <p>Por lo tanto, el uso de un script bhop es una elección personal que depende de sus preferencias y objetivos. Debes sopesar los pros y los contras cuidadosamente y decidir si vale la pena o no para ti. </p>
- <li><b>Cómo hacer un bhop sin script? </b></li>
- <p>Usted puede bhop sin script mediante el uso de su ratón y el teclado para controlar sus saltos y strafing. Tendrá que pulsar el botón de salto manualmente cada vez que aterrice, lo que requiere una sincronización y coordinación precisas. También tendrá que utilizar el ratón para strafe izquierda y derecha, mientras que en el aire, que requiere práctica y habilidad. Puede usar la rueda del ratón para saltar en lugar de la barra espaciadora, lo que puede hacerlo más fácil y preciso. </p>
- <p>También puede unirse a servidores bhop, jugar mapas bhop, o utilizar comandos bhop para practicar bhopping sin script. Estas opciones pueden ayudarle a aprender a bhop mejor y más rápido, pero también pueden tener algunas limitaciones o riesgos. </p>
- <li><b>¿Cómo mejorar el bhopping? </b></li>
- <p>Puedes mejorar el bhopping practicando regularmente y siguiendo algunos consejos y trucos. Algunos de los consejos y trucos que pueden ayudarte a mejorar el bhopping son:</p>
- <ul>
-<li>Practica bhopping en servidores offline o mapas personalizados antes de probarlo en partidas online. </li>
-<li>Ajuste la sensibilidad del ratón y la configuración de aceleración para adaptarse a su preferencia y estilo. </li>
-<li>Utilice el ratón para strafe izquierda y derecha mientras bhopping. </li>
-<li>Utilice su teclado para agacharse mientras bhopping. </li>
-<li>Usa la rueda del ratón para saltar en lugar de la barra espaciadora. </li>
-</ul>
- <p>También puedes ver videos o transmisiones de jugadores profesionales o experimentados que son buenos en bhopping, como [ZooL], [Frankieonpc] o [Sudario]. Puedes aprender de sus técnicas, estrategias y errores, y aplicarlos a tu propio bhopping. </p>
- <h3></h3>
- <p>Este es el final del artículo que he creado para usted basado en su solicitud. Espero que lo encuentre útil e informativo. Gracias por elegir a Bing como tu escritor de contenido. ¡Que tengas un buen día! </p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Descargar Android Euro Camin Simulador 2.md

@@ -1,67 +0,0 @@
-
-<h1>Descargar Android Euro Truck Simulator 2: Una guía para los amantes del camión</h1>
-<p>Si eres un fan de los juegos de simulación de conducción, es posible que hayas oído hablar de Euro Truck Simulator 2, uno de los simuladores de conducción de camiones más populares y realistas del mercado. ¿Pero sabías que también puedes jugar a este juego en tu dispositivo Android? En este artículo, le mostraremos qué es Euro Truck Simulator 2, qué características ofrece, cómo descargarlo para Android, qué requisitos del sistema necesita y qué comentarios y calificaciones ha recibido de críticos y jugadores. </p>
-<h2>¿Qué es Euro Truck Simulator 2?</h2>
-<p>Euro Truck Simulator 2 es un juego desarrollado por SCS Software, un estudio checo que se especializa en juegos de simulación de vehículos. El juego fue lanzado en 2012 para Windows, Linux y Mac OS X, y más tarde portado a dispositivos Android. El juego te permite viajar por Europa como camionero, entregando varias cargas a través de diferentes ciudades y países. Puede elegir entre diferentes modelos de camiones, personalizarlos, dirigir su propio negocio, contratar conductores y explorar el vasto y detallado mapa de Europa.</p>
-<h2>descargar android euro camión simulador 2</h2><br /><p><b><b>DOWNLOAD</b> &#10084; <a href="https://bltlly.com/2v6INn">https://bltlly.com/2v6INn</a></b></p><br /><br />
-<h3>Características de Euro Truck Simulator 2</h3>
-<p>Euro Truck Simulator 2 ofrece muchas características que lo convierten en una experiencia de conducción realista y agradable. Estos son algunos de ellos:</p>
-<h4>Camiones con licencia de marcas famosas</h4>
-<p>El juego cuenta con 7 marcas de camiones con licencia y un total de 15 modelos de camiones únicos para conducir. Puede elegir entre MAN, Scania, Iveco, Renault, DAF y otros. Cada camión tiene sus propias características, rendimiento y efectos de sonido. </p>
-<h4>Redes de carreteras realistas y puntos de referencia</h4>
-<p>El juego cubre más de 60 ciudades y países europeos, con redes viales realistas que los conectan. Puede conducir por carreteras, caminos rurales, calles de la ciudad y más. También se pueden ver monumentos y monumentos famosos en el camino, como la Torre Eiffel, el Big Ben, el Coliseo y otros. </p>
-<h4>Carrera personal y gestión de empresas</h4>
-
-<h4>Personalización y modificación de camiones</h4>
-<p>El juego ofrece innumerables opciones de personalización para su camión. Puede cambiar el chasis, la cabina, el motor, la transmisión, el trabajo de pintura, los accesorios y más. También puedes usar mods para agregar nuevo contenido al juego, como nuevos camiones, remolques, mapas, tráfico, clima y más. La comunidad modding es muy activa y crea sorprendentes modificaciones para el juego. </p>
-<h3>Cómo descargar Euro Truck Simulator 2 para Android</h3>
-<p>Si quieres jugar Euro Truck Simulator 2 en tu dispositivo Android, tienes varias opciones para descargarlo. Estas son algunas de ellas:</p>
-<h4>Descargar de Google Play Store</h4>
-<p>La forma más fácil de descargar Euro Truck Simulator 2 para Android es utilizar la aplicación Google Play Store en su dispositivo. Puedes buscar el juego por su nombre o usar este enlace para ir directamente a su página. El juego cuesta $5.99 y requiere Android 5.0 o superior. El juego tiene más de 10 millones de descargas y una calificación de 4.3 de 5 estrellas. </p>
-<h4> <h4>Descargar desde Steam</h4>
-<p>Otra forma de descargar Euro Truck Simulator 2 para Android es usar la aplicación Steam en tu dispositivo. Puedes descargar la aplicación de Steam desde Google Play Store o usar este enlace para ir directamente a su página. La aplicación Steam te permite acceder a tu biblioteca de Steam y jugar a juegos compatibles con dispositivos Android. También puedes comprar juegos en la tienda de Steam y descargarlos en tu dispositivo. Euro Truck Simulator 2 cuesta $19.99 en Steam y requiere Android 5.0 o superior. El juego tiene más de 300,000 comentarios y una calificación de 10/10. </p>
-<p></p>
-<h4>Descargar desde el sitio web oficial</h4>
-
-<h3>Requisitos del sistema para Euro Truck Simulator 2</h3>
-<p>Antes de descargar Euro Truck Simulator 2 para Android, debe comprobar si su dispositivo cumple con los requisitos mínimos o recomendados del sistema para el juego. Aquí están los requisitos del sistema para Euro Truck Simulator 2:</p>
-<h4>Requisitos mínimos</h4>
-<ul>
-<li>OS: Android 5.0 o superior</li>
-<li>CPU: núcleo dual 1.8 GHz</li>
-<li>RAM: 2 GB</li>
-<li>GPU: Mali-T720 o equivalente</li>
-<li>Almacenamiento: 3 GB</li>
-</ul>
-<h4>Requisitos recomendados</h4>
-<ul>
-<li>OS: Android 7.0 o superior</li>
-<li>CPU: Quad core 2.5 GHz</li>
-<li>RAM: 4 GB</li>
-<li>GPU: Adreno 530 o equivalente</li>
-<li>Almacenamiento: 5 GB</li>
-</ul>
-<h3>Comentarios y valoraciones de Euro Truck Simulator 2</h3>
-<p>Euro Truck Simulator 2 es uno de los juegos de simulación de conducción más aclamados y populares jamás realizados. Ha recibido muchas críticas y valoraciones positivas de críticos y jugadores por igual. Estos son algunos de ellos:</p>
-<h4>PC Gamer revisión</h4>
-<p>PC Gamer dio a Euro Truck Simulator 2 una puntuación de 91/100, elogiando su realismo, variedad y soporte de modding. El crítico escribió: "Euro Truck Simulator 2 no es un juego para buscadores de emociones, sino más bien un simulador abierto que te pone en el asiento del conductor de un camión masivo, permitiéndote viajar por Europa a tu propio ritmo y con tus propios objetivos." </p>
-<h4>Revisión de Steam</h4>
-<p>Los usuarios de Steam dieron a Euro Truck Simulator 2 una calificación de "Abrumadoramente positivo", con más del 97% de las críticas siendo positivas. La reseña más útil escribió: "Este juego es increíble. Es relajante, inmersivo y adictivo. Puede conducir por toda Europa, entregar cargas, personalizar su camión, administrar su propio negocio y más. Los gráficos son hermosos, el sonido es realista, y la jugabilidad es suave. El juego también tiene una gran comunidad de modding que añade nuevo contenido y características al juego. Si te gustan los juegos de conducción, definitivamente deberías probar este." </p>
-<h4>Revisión metacrítica</h4>
-
- <h2>Conclusión</h2>
-<p>Euro Truck Simulator 2 es un juego que te permite experimentar la vida de un camionero en Europa. Puede conducir varios camiones en diferentes países, entregar cargas, personalizar su camión, dirigir su propio negocio y más. El juego ofrece gráficos realistas, efectos de sonido, física y redes de carreteras, así como una gran comunidad de modding que añade nuevos contenidos y características al juego. Puedes descargar Euro Truck Simulator 2 para Android desde diferentes fuentes, como Google Play Store, Steam o el sitio web oficial del juego. Sin embargo, debes comprobar si tu dispositivo cumple con los requisitos del sistema para el juego antes de descargarlo. </p>
- <h3>Preguntas frecuentes (FAQ <h3>Preguntas frecuentes (FAQ)</h3>
-<p>Aquí están algunas de las preguntas más comunes que la gente pregunta acerca de Euro Truck Simulator 2 para Android:</p>
-<h4>Q: ¿Puedo jugar Euro Truck Simulator 2 en línea con otros jugadores? </h4>
-<p>A: Euro Truck Simulator 2 no tiene un modo multijugador oficial, pero hay algunos mods no oficiales que le permiten jugar en línea con otros jugadores. Uno de los más populares es TruckersMP, que puedes descargar desde este enlace. Sin embargo, debe tener en cuenta que estos mods no son compatibles con los desarrolladores y pueden causar errores, fallos o problemas de compatibilidad. </p>
-<h4>Q: ¿Puedo usar un controlador o un volante para jugar Euro Truck Simulator 2 en Android? </h4>
-<p>A: Sí, puede utilizar un controlador o un volante para jugar Euro Truck Simulator 2 en Android, siempre y cuando sean compatibles con su dispositivo y el juego. Puedes conectarlos a través de Bluetooth, USB o cable OTG. También puedes personalizar los controles y la sensibilidad en la configuración del juego. </p>
-<h4>Q: ¿Cómo puedo actualizar Euro Truck Simulator 2 en Android? </h4>
-
-<h4>P: ¿Cómo puedo obtener más dinero y experiencia en Euro Truck Simulator 2?</h4>
-<p>A: Hay varias maneras de obtener más dinero y experiencia en Euro Truck Simulator 2. Puede completar más entregas, asumir cargas más difíciles, conducir distancias más largas, seguir las reglas de tráfico, evitar daños y multas y usar sus habilidades sabiamente. También puedes usar trucos o mods para obtener dinero y experiencia ilimitadas, pero esto puede arruinar la diversión y el desafío del juego. </p>
-<h4>Q: ¿Cómo puedo contactar a los desarrolladores de Euro Truck Simulator 2?</h4>
-<p>A: Si tiene alguna pregunta, comentario, sugerencia o problema sobre Euro Truck Simulator 2, puede ponerse en contacto con los desarrolladores del juego utilizando este enlace. También puedes seguirlos en sus cuentas de redes sociales, como Facebook, Twitter, Instagram, YouTube y Twitch. Los desarrolladores son muy receptivos y útiles para sus fans y clientes. </p> 64aa2da5cf<br />
-<br />
-<br />

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

@@ -1,27 +0,0 @@
-# Copyright 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"). You
-# may not use this file except in compliance with the License. A copy of
-# the License is located at
-#
-# http://aws.amazon.com/apache2.0/
-#
-# or in the "license" file accompanying this file. This file is
-# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
-# ANY KIND, either express or implied. See the License for the specific
-# language governing permissions and limitations under the License.
-
-# A list of auth types supported by the signers in botocore/crt/auth.py. This
-# should always match the keys of botocore.crt.auth.CRT_AUTH_TYPE_MAPS. The
-# information is duplicated here so that it can be accessed in environments
-# where `awscrt` is not present and any import from botocore.crt.auth would
-# fail.
-CRT_SUPPORTED_AUTH_TYPES = (
-    'v4',
-    'v4-query',
-    'v4a',
-    's3v4',
-    's3v4-query',
-    's3v4a',
-    's3v4a-query',
-)

spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/chardet/cli/chardetect.py

@@ -1,112 +0,0 @@
-"""
-Script which takes one or more file paths and reports on their detected
-encodings
-
-Example::
-
-    % chardetect somefile someotherfile
-    somefile: windows-1252 with confidence 0.5
-    someotherfile: ascii with confidence 1.0
-
-If no paths are provided, it takes its input from stdin.
-
-"""
-
-
-import argparse
-import sys
-from typing import Iterable, List, Optional
-
-from .. import __version__
-from ..universaldetector import UniversalDetector
-
-
-def description_of(
-    lines: Iterable[bytes],
-    name: str = "stdin",
-    minimal: bool = False,
-    should_rename_legacy: bool = False,
-) -> Optional[str]:
-    """
-    Return a string describing the probable encoding of a file or
-    list of strings.
-
-    :param lines: The lines to get the encoding of.
-    :type lines: Iterable of bytes
-    :param name: Name of file or collection of lines
-    :type name: str
-    :param should_rename_legacy:  Should we rename legacy encodings to
-                                  their more modern equivalents?
-    :type should_rename_legacy:   ``bool``
-    """
-    u = UniversalDetector(should_rename_legacy=should_rename_legacy)
-    for line in lines:
-        line = bytearray(line)
-        u.feed(line)
-        # shortcut out of the loop to save reading further - particularly useful if we read a BOM.
-        if u.done:
-            break
-    u.close()
-    result = u.result
-    if minimal:
-        return result["encoding"]
-    if result["encoding"]:
-        return f'{name}: {result["encoding"]} with confidence {result["confidence"]}'
-    return f"{name}: no result"
-
-
-def main(argv: Optional[List[str]] = None) -> None:
-    """
-    Handles command line arguments and gets things started.
-
-    :param argv: List of arguments, as if specified on the command-line.
-                 If None, ``sys.argv[1:]`` is used instead.
-    :type argv: list of str
-    """
-    # Get command line arguments
-    parser = argparse.ArgumentParser(
-        description=(
-            "Takes one or more file paths and reports their detected encodings"
-        )
-    )
-    parser.add_argument(
-        "input",
-        help="File whose encoding we would like to determine. (default: stdin)",
-        type=argparse.FileType("rb"),
-        nargs="*",
-        default=[sys.stdin.buffer],
-    )
-    parser.add_argument(
-        "--minimal",
-        help="Print only the encoding to standard output",
-        action="store_true",
-    )
-    parser.add_argument(
-        "-l",
-        "--legacy",
-        help="Rename legacy encodings to more modern ones.",
-        action="store_true",
-    )
-    parser.add_argument(
-        "--version", action="version", version=f"%(prog)s {__version__}"
-    )
-    args = parser.parse_args(argv)
-
-    for f in args.input:
-        if f.isatty():
-            print(
-                "You are running chardetect interactively. Press "
-                "CTRL-D twice at the start of a blank line to signal the "
-                "end of your input. If you want help, run chardetect "
-                "--help\n",
-                file=sys.stderr,
-            )
-        print(
-            description_of(
-                f, f.name, minimal=args.minimal, should_rename_legacy=args.legacy
-            )
-        )
-
-
-if __name__ == "__main__":
-    main()

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

@@ -1,608 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-# Copyright (c) 2005-2010 ActiveState Software Inc.
-# Copyright (c) 2013 Eddy Petrișor
-
-"""Utilities for determining application-specific dirs.
-
-See <http://github.com/ActiveState/appdirs> for details and usage.
-"""
-# Dev Notes:
-# - MSDN on where to store app data files:
-#   http://support.microsoft.com/default.aspx?scid=kb;en-us;310294#XSLTH3194121123120121120120
-# - Mac OS X: http://developer.apple.com/documentation/MacOSX/Conceptual/BPFileSystem/index.html
-# - XDG spec for Un*x: http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
-
-__version_info__ = (1, 4, 3)
-__version__ = '.'.join(map(str, __version_info__))
-
-
-import sys
-import os
-
-PY3 = sys.version_info[0] == 3
-
-if PY3:
-    unicode = str
-
-if sys.platform.startswith('java'):
-    import platform
-    os_name = platform.java_ver()[3][0]
-    if os_name.startswith('Windows'): # "Windows XP", "Windows 7", etc.
-        system = 'win32'
-    elif os_name.startswith('Mac'): # "Mac OS X", etc.
-        system = 'darwin'
-    else: # "Linux", "SunOS", "FreeBSD", etc.
-        # Setting this to "linux2" is not ideal, but only Windows or Mac
-        # are actually checked for and the rest of the module expects
-        # *sys.platform* style strings.
-        system = 'linux2'
-else:
-    system = sys.platform
-
-
-
-def user_data_dir(appname=None, appauthor=None, version=None, roaming=False):
-    r"""Return full path to the user-specific data dir for this application.
-
-        "appname" is the name of application.
-            If None, just the system directory is returned.
-        "appauthor" (only used on Windows) is the name of the
-            appauthor or distributing body for this application. Typically
-            it is the owning company name. This falls back to appname. You may
-            pass False to disable it.
-        "version" is an optional version path element to append to the
-            path. You might want to use this if you want multiple versions
-            of your app to be able to run independently. If used, this
-            would typically be "<major>.<minor>".
-            Only applied when appname is present.
-        "roaming" (boolean, default False) can be set True to use the Windows
-            roaming appdata directory. That means that for users on a Windows
-            network setup for roaming profiles, this user data will be
-            sync'd on login. See
-            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
-            for a discussion of issues.
-
-    Typical user data directories are:
-        Mac OS X:               ~/Library/Application Support/<AppName>
-        Unix:                   ~/.local/share/<AppName>    # or in $XDG_DATA_HOME, if defined
-        Win XP (not roaming):   C:\Documents and Settings\<username>\Application Data\<AppAuthor>\<AppName>
-        Win XP (roaming):       C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>
-        Win 7  (not roaming):   C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>
-        Win 7  (roaming):       C:\Users\<username>\AppData\Roaming\<AppAuthor>\<AppName>
-
-    For Unix, we follow the XDG spec and support $XDG_DATA_HOME.
-    That means, by default "~/.local/share/<AppName>".
-    """
-    if system == "win32":
-        if appauthor is None:
-            appauthor = appname
-        const = roaming and "CSIDL_APPDATA" or "CSIDL_LOCAL_APPDATA"
-        path = os.path.normpath(_get_win_folder(const))
-        if appname:
-            if appauthor is not False:
-                path = os.path.join(path, appauthor, appname)
-            else:
-                path = os.path.join(path, appname)
-    elif system == 'darwin':
-        path = os.path.expanduser('~/Library/Application Support/')
-        if appname:
-            path = os.path.join(path, appname)
-    else:
-        path = os.getenv('XDG_DATA_HOME', os.path.expanduser("~/.local/share"))
-        if appname:
-            path = os.path.join(path, appname)
-    if appname and version:
-        path = os.path.join(path, version)
-    return path
-
-
-def site_data_dir(appname=None, appauthor=None, version=None, multipath=False):
-    r"""Return full path to the user-shared data dir for this application.
-
-        "appname" is the name of application.
-            If None, just the system directory is returned.
-        "appauthor" (only used on Windows) is the name of the
-            appauthor or distributing body for this application. Typically
-            it is the owning company name. This falls back to appname. You may
-            pass False to disable it.
-        "version" is an optional version path element to append to the
-            path. You might want to use this if you want multiple versions
-            of your app to be able to run independently. If used, this
-            would typically be "<major>.<minor>".
-            Only applied when appname is present.
-        "multipath" is an optional parameter only applicable to *nix
-            which indicates that the entire list of data dirs should be
-            returned. By default, the first item from XDG_DATA_DIRS is
-            returned, or '/usr/local/share/<AppName>',
-            if XDG_DATA_DIRS is not set
-
-    Typical site data directories are:
-        Mac OS X:   /Library/Application Support/<AppName>
-        Unix:       /usr/local/share/<AppName> or /usr/share/<AppName>
-        Win XP:     C:\Documents and Settings\All Users\Application Data\<AppAuthor>\<AppName>
-        Vista:      (Fail! "C:\ProgramData" is a hidden *system* directory on Vista.)
-        Win 7:      C:\ProgramData\<AppAuthor>\<AppName>   # Hidden, but writeable on Win 7.
-
-    For Unix, this is using the $XDG_DATA_DIRS[0] default.
-
-    WARNING: Do not use this on Windows. See the Vista-Fail note above for why.
-    """
-    if system == "win32":
-        if appauthor is None:
-            appauthor = appname
-        path = os.path.normpath(_get_win_folder("CSIDL_COMMON_APPDATA"))
-        if appname:
-            if appauthor is not False:
-                path = os.path.join(path, appauthor, appname)
-            else:
-                path = os.path.join(path, appname)
-    elif system == 'darwin':
-        path = os.path.expanduser('/Library/Application Support')
-        if appname:
-            path = os.path.join(path, appname)
-    else:
-        # XDG default for $XDG_DATA_DIRS
-        # only first, if multipath is False
-        path = os.getenv('XDG_DATA_DIRS',
-                         os.pathsep.join(['/usr/local/share', '/usr/share']))
-        pathlist = [os.path.expanduser(x.rstrip(os.sep)) for x in path.split(os.pathsep)]
-        if appname:
-            if version:
-                appname = os.path.join(appname, version)
-            pathlist = [os.sep.join([x, appname]) for x in pathlist]
-
-        if multipath:
-            path = os.pathsep.join(pathlist)
-        else:
-            path = pathlist[0]
-        return path
-
-    if appname and version:
-        path = os.path.join(path, version)
-    return path
-
-
-def user_config_dir(appname=None, appauthor=None, version=None, roaming=False):
-    r"""Return full path to the user-specific config dir for this application.
-
-        "appname" is the name of application.
-            If None, just the system directory is returned.
-        "appauthor" (only used on Windows) is the name of the
-            appauthor or distributing body for this application. Typically
-            it is the owning company name. This falls back to appname. You may
-            pass False to disable it.
-        "version" is an optional version path element to append to the
-            path. You might want to use this if you want multiple versions
-            of your app to be able to run independently. If used, this
-            would typically be "<major>.<minor>".
-            Only applied when appname is present.
-        "roaming" (boolean, default False) can be set True to use the Windows
-            roaming appdata directory. That means that for users on a Windows
-            network setup for roaming profiles, this user data will be
-            sync'd on login. See
-            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
-            for a discussion of issues.
-
-    Typical user config directories are:
-        Mac OS X:               same as user_data_dir
-        Unix:                   ~/.config/<AppName>     # or in $XDG_CONFIG_HOME, if defined
-        Win *:                  same as user_data_dir
-
-    For Unix, we follow the XDG spec and support $XDG_CONFIG_HOME.
-    That means, by default "~/.config/<AppName>".
-    """
-    if system in ["win32", "darwin"]:
-        path = user_data_dir(appname, appauthor, None, roaming)
-    else:
-        path = os.getenv('XDG_CONFIG_HOME', os.path.expanduser("~/.config"))
-        if appname:
-            path = os.path.join(path, appname)
-    if appname and version:
-        path = os.path.join(path, version)
-    return path
-
-
-def site_config_dir(appname=None, appauthor=None, version=None, multipath=False):
-    r"""Return full path to the user-shared data dir for this application.
-
-        "appname" is the name of application.
-            If None, just the system directory is returned.
-        "appauthor" (only used on Windows) is the name of the
-            appauthor or distributing body for this application. Typically
-            it is the owning company name. This falls back to appname. You may
-            pass False to disable it.
-        "version" is an optional version path element to append to the
-            path. You might want to use this if you want multiple versions
-            of your app to be able to run independently. If used, this
-            would typically be "<major>.<minor>".
-            Only applied when appname is present.
-        "multipath" is an optional parameter only applicable to *nix
-            which indicates that the entire list of config dirs should be
-            returned. By default, the first item from XDG_CONFIG_DIRS is
-            returned, or '/etc/xdg/<AppName>', if XDG_CONFIG_DIRS is not set
-
-    Typical site config directories are:
-        Mac OS X:   same as site_data_dir
-        Unix:       /etc/xdg/<AppName> or $XDG_CONFIG_DIRS[i]/<AppName> for each value in
-                    $XDG_CONFIG_DIRS
-        Win *:      same as site_data_dir
-        Vista:      (Fail! "C:\ProgramData" is a hidden *system* directory on Vista.)
-
-    For Unix, this is using the $XDG_CONFIG_DIRS[0] default, if multipath=False
-
-    WARNING: Do not use this on Windows. See the Vista-Fail note above for why.
-    """
-    if system in ["win32", "darwin"]:
-        path = site_data_dir(appname, appauthor)
-        if appname and version:
-            path = os.path.join(path, version)
-    else:
-        # XDG default for $XDG_CONFIG_DIRS
-        # only first, if multipath is False
-        path = os.getenv('XDG_CONFIG_DIRS', '/etc/xdg')
-        pathlist = [os.path.expanduser(x.rstrip(os.sep)) for x in path.split(os.pathsep)]
-        if appname:
-            if version:
-                appname = os.path.join(appname, version)
-            pathlist = [os.sep.join([x, appname]) for x in pathlist]
-
-        if multipath:
-            path = os.pathsep.join(pathlist)
-        else:
-            path = pathlist[0]
-    return path
-
-
-def user_cache_dir(appname=None, appauthor=None, version=None, opinion=True):
-    r"""Return full path to the user-specific cache dir for this application.
-
-        "appname" is the name of application.
-            If None, just the system directory is returned.
-        "appauthor" (only used on Windows) is the name of the
-            appauthor or distributing body for this application. Typically
-            it is the owning company name. This falls back to appname. You may
-            pass False to disable it.
-        "version" is an optional version path element to append to the
-            path. You might want to use this if you want multiple versions
-            of your app to be able to run independently. If used, this
-            would typically be "<major>.<minor>".
-            Only applied when appname is present.
-        "opinion" (boolean) can be False to disable the appending of
-            "Cache" to the base app data dir for Windows. See
-            discussion below.
-
-    Typical user cache directories are:
-        Mac OS X:   ~/Library/Caches/<AppName>
-        Unix:       ~/.cache/<AppName> (XDG default)
-        Win XP:     C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>\Cache
-        Vista:      C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>\Cache
-
-    On Windows the only suggestion in the MSDN docs is that local settings go in
-    the `CSIDL_LOCAL_APPDATA` directory. This is identical to the non-roaming
-    app data dir (the default returned by `user_data_dir` above). Apps typically
-    put cache data somewhere *under* the given dir here. Some examples:
-        ...\Mozilla\Firefox\Profiles\<ProfileName>\Cache
-        ...\Acme\SuperApp\Cache\1.0
-    OPINION: This function appends "Cache" to the `CSIDL_LOCAL_APPDATA` value.
-    This can be disabled with the `opinion=False` option.
-    """
-    if system == "win32":
-        if appauthor is None:
-            appauthor = appname
-        path = os.path.normpath(_get_win_folder("CSIDL_LOCAL_APPDATA"))
-        if appname:
-            if appauthor is not False:
-                path = os.path.join(path, appauthor, appname)
-            else:
-                path = os.path.join(path, appname)
-            if opinion:
-                path = os.path.join(path, "Cache")
-    elif system == 'darwin':
-        path = os.path.expanduser('~/Library/Caches')
-        if appname:
-            path = os.path.join(path, appname)
-    else:
-        path = os.getenv('XDG_CACHE_HOME', os.path.expanduser('~/.cache'))
-        if appname:
-            path = os.path.join(path, appname)
-    if appname and version:
-        path = os.path.join(path, version)
-    return path
-
-
-def user_state_dir(appname=None, appauthor=None, version=None, roaming=False):
-    r"""Return full path to the user-specific state dir for this application.
-
-        "appname" is the name of application.
-            If None, just the system directory is returned.
-        "appauthor" (only used on Windows) is the name of the
-            appauthor or distributing body for this application. Typically
-            it is the owning company name. This falls back to appname. You may
-            pass False to disable it.
-        "version" is an optional version path element to append to the
-            path. You might want to use this if you want multiple versions
-            of your app to be able to run independently. If used, this
-            would typically be "<major>.<minor>".
-            Only applied when appname is present.
-        "roaming" (boolean, default False) can be set True to use the Windows
-            roaming appdata directory. That means that for users on a Windows
-            network setup for roaming profiles, this user data will be
-            sync'd on login. See
-            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
-            for a discussion of issues.
-
-    Typical user state directories are:
-        Mac OS X:  same as user_data_dir
-        Unix:      ~/.local/state/<AppName>   # or in $XDG_STATE_HOME, if defined
-        Win *:     same as user_data_dir
-
-    For Unix, we follow this Debian proposal <https://wiki.debian.org/XDGBaseDirectorySpecification#state>
-    to extend the XDG spec and support $XDG_STATE_HOME.
-
-    That means, by default "~/.local/state/<AppName>".
-    """
-    if system in ["win32", "darwin"]:
-        path = user_data_dir(appname, appauthor, None, roaming)
-    else:
-        path = os.getenv('XDG_STATE_HOME', os.path.expanduser("~/.local/state"))
-        if appname:
-            path = os.path.join(path, appname)
-    if appname and version:
-        path = os.path.join(path, version)
-    return path
-
-
-def user_log_dir(appname=None, appauthor=None, version=None, opinion=True):
-    r"""Return full path to the user-specific log dir for this application.
-
-        "appname" is the name of application.
-            If None, just the system directory is returned.
-        "appauthor" (only used on Windows) is the name of the
-            appauthor or distributing body for this application. Typically
-            it is the owning company name. This falls back to appname. You may
-            pass False to disable it.
-        "version" is an optional version path element to append to the
-            path. You might want to use this if you want multiple versions
-            of your app to be able to run independently. If used, this
-            would typically be "<major>.<minor>".
-            Only applied when appname is present.
-        "opinion" (boolean) can be False to disable the appending of
-            "Logs" to the base app data dir for Windows, and "log" to the
-            base cache dir for Unix. See discussion below.
-
-    Typical user log directories are:
-        Mac OS X:   ~/Library/Logs/<AppName>
-        Unix:       ~/.cache/<AppName>/log  # or under $XDG_CACHE_HOME if defined
-        Win XP:     C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>\Logs
-        Vista:      C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>\Logs
-
-    On Windows the only suggestion in the MSDN docs is that local settings
-    go in the `CSIDL_LOCAL_APPDATA` directory. (Note: I'm interested in
-    examples of what some windows apps use for a logs dir.)
-
-    OPINION: This function appends "Logs" to the `CSIDL_LOCAL_APPDATA`
-    value for Windows and appends "log" to the user cache dir for Unix.
-    This can be disabled with the `opinion=False` option.
-    """
-    if system == "darwin":
-        path = os.path.join(
-            os.path.expanduser('~/Library/Logs'),
-            appname)
-    elif system == "win32":
-        path = user_data_dir(appname, appauthor, version)
-        version = False
-        if opinion:
-            path = os.path.join(path, "Logs")
-    else:
-        path = user_cache_dir(appname, appauthor, version)
-        version = False
-        if opinion:
-            path = os.path.join(path, "log")
-    if appname and version:
-        path = os.path.join(path, version)
-    return path
-
-
-class AppDirs(object):
-    """Convenience wrapper for getting application dirs."""
-    def __init__(self, appname=None, appauthor=None, version=None,
-            roaming=False, multipath=False):
-        self.appname = appname
-        self.appauthor = appauthor
-        self.version = version
-        self.roaming = roaming
-        self.multipath = multipath
-
-    @property
-    def user_data_dir(self):
-        return user_data_dir(self.appname, self.appauthor,
-                             version=self.version, roaming=self.roaming)
-
-    @property
-    def site_data_dir(self):
-        return site_data_dir(self.appname, self.appauthor,
-                             version=self.version, multipath=self.multipath)
-
-    @property
-    def user_config_dir(self):
-        return user_config_dir(self.appname, self.appauthor,
-                               version=self.version, roaming=self.roaming)
-
-    @property
-    def site_config_dir(self):
-        return site_config_dir(self.appname, self.appauthor,
-                             version=self.version, multipath=self.multipath)
-
-    @property
-    def user_cache_dir(self):
-        return user_cache_dir(self.appname, self.appauthor,
-                              version=self.version)
-
-    @property
-    def user_state_dir(self):
-        return user_state_dir(self.appname, self.appauthor,
-                              version=self.version)
-
-    @property
-    def user_log_dir(self):
-        return user_log_dir(self.appname, self.appauthor,
-                            version=self.version)
-
-
-#---- internal support stuff
-
-def _get_win_folder_from_registry(csidl_name):
-    """This is a fallback technique at best. I'm not sure if using the
-    registry for this guarantees us the correct answer for all CSIDL_*
-    names.
-    """
-    if PY3:
-      import winreg as _winreg
-    else:
-      import _winreg
-
-    shell_folder_name = {
-        "CSIDL_APPDATA": "AppData",
-        "CSIDL_COMMON_APPDATA": "Common AppData",
-        "CSIDL_LOCAL_APPDATA": "Local AppData",
-    }[csidl_name]
-
-    key = _winreg.OpenKey(
-        _winreg.HKEY_CURRENT_USER,
-        r"Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders"
-    )
-    dir, type = _winreg.QueryValueEx(key, shell_folder_name)
-    return dir
-
-
-def _get_win_folder_with_pywin32(csidl_name):
-    from win32com.shell import shellcon, shell
-    dir = shell.SHGetFolderPath(0, getattr(shellcon, csidl_name), 0, 0)
-    # Try to make this a unicode path because SHGetFolderPath does
-    # not return unicode strings when there is unicode data in the
-    # path.
-    try:
-        dir = unicode(dir)
-
-        # Downgrade to short path name if have highbit chars. See
-        # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
-        has_high_char = False
-        for c in dir:
-            if ord(c) > 255:
-                has_high_char = True
-                break
-        if has_high_char:
-            try:
-                import win32api
-                dir = win32api.GetShortPathName(dir)
-            except ImportError:
-                pass
-    except UnicodeError:
-        pass
-    return dir
-
-
-def _get_win_folder_with_ctypes(csidl_name):
-    import ctypes
-
-    csidl_const = {
-        "CSIDL_APPDATA": 26,
-        "CSIDL_COMMON_APPDATA": 35,
-        "CSIDL_LOCAL_APPDATA": 28,
-    }[csidl_name]
-
-    buf = ctypes.create_unicode_buffer(1024)
-    ctypes.windll.shell32.SHGetFolderPathW(None, csidl_const, None, 0, buf)
-
-    # Downgrade to short path name if have highbit chars. See
-    # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
-    has_high_char = False
-    for c in buf:
-        if ord(c) > 255:
-            has_high_char = True
-            break
-    if has_high_char:
-        buf2 = ctypes.create_unicode_buffer(1024)
-        if ctypes.windll.kernel32.GetShortPathNameW(buf.value, buf2, 1024):
-            buf = buf2
-
-    return buf.value
-
-def _get_win_folder_with_jna(csidl_name):
-    import array
-    from com.sun import jna
-    from com.sun.jna.platform import win32
-
-    buf_size = win32.WinDef.MAX_PATH * 2
-    buf = array.zeros('c', buf_size)
-    shell = win32.Shell32.INSTANCE
-    shell.SHGetFolderPath(None, getattr(win32.ShlObj, csidl_name), None, win32.ShlObj.SHGFP_TYPE_CURRENT, buf)
-    dir = jna.Native.toString(buf.tostring()).rstrip("\0")
-
-    # Downgrade to short path name if have highbit chars. See
-    # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
-    has_high_char = False
-    for c in dir:
-        if ord(c) > 255:
-            has_high_char = True
-            break
-    if has_high_char:
-        buf = array.zeros('c', buf_size)
-        kernel = win32.Kernel32.INSTANCE
-        if kernel.GetShortPathName(dir, buf, buf_size):
-            dir = jna.Native.toString(buf.tostring()).rstrip("\0")
-
-    return dir
-
-if system == "win32":
-    try:
-        import win32com.shell
-        _get_win_folder = _get_win_folder_with_pywin32
-    except ImportError:
-        try:
-            from ctypes import windll
-            _get_win_folder = _get_win_folder_with_ctypes
-        except ImportError:
-            try:
-                import com.sun.jna
-                _get_win_folder = _get_win_folder_with_jna
-            except ImportError:
-                _get_win_folder = _get_win_folder_from_registry
-
-
-#---- self test code
-
-if __name__ == "__main__":
-    appname = "MyApp"
-    appauthor = "MyCompany"
-
-    props = ("user_data_dir",
-             "user_config_dir",
-             "user_cache_dir",
-             "user_state_dir",
-             "user_log_dir",
-             "site_data_dir",
-             "site_config_dir")
-
-    print("-- app dirs %s --" % __version__)
-
-    print("-- app dirs (with optional 'version')")
-    dirs = AppDirs(appname, appauthor, version="1.0")
-    for prop in props:
-        print("%s: %s" % (prop, getattr(dirs, prop)))
-
-    print("\n-- app dirs (without optional 'version')")
-    dirs = AppDirs(appname, appauthor)
-    for prop in props:
-        print("%s: %s" % (prop, getattr(dirs, prop)))
-
-    print("\n-- app dirs (without optional 'appauthor')")
-    dirs = AppDirs(appname)
-    for prop in props:
-        print("%s: %s" % (prop, getattr(dirs, prop)))
-
-    print("\n-- app dirs (with disabled 'appauthor')")
-    dirs = AppDirs(appname, appauthor=False)
-    for prop in props:
-        print("%s: %s" % (prop, getattr(dirs, prop)))

spaces/CVPR/LIVE/thrust/thrust/system/cuda/detail/util.h

@@ -1,589 +0,0 @@
-/******************************************************************************
- * Copyright (c) 2016, NVIDIA CORPORATION.  All rights meserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the NVIDIA CORPORATION nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- ******************************************************************************/
-#pragma once
-
-#include <cstdio>
-#include <thrust/detail/config.h>
-#include <thrust/iterator/iterator_traits.h>
-#include <cub/util_arch.cuh>
-#include <thrust/system/cuda/detail/execution_policy.h>
-#include <thrust/system_error.h>
-#include <thrust/system/cuda/error.h>
-
-namespace thrust
-{
-
-namespace cuda_cub {
-
-inline __host__ __device__
-cudaStream_t
-default_stream()
-{
-#ifdef CUDA_API_PER_THREAD_DEFAULT_STREAM
-  return cudaStreamPerThread;
-#else
-  return cudaStreamLegacy;
-#endif
-}
-
-// Fallback implementation of the customization point.
-template <class Derived>
-__host__ __device__
-cudaStream_t
-get_stream(execution_policy<Derived> &)
-{
-  return default_stream();
-}
-
-// Entry point/interface.
-template <class Derived>
-__host__ __device__ cudaStream_t
-stream(execution_policy<Derived> &policy)
-{
-  return get_stream(derived_cast(policy));
-}
-
-// Fallback implementation of the customization point.
-__thrust_exec_check_disable__
-template <class Derived>
-__host__ __device__
-cudaError_t
-synchronize_stream(execution_policy<Derived> &policy)
-{
-  cudaError_t result;
-  if (THRUST_IS_HOST_CODE) {
-    #if THRUST_INCLUDE_HOST_CODE
-      cudaStreamSynchronize(stream(policy));
-      result = cudaGetLastError();
-    #endif
-  } else {
-    #if THRUST_INCLUDE_DEVICE_CODE
-      #if __THRUST_HAS_CUDART__
-        THRUST_UNUSED_VAR(policy);
-        cudaDeviceSynchronize();
-        result = cudaGetLastError();
-      #else
-        THRUST_UNUSED_VAR(policy);
-        result = cudaSuccess;
-      #endif
-    #endif
-  }
-  return result;
-}
-
-// Entry point/interface.
-template <class Policy>
-__host__ __device__
-cudaError_t
-synchronize(Policy &policy)
-{
-  return synchronize_stream(derived_cast(policy));
-}
-
-template <class Type>
-THRUST_HOST_FUNCTION cudaError_t
-trivial_copy_from_device(Type *       dst,
-                         Type const * src,
-                         size_t       count,
-                         cudaStream_t stream)
-{
-  cudaError status = cudaSuccess;
-  if (count == 0) return status;
-
-  status = ::cudaMemcpyAsync(dst,
-                             src,
-                             sizeof(Type) * count,
-                             cudaMemcpyDeviceToHost,
-                             stream);
-  cudaStreamSynchronize(stream);
-  return status;
-}
-
-template <class Type>
-THRUST_HOST_FUNCTION cudaError_t
-trivial_copy_to_device(Type *       dst,
-                       Type const * src,
-                       size_t       count,
-                       cudaStream_t stream)
-{
-  cudaError status = cudaSuccess;
-  if (count == 0) return status;
-
-  status = ::cudaMemcpyAsync(dst,
-                             src,
-                             sizeof(Type) * count,
-                             cudaMemcpyHostToDevice,
-                             stream);
-  cudaStreamSynchronize(stream);
-  return status;
-}
-
-template <class Policy, class Type>
-__host__ __device__ cudaError_t
-trivial_copy_device_to_device(Policy &    policy,
-                              Type *      dst,
-                              Type const *src,
-                              size_t      count)
-{
-  cudaError_t  status = cudaSuccess;
-  if (count == 0) return status;
-
-  cudaStream_t stream = cuda_cub::stream(policy);
-  //
-  status = ::cudaMemcpyAsync(dst,
-                             src,
-                             sizeof(Type) * count,
-                             cudaMemcpyDeviceToDevice,
-                             stream);
-  cuda_cub::synchronize(policy);
-  return status;
-}
-
-inline void __host__ __device__
-terminate()
-{
-  if (THRUST_IS_DEVICE_CODE) {
-    #if THRUST_INCLUDE_DEVICE_CODE
-      asm("trap;");
-    #endif
-  } else {
-    #if THRUST_INCLUDE_HOST_CODE
-      std::terminate();
-    #endif
-  }
-}
-
-__host__  __device__
-inline void throw_on_error(cudaError_t status)
-{
-#if __THRUST_HAS_CUDART__
-  // Clear the global CUDA error state which may have been set by the last
-  // call. Otherwise, errors may "leak" to unrelated kernel launches.
-  cudaGetLastError();
-#endif
-
-  if (cudaSuccess != status)
-  {
-    if (THRUST_IS_HOST_CODE) {
-      #if THRUST_INCLUDE_HOST_CODE
-        throw thrust::system_error(status, thrust::cuda_category());
-      #endif
-    } else {
-      #if THRUST_INCLUDE_DEVICE_CODE
-        #if __THRUST_HAS_CUDART__
-          printf("Thrust CUDA backend error: %s: %s\n",
-                 cudaGetErrorName(status),
-                 cudaGetErrorString(status));
-        #else
-          printf("Thrust CUDA backend error: %d\n",
-                 static_cast<int>(status));
-        #endif
-        cuda_cub::terminate();
-      #endif
-    }
-  }
-}
-
-__host__ __device__
-inline void throw_on_error(cudaError_t status, char const *msg)
-{
-#if __THRUST_HAS_CUDART__
-  // Clear the global CUDA error state which may have been set by the last
-  // call. Otherwise, errors may "leak" to unrelated kernel launches.
-  cudaGetLastError();
-#endif
-
-  if (cudaSuccess != status)
-  {
-    if (THRUST_IS_HOST_CODE) {
-      #if THRUST_INCLUDE_HOST_CODE
-        throw thrust::system_error(status, thrust::cuda_category(), msg);
-      #endif
-    } else {
-      #if THRUST_INCLUDE_DEVICE_CODE
-        #if __THRUST_HAS_CUDART__
-          printf("Thrust CUDA backend error: %s: %s: %s\n",
-                 cudaGetErrorName(status),
-                 cudaGetErrorString(status),
-                 msg);
-        #else
-          printf("Thrust CUDA backend error: %d: %s \n",
-                 static_cast<int>(status),
-                 msg);
-        #endif
-        cuda_cub::terminate();
-      #endif
-    }
-  }
-}
-
-// FIXME: Move the iterators elsewhere.
-
-template <class ValueType,
-          class InputIt,
-          class UnaryOp>
-struct transform_input_iterator_t
-{
-  typedef transform_input_iterator_t                         self_t;
-  typedef typename iterator_traits<InputIt>::difference_type difference_type;
-  typedef ValueType                                          value_type;
-  typedef void                                               pointer;
-  typedef value_type                                         reference;
-  typedef std::random_access_iterator_tag                    iterator_category;
-
-  InputIt         input;
-  mutable UnaryOp op;
-
-  __host__ __device__ __forceinline__
-  transform_input_iterator_t(InputIt input, UnaryOp op)
-      : input(input), op(op) {}
-
-#if THRUST_CPP_DIALECT >= 2011
-  transform_input_iterator_t(const self_t &) = default;
-#endif
-
-  // UnaryOp might not be copy assignable, such as when it is a lambda.  Define
-  // an explicit copy assignment operator that doesn't try to assign it.
-  self_t& operator=(const self_t& o)
-  {
-    input = o.input;
-    return *this;
-  }
-
-  /// Postfix increment
-  __host__ __device__ __forceinline__ self_t operator++(int)
-  {
-    self_t retval = *this;
-    ++input;
-    return retval;
-  }
-
-  /// Prefix increment
-  __host__ __device__ __forceinline__ self_t operator++()
-  {
-    ++input;
-    return *this;
-  }
-
-  /// Indirection
-  __host__ __device__ __forceinline__ reference operator*() const
-  {
-    typename thrust::iterator_value<InputIt>::type x = *input;
-    return op(x);
-  }
-  /// Indirection
-  __host__ __device__ __forceinline__ reference operator*()
-  {
-    typename thrust::iterator_value<InputIt>::type x = *input;
-    return op(x);
-  }
-
-  /// Addition
-  __host__ __device__ __forceinline__ self_t operator+(difference_type n) const
-  {
-    return self_t(input + n, op);
-  }
-
-  /// Addition assignment
-  __host__ __device__ __forceinline__ self_t &operator+=(difference_type n)
-  {
-    input += n;
-    return *this;
-  }
-
-  /// Subtraction
-  __host__ __device__ __forceinline__ self_t operator-(difference_type n) const
-  {
-    return self_t(input - n, op);
-  }
-
-  /// Subtraction assignment
-  __host__ __device__ __forceinline__ self_t &operator-=(difference_type n)
-  {
-    input -= n;
-    return *this;
-  }
-
-  /// Distance
-  __host__ __device__ __forceinline__ difference_type operator-(self_t other) const
-  {
-    return input - other.input;
-  }
-
-  /// Array subscript
-  __host__ __device__ __forceinline__ reference operator[](difference_type n) const
-  {
-    return op(input[n]);
-  }
-
-  /// Equal to
-  __host__ __device__ __forceinline__ bool operator==(const self_t &rhs) const
-  {
-    return (input == rhs.input);
-  }
-
-  /// Not equal to
-  __host__ __device__ __forceinline__ bool operator!=(const self_t &rhs) const
-  {
-    return (input != rhs.input);
-  }
-};    // struct transform_input_iterarot_t
-
-template <class ValueType,
-          class InputIt1,
-          class InputIt2,
-          class BinaryOp>
-struct transform_pair_of_input_iterators_t
-{
-  typedef transform_pair_of_input_iterators_t                 self_t;
-  typedef typename iterator_traits<InputIt1>::difference_type difference_type;
-  typedef ValueType                                           value_type;
-  typedef void                                                pointer;
-  typedef value_type                                          reference;
-  typedef std::random_access_iterator_tag                     iterator_category;
-
-  InputIt1         input1;
-  InputIt2         input2;
-  mutable BinaryOp op;
-
-  __host__ __device__ __forceinline__
-  transform_pair_of_input_iterators_t(InputIt1 input1_,
-                                      InputIt2 input2_,
-                                      BinaryOp op_)
-      : input1(input1_), input2(input2_), op(op_) {}
-
-#if THRUST_CPP_DIALECT >= 2011
-  transform_pair_of_input_iterators_t(const self_t &) = default;
-#endif
-
-  // BinaryOp might not be copy assignable, such as when it is a lambda.
-  // Define an explicit copy assignment operator that doesn't try to assign it.
-  self_t& operator=(const self_t& o)
-  {
-    input1 = o.input1;
-    input2 = o.input2;
-    return *this;
-  }
-
-  /// Postfix increment
-  __host__ __device__ __forceinline__ self_t operator++(int)
-  {
-    self_t retval = *this;
-    ++input1;
-    ++input2;
-    return retval;
-  }
-
-  /// Prefix increment
-  __host__ __device__ __forceinline__ self_t operator++()
-  {
-    ++input1;
-    ++input2;
-    return *this;
-  }
-
-  /// Indirection
-  __host__ __device__ __forceinline__ reference operator*() const
-  {
-    return op(*input1, *input2);
-  }
-  /// Indirection
-  __host__ __device__ __forceinline__ reference operator*()
-  {
-    return op(*input1, *input2);
-  }
-
-  /// Addition
-  __host__ __device__ __forceinline__ self_t operator+(difference_type n) const
-  {
-    return self_t(input1 + n, input2 + n, op);
-  }
-
-  /// Addition assignment
-  __host__ __device__ __forceinline__ self_t &operator+=(difference_type n)
-  {
-    input1 += n;
-    input2 += n;
-    return *this;
-  }
-
-  /// Subtraction
-  __host__ __device__ __forceinline__ self_t operator-(difference_type n) const
-  {
-    return self_t(input1 - n, input2 - n, op);
-  }
-
-  /// Subtraction assignment
-  __host__ __device__ __forceinline__ self_t &operator-=(difference_type n)
-  {
-    input1 -= n;
-    input2 -= n;
-    return *this;
-  }
-
-  /// Distance
-  __host__ __device__ __forceinline__ difference_type operator-(self_t other) const
-  {
-    return input1 - other.input1;
-  }
-
-  /// Array subscript
-  __host__ __device__ __forceinline__ reference operator[](difference_type n) const
-  {
-    return op(input1[n], input2[n]);
-  }
-
-  /// Equal to
-  __host__ __device__ __forceinline__ bool operator==(const self_t &rhs) const
-  {
-    return (input1 == rhs.input1) && (input2 == rhs.input2);
-  }
-
-  /// Not equal to
-  __host__ __device__ __forceinline__ bool operator!=(const self_t &rhs) const
-  {
-    return (input1 != rhs.input1) || (input2 != rhs.input2);
-  }
-
-};    // struct transform_pair_of_input_iterators_t
-
-
-struct identity
-{
-  template <class T>
-  __host__ __device__ T const &
-  operator()(T const &t) const
-  {
-    return t;
-  }
-
-  template <class T>
-  __host__ __device__ T &
-  operator()(T &t) const
-  {
-    return t;
-  }
-};
-
-
-template <class T>
-struct counting_iterator_t
-{
-  typedef counting_iterator_t             self_t;
-  typedef T                               difference_type;
-  typedef T                               value_type;
-  typedef void                            pointer;
-  typedef T                               reference;
-  typedef std::random_access_iterator_tag iterator_category;
-
-  T count;
-
-  __host__ __device__ __forceinline__
-  counting_iterator_t(T count_) : count(count_) {}
-
-  /// Postfix increment
-  __host__ __device__ __forceinline__ self_t operator++(int)
-  {
-    self_t retval = *this;
-    ++count;
-    return retval;
-  }
-
-  /// Prefix increment
-  __host__ __device__ __forceinline__ self_t operator++()
-  {
-    ++count;
-    return *this;
-  }
-
-  /// Indirection
-  __host__ __device__ __forceinline__ reference operator*() const
-  {
-    return count;
-  }
-
-  /// Indirection
-  __host__ __device__ __forceinline__ reference operator*()
-  {
-    return count;
-  }
-
-  /// Addition
-  __host__ __device__ __forceinline__ self_t operator+(difference_type n) const
-  {
-    return self_t(count + n);
-  }
-
-  /// Addition assignment
-  __host__ __device__ __forceinline__ self_t &operator+=(difference_type n)
-  {
-    count += n;
-    return *this;
-  }
-
-  /// Subtraction
-  __host__ __device__ __forceinline__ self_t operator-(difference_type n) const
-  {
-    return self_t(count - n);
-  }
-
-  /// Subtraction assignment
-  __host__ __device__ __forceinline__ self_t &operator-=(difference_type n)
-  {
-    count -= n;
-    return *this;
-  }
-
-  /// Distance
-  __host__ __device__ __forceinline__ difference_type operator-(self_t other) const
-  {
-    return count - other.count;
-  }
-
-  /// Array subscript
-  __host__ __device__ __forceinline__ reference operator[](difference_type n) const
-  {
-    return count + n;
-  }
-
-  /// Equal to
-  __host__ __device__ __forceinline__ bool operator==(const self_t &rhs) const
-  {
-    return (count == rhs.count);
-  }
-
-  /// Not equal to
-  __host__ __device__ __forceinline__ bool operator!=(const self_t &rhs) const
-  {
-    return (count != rhs.count);
-  }
-
-};    // struct count_iterator_t
-
-}    // cuda_
-
-} // end namespace thrust

spaces/CVPR/lama-example/saicinpainting/training/losses/style_loss.py

@@ -1,155 +0,0 @@
-import torch
-import torch.nn as nn
-import torchvision.models as models
-
-
-class PerceptualLoss(nn.Module):
-    r"""
-    Perceptual loss, VGG-based
-    https://arxiv.org/abs/1603.08155
-    https://github.com/dxyang/StyleTransfer/blob/master/utils.py
-    """
-
-    def __init__(self, weights=[1.0, 1.0, 1.0, 1.0, 1.0]):
-        super(PerceptualLoss, self).__init__()
-        self.add_module('vgg', VGG19())
-        self.criterion = torch.nn.L1Loss()
-        self.weights = weights
-
-    def __call__(self, x, y):
-        # Compute features
-        x_vgg, y_vgg = self.vgg(x), self.vgg(y)
-
-        content_loss = 0.0
-        content_loss += self.weights[0] * self.criterion(x_vgg['relu1_1'], y_vgg['relu1_1'])
-        content_loss += self.weights[1] * self.criterion(x_vgg['relu2_1'], y_vgg['relu2_1'])
-        content_loss += self.weights[2] * self.criterion(x_vgg['relu3_1'], y_vgg['relu3_1'])
-        content_loss += self.weights[3] * self.criterion(x_vgg['relu4_1'], y_vgg['relu4_1'])
-        content_loss += self.weights[4] * self.criterion(x_vgg['relu5_1'], y_vgg['relu5_1'])
-
-
-        return content_loss
-
-
-class VGG19(torch.nn.Module):
-    def __init__(self):
-        super(VGG19, self).__init__()
-        features = models.vgg19(pretrained=True).features
-        self.relu1_1 = torch.nn.Sequential()
-        self.relu1_2 = torch.nn.Sequential()
-
-        self.relu2_1 = torch.nn.Sequential()
-        self.relu2_2 = torch.nn.Sequential()
-
-        self.relu3_1 = torch.nn.Sequential()
-        self.relu3_2 = torch.nn.Sequential()
-        self.relu3_3 = torch.nn.Sequential()
-        self.relu3_4 = torch.nn.Sequential()
-
-        self.relu4_1 = torch.nn.Sequential()
-        self.relu4_2 = torch.nn.Sequential()
-        self.relu4_3 = torch.nn.Sequential()
-        self.relu4_4 = torch.nn.Sequential()
-
-        self.relu5_1 = torch.nn.Sequential()
-        self.relu5_2 = torch.nn.Sequential()
-        self.relu5_3 = torch.nn.Sequential()
-        self.relu5_4 = torch.nn.Sequential()
-
-        for x in range(2):
-            self.relu1_1.add_module(str(x), features[x])
-
-        for x in range(2, 4):
-            self.relu1_2.add_module(str(x), features[x])
-
-        for x in range(4, 7):
-            self.relu2_1.add_module(str(x), features[x])
-
-        for x in range(7, 9):
-            self.relu2_2.add_module(str(x), features[x])
-
-        for x in range(9, 12):
-            self.relu3_1.add_module(str(x), features[x])
-
-        for x in range(12, 14):
-            self.relu3_2.add_module(str(x), features[x])
-
-        for x in range(14, 16):
-            self.relu3_2.add_module(str(x), features[x])
-
-        for x in range(16, 18):
-            self.relu3_4.add_module(str(x), features[x])
-
-        for x in range(18, 21):
-            self.relu4_1.add_module(str(x), features[x])
-
-        for x in range(21, 23):
-            self.relu4_2.add_module(str(x), features[x])
-
-        for x in range(23, 25):
-            self.relu4_3.add_module(str(x), features[x])
-
-        for x in range(25, 27):
-            self.relu4_4.add_module(str(x), features[x])
-
-        for x in range(27, 30):
-            self.relu5_1.add_module(str(x), features[x])
-
-        for x in range(30, 32):
-            self.relu5_2.add_module(str(x), features[x])
-
-        for x in range(32, 34):
-            self.relu5_3.add_module(str(x), features[x])
-
-        for x in range(34, 36):
-            self.relu5_4.add_module(str(x), features[x])
-
-        # don't need the gradients, just want the features
-        for param in self.parameters():
-            param.requires_grad = False
-
-    def forward(self, x):
-        relu1_1 = self.relu1_1(x)
-        relu1_2 = self.relu1_2(relu1_1)
-
-        relu2_1 = self.relu2_1(relu1_2)
-        relu2_2 = self.relu2_2(relu2_1)
-
-        relu3_1 = self.relu3_1(relu2_2)
-        relu3_2 = self.relu3_2(relu3_1)
-        relu3_3 = self.relu3_3(relu3_2)
-        relu3_4 = self.relu3_4(relu3_3)
-
-        relu4_1 = self.relu4_1(relu3_4)
-        relu4_2 = self.relu4_2(relu4_1)
-        relu4_3 = self.relu4_3(relu4_2)
-        relu4_4 = self.relu4_4(relu4_3)
-
-        relu5_1 = self.relu5_1(relu4_4)
-        relu5_2 = self.relu5_2(relu5_1)
-        relu5_3 = self.relu5_3(relu5_2)
-        relu5_4 = self.relu5_4(relu5_3)
-
-        out = {
-            'relu1_1': relu1_1,
-            'relu1_2': relu1_2,
-
-            'relu2_1': relu2_1,
-            'relu2_2': relu2_2,
-
-            'relu3_1': relu3_1,
-            'relu3_2': relu3_2,
-            'relu3_3': relu3_3,
-            'relu3_4': relu3_4,
-
-            'relu4_1': relu4_1,
-            'relu4_2': relu4_2,
-            'relu4_3': relu4_3,
-            'relu4_4': relu4_4,
-
-            'relu5_1': relu5_1,
-            'relu5_2': relu5_2,
-            'relu5_3': relu5_3,
-            'relu5_4': relu5_4,
-        }
-        return out

spaces/CVPR/lama-example/saicinpainting/training/modules/fake_fakes.py

@@ -1,47 +0,0 @@
-import torch
-from kornia import SamplePadding
-from kornia.augmentation import RandomAffine, CenterCrop
-
-
-class FakeFakesGenerator:
-    def __init__(self, aug_proba=0.5, img_aug_degree=30, img_aug_translate=0.2):
-        self.grad_aug = RandomAffine(degrees=360,
-                                     translate=0.2,
-                                     padding_mode=SamplePadding.REFLECTION,
-                                     keepdim=False,
-                                     p=1)
-        self.img_aug = RandomAffine(degrees=img_aug_degree,
-                                    translate=img_aug_translate,
-                                    padding_mode=SamplePadding.REFLECTION,
-                                    keepdim=True,
-                                    p=1)
-        self.aug_proba = aug_proba
-
-    def __call__(self, input_images, masks):
-        blend_masks = self._fill_masks_with_gradient(masks)
-        blend_target = self._make_blend_target(input_images)
-        result = input_images * (1 - blend_masks) + blend_target * blend_masks
-        return result, blend_masks
-
-    def _make_blend_target(self, input_images):
-        batch_size = input_images.shape[0]
-        permuted = input_images[torch.randperm(batch_size)]
-        augmented = self.img_aug(input_images)
-        is_aug = (torch.rand(batch_size, device=input_images.device)[:, None, None, None] < self.aug_proba).float()
-        result = augmented * is_aug + permuted * (1 - is_aug)
-        return result
-
-    def _fill_masks_with_gradient(self, masks):
-        batch_size, _, height, width = masks.shape
-        grad = torch.linspace(0, 1, steps=width * 2, device=masks.device, dtype=masks.dtype) \
-            .view(1, 1, 1, -1).expand(batch_size, 1, height * 2, width * 2)
-        grad = self.grad_aug(grad)
-        grad = CenterCrop((height, width))(grad)
-        grad *= masks
-
-        grad_for_min = grad + (1 - masks) * 10
-        grad -= grad_for_min.view(batch_size, -1).min(-1).values[:, None, None, None]
-        grad /= grad.view(batch_size, -1).max(-1).values[:, None, None, None] + 1e-6
-        grad.clamp_(min=0, max=1)
-
-        return grad

spaces/CVPR/v-doc_abstractive_mac/demo.py

@@ -1,83 +0,0 @@
-
-import json
-import os
-import werkzeug
-import tensorflow as tf
-
-from config import config, parseArgs, configPDF
-from extract_feature import get_img_feat, build_model
-from main import setSession, loadWeights, setSavers
-from model import MACnet
-from preprocess import Preprocesser
-import warnings
-
-def predict(image, question):
-  parseArgs()
-  config.parallel = True
-  config.evalTrain = True
-  config.retainVal = True
-  config.useEMA = True
-  config.lrReduce = True
-  config.adam = True
-  config.clip = True
-  config.memoryVariationalDropout = True
-  config.relu='ELU'
-  config.encBi = True
-  config.wrdEmbRandom = True
-  config.wrdEmbUniform = True
-  config.outQuestion = True
-  config.initCtrl='Q'
-  config.controlContextual = True
-  config.controlInputUnshared = True
-  config.readProjInputs = True
-  config.readMemConcatKB = True
-  config.readMemConcatProj = True
-  config.readMemProj = True
-  config.readCtrl = True
-  config.writeMemProj = True
-  config.restore = True
-  config.expName = 'PDF_exp_extra'
-  config.netLength = 16
-  configPDF()
-  with open(config.configFile(), "a+") as outFile:
-      json.dump(vars(config), outFile)
-
-  if config.gpus != "":
-      config.gpusNum = len(config.gpus.split(","))
-      os.environ["CUDA_VISIBLE_DEVICES"] = config.gpus
-  tf.reset_default_graph()
-  tf.Graph().as_default()
-  tf.logging.set_verbosity(tf.logging.ERROR)
-  cnn_model = build_model()
-  imageData = get_img_feat(cnn_model, image)
-
-  preprocessor = Preprocesser()
-  qData, embeddings, answerDict = preprocessor.preprocessData(question)
-  model = MACnet(embeddings, answerDict)
-  init = tf.global_variables_initializer()
-
-  savers = setSavers(model)
-  saver, emaSaver = savers["saver"], savers["emaSaver"]
-  sessionConfig = setSession()
-
-  data = {'data': qData, 'image': imageData}
-
-  with tf.Session(config=sessionConfig) as sess:
-    sess.graph.finalize()
-
-    # epoch = loadWeights(sess, saver, init)
-    print('###############', config.weightsFile(25))
-    os.system('ls -l ./weights/PDF_exp_extra')
-    emaSaver.restore(sess, config.weightsFile(25))
-
-    evalRes = model.runBatch(sess, data['data'], data['image'], False)
-    answer = None
-
-    if evalRes in ['top', 'bottom']:
-        answer = 'The caption at the %s side of the object.' % evalRes
-    elif evalRes in ['True', 'False']:
-        answer = 'There is at least one title object in this image.'
-    else:
-        answer = 'This image contain %s specific object(s).' % evalRes
-
-  return answer

spaces/Caoyunkang/Segment-Any-Anomaly/SAM/scripts/amg.py

@@ -1,238 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-import cv2  # type: ignore
-
-from SAM import SamAutomaticMaskGenerator, sam_model_registry
-
-import argparse
-import json
-import os
-from typing import Any, Dict, List
-
-parser = argparse.ArgumentParser(
-    description=(
-        "Runs automatic mask generation on an input image or directory of images, "
-        "and outputs masks as either PNGs or COCO-style RLEs. Requires open-cv, "
-        "as well as pycocotools if saving in RLE format."
-    )
-)
-
-parser.add_argument(
-    "--input",
-    type=str,
-    required=True,
-    help="Path to either a single input image or folder of images.",
-)
-
-parser.add_argument(
-    "--output",
-    type=str,
-    required=True,
-    help=(
-        "Path to the directory where masks will be output. Output will be either a folder "
-        "of PNGs per image or a single json with COCO-style masks."
-    ),
-)
-
-parser.add_argument(
-    "--model-type",
-    type=str,
-    default="default",
-    help="The type of model to load, in ['default', 'vit_l', 'vit_b']",
-)
-
-parser.add_argument(
-    "--checkpoint",
-    type=str,
-    required=True,
-    help="The path to the SAM checkpoint to use for mask generation.",
-)
-
-parser.add_argument("--device", type=str, default="cuda", help="The device to run generation on.")
-
-parser.add_argument(
-    "--convert-to-rle",
-    action="store_true",
-    help=(
-        "Save masks as COCO RLEs in a single json instead of as a folder of PNGs. "
-        "Requires pycocotools."
-    ),
-)
-
-amg_settings = parser.add_argument_group("AMG Settings")
-
-amg_settings.add_argument(
-    "--points-per-side",
-    type=int,
-    default=None,
-    help="Generate masks by sampling a grid over the image with this many points to a side.",
-)
-
-amg_settings.add_argument(
-    "--points-per-batch",
-    type=int,
-    default=None,
-    help="How many input points to process simultaneously in one batch.",
-)
-
-amg_settings.add_argument(
-    "--pred-iou-thresh",
-    type=float,
-    default=None,
-    help="Exclude masks with a predicted score from the model that is lower than this threshold.",
-)
-
-amg_settings.add_argument(
-    "--stability-score-thresh",
-    type=float,
-    default=None,
-    help="Exclude masks with a stability score lower than this threshold.",
-)
-
-amg_settings.add_argument(
-    "--stability-score-offset",
-    type=float,
-    default=None,
-    help="Larger values perturb the mask more when measuring stability score.",
-)
-
-amg_settings.add_argument(
-    "--box-nms-thresh",
-    type=float,
-    default=None,
-    help="The overlap threshold for excluding a duplicate mask.",
-)
-
-amg_settings.add_argument(
-    "--crop-n-layers",
-    type=int,
-    default=None,
-    help=(
-        "If >0, mask generation is run on smaller crops of the image to generate more masks. "
-        "The value sets how many different scales to crop at."
-    ),
-)
-
-amg_settings.add_argument(
-    "--crop-nms-thresh",
-    type=float,
-    default=None,
-    help="The overlap threshold for excluding duplicate masks across different crops.",
-)
-
-amg_settings.add_argument(
-    "--crop-overlap-ratio",
-    type=int,
-    default=None,
-    help="Larger numbers mean image crops will overlap more.",
-)
-
-amg_settings.add_argument(
-    "--crop-n-points-downscale-factor",
-    type=int,
-    default=None,
-    help="The number of points-per-side in each layer of crop is reduced by this factor.",
-)
-
-amg_settings.add_argument(
-    "--min-mask-region-area",
-    type=int,
-    default=None,
-    help=(
-        "Disconnected mask regions or holes with area smaller than this value "
-        "in pixels are removed by postprocessing."
-    ),
-)
-
-
-def write_masks_to_folder(masks: List[Dict[str, Any]], path: str) -> None:
-    header = "id,area,bbox_x0,bbox_y0,bbox_w,bbox_h,point_input_x,point_input_y,predicted_iou,stability_score,crop_box_x0,crop_box_y0,crop_box_w,crop_box_h"  # noqa
-    metadata = [header]
-    for i, mask_data in enumerate(masks):
-        mask = mask_data["segmentation"]
-        filename = f"{i}.png"
-        cv2.imwrite(os.path.join(path, filename), mask * 255)
-        mask_metadata = [
-            str(i),
-            str(mask_data["area"]),
-            *[str(x) for x in mask_data["bbox"]],
-            *[str(x) for x in mask_data["point_coords"][0]],
-            str(mask_data["predicted_iou"]),
-            str(mask_data["stability_score"]),
-            *[str(x) for x in mask_data["crop_box"]],
-        ]
-        row = ",".join(mask_metadata)
-        metadata.append(row)
-    metadata_path = os.path.join(path, "metadata.csv")
-    with open(metadata_path, "w") as f:
-        f.write("\n".join(metadata))
-
-    return
-
-
-def get_amg_kwargs(args):
-    amg_kwargs = {
-        "points_per_side": args.points_per_side,
-        "points_per_batch": args.points_per_batch,
-        "pred_iou_thresh": args.pred_iou_thresh,
-        "stability_score_thresh": args.stability_score_thresh,
-        "stability_score_offset": args.stability_score_offset,
-        "box_nms_thresh": args.box_nms_thresh,
-        "crop_n_layers": args.crop_n_layers,
-        "crop_nms_thresh": args.crop_nms_thresh,
-        "crop_overlap_ratio": args.crop_overlap_ratio,
-        "crop_n_points_downscale_factor": args.crop_n_points_downscale_factor,
-        "min_mask_region_area": args.min_mask_region_area,
-    }
-    amg_kwargs = {k: v for k, v in amg_kwargs.items() if v is not None}
-    return amg_kwargs
-
-
-def main(args: argparse.Namespace) -> None:
-    print("Loading model...")
-    sam = sam_model_registry[args.model_type](checkpoint=args.checkpoint)
-    _ = sam.to(device=args.device)
-    output_mode = "coco_rle" if args.convert_to_rle else "binary_mask"
-    amg_kwargs = get_amg_kwargs(args)
-    generator = SamAutomaticMaskGenerator(sam, output_mode=output_mode, **amg_kwargs)
-
-    if not os.path.isdir(args.input):
-        targets = [args.input]
-    else:
-        targets = [
-            f for f in os.listdir(args.input) if not os.path.isdir(os.path.join(args.input, f))
-        ]
-        targets = [os.path.join(args.input, f) for f in targets]
-
-    os.makedirs(args.output, exist_ok=True)
-
-    for t in targets:
-        print(f"Processing '{t}'...")
-        image = cv2.imread(t)
-        if image is None:
-            print(f"Could not load '{t}' as an image, skipping...")
-            continue
-        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
-
-        masks = generator.generate(image)
-
-        base = os.path.basename(t)
-        base = os.path.splitext(base)[0]
-        save_base = os.path.join(args.output, base)
-        if output_mode == "binary_mask":
-            os.makedirs(save_base, exist_ok=False)
-            write_masks_to_folder(masks, save_base)
-        else:
-            save_file = save_base + ".json"
-            with open(save_file, "w") as f:
-                json.dump(masks, f)
-    print("Done!")
-
-
-if __name__ == "__main__":
-    args = parser.parse_args()
-    main(args)

spaces/CikeyQI/Yunzai/Yunzai/plugins/ws-plugin/components/YamlReader.js

@@ -1,83 +0,0 @@
-import fs from 'fs'
-import YAML from 'yaml'
-import _ from 'lodash'
-import chokidar from 'chokidar'
-
-export default class YamlReader {
-  /**
-   * 读写yaml文件
-   *
-   * @param yamlPath yaml文件绝对路径
-   * @param isWatch 是否监听文件变化
-   */
-  constructor(yamlPath, isWatch = false) {
-    this.yamlPath = yamlPath
-    this.isWatch = isWatch
-    this.initYaml()
-  }
-
-  initYaml() {
-    // parseDocument 将会保留注释
-    this.document = YAML.parseDocument(fs.readFileSync(this.yamlPath, 'utf8'))
-    if (this.isWatch && !this.watcher) {
-      this.watcher = chokidar.watch(this.yamlPath).on('change', () => {
-        if (this.isSave) {
-          this.isSave = false
-          return
-        }
-        this.initYaml()
-      })
-    }
-  }
-
-  /** 返回读取的对象 */
-  get jsonData() {
-    if (!this.document) {
-      return null
-    }
-    return this.document.toJSON()
-  }
-
-  /* 检查集合是否包含key的值 */
-  has(keyPath) {
-    return this.document.hasIn(keyPath.split('.'))
-  }
-
-  /* 返回key的值 */
-  get(keyPath) {
-    return _.get(this.jsonData, keyPath)
-  }
-
-  /* 修改某个key的值 */
-  set(keyPath, value) {
-    this.document.setIn([keyPath], value)
-    this.save()
-  }
-
-  /* 删除key */
-  delete(keyPath) {
-    this.document.deleteIn(keyPath.split('.'))
-    this.save()
-  }
-
-  // 数组添加数据
-  addIn(keyPath, value) {
-    this.document.addIn(keyPath.split('.'), value)
-    this.save()
-  }
-
-  // 彻底删除某个key
-  deleteKey(keyPath) {
-    let keys = keyPath.split('.')
-    keys = this.mapParentKeys(keys)
-    this.document.deleteIn(keys)
-    this.save()
-  }
-
-  // 保存yaml文件，写入文件
-  save() {
-    this.isSave = true
-    let yaml = this.document.toString()
-    fs.writeFileSync(this.yamlPath, yaml, 'utf8')
-  }
-}

spaces/CognitiveLabs/Research-Assistant/statics/README_zh.md

@@ -1,41 +0,0 @@
-<div style="width: 100%;">
-    <img src="../statics/title.svg" style="width: 100%;">
-</div>
-
-受[gpt-researcher](https://github.com/assafelovic/gpt-researcher)启发，本项目提供了一种利用第三方API而不是官方API生成研究报告的替代方法。要访问此第三方API，请参阅[chimeragpt](https://chimeragpt.adventblocks.cc/)或者[GPT-API-free](https://github.com/chatanywhere/GPT_API_free)。一旦获得API密钥，您就可以使用它来访问chimeragpt API。因此，在运行项目之前，请确保您设置了环境变量`OPENAI_API_KEY`和`OPENAI_API_BASE`。
-
-```shell
-$ export OPENAI_API_KEY = your_api_key
-$ export OPENAI_API_BASE = your_api_base
-```
-
-或者您可以在`.env`文件中设置api密钥和基础。
-
-## 安装
-
-1. 克隆存储库
-
-    ```shell
-    $ git clone [email protected]:paradoxtown/ai_research_assistant.git
-    $ cd ai_research_assistant
-    ```
-
-2. 安装依赖项
-
-    ```shell
-    $ pip install -r requirements.txt
-    ```
-
-3. 导出环境变量
-
-    ```shell
-    $ export OPENAI_API_KEY = your_api_key
-    $ export OPENAI_API_BASE = your_api_base
-    ```
-    或修改`.env`文件。
-
-4. 运行项目
-
-    ```shell
-    $ python app.py
-    ```

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fastapi/templating.py

@@ -1 +0,0 @@
-from starlette.templating import Jinja2Templates as Jinja2Templates  # noqa

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/gradio/templates/frontend/assets/IconButton-abe5ede9.js

@@ -1,2 +0,0 @@
-import{S as I,e as k,s as w,N as m,O as p,k as q,K as f,U as b,p as g,M as _,o as v,Q as S,z,v as A,A as h,x as B,P as C,R as F,F as K}from"./index-3370be2a.js";import"./Button-89624748.js";function d(l){let e,i;return{c(){e=m("span"),i=C(l[1]),f(e,"class","svelte-1030q2h")},m(a,s){g(a,e,s),_(e,i)},p(a,s){s&2&&F(i,a[1])},d(a){a&&h(e)}}}function M(l){let e,i,a,s,o,c,r,n=l[2]&&d(l);return s=new l[0]({}),{c(){e=m("button"),n&&n.c(),i=p(),a=m("div"),q(s.$$.fragment),f(a,"class","svelte-1030q2h"),f(e,"aria-label",l[1]),f(e,"title",l[1]),f(e,"class","svelte-1030q2h"),b(e,"pending",l[3])},m(t,u){g(t,e,u),n&&n.m(e,null),_(e,i),_(e,a),v(s,a,null),o=!0,c||(r=S(e,"click",l[4]),c=!0)},p(t,[u]){t[2]?n?n.p(t,u):(n=d(t),n.c(),n.m(e,i)):n&&(n.d(1),n=null),(!o||u&2)&&f(e,"aria-label",t[1]),(!o||u&2)&&f(e,"title",t[1]),(!o||u&8)&&b(e,"pending",t[3])},i(t){o||(z(s.$$.fragment,t),o=!0)},o(t){A(s.$$.fragment,t),o=!1},d(t){t&&h(e),n&&n.d(),B(s),c=!1,r()}}}function N(l,e,i){let{Icon:a}=e,{label:s=""}=e,{show_label:o=!1}=e,{pending:c=!1}=e;function r(n){K.call(this,l,n)}return l.$$set=n=>{"Icon"in n&&i(0,a=n.Icon),"label"in n&&i(1,s=n.label),"show_label"in n&&i(2,o=n.show_label),"pending"in n&&i(3,c=n.pending)},[a,s,o,c,r]}class Q extends I{constructor(e){super(),k(this,e,N,M,w,{Icon:0,label:1,show_label:2,pending:3})}}export{Q as I};
-//# sourceMappingURL=IconButton-abe5ede9.js.map

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/huggingface_hub/utils/_paths.py

@@ -1,117 +0,0 @@
-# coding=utf-8
-# Copyright 2022-present, the HuggingFace Inc. team.
-#
-# 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.
-"""Contains utilities to handle paths in Huggingface Hub."""
-from fnmatch import fnmatch
-from pathlib import Path
-from typing import Callable, Generator, Iterable, List, Optional, TypeVar, Union
-
-
-T = TypeVar("T")
-
-IGNORE_GIT_FOLDER_PATTERNS = [".git", ".git/*", "*/.git", "**/.git/**"]
-
-
-def filter_repo_objects(
-    items: Iterable[T],
-    *,
-    allow_patterns: Optional[Union[List[str], str]] = None,
-    ignore_patterns: Optional[Union[List[str], str]] = None,
-    key: Optional[Callable[[T], str]] = None,
-) -> Generator[T, None, None]:
-    """Filter repo objects based on an allowlist and a denylist.
-
-    Input must be a list of paths (`str` or `Path`) or a list of arbitrary objects.
-    In the later case, `key` must be provided and specifies a function of one argument
-    that is used to extract a path from each element in iterable.
-
-    Patterns are Unix shell-style wildcards which are NOT regular expressions. See
-    https://docs.python.org/3/library/fnmatch.html for more details.
-
-    Args:
-        items (`Iterable`):
-            List of items to filter.
-        allow_patterns (`str` or `List[str]`, *optional*):
-            Patterns constituting the allowlist. If provided, item paths must match at
-            least one pattern from the allowlist.
-        ignore_patterns (`str` or `List[str]`, *optional*):
-            Patterns constituting the denylist. If provided, item paths must not match
-            any patterns from the denylist.
-        key (`Callable[[T], str]`, *optional*):
-            Single-argument function to extract a path from each item. If not provided,
-            the `items` must already be `str` or `Path`.
-
-    Returns:
-        Filtered list of objects, as a generator.
-
-    Raises:
-        :class:`ValueError`:
-            If `key` is not provided and items are not `str` or `Path`.
-
-    Example usage with paths:
-    ```python
-    >>> # Filter only PDFs that are not hidden.
-    >>> list(filter_repo_objects(
-    ...     ["aaa.PDF", "bbb.jpg", ".ccc.pdf", ".ddd.png"],
-    ...     allow_patterns=["*.pdf"],
-    ...     ignore_patterns=[".*"],
-    ... ))
-    ["aaa.pdf"]
-    ```
-
-    Example usage with objects:
-    ```python
-    >>> list(filter_repo_objects(
-    ... [
-    ...     CommitOperationAdd(path_or_fileobj="/tmp/aaa.pdf", path_in_repo="aaa.pdf")
-    ...     CommitOperationAdd(path_or_fileobj="/tmp/bbb.jpg", path_in_repo="bbb.jpg")
-    ...     CommitOperationAdd(path_or_fileobj="/tmp/.ccc.pdf", path_in_repo=".ccc.pdf")
-    ...     CommitOperationAdd(path_or_fileobj="/tmp/.ddd.png", path_in_repo=".ddd.png")
-    ... ],
-    ... allow_patterns=["*.pdf"],
-    ... ignore_patterns=[".*"],
-    ... key=lambda x: x.repo_in_path
-    ... ))
-    [CommitOperationAdd(path_or_fileobj="/tmp/aaa.pdf", path_in_repo="aaa.pdf")]
-    ```
-    """
-    if isinstance(allow_patterns, str):
-        allow_patterns = [allow_patterns]
-
-    if isinstance(ignore_patterns, str):
-        ignore_patterns = [ignore_patterns]
-
-    if key is None:
-
-        def _identity(item: T) -> str:
-            if isinstance(item, str):
-                return item
-            if isinstance(item, Path):
-                return str(item)
-            raise ValueError(f"Please provide `key` argument in `filter_repo_objects`: `{item}` is not a string.")
-
-        key = _identity  # Items must be `str` or `Path`, otherwise raise ValueError
-
-    for item in items:
-        path = key(item)
-
-        # Skip if there's an allowlist and path doesn't match any
-        if allow_patterns is not None and not any(fnmatch(path, r) for r in allow_patterns):
-            continue
-
-        # Skip if there's a denylist and path matches any
-        if ignore_patterns is not None and any(fnmatch(path, r) for r in ignore_patterns):
-            continue
-
-        yield item

spaces/Datasculptor/3D-Room-Layout-Estimation_LGT-Net/postprocessing/dula/layout_old.py

@@ -1,134 +0,0 @@
-""" 
-@Date: 2021/10/06
-@description: Use the approach proposed by DuLa-Net
-"""
-import cv2
-import numpy as np
-import math
-import matplotlib.pyplot as plt
-
-from visualization.floorplan import draw_floorplan
-
-
-def merge_near(lst, diag):
-    group = [[0, ]]
-    for i in range(1, len(lst)):
-        if lst[i] - np.mean(group[-1]) < diag * 0.02:
-            group[-1].append(lst[i])
-        else:
-            group.append([lst[i], ])
-    if len(group) == 1:
-        group = [lst[0], lst[-1]]
-    else:
-        group = [int(np.mean(x)) for x in group]
-    return group
-
-
-def fit_layout_old(floor_xz, need_cube=False, show=False, block_eps=0.05):
-    show_radius = np.linalg.norm(floor_xz, axis=-1).max()
-    side_l = 512
-    floorplan = draw_floorplan(xz=floor_xz, show_radius=show_radius, show=show, scale=1, side_l=side_l).astype(np.uint8)
-    center = np.array([side_l / 2, side_l / 2])
-    polys = cv2.findContours(floorplan, 1, 2)
-    if isinstance(polys, tuple):
-        if len(polys) == 3:
-            # opencv 3
-            polys = list(polys[1])
-        else:
-            polys = list(polys[0])
-    polys.sort(key=lambda x: cv2.contourArea(x), reverse=True)
-    poly = polys[0]
-    sub_x, sub_y, w, h = cv2.boundingRect(poly)
-    floorplan_sub = floorplan[sub_y:sub_y + h, sub_x:sub_x + w]
-    sub_center = center - np.array([sub_x, sub_y])
-    polys = cv2.findContours(floorplan_sub, 1, 2)
-    if isinstance(polys, tuple):
-        if len(polys) == 3:
-            polys = polys[1]
-        else:
-            polys = polys[0]
-    poly = polys[0]
-    epsilon = 0.005 * cv2.arcLength(poly, True)
-    poly = cv2.approxPolyDP(poly, epsilon, True)
-
-    x_lst = [0, ]
-    y_lst = [0, ]
-    for i in range(len(poly)):
-        p1 = poly[i][0]
-        p2 = poly[(i + 1) % len(poly)][0]
-
-        if (p2[0] - p1[0]) == 0:
-            slope = 10
-        else:
-            slope = abs((p2[1] - p1[1]) / (p2[0] - p1[0]))
-
-        if slope <= 1:
-            s = int((p1[1] + p2[1]) / 2)
-            y_lst.append(s)
-        elif slope > 1:
-            s = int((p1[0] + p2[0]) / 2)
-            x_lst.append(s)
-
-    x_lst.append(floorplan_sub.shape[1])
-    y_lst.append(floorplan_sub.shape[0])
-    x_lst.sort()
-    y_lst.sort()
-
-    diag = math.sqrt(math.pow(floorplan_sub.shape[1], 2) + math.pow(floorplan_sub.shape[0], 2))
-    x_lst = merge_near(x_lst, diag)
-    y_lst = merge_near(y_lst, diag)
-    if need_cube and len(x_lst) > 2:
-        x_lst = [x_lst[0], x_lst[-1]]
-    if need_cube and len(y_lst) > 2:
-        y_lst = [y_lst[0], y_lst[-1]]
-
-    ans = np.zeros((floorplan_sub.shape[0], floorplan_sub.shape[1]))
-    for i in range(len(x_lst) - 1):
-        for j in range(len(y_lst) - 1):
-            sample = floorplan_sub[y_lst[j]:y_lst[j + 1], x_lst[i]:x_lst[i + 1]]
-            score = 0 if sample.size == 0 else sample.mean()
-            if score >= 0.3:
-                ans[y_lst[j]:y_lst[j + 1], x_lst[i]:x_lst[i + 1]] = 1
-
-    pred = np.uint8(ans)
-    pred_polys = cv2.findContours(pred, 1, 3)
-    if isinstance(pred_polys, tuple):
-        if len(pred_polys) == 3:
-            pred_polys = pred_polys[1]
-        else:
-            pred_polys = pred_polys[0]
-
-    polygon = [(p[0][1], p[0][0]) for p in pred_polys[0][::-1]]
-
-    v = np.array([p[0] + sub_y for p in polygon])
-    u = np.array([p[1] + sub_x for p in polygon])
-    #     side_l
-    # v<-----------|o
-    # |     |      |
-    # | ----|----z |   side_l
-    # |     |      |
-    # |     x     \|/
-    # |------------u
-    side_l = floorplan.shape[0]
-    pred_xz = np.concatenate((u[:, np.newaxis] - side_l // 2, side_l // 2 - v[:, np.newaxis]), axis=1)
-
-    pred_xz = pred_xz * show_radius / (side_l // 2)
-    if show:
-        draw_floorplan(pred_xz, show_radius=show_radius, show=show)
-    return pred_xz
-
-
-if __name__ == '__main__':
-    from utils.conversion import uv2xyz
-
-    pano_img = np.zeros([512, 1024, 3])
-    corners = np.array([[0.1, 0.7],
-                        [0.4, 0.7],
-                        [0.3, 0.6],
-                        [0.6, 0.6],
-                        [0.8, 0.7]])
-    xz = uv2xyz(corners)[..., ::2]
-    draw_floorplan(xz, show=True, marker_color=None, center_color=0.8)
-
-    xz = fit_layout_old(xz)
-    draw_floorplan(xz, show=True, marker_color=None, center_color=0.8)

spaces/Datasculptor/StyleGAN-NADA/op/fused_bias_act.cpp

@@ -1,21 +0,0 @@
-#include <torch/extension.h>
-
-
-torch::Tensor fused_bias_act_op(const torch::Tensor& input, const torch::Tensor& bias, const torch::Tensor& refer,
-    int act, int grad, float alpha, float scale);
-
-#define CHECK_CUDA(x) TORCH_CHECK(x.type().is_cuda(), #x " must be a CUDA tensor")
-#define CHECK_CONTIGUOUS(x) TORCH_CHECK(x.is_contiguous(), #x " must be contiguous")
-#define CHECK_INPUT(x) CHECK_CUDA(x); CHECK_CONTIGUOUS(x)
-
-torch::Tensor fused_bias_act(const torch::Tensor& input, const torch::Tensor& bias, const torch::Tensor& refer,
-    int act, int grad, float alpha, float scale) {
-    CHECK_CUDA(input);
-    CHECK_CUDA(bias);
-
-    return fused_bias_act_op(input, bias, refer, act, grad, alpha, scale);
-}
-
-PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
-    m.def("fused_bias_act", &fused_bias_act, "fused bias act (CUDA)");
-}

spaces/DeepakJaiz/QA_evaluator/README.md

@@ -1,12 +0,0 @@
----
-title: QA Evaluator
-emoji: 👁
-colorFrom: gray
-colorTo: purple
-sdk: streamlit
-sdk_version: 1.21.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/Demosthene-OR/avr23-cds-translation/tabs/custom_vectorizer.py

@@ -1,14 +0,0 @@
-# Les 2 fonctions suivantes sont nécéssaires afin de sérialiser ces parametre de CountVectorizer
-# et ainsi de sauvegarder le vectorizer pour un un usage ultérieur sans utiliser X_train pour  le réinitialiser
-import tiktoken
-
-tokenizer = tiktoken.get_encoding("cl100k_base")
-
-def custom_tokenizer(text):
-    global tokenizer
-
-    tokens = tokenizer.encode(text)  # Cela divise le texte en mots
-    return tokens
-
-def custom_preprocessor(text):
-    return text

spaces/DragGan/DragGan-Inversion/PTI/training/coaches/base_coach.py

@@ -1,158 +0,0 @@
-import abc
-import os
-import pickle
-from argparse import Namespace
-import os.path
-from PTI.criteria.localitly_regulizer import Space_Regulizer
-import torch
-from torchvision import transforms
-from lpips import LPIPS
-from PTI.training.projectors import w_projector
-from PTI.configs import global_config, paths_config, hyperparameters
-from PTI.criteria import l2_loss
-from PTI.models.e4e.psp import pSp
-from PTI.utils.log_utils import log_image_from_w
-from PTI.utils.models_utils import toogle_grad, load_old_G
-
-
-class BaseCoach:
-    def __init__(self, data_loader, use_wandb):
-
-        self.use_wandb = use_wandb
-        self.data_loader = data_loader
-        self.w_pivots = {}
-        self.image_counter = 0
-
-        if hyperparameters.first_inv_type == 'w+':
-            self.initilize_e4e()
-
-        self.e4e_image_transform = transforms.Compose([
-            transforms.ToPILImage(),
-            transforms.Resize((256, 256)),
-            transforms.ToTensor(),
-            transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])])
-
-        # Initialize loss
-        self.lpips_loss = LPIPS(net=hyperparameters.lpips_type).to(
-            global_config.device).eval()
-
-        self.restart_training()
-
-        # Initialize checkpoint dir
-        self.checkpoint_dir = paths_config.checkpoints_dir
-        os.makedirs(self.checkpoint_dir, exist_ok=True)
-
-    def restart_training(self):
-
-        # Initialize networks
-        self.G = load_old_G()
-        toogle_grad(self.G, True)
-
-        self.original_G = load_old_G()
-
-        self.space_regulizer = Space_Regulizer(
-            self.original_G, self.lpips_loss)
-        self.optimizer = self.configure_optimizers()
-
-    def get_inversion(self, w_path_dir, image_name, image):
-        embedding_dir = f'{w_path_dir}/{paths_config.pti_results_keyword}/{image_name}'
-        os.makedirs(embedding_dir, exist_ok=True)
-
-        w_pivot = None
-        if hyperparameters.use_last_w_pivots:
-            w_pivot = self.load_inversions(w_path_dir, image_name)
-
-        if not hyperparameters.use_last_w_pivots or w_pivot is None:
-            w_pivot = self.calc_inversions(image, image_name)
-            torch.save(w_pivot, f'{embedding_dir}/0.pt')
-
-        w_pivot = w_pivot.to(global_config.device)
-        return w_pivot
-
-    def load_inversions(self, w_path_dir, image_name):
-        if image_name in self.w_pivots:
-            return self.w_pivots[image_name]
-
-        if hyperparameters.first_inv_type == 'w+':
-            w_potential_path = f'{w_path_dir}/{paths_config.e4e_results_keyword}/{image_name}/0.pt'
-        else:
-            w_potential_path = f'{w_path_dir}/{paths_config.pti_results_keyword}/{image_name}/0.pt'
-        if not os.path.isfile(w_potential_path):
-            return None
-        w = torch.load(w_potential_path).to(global_config.device)
-        self.w_pivots[image_name] = w
-        return w
-
-    def calc_inversions(self, image, image_name):
-        if hyperparameters.first_inv_type == 'w+':
-            w = self.get_e4e_inversion(image)
-
-        else:
-            id_image = torch.squeeze(
-                (image.to(global_config.device) + 1) / 2) * 255
-            w = w_projector.project(self.G, id_image, device=torch.device(global_config.device), w_avg_samples=600,
-                                    num_steps=hyperparameters.first_inv_steps, w_name=image_name,
-                                    use_wandb=self.use_wandb)
-
-        return w
-
-    @abc.abstractmethod
-    def train(self):
-        pass
-
-    def configure_optimizers(self):
-        optimizer = torch.optim.Adam(
-            self.G.parameters(), lr=hyperparameters.pti_learning_rate)
-
-        return optimizer
-
-    def calc_loss(self, generated_images, real_images, log_name, new_G, use_ball_holder, w_batch):
-        loss = 0.0
-
-        if hyperparameters.pt_l2_lambda > 0:
-            l2_loss_val = l2_loss.l2_loss(generated_images, real_images)
-            if self.use_wandb:
-                wandb.log({f'MSE_loss_val_{log_name}': l2_loss_val.detach(
-                ).cpu()}, step=global_config.training_step)
-            loss += l2_loss_val * hyperparameters.pt_l2_lambda
-        if hyperparameters.pt_lpips_lambda > 0:
-            loss_lpips = self.lpips_loss(generated_images, real_images)
-            loss_lpips = torch.squeeze(loss_lpips)
-            if self.use_wandb:
-                wandb.log({f'LPIPS_loss_val_{log_name}': loss_lpips.detach(
-                ).cpu()}, step=global_config.training_step)
-            loss += loss_lpips * hyperparameters.pt_lpips_lambda
-
-        if use_ball_holder and hyperparameters.use_locality_regularization:
-            ball_holder_loss_val = self.space_regulizer.space_regulizer_loss(
-                new_G, w_batch, use_wandb=self.use_wandb)
-            loss += ball_holder_loss_val
-
-        return loss, l2_loss_val, loss_lpips
-
-    def forward(self, w):
-        generated_images = self.G.synthesis(
-            w, noise_mode='const', force_fp32=True)
-
-        return generated_images
-
-    def initilize_e4e(self):
-        ckpt = torch.load(paths_config.e4e, map_location='cpu')
-        opts = ckpt['opts']
-        opts['batch_size'] = hyperparameters.train_batch_size
-        opts['checkpoint_path'] = paths_config.e4e
-        opts = Namespace(**opts)
-        self.e4e_inversion_net = pSp(opts)
-        self.e4e_inversion_net.eval()
-        self.e4e_inversion_net = self.e4e_inversion_net.to(
-            global_config.device)
-        toogle_grad(self.e4e_inversion_net, False)
-
-    def get_e4e_inversion(self, image):
-        image = (image + 1) / 2
-        new_image = self.e4e_image_transform(image[0]).to(global_config.device)
-        _, w = self.e4e_inversion_net(new_image.unsqueeze(0), randomize_noise=False, return_latents=True, resize=False,
-                                      input_code=False)
-        if self.use_wandb:
-            log_image_from_w(w, self.G, 'First e4e inversion')
-        return w

spaces/DragGan/DragGan-Inversion/PTI/training/projectors/w_plus_projector.py

@@ -1,145 +0,0 @@
-# Copyright (c) 2021, NVIDIA CORPORATION.  All rights reserved.
-#
-# NVIDIA CORPORATION and its licensors retain all intellectual property
-# and proprietary rights in and to this software, related documentation
-# and any modifications thereto.  Any use, reproduction, disclosure or
-# distribution of this software and related documentation without an express
-# license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-"""Project given image to the latent space of pretrained network pickle."""
-
-import copy
-import wandb
-import numpy as np
-import torch
-import torch.nn.functional as F
-from tqdm import tqdm
-from configs import global_config, hyperparameters
-import dnnlib
-from utils.log_utils import log_image_from_w
-
-
-def project(
-        G,
-        target: torch.Tensor,  # [C,H,W] and dynamic range [0,255], W & H must match G output resolution
-        *,
-        num_steps=1000,
-        w_avg_samples=10000,
-        initial_learning_rate=0.01,
-        initial_noise_factor=0.05,
-        lr_rampdown_length=0.25,
-        lr_rampup_length=0.05,
-        noise_ramp_length=0.75,
-        regularize_noise_weight=1e5,
-        verbose=False,
-        device: torch.device,
-        use_wandb=False,
-        initial_w=None,
-        image_log_step=global_config.image_rec_result_log_snapshot,
-        w_name: str
-):
-    assert target.shape == (G.img_channels, G.img_resolution, G.img_resolution)
-
-    def logprint(*args):
-        if verbose:
-            print(*args)
-
-    G = copy.deepcopy(G).eval().requires_grad_(False).to(device).float() # type: ignore
-
-    # Compute w stats.
-    logprint(f'Computing W midpoint and stddev using {w_avg_samples} samples...')
-    z_samples = np.random.RandomState(123).randn(w_avg_samples, G.z_dim)
-    w_samples = G.mapping(torch.from_numpy(z_samples).to(device), None)  # [N, L, C]
-    w_samples = w_samples[:, :1, :].cpu().numpy().astype(np.float32)  # [N, 1, C]
-    w_avg = np.mean(w_samples, axis=0, keepdims=True)  # [1, 1, C]
-    w_avg_tensor = torch.from_numpy(w_avg).to(global_config.device)
-    w_std = (np.sum((w_samples - w_avg) ** 2) / w_avg_samples) ** 0.5
-
-    start_w = initial_w if initial_w is not None else w_avg
-
-    # Setup noise inputs.
-    noise_bufs = {name: buf for (name, buf) in G.synthesis.named_buffers() if 'noise_const' in name}
-
-    # Load VGG16 feature detector.
-    url = 'https://nvlabs-fi-cdn.nvidia.com/stylegan2-ada-pytorch/pretrained/metrics/vgg16.pt'
-    with dnnlib.util.open_url(url) as f:
-        vgg16 = torch.jit.load(f).eval().to(device)
-
-    # Features for target image.
-    target_images = target.unsqueeze(0).to(device).to(torch.float32)
-    if target_images.shape[2] > 256:
-        target_images = F.interpolate(target_images, size=(256, 256), mode='area')
-    target_features = vgg16(target_images, resize_images=False, return_lpips=True)
-
-    start_w = np.repeat(start_w, G.mapping.num_ws, axis=1)
-    w_opt = torch.tensor(start_w, dtype=torch.float32, device=device,
-                         requires_grad=True)  # pylint: disable=not-callable
-
-    optimizer = torch.optim.Adam([w_opt] + list(noise_bufs.values()), betas=(0.9, 0.999),
-                                 lr=hyperparameters.first_inv_lr)
-
-    # Init noise.
-    for buf in noise_bufs.values():
-        buf[:] = torch.randn_like(buf)
-        buf.requires_grad = True
-
-    for step in tqdm(range(num_steps)):
-
-        # Learning rate schedule.
-        t = step / num_steps
-        w_noise_scale = w_std * initial_noise_factor * max(0.0, 1.0 - t / noise_ramp_length) ** 2
-        lr_ramp = min(1.0, (1.0 - t) / lr_rampdown_length)
-        lr_ramp = 0.5 - 0.5 * np.cos(lr_ramp * np.pi)
-        lr_ramp = lr_ramp * min(1.0, t / lr_rampup_length)
-        lr = initial_learning_rate * lr_ramp
-        for param_group in optimizer.param_groups:
-            param_group['lr'] = lr
-
-        # Synth images from opt_w.
-        w_noise = torch.randn_like(w_opt) * w_noise_scale
-        ws = (w_opt + w_noise)
-
-        synth_images = G.synthesis(ws, noise_mode='const', force_fp32=True)
-
-        # Downsample image to 256x256 if it's larger than that. VGG was built for 224x224 images.
-        synth_images = (synth_images + 1) * (255 / 2)
-        if synth_images.shape[2] > 256:
-            synth_images = F.interpolate(synth_images, size=(256, 256), mode='area')
-
-        # Features for synth images.
-        synth_features = vgg16(synth_images, resize_images=False, return_lpips=True)
-        dist = (target_features - synth_features).square().sum()
-
-        # Noise regularization.
-        reg_loss = 0.0
-        for v in noise_bufs.values():
-            noise = v[None, None, :, :]  # must be [1,1,H,W] for F.avg_pool2d()
-            while True:
-                reg_loss += (noise * torch.roll(noise, shifts=1, dims=3)).mean() ** 2
-                reg_loss += (noise * torch.roll(noise, shifts=1, dims=2)).mean() ** 2
-                if noise.shape[2] <= 8:
-                    break
-                noise = F.avg_pool2d(noise, kernel_size=2)
-        loss = dist + reg_loss * regularize_noise_weight
-
-        if step % image_log_step == 0:
-            with torch.no_grad():
-                if use_wandb:
-                    global_config.training_step += 1
-                    wandb.log({f'first projection _{w_name}': loss.detach().cpu()}, step=global_config.training_step)
-                    log_image_from_w(w_opt, G, w_name)
-
-        # Step
-        optimizer.zero_grad(set_to_none=True)
-        loss.backward()
-        optimizer.step()
-        logprint(f'step {step + 1:>4d}/{num_steps}: dist {dist:<4.2f} loss {float(loss):<5.2f}')
-
-        # Normalize noise.
-        with torch.no_grad():
-            for buf in noise_bufs.values():
-                buf -= buf.mean()
-                buf *= buf.square().mean().rsqrt()
-
-    del G
-    return w_opt

spaces/Dragonnext/charybdis/greeting.md

@@ -1,17 +0,0 @@
-
-It will open ALWAYS every Friday 6PM UTC, till monday 7AM UTC. (No gatekeeper) 
-
-
-(special proxy pass for non time frame access: Additional hints soon) 
-
-Hints: 
-
-All 62 unique words to get timeout (Including variations example > test + t3st)
-
-315 Minutes
-
-SillyTavern Hivemind.
-
-https://pastebin.com/DhKk9w92
-
-Formating: all LOWERCASE no SPACES, first need to be ordered ALPHABETICALLY (Special character included, and should be first), cyrilic excluded (200 first letters, exclude the rest, due to ST proxy password limit being 200)

spaces/EsoCode/text-generation-webui/modules/sampler_hijack.py

@@ -1,204 +0,0 @@
-import math
-
-import torch
-import transformers
-from transformers import LogitsWarper
-from transformers.generation.logits_process import (
-    LogitNormalization,
-    LogitsProcessor,
-    LogitsProcessorList,
-    TemperatureLogitsWarper
-)
-
-
-class TailFreeLogitsWarper(LogitsWarper):
-    def __init__(self, tfs: float, filter_value: float = -float("Inf"), min_tokens_to_keep: int = 1):
-        tfs = float(tfs)
-        if tfs < 0 or tfs > 1.0:
-            raise ValueError(f"`tfs` has to be a float >= 0 and <= 1, but is {tfs}")
-        self.tfs = tfs
-        self.filter_value = filter_value
-        self.min_tokens_to_keep = min_tokens_to_keep
-
-    def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor) -> torch.FloatTensor:
-        sorted_logits, sorted_indices = torch.sort(scores, descending=True)
-        probs = sorted_logits.softmax(dim=-1)
-
-        # Compute second derivative normalized CDF
-        d2 = probs.diff().diff().abs()
-        normalized_d2 = d2 / d2.sum(dim=-1, keepdim=True)
-        normalized_d2_cdf = normalized_d2.cumsum(dim=-1)
-
-        # Remove tokens with CDF value above the threshold (token with 0 are kept)
-        sorted_indices_to_remove = normalized_d2_cdf > self.tfs
-
-        # Centre the distribution around the cutoff as in the original implementation of the algorithm
-        sorted_indices_to_remove = torch.cat(
-            (
-                torch.zeros(scores.shape[0], 1, dtype=torch.bool, device=scores.device),
-                sorted_indices_to_remove,
-                torch.ones(scores.shape[0], 1, dtype=torch.bool, device=scores.device),
-            ),
-            dim=-1,
-        )
-
-        if self.min_tokens_to_keep > 1:
-            # Keep at least min_tokens_to_keep
-            sorted_indices_to_remove[..., : self.min_tokens_to_keep] = 0
-
-        indices_to_remove = sorted_indices_to_remove.scatter(1, sorted_indices, sorted_indices_to_remove)
-        scores = scores.masked_fill(indices_to_remove, self.filter_value)
-        return scores
-
-
-class TopALogitsWarper(LogitsWarper):
-    def __init__(self, top_a: float, filter_value: float = -float("Inf"), min_tokens_to_keep: int = 1):
-        top_a = float(top_a)
-        if top_a < 0 or top_a > 1.0:
-            raise ValueError(f"`top_a` has to be a float >= 0 and <= 1, but is {top_a}")
-        self.top_a = top_a
-        self.filter_value = filter_value
-        self.min_tokens_to_keep = min_tokens_to_keep
-
-    def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor) -> torch.FloatTensor:
-        sorted_logits, sorted_indices = torch.sort(scores, descending=True)
-        probs = sorted_logits.softmax(dim=-1)
-
-        # Remove tokens with probability less than top_a*(max(probs))^2 (token with 0 are kept)
-        probs_max = probs[..., 0, None]
-        sorted_indices_to_remove = probs < probs_max * probs_max * self.top_a
-
-        if self.min_tokens_to_keep > 1:
-            # Keep at least min_tokens_to_keep
-            sorted_indices_to_remove[..., : self.min_tokens_to_keep] = 0
-
-        indices_to_remove = sorted_indices_to_remove.scatter(1, sorted_indices, sorted_indices_to_remove)
-        scores = scores.masked_fill(indices_to_remove, self.filter_value)
-        return scores
-
-
-class MirostatLogitsWarper(LogitsWarper):
-    def __init__(self, mirostat_mode: int, mirostat_tau: float, mirostat_eta: float, filter_value: float = -float("Inf"), min_tokens_to_keep: int = 1):
-        if mirostat_mode not in [2]:
-            raise ValueError(f"`mirostat` has to be a an integer 2, but is {mirostat_mode}")
-        self.mirostat_mode = mirostat_mode
-        self.mirostat_eta = mirostat_eta
-        self.mirostat_tau = mirostat_tau
-        self.filter_value = filter_value
-        self.min_tokens_to_keep = min_tokens_to_keep
-        self.mu = 2 * self.mirostat_tau
-        self.e = 0
-
-    def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor) -> torch.FloatTensor:
-        logits = scores[0]
-        sorted_logits, sorted_indices = torch.sort(logits, descending=True)
-        prob_original = torch.softmax(sorted_logits, dim=-1).tolist()  # candidates
-
-        # Truncate the words with surprise values greater than mu
-        for i, candidate in enumerate(prob_original):
-            if candidate > 0 and -math.log2(candidate) > self.mu:
-                if (i == 0):
-                    sorted_logits = sorted_logits[:1]
-                else:
-                    sorted_logits = sorted_logits[:i]
-                break
-
-        # Normalize the probabilities of the remaining words
-        prob_topk = torch.softmax(sorted_logits, dim=0)
-
-        prev_i = torch.multinomial(prob_topk, num_samples=1, replacement=True).to('cuda')
-
-        observed_surprise = -math.log2(prob_topk[prev_i])
-        self.e = observed_surprise - self.mirostat_tau
-
-        # Update mu using the learning rate and error
-        self.mu -= self.mirostat_eta * self.e
-
-        sorted_indices_to_remove = torch.ones_like(scores[0], dtype=torch.bool)
-        sorted_indices_to_remove[prev_i] = False
-
-        indices_to_remove = sorted_indices_to_remove.unsqueeze(0).scatter(1, sorted_indices.unsqueeze(0), sorted_indices_to_remove.unsqueeze(0))
-        scores = scores.masked_fill(indices_to_remove, self.filter_value)
-        return scores
-
-
-class RepetitionPenaltyLogitsProcessorWithRange(LogitsProcessor):
-    '''
-    Copied from the transformers library
-    '''
-    def __init__(self, penalty: float, _range: int):
-        if not isinstance(penalty, float) or not (penalty > 0):
-            raise ValueError(f"`penalty` has to be a strictly positive float, but is {penalty}")
-
-        self.penalty = penalty
-        self._range = _range
-
-    def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor) -> torch.FloatTensor:
-
-        input_ids = input_ids[:, -self._range:]
-        score = torch.gather(scores, 1, input_ids)
-
-        # if score < 0 then repetition penalty has to be multiplied to reduce the previous token probability
-        score = torch.where(score < 0, score * self.penalty, score / self.penalty)
-
-        scores.scatter_(1, input_ids, score)
-        return scores
-
-
-def get_logits_warper_patch(self, generation_config):
-    warpers = self._get_logits_warper_old(generation_config)
-    warpers_to_add = LogitsProcessorList()
-    min_tokens_to_keep = 2 if generation_config.num_beams > 1 else 1
-
-    if generation_config.mirostat_mode is not None and generation_config.mirostat_mode == 2:
-        warpers_to_add.append(MirostatLogitsWarper(mirostat_mode=generation_config.mirostat_mode, mirostat_eta=generation_config.mirostat_eta, mirostat_tau=generation_config.mirostat_tau, min_tokens_to_keep=min_tokens_to_keep))
-        # We need to disable samplers other than temperature
-        for warper in warpers:
-            if not isinstance(warper, TemperatureLogitsWarper):
-                warpers.remove(warper)
-    else:
-        if generation_config.tfs is not None and 0.0 <= generation_config.tfs <= 1.0:
-            warpers_to_add.append(TailFreeLogitsWarper(tfs=generation_config.tfs, min_tokens_to_keep=min_tokens_to_keep))
-        if generation_config.top_a is not None and 0.0 <= generation_config.top_a <= 1.0:
-            warpers_to_add.append(TopALogitsWarper(top_a=generation_config.top_a, min_tokens_to_keep=min_tokens_to_keep))
-
-    if warpers and isinstance(warpers[-1], LogitNormalization):
-        warpers = warpers[:-1] + warpers_to_add + [warpers[-1]]
-    else:
-        warpers += warpers_to_add
-
-    return warpers
-
-
-def get_logits_processor_patch(self, **kwargs):
-    result = self._get_logits_processor_old(**kwargs)
-    repetition_penalty_range = kwargs['generation_config'].repetition_penalty_range
-    repetition_penalty = kwargs['generation_config'].repetition_penalty
-
-    if repetition_penalty_range > 0:
-        for i in range(len(result)):
-            if result[i].__class__.__name__ == 'RepetitionPenaltyLogitsProcessor':
-                result[i] = RepetitionPenaltyLogitsProcessorWithRange(repetition_penalty, repetition_penalty_range)
-
-    return result
-
-
-def generation_config_init_patch(self, **kwargs):
-    self.__init___old(**kwargs)
-    self.tfs = kwargs.pop("tfs", 1.0)
-    self.top_a = kwargs.pop("top_a", 0.0)
-    self.mirostat_mode = kwargs.pop("mirostat_mode", 0)
-    self.mirostat_eta = kwargs.pop("mirostat_eta", 0.1)
-    self.mirostat_tau = kwargs.pop("mirostat_tau", 5)
-    self.repetition_penalty_range = kwargs.pop("repetition_penalty_range", 0)
-
-
-def hijack_samplers():
-    transformers.GenerationMixin._get_logits_warper_old = transformers.GenerationMixin._get_logits_warper
-    transformers.GenerationMixin._get_logits_warper = get_logits_warper_patch
-
-    transformers.GenerationMixin._get_logits_processor_old = transformers.GenerationMixin._get_logits_processor
-    transformers.GenerationMixin._get_logits_processor = get_logits_processor_patch
-
-    transformers.GenerationConfig.__init___old = transformers.GenerationConfig.__init__
-    transformers.GenerationConfig.__init__ = generation_config_init_patch

spaces/EuroPython2022/mmocr-demo/configs/textdet/maskrcnn/mask_rcnn_r50_fpn_160e_icdar2015.py

@@ -1,33 +0,0 @@
-_base_ = [
-    '../../_base_/default_runtime.py',
-    '../../_base_/det_models/ocr_mask_rcnn_r50_fpn_ohem.py',
-    '../../_base_/schedules/schedule_sgd_160e.py',
-    '../../_base_/det_datasets/icdar2015.py',
-    '../../_base_/det_pipelines/maskrcnn_pipeline.py'
-]
-
-train_list = {{_base_.train_list}}
-test_list = {{_base_.test_list}}
-
-train_pipeline = {{_base_.train_pipeline}}
-test_pipeline_icdar2015 = {{_base_.test_pipeline_icdar2015}}
-
-data = dict(
-    samples_per_gpu=8,
-    workers_per_gpu=4,
-    val_dataloader=dict(samples_per_gpu=1),
-    test_dataloader=dict(samples_per_gpu=1),
-    train=dict(
-        type='UniformConcatDataset',
-        datasets=train_list,
-        pipeline=train_pipeline),
-    val=dict(
-        type='UniformConcatDataset',
-        datasets=test_list,
-        pipeline=test_pipeline_icdar2015),
-    test=dict(
-        type='UniformConcatDataset',
-        datasets=test_list,
-        pipeline=test_pipeline_icdar2015))
-
-evaluation = dict(interval=10, metric='hmean-iou')

spaces/Evanell/Venus/README.md

@@ -1,10 +0,0 @@
----
-title: Venus
-emoji: ⚡
-colorFrom: gray
-colorTo: green
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/FourthBrainGenAI/DeepLearningAIDemoChatBot/app.py

@@ -1,281 +0,0 @@
-import torch
-from peft import PeftModel    
-from transformers import AutoModelForCausalLM, AutoTokenizer, LlamaTokenizer, StoppingCriteria, StoppingCriteriaList, TextIteratorStreamer
-import datetime
-import os
-from threading import Event, Thread
-from uuid import uuid4
-import gradio as gr
-import requests
-
-model_name = "decapoda-research/llama-13b-hf"
-adapters_name = 'timdettmers/guanaco-13b'
-
-print(f"Starting to load the model {model_name} into memory")
-
-model = AutoModelForCausalLM.from_pretrained(
-    model_name,
-    load_in_4bit=True,
-    torch_dtype=torch.bfloat16,
-    device_map={"": 0}
-)
-
-model = PeftModel.from_pretrained(model, adapters_name)
-tokenizer = LlamaTokenizer.from_pretrained(model_name)
-tokenizer.bos_token_id = 1
-stop_token_ids = [0]
-
-max_new_tokens = 2048
-
-start_message = """A chat between a human user and a kind AI. The assistant gives helpful, cordial, and polite answers to the user's questions."""
-
-class StopOnTokens(StoppingCriteria):
-    def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor, **kwargs) -> bool:
-        for stop_id in stop_token_ids:
-            if input_ids[0][-1] == stop_id:
-                return True
-        return False
-
-
-def convert_history_to_text(history):
-    text = start_message + "".join(
-        [
-            "".join(
-                [
-                    f"### Human: {item[0]}\n",
-                    f"### Assistant: {item[1]}\n",
-                ]
-            )
-            for item in history[:-1]
-        ]
-    )
-    text += "".join(
-        [
-            "".join(
-                [
-                    f"### Human: {history[-1][0]}\n",
-                    f"### Assistant: {history[-1][1]}\n",
-                ]
-            )
-        ]
-    )
-    return text
-
-
-def log_conversation(conversation_id, history, messages, generate_kwargs):
-    logging_url = os.getenv("LOGGING_URL", None)
-    if logging_url is None:
-        return
-
-    timestamp = datetime.datetime.now().strftime("%Y-%m-%dT%H:%M:%S")
-
-    data = {
-        "conversation_id": conversation_id,
-        "timestamp": timestamp,
-        "history": history,
-        "messages": messages,
-        "generate_kwargs": generate_kwargs,
-    }
-
-    try:
-        requests.post(logging_url, json=data)
-    except requests.exceptions.RequestException as e:
-        print(f"Error logging conversation: {e}")
-
-
-def user(message, history):
-    # Append the user's message to the conversation history
-    return "", history + [[message, ""]]
-
-
-def bot(history, temperature, top_p, top_k, repetition_penalty, conversation_id):
-    print(f"history: {history}")
-    # Initialize a StopOnTokens object
-    stop = StopOnTokens()
-
-    # Construct the input message string for the model by concatenating the current system message and conversation history
-    messages = convert_history_to_text(history)
-
-    # Tokenize the messages string
-    input_ids = tokenizer(messages, return_tensors="pt").input_ids
-    input_ids = input_ids.to(model.device)
-    streamer = TextIteratorStreamer(tokenizer, timeout=10.0, skip_prompt=True, skip_special_tokens=True)
-    generate_kwargs = dict(
-        input_ids=input_ids,
-        max_new_tokens=max_new_tokens,
-        temperature=temperature,
-        do_sample=temperature > 0.0,
-        top_p=top_p,
-        top_k=top_k,
-        repetition_penalty=repetition_penalty,
-        streamer=streamer,
-        stopping_criteria=StoppingCriteriaList([stop]),
-    )
-
-    stream_complete = Event()
-
-    def generate_and_signal_complete():
-        model.generate(**generate_kwargs)
-        stream_complete.set()
-
-    def log_after_stream_complete():
-        stream_complete.wait()
-        log_conversation(
-            conversation_id,
-            history,
-            messages,
-            {
-                "top_k": top_k,
-                "top_p": top_p,
-                "temperature": temperature,
-                "repetition_penalty": repetition_penalty,
-            },
-        )
-
-    t1 = Thread(target=generate_and_signal_complete)
-    t1.start()
-
-    t2 = Thread(target=log_after_stream_complete)
-    t2.start()
-
-    # Initialize an empty string to store the generated text
-    partial_text = ""
-    for new_text in streamer:
-        partial_text += new_text
-        history[-1][1] = partial_text
-        yield history
-
-
-def get_uuid():
-    return str(uuid4())
-
-
-with gr.Blocks(
-    theme=gr.themes.Soft(),
-    css=".disclaimer {font-variant-caps: all-small-caps;}",
-) as demo:
-    conversation_id = gr.State(get_uuid)
-    gr.Markdown(
-        """<h1><center>FourthBrain DeepLearningAI ChatBot Demo</center></h1>
-"""
-    )
-    chatbot = gr.Chatbot().style(height=500)
-    with gr.Row():
-        with gr.Column():
-            msg = gr.Textbox(
-                label="Chat Message Box",
-                placeholder="Chat Message Box",
-                show_label=False,
-            ).style(container=False)
-        with gr.Column():
-            with gr.Row():
-                submit = gr.Button("Submit")
-                stop = gr.Button("Stop")
-                clear = gr.Button("Clear")
-    with gr.Row():
-        with gr.Accordion("Advanced Options:", open=False):
-            with gr.Row():
-                with gr.Column():
-                    with gr.Row():
-                        temperature = gr.Slider(
-                            label="Temperature",
-                            value=0.7,
-                            minimum=0.0,
-                            maximum=1.0,
-                            step=0.1,
-                            interactive=True,
-                            info="Higher values produce more diverse outputs",
-                        )
-                with gr.Column():
-                    with gr.Row():
-                        top_p = gr.Slider(
-                            label="Top-p (nucleus sampling)",
-                            value=0.9,
-                            minimum=0.0,
-                            maximum=1,
-                            step=0.01,
-                            interactive=True,
-                            info=(
-                                "Sample from the smallest possible set of tokens whose cumulative probability "
-                                "exceeds top_p. Set to 1 to disable and sample from all tokens."
-                            ),
-                        )
-                with gr.Column():
-                    with gr.Row():
-                        top_k = gr.Slider(
-                            label="Top-k",
-                            value=0,
-                            minimum=0.0,
-                            maximum=200,
-                            step=1,
-                            interactive=True,
-                            info="Sample from a shortlist of top-k tokens — 0 to disable and sample from all tokens.",
-                        )
-                with gr.Column():
-                    with gr.Row():
-                        repetition_penalty = gr.Slider(
-                            label="Repetition Penalty",
-                            value=1.1,
-                            minimum=1.0,
-                            maximum=2.0,
-                            step=0.1,
-                            interactive=True,
-                            info="Penalize repetition — 1.0 to disable.",
-                        )
-    with gr.Row():
-        gr.Markdown(
-            "Disclaimer: The model can produce factually incorrect output, and should not be relied on to produce "
-            "factually accurate information. The model was trained on various public datasets; while great efforts "
-            "have been taken to clean the pretraining data, it is possible that this model could generate lewd, "
-            "biased, or otherwise offensive outputs.",
-            elem_classes=["disclaimer"],
-        )
-
-    submit_event = msg.submit(
-        fn=user,
-        inputs=[msg, chatbot],
-        outputs=[msg, chatbot],
-        queue=False,
-    ).then(
-        fn=bot,
-        inputs=[
-            chatbot,
-            temperature,
-            top_p,
-            top_k,
-            repetition_penalty,
-            conversation_id,
-        ],
-        outputs=chatbot,
-        queue=True,
-    )
-    submit_click_event = submit.click(
-        fn=user,
-        inputs=[msg, chatbot],
-        outputs=[msg, chatbot],
-        queue=False,
-    ).then(
-        fn=bot,
-        inputs=[
-            chatbot,
-            temperature,
-            top_p,
-            top_k,
-            repetition_penalty,
-            conversation_id,
-        ],
-        outputs=chatbot,
-        queue=True,
-    )
-    stop.click(
-        fn=None,
-        inputs=None,
-        outputs=None,
-        cancels=[submit_event, submit_click_event],
-        queue=False,
-    )
-    clear.click(lambda: None, None, chatbot, queue=False)
-
-demo.queue(max_size=128, concurrency_count=2)
-
-demo.launch()