Update parquet files (step 20 of 476)

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Download PATCHED Facebook Messenger For Samsung Gt-e2252 Tools Sesiones Speed.md

@@ -1,32 +0,0 @@
-
-<h1>How to Download Facebook Messenger for Samsung E2252</h1>
-<p>Facebook Messenger is a popular app that allows you to chat with your friends and family on the social media platform. You can also send text messages, images, videos, stickers, voice notes, and more in free group chats. But how can you download Facebook Messenger for Samsung E2252, a feature phone that runs on a proprietary operating system?</p>
-<h2>Download Facebook Messenger For Samsung Gt-e2252 tools sesiones speed</h2><br /><p><b><b>DOWNLOAD</b> &hArr; <a href="https://byltly.com/2uKwkO">https://byltly.com/2uKwkO</a></b></p><br /><br />
-<p>In this article, we will show you the steps to download and install Facebook Messenger for Samsung E2252 using a third-party website called Apkpure. Apkpure is a website that offers free APK files of various apps and games for Android devices. APK files are the installation packages that contain all the necessary files and data for an app to run on your device.</p>
-<p>Before we begin, please note that downloading and installing APK files from unknown sources may pose some risks to your device and personal data. You should only download APK files from trusted and verified websites, and scan them with an antivirus software before opening them. We are not responsible for any damage or loss that may occur as a result of following this guide.</p>
-<h2>Steps to Download Facebook Messenger for Samsung E2252</h2>
-<ol>
-<li>On your Samsung E2252, open the browser app and go to <a href="https://apkpure.com/facebook-messenger/com.facebook.orca">https://apkpure.com/facebook-messenger/com.facebook.orca</a>. This is the official page of Facebook Messenger on Apkpure.</li>
-<li>Scroll down and tap on the green "Download APK" button. This will start downloading the APK file of Facebook Messenger to your device.</li>
-<li>Once the download is complete, go to your file manager app and locate the downloaded APK file. It should be in the "Downloads" folder or a similar location.</li>
-<li>Tap on the APK file to open it. You may see a warning message that says "Install blocked" or "For security, your phone is set to block installation of apps obtained from unknown sources". If you see this message, tap on "Settings" and enable the option to allow installation of apps from unknown sources. You may need to enter your password or PIN to confirm this action.</li>
-<li>After enabling the option, go back to the APK file and tap on it again. You should see a screen that shows the app's permissions and information. Tap on "Install" to start installing Facebook Messenger on your device.</li>
-<li>Wait for the installation process to finish. You should see a message that says "App installed" when it is done.</li>
-<li>Tap on "Open" to launch Facebook Messenger on your device. You may need to sign in with your Facebook account or create a new one if you don't have one already.</li>
-</ol>
-<p>Congratulations! You have successfully downloaded and installed Facebook Messenger for Samsung E2252. You can now enjoy chatting with your friends and family on Facebook using this app.</p>
-<p></p><h2>Tips and Tricks for Using Facebook Messenger on Samsung E2252</h2>
-<p>Now that you have Facebook Messenger on your device, you may want to know some tips and tricks to make the most out of it. Here are some of them:</p>
-<ul>
-<li>To access the app's settings, tap on your profile picture in the top left corner of the screen. Here you can change your name, photo, status, notifications, chat colors, emoji, and more.</li>
-<li>To start a new chat, tap on the blue "+" icon in the bottom right corner of the screen. You can search for a contact by name or phone number, or scan a QR code to add them. You can also create a group chat by selecting multiple contacts.</li>
-<li>To send a message, type it in the text box at the bottom of the chat screen and tap on the send icon. You can also send voice notes by tapping and holding the microphone icon, or send photos and videos by tapping on the camera icon. To send stickers, GIFs, or emojis, tap on the smiley icon.</li>
-<li>To make a voice or video call, tap on the phone or video icon in the top right corner of the chat screen. You can also switch between voice and video during a call by tapping on the same icons. To end a call, tap on the red hang up icon.</li>
-<li>To delete a message, tap and hold on it and select "Delete". You can also delete an entire chat by tapping and holding on it in the main screen and selecting "Delete". Note that deleting a message or chat will only remove it from your device, not from the other person's device.</li>
-<li>To archive a chat, swipe left on it in the main screen and select "Archive". This will hide the chat from your main screen but you can still access it by tapping on the search icon and typing the contact's name. To unarchive a chat, swipe left on it in the search screen and select "Unarchive".</li>
-<li>To mute a chat, swipe left on it in the main screen and select "Mute". This will stop receiving notifications from that chat until you unmute it. To unmute a chat, swipe left on it in the main screen and select "Unmute".</li>
-<li>To block a contact, tap on their name or profile picture in the chat screen and select "Block". This will prevent them from sending you messages or calling you. To unblock a contact, tap on their name or profile picture in the chat screen and select "Unblock".</li>
-</ul>
-<p>These are some of the tips and tricks for using Facebook Messenger on Samsung E2252. We hope you find them useful and enjoy using this app.</p> 81aa517590<br />
-<br />
-<br />

spaces/1gistliPinn/ChatGPT4/Examples/Carte Maroc Format Fbl.md

@@ -1,6 +0,0 @@
-<h2>Carte maroc format fbl</h2><br /><p><b><b>Download Zip</b> &#10001; &#10001; &#10001; <a href="https://imgfil.com/2uxYoa">https://imgfil.com/2uxYoa</a></b></p><br /><br />
-
- 3cee63e6c2<br />
-<br />
-<br />
-<p></p>

spaces/1phancelerku/anime-remove-background/City of Angels - The Masterpiece by Thirty Seconds to Mars How to Download MP3.md

@@ -1,116 +0,0 @@
-
-<h1>City of Angels MP3 Download 30 Seconds to Mars</h1>
-<p>If you are looking for a song that will inspire you, touch your emotions, and make you feel alive, then you should check out City of Angels by 30 Seconds to Mars. This song is one of the most popular and acclaimed tracks by the American rock band, and it has a lot to offer to the listeners. In this article, we will tell you everything you need to know about City of Angels, and how you can download it as an MP3 file for your convenience.</p>
- <h2>What is City of Angels by 30 Seconds to Mars?</h2>
-<p>City of Angels is a song by 30 Seconds to Mars, released in 2013 as the fourth single from their fourth studio album, Love Lust Faith + Dreams. The song was written and produced by the lead vocalist and founder of the band, Jared Leto, who also directed the music video and the short film based on the song.</p>
-<h2>city of angels mp3 download 30 seconds to mars</h2><br /><p><b><b>DOWNLOAD</b> &#10084; <a href="https://jinyurl.com/2uNNFd">https://jinyurl.com/2uNNFd</a></b></p><br /><br />
- <h3>The meaning and inspiration behind the song</h3>
-<p>City of Angels is a tribute to Los Angeles, the city where 30 Seconds to Mars was formed and where they achieved their success. The song explores the themes of dreams, hopes, struggles, and realities that people face in the city, as well as the beauty and diversity that it offers. Jared Leto said that he wanted to capture the spirit and essence of Los Angeles in the song, and that he was inspired by his own personal experiences and stories from other people who live or have lived in the city.</p>
- <h3>The music video and the short film</h3>
-<p>The music video for City of Angels was released in October 2013, and it features a series of interviews with various celebrities, artists, musicians, athletes, and ordinary people who share their thoughts and feelings about Los Angeles. Some of the famous faces that appear in the video include Kanye West, James Franco, Selena Gomez, Lindsay Lohan, Olivia Wilde, Steve Nash, Corey Feldman, Ashley Olsen, Alan Cumming, Juliette Lewis, Shaun White, Lily Collins, and many more. The video also shows scenes of the band performing the song in different locations around the city.</p>
-<p>The short film for City of Angels was released in November 2013, and it is an extended version of the music video that runs for about 11 minutes. The short film includes more interviews and footage that were not shown in the music video, as well as some additional narration by Jared Leto. The short film was praised by critics and fans alike for its artistic vision and emotional impact.</p>
- <h2>How to download City of Angels MP3 by 30 Seconds to Mars?</h2>
-<p>If you want to enjoy City of Angels by 30 Seconds to Mars anytime and anywhere, you might want to download it as an MP3 file that you can store on your device or transfer to other devices. There are several ways you can do this, depending on your preferences and budget.</p>
- <h3>The official sources and platforms</h3>
-<p>The most recommended way to download City of Angels MP3 by 30 Seconds to Mars is to use the official sources and platforms that are authorized by the band and their record label. This way, you can support the band financially and legally, as well as get the best quality and security for your download. Some of the official sources and platforms that you can use are:</p>
-<ul>
-<li>iTunes: You can buy City of Angels as a single track or as part of the Love Lust Faith + Dreams album on iTunes for $1.29 or $9.99 respectively. You can also stream it on Apple Music if you have a subscription.</li>
-<li>Amazon: You <li>Amazon: You can buy City of Angels as a single track or as part of the Love Lust Faith + Dreams album on Amazon for $1.29 or $9.99 respectively. You can also stream it on Amazon Music if you have a subscription.</li>
-<li>Spotify: You can stream City of Angels on Spotify if you have a subscription, or listen to it with ads if you use the free version. You can also download it for offline listening if you have a premium account.</li>
-<li>YouTube: You can watch the music video or the short film for City of Angels on YouTube for free, or buy the song as an MP3 file for $1.29 on YouTube Music.</li>
-</ul>
- <h3>The alternative methods and tools</h3>
-<p>If you don't want to use the official sources and platforms, or if you want to save some money, you can also try some alternative methods and tools to download City of Angels MP3 by 30 Seconds to Mars. However, you should be aware that these methods and tools are not endorsed by the band or their record label, and they may violate some copyright laws or terms of service. You should also be careful about the quality and security of your download, as some of these methods and tools may contain viruses, malware, or spyware. Some of the alternative methods and tools that you can use are:</p>
-<ul>
-<li>Online converters: You can use some online converters that allow you to convert YouTube videos or other online audio files into MP3 files that you can download. Some examples of these online converters are YTMP3, MP3FY, and OnlineVideoConverter. You just need to copy and paste the URL of the video or audio file that you want to convert, choose the output format and quality, and click on the download button.</li>
-<li>Desktop software: You can use some desktop software that allow you to download YouTube videos or other online audio files as MP3 files. Some examples of these desktop software are 4K Video Downloader, Freemake Video Downloader, and Any Video Converter. You just need to install the software on your computer, copy and paste the URL of the video or audio file that you want to download, choose the output format and quality, and click on the download button.</li>
-<li>Mobile apps: You can use some mobile apps that allow you to download YouTube videos or other online audio files as MP3 files. Some examples of these mobile apps are TubeMate, VidMate, and SnapTube. You just need to install the app on your smartphone or tablet, search for the video or audio file that you want to download, choose the output format and quality, and click on the download button.</li>
-</ul>
- <h2>Why you should listen to City of Angels MP3 by 30 Seconds to Mars?</h2>
-<p>Now that you know how to download City of Angels MP3 by 30 Seconds to Mars, you might be wondering why you should listen to it in the first place. Well, there are many reasons why listening to music in general, and City of Angels in particular, can be beneficial for you.</p>
- <h3>The benefits of listening to music</h3>
-<p>Listening to music can have many positive effects on your physical, mental, and emotional well-being. Some of the benefits of listening to music are:</p>
-<p>city of angels 30 seconds to mars free mp3<br />
-download city of angels by 30 seconds to mars<br />
-city of angels song 30 seconds to mars mp3<br />
-30 seconds to mars city of angels remix mp3<br />
-city of angels 30stm mp3 download<br />
-30 seconds to mars city of angels acoustic mp3<br />
-city of angels thirty seconds to mars mp3<br />
-30 seconds to mars city of angels official video mp3<br />
-city of angels 30 seconds to mars lyrics mp3<br />
-30 seconds to mars city of angels live mp3<br />
-city of angels soundtrack 30 seconds to mars mp3<br />
-30 seconds to mars city of angels piano mp3<br />
-city of angels 30 seconds to mars instrumental mp3<br />
-30 seconds to mars city of angels album mp3<br />
-city of angels 30 seconds to mars karaoke mp3<br />
-30 seconds to mars city of angels radio edit mp3<br />
-city of angels 30 seconds to mars guitar mp3<br />
-30 seconds to mars city of angels unplugged mp3<br />
-city of angels 30 seconds to mars cover mp3<br />
-30 seconds to mars city of angels extended mp3<br />
-city of angels 30 seconds to mars spotify mp3<br />
-30 seconds to mars city of angels youtube mp3<br />
-city of angels 30 seconds to mars itunes mp3<br />
-30 seconds to mars city of angels soundcloud mp3<br />
-city of angels 30 seconds to mars amazon mp3<br />
-30 seconds to mars city of angels vevo mp3<br />
-city of angels 30 seconds to mars apple music mp3<br />
-30 seconds to mars city of angels last.fm mp3<br />
-city of angels 30 seconds to mars markus schulz remix mp3<br />
-30 seconds to mars city of angels single mp3<br />
-city of angels love lust faith + dreams 30 seconds to mars mp3<br />
-download lagu city of angels 30 seconds to mars mp3<br />
-descargar city of angels de 30 seconds to mars mp3<br />
-baixar musica city of angels de 30 seconds to mars mp3<br />
-telecharger musique city of angels de 30 seconds to mars mp3<br />
-scaricare musica city of angels di 30 seconds to mars mp3<br />
-herunterladen musik city of angels von 30 seconds to mars mp3<br />
-pobierz muzyke city of angels zespolu 30 seconds to mars mp3<br />
-indir muzik sehir melekleri otuz saniye marsempireye ait olan sarki.mp3 (Turkish)<br />
-skachat' muzyku gorod angelov ot tridtsati sekund do marsempireye pesnya.mp3 (Russian)<br />
-xiazai yinyue shengshi tianshi cong sanshi miaozhong dao huoxingempireye gequ.mp3 (Chinese)<br />
-daunrodeu eumak seongsi cheonsa buleoseu san-sibcho dong-an hwa-seongempireye nolae.mp3 (Korean)<br />
-kounyuu ongaku tenshi no machi kara sanjuppun made kaseiempireye kyoku.mp3 (Japanese)<br />
-descargar musica ciutat dels àngels de trenta segons a marsempireye cançó.mp3 (Catalan)<br />
-aflaai musiek stad van engele van dertig sekondes tot marsempireye lied.mp3 (Afrikaans)<br />
-stiahnut hudbu mesto anjelov od tridsiatich sekund do marsempireye piesen.mp3 (Slovak)<br />
-letoltes zene angyalok varosa harminc masodpercig marsempireye dal.mp3 (Hungarian)<br />
-preuzimanje glazbe grad andjela od trideset sekundi do marsempireye pjesma.mp3 (Croatian)<br />
-lataa musiikkia enkelten kaupunki kolmekymmentä sekuntia marsempireye laulu.mp3 (Finnish)</p>
-<ul>
-<li>It can reduce stress and anxiety by lowering your blood pressure, heart rate, and cortisol levels.</li>
-<li>It can improve your mood and happiness by releasing dopamine, serotonin, and oxytocin in your brain.</li>
-<li>It can enhance your memory and cognition by stimulating your hippocampus and prefrontal cortex.</li>
-<li>It can boost your creativity and productivity by activating your right hemisphere and increasing your alpha waves.</li>
-<li>It can strengthen your immune system and fight infections by increasing your antibodies and natural killer cells.</li>
-</ul>
- <h3>The reasons why City of Angels is a great song</h3>
-<p>Besides the general benefits of listening to music, City of Angels by 30 Seconds to Mars has some specific qualities that make it a great song to listen to. Some of the reasons why City of Angels is a great song are:</p>
-<ul>
-<li>It has a powerful and uplifting message that encourages you to follow your dreams and overcome your challenges.</li>
-<li>It has a catchy and melodic tune that makes you want to sing along and dance.</li>
-<li>It has a rich and diverse sound that blends rock, pop, electronic, orchestral, and choir elements.</li>
-<li>It has a passionate and expressive performance by Jared Leto and his bandmates.</li>
-<li>It has a stunning and inspiring visual representation by the music video and the short film.</li>
-</ul>
- <h2>Conclusion</h2>
-<p>In conclusion, City of Angels by 30 Seconds to Mars is a song <p>In conclusion, City of Angels by 30 Seconds to Mars is a song that you should definitely listen to and download as an MP3 file. It is a song that celebrates Los Angeles, the city of dreams, and the people who live or have lived there. It is a song that has a beautiful and meaningful message, a catchy and melodic tune, a rich and diverse sound, a passionate and expressive performance, and a stunning and inspiring visual representation. It is a song that can make you feel inspired, touched, and alive.</p>
-<p>If you want to download City of Angels MP3 by 30 Seconds to Mars, you can use the official sources and platforms that are authorized by the band and their record label, such as iTunes, Amazon, Spotify, YouTube, or YouTube Music. Alternatively, you can use some online converters, desktop software, or mobile apps that can convert YouTube videos or other online audio files into MP3 files. However, you should be careful about the quality and security of your download, and respect the rights of the band and their record label.</p>
-<p>So what are you waiting for? Go ahead and download City of Angels MP3 by 30 Seconds to Mars today, and enjoy this amazing song that will make you feel like you are in the city of angels.</p>
- <h3>FAQs</h3>
-<ul>
-<li>Q: Who are 30 Seconds to Mars?<br>
-A: 30 Seconds to Mars is an American rock band that was formed in Los Angeles in 1998 by Jared Leto and his brother Shannon Leto. The band currently consists of Jared Leto (lead vocals, guitar, keyboards), Shannon Leto (drums, percussion), and Tomo Miličević (lead guitar, keyboards). The band has released five studio albums, four EPs, and 16 singles.</li>
-<li>Q: What is the genre of City of Angels?<br>
-A: City of Angels is a song that belongs to the genre of alternative rock, with elements of pop rock, electronic rock, orchestral rock, and choir music.</li>
-<li>Q: How long is City of Angels?<br>
-A: City of Angels is a song that has a duration of 5 minutes and 2 seconds. The music video has a duration of 4 minutes and 54 seconds. The short film has a duration of 11 minutes and 13 seconds.</li>
-<li>Q: How many awards did City of Angels win?<br>
-A: City of Angels won several awards for its music video and short film, such as the MTV Video Music Award for Best Rock Video in 2014, the iHeartRadio Music Award for Alternative Rock Song of the Year in 2014, the Kerrang! Award for Best Single in 2014, the MTV Europe Music Award for Best Video in 2014, and the Berlin Music Video Award for Best Cinematography in 2015.</li>
-<li>Q: Where can I watch the music video or the short film for City of Angels?<br>
-A: You can watch the music video or the short film for City of Angels on YouTube. You can also find them on the official website of 30 Seconds to Mars or on their social media accounts.</li>
-</ul></p> 197e85843d<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Download dan Nonton Film Ashfall (2019) Sub Indo Full Movie HD.md

@@ -1,133 +0,0 @@
-<br />
-<h1>Download Film Ashfall Full Movie Sub Indo: A Review of the Epic Disaster Film</h1>
-<p>If you are a fan of action-packed disaster movies, you might have heard of Ashfall, a 2019 South Korean film that depicts the aftermath of a volcanic eruption on the Korean peninsula. But how can you watch this film online with Indonesian subtitles? And is it worth your time and money? In this article, I will give you a brief overview of what Ashfall is about, how to download film ashfall full movie sub indo legally and safely, and my personal opinion on whether you should watch it or not.</p>
- <h2>What is Ashfall?</h2>
-<p>Ashfall (Korean: 백두산; Hanja: 白頭山; RR: Baekdusan), also known as Mount Paektu, is a 2019 South Korean disaster film directed by Lee Hae-jun and Kim Byung-seo, starring Lee Byung-hun, Ha Jung-woo, Ma Dong-seok, Jeon Hye-jin and Bae Suzy. The film was released in December 2019 in South Korea and became one of the highest-grossing films of the year.</p>
-<h2>download film ashfall full movie sub indo</h2><br /><p><b><b>Download Zip</b> &harr; <a href="https://jinyurl.com/2uNM3g">https://jinyurl.com/2uNM3g</a></b></p><br /><br />
- <h3>The Plot of Ashfall</h3>
-<p>The film follows the events that unfold when Paektu Mountain, an active volcano straddling the China–North Korea border, suddenly erupts, causing severe earthquakes in both North and South Korea. To prevent another disaster, Jeon Yoo-kyung (Jeon Hye-jin), a government official, plans an operation based on a theory by Professor Kang Bong-rae (Ma Dong-seok), who had studied Mount Paektu and its possible future eruptions. Jo In-chang (Ha Jung-woo) is assigned to be the captain of a special forces team taking part in the operation. He contacts Lee Joon-pyeong (Lee Byung-hun), who is part of the Korean People's Army in North Korea as a spy. Joon-pyeong is the only one who knows where to find nuclear warheads that can be used to stop the volcano from erupting again. Meanwhile, Jo In-chang's pregnant wife Choi Ji-young (Bae Suzy) is alone in Seoul and struggling to survive amidst the chaos.</p>
- <h3>The Cast and Characters of Ashfall</h3>
-<p>The film features a star-studded cast of some of the most popular actors and actresses in South Korea. Here are some of the main characters and their roles:</p>
-<ul>
-<li>Lee Byung-hun as Lee Joon-pyeong: A North Korean spy who holds the key to stopping the volcano. He is also a father who wants to reunite with his daughter.</li>
-<li>Ha Jung-woo as Jo In-chang: A South Korean special forces captain who leads the mission to find J oon-pyeong and the nuclear warheads. He is also a husband who wants to protect his wife and unborn child.</li>
-<li>Ma Dong-seok as Professor Kang Bong-rae: A geologist who has studied Mount Paektu and its potential eruptions. He is the one who proposes the idea of using nuclear bombs to seal the volcano.</li>
-<li>Jeon Hye-jin as Jeon Yoo-kyung: A government official who is in charge of the operation to stop the volcano. She is also a former colleague and lover of Joon-pyeong.</li>
-<li>Bae Suzy as Choi Ji-young: Jo In-chang's wife who is pregnant with their first child. She is trapped in Seoul and faces many dangers as the city is shaken by earthquakes and ashfall.</li>
-</ul>
- <h3>The Special Effects and Cinematography of Ashfall</h3>
-<p>One of the most impressive aspects of Ashfall is the realistic and spectacular depiction of the volcanic eruption and its consequences. The film used a combination of practical and computer-generated effects to create the scenes of destruction, chaos, and panic. The film also employed various techniques such as aerial shots, drone shots, handheld shots, and slow-motion shots to capture the scale and intensity of the disaster. The film's cinematography was praised by critics and audiences alike for its stunning visuals and immersive experience.</p>
- <h2>How to Download Film Ashfall Full Movie Sub Indo</h2>
-<p>If you are interested in watching Ashfall with Indonesian subtitles, you might be wondering how to download film ashfall full movie sub indo online. There are two main ways to do this: legal and safe ways, and illegal and risky ways. Let's take a look at each option and weigh their pros and cons.</p>
- <h3>Legal and Safe Ways to Watch Ashfall Online</h3>
-<p>The best way to watch Ashfall online is to use legal and safe streaming services that offer the film with Indonesian subtitles. This way, you can enjoy the film without worrying about breaking the law, harming your device, or compromising your personal information. Here are some of the streaming services that offer Ashfall:</p>
- <h4>Streaming Services that Offer Ashfall</h4>
-<table>
-<tr><th>Streaming Service</th><th>Price</th><th>Availability</th></tr>
-<tr><td>Netflix</td><td>$8.99-$17.99 per month</td><td>Worldwide (except China, Syria, North Korea, and Crimea)</td></tr>
-<tr><td>iQIYI</td><td>$2.99-$19.99 per month</td><td>Asia-Pacific (except Japan)</td></tr>
-<tr><td>Viu</td><td>$2.99-$6.99 per month</td><td>Asia-Pacific (except China)</td></tr>
-<tr><td>Iflix</td><td>$0-$9.99 per month</td><td>Asia-Pacific (except China, Japan, Taiwan, Hong Kong, Macau)</td></tr>
-<tr><td>HOOQ</td><td>$1.99-$7.99 per month</td><td>Asia-Pacific (except China, Japan)</td></tr>
-</table>
- <h4>Websites that Provide Ashfall Subtitles</h4>
-<p>If you already have access to Ashfall through a streaming service or a DVD, but you need Indonesian subtitles, you can also download them from websites that provide subtitles for various languages. However, you should be careful when downloading subtitles from unknown sources, as they might contain malware or viruses that can harm your device or steal your data. Here are some of the websites that provide Ashfall subtitles:</p>
-<ul>
-<li>[Subscene]: A website that offers subtitles for movies and TV shows in various languages, including Indonesian.</li>
-<li>[Opensubtitles]: A website that provides subtitles for movies and TV shows in multiple languages, including Indonesian.</li>
-<li>[YIFY Subtitles]: A website that offers subtitles for YIFY movies in different languages, including Indonesian.</li>
-</ul>
- <h3>Illegal and Risky Ways to Download Ashfall for Free</h3>
-<p>Another way to download film ashfall full movie sub indo online is to use illegal and risky methods such as torrent sites or file-sharing platforms. These methods allow you to download the film for free, but they also come with many drawbacks and dangers. Here are some of the reasons why you should avoid using these methods:</p>
-<p>download film ashfall full movie sub indo lk21<br />
-download film ashfall full movie sub indo gratis<br />
-download film ashfall full movie sub indo 480p<br />
-download film ashfall full movie sub indo 720p<br />
-download film ashfall full movie sub indo bluray<br />
-download film ashfall full movie sub indo mp4<br />
-download film ashfall full movie sub indo hd<br />
-download film ashfall full movie sub indo streaming<br />
-download film ashfall full movie sub indo xxi<br />
-download film ashfall full movie sub indo bioskopkeren<br />
-download film ashfall full movie sub indo terbaru<br />
-download film ashfall full movie sub indo pusatfilm21<br />
-download film ashfall full movie sub indo nontongratis88<br />
-download film ashfall full movie sub indo rebahin<br />
-download film ashfall full movie sub indo cgvido<br />
-download film ashfall full movie sub indo idlix<br />
-download film ashfall full movie sub indo cinema 21<br />
-download film ashfall full movie sub indo ganool<br />
-download film ashfall full movie sub indo layarkaca21<br />
-download film ashfall full movie sub indo dunia21<br />
-download film ashfall full movie sub indo gudangmovies21<br />
-download film ashfall full movie sub indo indomovie88<br />
-download film ashfall full movie sub indo juraganfilm<br />
-download film ashfall full movie sub indo kawanfilm21<br />
-download film ashfall full movie sub indo lebahmovie<br />
-download film ashfall full movie sub indo melongfilm<br />
-download film ashfall full movie sub indo nontonfilm168<br />
-download film ashfall full movie sub indo nontonfilm77<br />
-download film ashfall full movie sub indo nontonfilm88<br />
-download film ashfall full movie sub indo nontonfilm99<br />
-download film ashfall full movie sub indo nontonindoxxi<br />
-download film ashfall full movie sub indo nontonplus<br />
-download film ashfall full movie sub indo nontonxxi<br />
-download film ashfall full movie sub indo pahe.in<br />
-download film ashfall full movie sub indo savefilm21<br />
-download film ashfall full movie sub indo sobatkeren21<br />
-download film ashfall full movie sub indo sogafime<br />
-download film ashfall full movie sub indo terbit21<br />
-download film ashfall full movie sub indo viu.com<br />
-watch online film ashfall full movie with english subtitles</p>
- <h4>Torrent Sites that Host Ashfall Files</h4>
-<p>Torrent sites are websites that allow users to share files through peer-to-peer networks. Some of the torrent sites that host Ashfall files are:</p> <ul>
-<li>[The Pirate Bay]: One of the most popular and notorious torrent sites in the world, known for hosting a variety of content, including movies, TV shows, music, games, software, and more.</li>
-<li>[1337x]: A torrent site that offers a wide range of content, including movies, TV shows, music, games, software, and more.</li>
-<li>[RARBG]: A torrent site that specializes in high-quality video content, such as movies and TV shows.</li>
-</ul>
- <h4>Risks and Consequences of Using Torrent Sites</h4>
-<p>Using torrent sites to download film ashfall full movie sub indo online might seem tempting, but it also comes with many risks and consequences. Some of them are:</p>
-<ul>
-<li>Legal issues: Downloading or sharing copyrighted content without permission is illegal and can result in fines or lawsuits. You might also be violating the terms and conditions of your streaming service or internet provider.</li>
-<li>Security issues: Torrent sites often contain malware or viruses that can infect your device or steal your personal information. You might also expose your IP address and location to hackers or cybercriminals.</li>
-<li>Quality issues: Torrent files often have poor quality, such as low resolution, distorted sound, or missing subtitles. You might also encounter fake or corrupted files that do not work or contain unwanted content.</li>
-<li>Ethical issues: Downloading or sharing pirated content is unfair to the creators and producers of the film, who invested time, money, and effort to make it. You might also be supporting illegal activities or organizations that profit from piracy.</li>
-</ul>
- <h2>Conclusion: Is Ashfall Worth Watching?</h2>
-<p>Now that you know what Ashfall is about and how to download film ashfall full movie sub indo online, you might be wondering if it is worth watching. To help you decide, here are some of the pros and cons of Ashfall:</p>
- <h3>The Pros and Cons of Ashfall</h3>
-<table>
-<tr><th>Pros</th><th>Cons</th></tr>
-<tr><td>A thrilling and exciting disaster film with realistic and spectacular special effects and cinematography.</td><td>A clichéd and predictable plot with some logical flaws and inconsistencies.</td></tr>
-<tr><td>A star-studded cast with impressive performances and chemistry.</td><td>A lack of character development and depth for some of the main characters.</td></tr>
-<tr><td>A message of hope and unity in the face of adversity and conflict.</td><td>A simplistic and idealistic portrayal of the political and social situation on the Korean peninsula.</td></tr>
-<tr><td>A cultural and commercial success that showcases the potential of the South Korean film industry.</td><td>A limited availability and accessibility for international audiences who might not be familiar with the context or language of the film.</td></tr>
-</table>
- <h3>My Personal Opinion on Ashfall</h3>
-<p>In my personal opinion, Ashfall is a film that is worth watching if you are a fan of disaster movies or Korean cinema. It is a film that delivers on its promise of providing an entertaining and thrilling experience with stunning visuals and sound. It is also a film that has a heart and a message that resonates with the current times. However, it is not a film that is perfect or flawless. It has its share of weaknesses and shortcomings that might disappoint some viewers who expect more from it. It is also not a film that is easy to watch or understand for everyone. It requires some background knowledge and appreciation of the culture and history of Korea. Therefore, I would recommend Ashfall to anyone who is looking for a fun and exciting movie night, but not to anyone who is looking for a deep and meaningful cinematic masterpiece.</p>
- <h2>Frequently Asked Questions</h2>
-<p>Here are some of the frequently asked questions about Ashfall:</p>
- <h4>Q: Is Ashfall based on a true story?</h4>
-<p>A: No, Ashfall is not based on a true story. It is a fictional story that imagines what would happen if Mount Paektu erupted in the present day. However, Mount Paektu is a real volcano that has erupted in the past and could erupt again in the future. The film was inspired by the historical and scientific research on Mount Paektu and its potential eruptions.</p>
- <h4>Q: How accurate is Ashfall?</h4>
-<p>A: Ashfall is not meant to be a realistic or accurate depiction of a volcanic eruption or its consequences. It is a fictional story that exaggerates and dramatizes some aspects of the disaster for entertainment purposes. The film does not follow the scientific facts or data on Mount Paektu or its eruptions. The film also does not reflect the actual political or social situation on the Korean peninsula or its relations with other countries.</p>
- <h4>Q: How Q: How did Ashfall perform at the box office?</h4>
-<p>A: Ashfall was a commercial success at the box office, both domestically and internationally. It grossed over $61 million in South Korea, becoming the fourth highest-grossing film of 2019 and the 11th highest-grossing film of all time in the country. It also grossed over $24 million in other countries, mainly in Asia, bringing its worldwide total to over $85 million. It was also nominated for several awards, including the Baeksang Arts Awards, the Blue Dragon Film Awards, and the Grand Bell Awards.</p>
- <h4>Q: Where can I find more information about Ashfall?</h4>
-<p>A: If you want to learn more about Ashfall, you can visit the following websites:</p>
-<ul>
-<li>[Ashfall Official Website]: The official website of the film, where you can find the trailer, synopsis, cast and crew information, gallery, and more.</li>
-<li>[Ashfall IMDb Page]: The IMDb page of the film, where you can find the ratings, reviews, trivia, quotes, and more.</li>
-<li>[Ashfall Wikipedia Page]: The Wikipedia page of the film, where you can find the plot summary, production details, reception, and more.</li>
-</ul>
- <h4>Q: What are some other films like Ashfall?</h4>
-<p>A: If you enjoyed Ashfall and want to watch more films like it, you might like these films:</p>
-<ul>
-<li>[2012]: A 2009 American disaster film directed by Roland Emmerich, starring John Cusack, Chiwetel Ejiofor, Amanda Peet, Thandie Newton, and Danny Glover. The film depicts a series of cataclysmic events that occur in 2012 as a result of a massive solar flare that causes the Earth's crust to shift.</li>
-<li>[The Day After Tomorrow]: A 2004 American disaster film directed by Roland Emmerich, starring Dennis Quaid, Jake Gyllenhaal, Emmy Rossum, Ian Holm, and Sela Ward. The film depicts a global climate change that triggers a new ice age and forces a group of survivors to cope with the harsh conditions.</li>
-<li>[Train to Busan]: A 2016 South Korean zombie apocalypse film directed by Yeon Sang-ho, starring Gong Yoo, Ma Dong-seok, Jung Yu-mi, Kim Su-an, Kim Eui-sung, Choi Woo-shik, and Ahn So-hee. The film follows a group of passengers on a train from Seoul to Busan as they try to survive a zombie outbreak that spreads across the country.</li>
-</ul>
- <h2></h2>
-<p>Thank you for reading my article on how to download film ashfall full movie sub indo online. I hope you found it helpful and informative. If you have any questions or feedback, please feel free to leave a comment below. Have a great day!</p> 197e85843d<br />
-<br />
-<br />

spaces/801artistry/RVC801/demucs/augment.py

@@ -1,106 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-import random
-import torch as th
-from torch import nn
-
-
-class Shift(nn.Module):
-    """
-    Randomly shift audio in time by up to `shift` samples.
-    """
-    def __init__(self, shift=8192):
-        super().__init__()
-        self.shift = shift
-
-    def forward(self, wav):
-        batch, sources, channels, time = wav.size()
-        length = time - self.shift
-        if self.shift > 0:
-            if not self.training:
-                wav = wav[..., :length]
-            else:
-                offsets = th.randint(self.shift, [batch, sources, 1, 1], device=wav.device)
-                offsets = offsets.expand(-1, -1, channels, -1)
-                indexes = th.arange(length, device=wav.device)
-                wav = wav.gather(3, indexes + offsets)
-        return wav
-
-
-class FlipChannels(nn.Module):
-    """
-    Flip left-right channels.
-    """
-    def forward(self, wav):
-        batch, sources, channels, time = wav.size()
-        if self.training and wav.size(2) == 2:
-            left = th.randint(2, (batch, sources, 1, 1), device=wav.device)
-            left = left.expand(-1, -1, -1, time)
-            right = 1 - left
-            wav = th.cat([wav.gather(2, left), wav.gather(2, right)], dim=2)
-        return wav
-
-
-class FlipSign(nn.Module):
-    """
-    Random sign flip.
-    """
-    def forward(self, wav):
-        batch, sources, channels, time = wav.size()
-        if self.training:
-            signs = th.randint(2, (batch, sources, 1, 1), device=wav.device, dtype=th.float32)
-            wav = wav * (2 * signs - 1)
-        return wav
-
-
-class Remix(nn.Module):
-    """
-    Shuffle sources to make new mixes.
-    """
-    def __init__(self, group_size=4):
-        """
-        Shuffle sources within one batch.
-        Each batch is divided into groups of size `group_size` and shuffling is done within
-        each group separatly. This allow to keep the same probability distribution no matter
-        the number of GPUs. Without this grouping, using more GPUs would lead to a higher
-        probability of keeping two sources from the same track together which can impact
-        performance.
-        """
-        super().__init__()
-        self.group_size = group_size
-
-    def forward(self, wav):
-        batch, streams, channels, time = wav.size()
-        device = wav.device
-
-        if self.training:
-            group_size = self.group_size or batch
-            if batch % group_size != 0:
-                raise ValueError(f"Batch size {batch} must be divisible by group size {group_size}")
-            groups = batch // group_size
-            wav = wav.view(groups, group_size, streams, channels, time)
-            permutations = th.argsort(th.rand(groups, group_size, streams, 1, 1, device=device),
-                                      dim=1)
-            wav = wav.gather(1, permutations.expand(-1, -1, -1, channels, time))
-            wav = wav.view(batch, streams, channels, time)
-        return wav
-
-
-class Scale(nn.Module):
-    def __init__(self, proba=1., min=0.25, max=1.25):
-        super().__init__()
-        self.proba = proba
-        self.min = min
-        self.max = max
-
-    def forward(self, wav):
-        batch, streams, channels, time = wav.size()
-        device = wav.device
-        if self.training and random.random() < self.proba:
-            scales = th.empty(batch, streams, 1, 1, device=device).uniform_(self.min, self.max)
-            wav *= scales
-        return wav

spaces/A00001/bingothoo/tests/kblob.ts

@@ -1,27 +0,0 @@
-import FormData from 'form-data'
-
-import { fetch } from '@/lib/isomorphic'
-
-const formData = new FormData()
-
-const knowledgeRequest = {"imageInfo":{"url":"https://www.baidu.com/img/PCfb_5bf082d29588c07f842ccde3f97243ea.png"},"knowledgeRequest":{"invokedSkills":["ImageById"],"subscriptionId":"Bing.Chat.Multimodal","invokedSkillsRequestData":{"enableFaceBlur":true},"convoData":{"convoid":"51D|BingProdUnAuthenticatedUsers|E3DCA904FF236C67C3450163BCEC64CFF3F618CC8A4AFD75FD518F5ED0ADA080","convotone":"Creative"}}}
-
-formData.append('knowledgeRequest', JSON.stringify(knowledgeRequest))
-
-
-fetch('https://bing.vcanbb.top/images/kblob',
-  {
-    method: 'POST',
-    body: formData.getBuffer(),
-    headers: {
-      "sec-ch-ua": "\"Not/A)Brand\";v=\"99\", \"Google Chrome\";v=\"115\", \"Chromium\";v=\"115\"",
-      "sec-ch-ua-mobile": "?0",
-      "sec-ch-ua-platform": "\"Windows\"",
-      "Referer": "https://bing.vcanbb.top/web/index.html",
-      "Referrer-Policy": "origin-when-cross-origin",
-      ...formData.getHeaders()
-    }
-
-  }
-).then(res => res.text())
-.then(res => console.log('res', res))

spaces/AAYUSH27/Neuro/app.py

@@ -1,98 +0,0 @@
-import streamlit as st
-from streamlit_chat import message
-from langchain.chains import ConversationalRetrievalChain
-from langchain.document_loaders import PyPDFLoader, DirectoryLoader
-from langchain.embeddings import HuggingFaceEmbeddings
-from langchain.llms import CTransformers
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-from langchain.vectorstores import FAISS
-from langchain.memory import ConversationBufferMemory
-
-# load the pdf files from the path
-loader = DirectoryLoader("data/", glob="*.pdf", loader_cls=PyPDFLoader)
-documents = loader.load()
-
-# split text into chunks
-text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
-text_chunks = text_splitter.split_documents(documents)
-
-# create embeddings
-embeddings = HuggingFaceEmbeddings(
-    model_name="sentence-transformers/all-MiniLM-L6-v2", model_kwargs={"device": "cpu"}
-)
-
-# vectorstore
-vector_store = FAISS.from_documents(text_chunks, embeddings)
-
-# create llm
-llm = CTransformers(
-    model="llama-2-7b-chat.ggmlv3.q4_0.bin",
-    model_type="llama",
-    config={"max_new_tokens": 128, "temperature": 0.01},
-)
-
-memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
-
-chain = ConversationalRetrievalChain.from_llm(
-    llm=llm,
-    chain_type="stuff",
-    retriever=vector_store.as_retriever(search_kwargs={"k": 2}),
-    memory=memory,
-)
-
-st.title("Neuro Health-Care Chat Bot")
-
-
-def conversation_chat(query):
-    result = chain({"question": query, "chat_history": st.session_state["history"]})
-    st.session_state["history"].append((query, result["answer"]))
-    return result["answer"]
-
-
-def initialize_session_state():
-    if "history" not in st.session_state:
-        st.session_state["history"] = []
-
-    if "generated" not in st.session_state:
-        st.session_state["generated"] = ["Hello! Ask me anything about Neuro"]
-
-    if "past" not in st.session_state:
-        st.session_state["past"] = ["Hello!"]
-
-
-def display_chat_history():
-    reply_container = st.container()
-    container = st.container()
-
-    with container:
-        with st.form(key="my_form", clear_on_submit=True):
-            user_input = st.text_input(
-                "Question:", placeholder="Ask anything about Neuro", key="input"
-            )
-            submit_button = st.form_submit_button(label="Send")
-
-        if submit_button and user_input:
-            output = conversation_chat(user_input)
-
-            st.session_state["past"].append(user_input)
-            st.session_state["generated"].append(output)
-
-    if st.session_state["generated"]:
-        with reply_container:
-            for i in range(len(st.session_state["generated"])):
-                message(
-                    st.session_state["past"][i],
-                    is_user=True,
-                    key=str(i) + "_user",
-                    avatar_style="person",
-                )
-
-                message(
-                    st.session_state["generated"][i],
-                    key=str(i),
-                    logo="https://img.icons8.com/?size=96&id=19625&format=png",
-                )
-# Initialize session state
-initialize_session_state()
-# Display chat history
-display_chat_history()

spaces/AFRAC/NCM_DEMO/README.md

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

spaces/AIConsultant/MusicGen/audiocraft/modules/transformer.py

@@ -1,747 +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.
-
-"""
-Transformer model, with streaming support, xformer attention support
-and easy causal attention with a potentially finite receptive field.
-
-See `StreamingTransformer` for more information.
-
-Unlike regular PyTorch Transformer, we make the hard choice that batches are first.
-"""
-
-import typing as tp
-
-from einops import rearrange
-import torch
-import torch.nn as nn
-from torch.nn import functional as F
-from torch.utils.checkpoint import checkpoint as torch_checkpoint
-from xformers import ops
-
-from .rope import RotaryEmbedding
-from .streaming import StreamingModule
-
-_efficient_attention_backend: str = 'torch'
-
-
-def set_efficient_attention_backend(backend: str = 'torch'):
-    # Using torch by default, it seems a bit faster on older P100 GPUs (~20% faster).
-    global _efficient_attention_backend
-    assert _efficient_attention_backend in ['xformers', 'torch']
-    _efficient_attention_backend = backend
-
-
-def _get_attention_time_dimension() -> int:
-    if _efficient_attention_backend == 'torch':
-        return 2
-    else:
-        return 1
-
-
-def _is_profiled() -> bool:
-    # Return true if we are currently running with a xformers profiler activated.
-    try:
-        from xformers.profiler import profiler
-    except ImportError:
-        return False
-    return profiler._Profiler._CURRENT_PROFILER is not None
-
-
-def create_norm_fn(norm_type: str, dim: int, **kwargs) -> nn.Module:
-    """Create normalization module for transformer encoder layer.
-
-    Args:
-        norm_type (str): Normalization method.
-        dim (int): Dimension of the normalized layer.
-        **kwargs (dict): Additional parameters for normalization layer.
-    Returns:
-        nn.Module: Normalization module.
-    """
-    if norm_type == 'layer_norm':
-        return nn.LayerNorm(dim, eps=1e-5, **kwargs)
-    else:
-        raise ValueError(f"Unknown norm type: {norm_type}")
-
-
-def create_sin_embedding(positions: torch.Tensor, dim: int, max_period: float = 10000,
-                         dtype: torch.dtype = torch.float32) -> torch.Tensor:
-    """Create sinusoidal positional embedding, with shape `[B, T, C]`.
-
-    Args:
-        positions (torch.Tensor): LongTensor of positions.
-        dim (int): Dimension of the embedding.
-        max_period (float): Maximum period of the cosine/sine functions.
-        dtype (torch.dtype or str): dtype to use to generate the embedding.
-    Returns:
-        torch.Tensor: Sinusoidal positional embedding.
-    """
-    # We aim for BTC format
-    assert dim % 2 == 0
-    half_dim = dim // 2
-    positions = positions.to(dtype)
-    adim = torch.arange(half_dim, device=positions.device, dtype=dtype).view(1, 1, -1)
-    max_period_tensor = torch.full([], max_period, device=positions.device, dtype=dtype)  # avoid sync point
-    phase = positions / (max_period_tensor ** (adim / (half_dim - 1)))
-    return torch.cat([torch.cos(phase), torch.sin(phase)], dim=-1)
-
-
-def expand_repeated_kv(x: torch.Tensor, n_rep: int) -> torch.Tensor:
-    """torch.repeat_interleave(x, dim=2, repeats=n_rep) from xlformers."""
-    if n_rep == 1:
-        return x
-    if _efficient_attention_backend == 'torch':
-        bs, n_kv_heads, slen, head_dim = x.shape
-        return (
-            x[:, :, None, :, :]
-            .expand(bs, n_kv_heads, n_rep, slen, head_dim)
-            .reshape(bs, n_kv_heads * n_rep, slen, head_dim)
-        )
-    else:
-        bs, slen, n_kv_heads, head_dim = x.shape
-        return (
-            x[:, :, :, None, :]
-            .expand(bs, slen, n_kv_heads, n_rep, head_dim)
-            .reshape(bs, slen, n_kv_heads * n_rep, head_dim)
-        )
-
-
-class LayerScale(nn.Module):
-    """Layer scale from [Touvron et al 2021] (https://arxiv.org/pdf/2103.17239.pdf).
-    This rescales diagonally the residual outputs close to 0, with a learnt scale.
-
-    Args:
-        channels (int): Number of channels.
-        init (float): Initial scale.
-        channel_last (bool): If True, expect `[*, C]` shaped tensors, otherwise, `[*, C, T]`.
-        device (torch.device or str, optional): Device on which to initialize the module.
-        dtype (torch.dtype, optional): dtype to use to initialize the module.
-    """
-    def __init__(self, channels: int, init: float = 1e-4, channel_last: bool = True,
-                 device=None, dtype=None):
-        super().__init__()
-        self.channel_last = channel_last
-        self.scale = nn.Parameter(
-            torch.full((channels,), init,
-                       requires_grad=True, device=device, dtype=dtype))
-
-    def forward(self, x: torch.Tensor):
-        if self.channel_last:
-            return self.scale * x
-        else:
-            return self.scale[:, None] * x
-
-
-class StreamingMultiheadAttention(StreamingModule):
-    """Similar to `nn.MultiheadAttention` but with support for streaming, causal evaluation.
-
-    Args:
-        embed_dim (int): Dimension to project to.
-        num_heads (int): Number of heads.
-        dropout (float): Dropout level.
-        bias (bool): Use bias in projections.
-        causal (bool): Causal mask applied automatically.
-        past_context (int, optional): Receptive field for the causal mask, infinite if None.
-        custom (bool): Use custom MHA implementation, for testing / benchmarking.
-        memory_efficient (bool): Use xformers based memory efficient attention.
-        attention_as_float32 (bool): Perform the attention as float32
-            (especially important with memory_efficient as autocast won't do this automatically).
-        rope (`RotaryEmbedding`, optional): Rope embedding to use.
-        cross_attention: Should be true when used as a cross attention.
-            All keys and values must be available at once, streaming is only for the queries.
-            Cannot be used with `causal` or `rope` (as it wouldn't make sens to
-            interpret the time steps in the keys relative to those in the queries).
-        safe_streaming (bool): Bug fix, will go away with xformers update.
-        qk_layer_norm (bool): Layer normalization applied to queries and keys before dot product.
-        kv_repeat (int): If > 1, will repeat keys and queries multiple times (need to divide num_heads).
-            This will lead to faster decoding time on A100 or other GPUs with tensorcore.
-        device (torch.device, optional): Device on which to initialize.
-        dtype (torch.dtype, optional): dtype to use.
-    """
-    def __init__(self, embed_dim: int, num_heads: int, dropout: float = 0.0, bias: bool = True,
-                 causal: bool = False, past_context: tp.Optional[int] = None, custom: bool = False,
-                 memory_efficient: bool = False, attention_as_float32: bool = False,
-                 rope: tp.Optional[RotaryEmbedding] = None, cross_attention: bool = False,
-                 safe_streaming: bool = True, qk_layer_norm: bool = False, kv_repeat: int = 1,
-                 device=None, dtype=None):
-        super().__init__()
-        factory_kwargs = {'device': device, 'dtype': dtype}
-        if past_context is not None:
-            assert causal
-
-        self.embed_dim = embed_dim
-        self.causal = causal
-        self.past_context = past_context
-        self.memory_efficient = memory_efficient
-        self.attention_as_float32 = attention_as_float32
-        self.rope = rope
-        self.cross_attention = cross_attention
-        self.safe_streaming = safe_streaming
-        self.num_heads = num_heads
-        self.dropout = dropout
-        self.kv_repeat = kv_repeat
-        if cross_attention:
-            assert not causal, "Causal cannot work with cross attention."
-            assert rope is None, "Rope cannot work with cross attention."
-
-        if memory_efficient:
-            _verify_xformers_memory_efficient_compat()
-
-        self.custom = _is_custom(custom, memory_efficient)
-        if self.custom:
-            out_dim = embed_dim
-            assert num_heads % kv_repeat == 0
-            assert not cross_attention or kv_repeat == 1
-            num_kv = num_heads // kv_repeat
-            kv_dim = (embed_dim // num_heads) * num_kv
-            out_dim += 2 * kv_dim
-            in_proj = nn.Linear(embed_dim, out_dim, bias=bias, **factory_kwargs)
-            # We try to follow the default PyTorch MHA convention, to easily compare results.
-            self.in_proj_weight = in_proj.weight
-            self.in_proj_bias = in_proj.bias
-            if bias:
-                self.in_proj_bias.data.zero_()  # Following Pytorch convention
-            self.out_proj = nn.Linear(embed_dim, embed_dim, bias=bias, **factory_kwargs)
-            if bias:
-                self.out_proj.bias.data.zero_()
-        else:
-            assert not qk_layer_norm
-            assert kv_repeat == 1
-            self.mha = nn.MultiheadAttention(
-                embed_dim, num_heads, dropout=dropout, bias=bias, batch_first=True,
-                **factory_kwargs)
-        self.qk_layer_norm = qk_layer_norm
-        if qk_layer_norm:
-            assert self.custom
-            assert kv_repeat == 1
-            ln_dim = embed_dim
-            self.q_layer_norm = nn.LayerNorm(ln_dim)
-            self.k_layer_norm = nn.LayerNorm(ln_dim)
-
-    def _load_from_state_dict(self, state_dict, prefix, *args, **kwargs):
-        if not self.custom:
-            # Support compat with regular MHA
-            keys = [n for n, _ in self.mha.named_parameters()]
-            for key in keys:
-                if prefix + key in state_dict:
-                    state_dict[prefix + "mha." + key] = state_dict.pop(prefix + key)
-        super()._load_from_state_dict(state_dict, prefix, *args, **kwargs)
-
-    def _get_mask(self, current_steps: int, device: torch.device, dtype: torch.dtype):
-        # Return a causal mask, accounting for potentially stored past keys/values
-        # We actually return a bias for the attention score, as this has the same
-        # convention both in the builtin MHA in Pytorch, and Xformers functions.
-        time_dim = _get_attention_time_dimension()
-        if self.memory_efficient:
-            from xformers.ops import LowerTriangularMask
-            if current_steps == 1:
-                # If we only have one step, then we do not need a mask.
-                return None
-            elif 'past_keys' in self._streaming_state:
-                raise RuntimeError("Not supported at the moment")
-            else:
-                # Then we can safely use a lower triangular mask
-                return LowerTriangularMask()
-        if self._streaming_state:
-            past_keys = self._streaming_state['past_keys']
-            past_steps = past_keys.shape[time_dim]
-        else:
-            past_steps = 0
-
-        queries_pos = torch.arange(
-            past_steps, current_steps + past_steps, device=device).view(-1, 1)
-        keys_pos = torch.arange(past_steps + current_steps, device=device).view(1, -1)
-        delta = queries_pos - keys_pos
-        valid = delta >= 0
-        if self.past_context is not None:
-            valid &= (delta <= self.past_context)
-        return torch.where(
-            valid,
-            torch.zeros([], device=device, dtype=dtype),
-            torch.full([], float('-inf'), device=device, dtype=dtype))
-
-    def _complete_kv(self, k, v):
-        time_dim = _get_attention_time_dimension()
-        if self.cross_attention:
-            # With cross attention we assume all keys and values
-            # are already available, and streaming is with respect
-            # to the queries only.
-            return k, v
-        # Complete the key/value pair using the streaming state.
-        if self._streaming_state:
-            pk = self._streaming_state['past_keys']
-            nk = torch.cat([pk, k], dim=time_dim)
-            if v is k:
-                nv = nk
-            else:
-                pv = self._streaming_state['past_values']
-                nv = torch.cat([pv, v], dim=time_dim)
-        else:
-            nk = k
-            nv = v
-
-        assert nk.shape[time_dim] == nv.shape[time_dim]
-        offset = 0
-        if self.past_context is not None:
-            offset = max(0, nk.shape[time_dim] - self.past_context)
-        if self._is_streaming:
-            self._streaming_state['past_keys'] = nk[:, offset:]
-            if v is not k:
-                self._streaming_state['past_values'] = nv[:, offset:]
-            if 'offset' in self._streaming_state:
-                self._streaming_state['offset'] += offset
-            else:
-                self._streaming_state['offset'] = torch.tensor(0)
-        return nk, nv
-
-    def _apply_rope(self, query: torch.Tensor, key: torch.Tensor):
-        # TODO: fix and verify layout.
-        assert _efficient_attention_backend == 'xformers', "Rope not supported with torch attn."
-        # Apply rope embeddings to query and key tensors.
-        assert self.rope is not None
-        if 'past_keys' in self._streaming_state:
-            past_keys_offset = self._streaming_state['past_keys'].shape[1]
-        else:
-            past_keys_offset = 0
-        if 'offset' in self._streaming_state:
-            past_context_offset = int(self._streaming_state['offset'].item())
-        else:
-            past_context_offset = 0
-        streaming_offset = past_context_offset + past_keys_offset
-        return self.rope.rotate_qk(query, key, start=streaming_offset)
-
-    def forward(self, query: torch.Tensor, key: torch.Tensor, value: torch.Tensor,
-                key_padding_mask=None, need_weights=False, attn_mask=None,
-                average_attn_weights=True, is_causal=False):
-        assert attn_mask is None
-        assert not is_causal, ("New param added in torch 2.0.1 not supported, "
-                               "use the causal args in the constructor.")
-
-        time_dim = _get_attention_time_dimension()
-        if time_dim == 2:
-            layout = "b h t d"
-        else:
-            layout = "b t h d"
-        dtype = query.dtype
-        if self._is_streaming:
-            assert self.causal or self.cross_attention, \
-                "Streaming only available for causal or cross attention"
-
-        if self.causal:
-            # At the moment we specialize only for the self-attention case.
-            assert query.shape[1] == key.shape[1], "Causal only for same length query / key / value"
-            assert value.shape[1] == key.shape[1], "Causal only for same length query / key / value"
-            attn_mask = self._get_mask(query.shape[1], query.device, query.dtype)
-
-        if self.custom:
-            # custom implementation
-            assert need_weights is False
-            assert key_padding_mask is None
-            if self.cross_attention:
-                # Different queries, keys, values, we have to spit manually the weights
-                # before applying the linear.
-                dim = self.in_proj_weight.shape[0] // 3
-                if self.in_proj_bias is None:
-                    bias_q, bias_k, bias_v = None, None, None
-                else:
-                    bias_q = self.in_proj_bias[:dim]
-                    bias_k = self.in_proj_bias[dim: 2 * dim]
-                    bias_v = self.in_proj_bias[2 * dim:]
-                q = nn.functional.linear(query, self.in_proj_weight[:dim], bias_q)
-                # todo: when streaming, we could actually save k, v and check the shape actually match.
-                k = nn.functional.linear(key, self.in_proj_weight[dim: 2 * dim], bias_k)
-                v = nn.functional.linear(value, self.in_proj_weight[2 * dim:], bias_v)
-                if self.qk_layer_norm is True:
-                    q = self.q_layer_norm(q)
-                    k = self.k_layer_norm(k)
-                q, k, v = [rearrange(x, f"b t (h d) -> {layout}", h=self.num_heads) for x in [q, k, v]]
-            else:
-                if not _is_profiled():
-                    # profiling breaks that propertysomehow.
-                    assert query is key, "specialized implementation"
-                    assert value is key, "specialized implementation"
-                projected = nn.functional.linear(query, self.in_proj_weight, self.in_proj_bias)
-                if self.kv_repeat == 1:
-                    if time_dim == 2:
-                        bound_layout = "b h p t d"
-                    else:
-                        bound_layout = "b t p h d"
-                    packed = rearrange(projected, f"b t (p h d) -> {bound_layout}", p=3, h=self.num_heads)
-                    q, k, v = ops.unbind(packed, dim=2)
-                else:
-                    embed_dim = self.embed_dim
-                    per_head_dim = (embed_dim // self.num_heads)
-                    kv_heads = self.num_heads // self.kv_repeat
-                    q = projected[:, :, :embed_dim]
-                    start = embed_dim
-                    end = start + per_head_dim * kv_heads
-                    k = projected[:, :, start: end]
-                    v = projected[:, :, end:]
-                    q = rearrange(q, f"b t (h d) -> {layout}", h=self.num_heads)
-                    k = rearrange(k, f"b t (h d) -> {layout}", h=kv_heads)
-                    v = rearrange(v, f"b t (h d) -> {layout}", h=kv_heads)
-
-                if self.qk_layer_norm is True:
-                    assert self.kv_repeat == 1
-                    q, k = [rearrange(x, f"{layout} -> b t (h d)") for x in [q, k]]
-                    q = self.q_layer_norm(q)
-                    k = self.k_layer_norm(k)
-                    q, k = [rearrange(x, f"b t (h d) -> {layout}", h=self.num_heads) for x in [q, k]]
-                if self.rope:
-                    q, k = self._apply_rope(q, k)
-                k, v = self._complete_kv(k, v)
-                if self.kv_repeat > 1:
-                    k = expand_repeated_kv(k, self.kv_repeat)
-                    v = expand_repeated_kv(v, self.kv_repeat)
-            if self.attention_as_float32:
-                q, k, v = [x.float() for x in [q, k, v]]
-            if self.memory_efficient:
-                p = self.dropout if self.training else 0
-                if _efficient_attention_backend == 'torch':
-                    x = torch.nn.functional.scaled_dot_product_attention(
-                        q, k, v, is_causal=attn_mask is not None, dropout_p=p)
-                else:
-                    x = ops.memory_efficient_attention(q, k, v, attn_mask, p=p)
-            else:
-                # We include the dot product as float32, for consistency
-                # with the other implementations that include that step
-                # as part of the attention. Note that when using `autocast`,
-                # the einsums would be done as bfloat16, but the softmax
-                # would be done as bfloat16, so `attention_as_float32` will
-                # extend a bit the range of operations done in float32,
-                # although this should make no difference.
-                q = q / q.shape[-1] ** 0.5
-                key_layout = layout.replace('t', 'k')
-                query_layout = layout
-                if self._is_streaming and self.safe_streaming and q.device.type == 'cuda':
-                    with torch.autocast(device_type=q.device.type, dtype=torch.float32):
-                        pre_w = torch.einsum(f"{query_layout},{key_layout}-> b h t k", q, k)
-                else:
-                    pre_w = torch.einsum(f"{query_layout},{key_layout}-> b h t k", q, k)
-                if attn_mask is not None:
-                    pre_w = pre_w + attn_mask
-                w = torch.softmax(pre_w, dim=-1)
-                w = F.dropout(w, self.dropout, training=self.training).to(v)
-                # Key and value have the same format.
-                x = torch.einsum(f"b h t k, {key_layout} -> {layout}", w, v)
-            x = x.to(dtype)
-            x = rearrange(x, f"{layout} -> b t (h d)", h=self.num_heads)
-            x = self.out_proj(x)
-        else:
-            key, value = self._complete_kv(key, value)
-            if self.attention_as_float32:
-                query, key, value = [x.float() for x in [query, key, value]]
-            x, _ = self.mha(
-                query, key, value, key_padding_mask,
-                need_weights, attn_mask, average_attn_weights)
-            x = x.to(dtype)
-
-        return x, None
-
-
-class StreamingTransformerLayer(nn.TransformerEncoderLayer):
-    """TransformerLayer with Streaming / Causal support.
-    This also integrates cross_attention, when passing `cross_attention=True`,
-    rather than having two separate classes like in PyTorch.
-
-    Args:
-        d_model (int): Dimension of the data.
-        num_heads (int): Number of heads.
-        dim_feedforward (int): Intermediate dimension of FF module.
-        dropout (float): Dropout both for MHA and FF.
-        bias_ff (bool): Use bias for FF.
-        bias_attn (bool): Use bias for MHA.
-        causal (bool): Causal mask applied automatically.
-        past_context (int, optional): Receptive field for the causal mask, infinite if None.
-        custom (bool): Use custom MHA implementation, for testing / benchmarking.
-        memory_efficient (bool): Use xformers based memory efficient attention.
-        attention_as_float32 (bool): Perform the attention as float32
-            (especially important with memory_efficient as autocast won't do this automatically).
-        qk_layer_norm (bool): Layer normalization applied to queries and keys before dot product in attention.
-        qk_layer_norm_cross (bool): Same for the cross attention.
-        cross_attention (bool): If True, expect to get secondary input for cross-attention.
-            Cross attention will use the default MHA, as it typically won't require
-            special treatment.
-        layer_scale (float, optional): If not None, LayerScale will be used with
-            the given value as initial scale.
-        rope (`RotaryEmbedding`, optional): Rope embedding to use.
-        attention_dropout (float, optional): If not None, separate the value of the dimension dropout
-            in FFN and of the attention dropout.
-        kv_repeat (int): If > 1, will repeat keys and queries multiple times (need to divide num_heads).
-            This will lead to faster decoding time on A100 or other GPUs with tensorcore.
-        device (torch.device, optional): Device on which to initialize.
-        dtype (torch.dtype, optional): dtype to use.
-        **kwargs: See `nn.TransformerEncoderLayer`.
-    """
-    def __init__(self, d_model: int, num_heads: int, dim_feedforward: int = 2048, dropout: float = 0.1,
-                 bias_ff: bool = True, bias_attn: bool = True, causal: bool = False,
-                 past_context: tp.Optional[int] = None, custom: bool = False,
-                 memory_efficient: bool = False, attention_as_float32: bool = False,
-                 qk_layer_norm: bool = False, qk_layer_norm_cross: bool = False,
-                 cross_attention: bool = False, layer_scale: tp.Optional[float] = None,
-                 rope: tp.Optional[RotaryEmbedding] = None, attention_dropout: tp.Optional[float] = None,
-                 kv_repeat: int = 1, norm: str = 'layer_norm', device=None, dtype=None, **kwargs):
-        super().__init__(d_model, num_heads, dim_feedforward, dropout,
-                         device=device, dtype=dtype, batch_first=True, **kwargs)
-        factory_kwargs = {'device': device, 'dtype': dtype}
-        # Redefine self_attn to our streaming multi-head attention
-        attn_kwargs: tp.Dict[str, tp.Any] = {
-            'embed_dim': d_model,
-            'num_heads': num_heads,
-            'dropout': dropout if attention_dropout is None else attention_dropout,
-            'bias': bias_attn,
-            'custom': custom,
-            'memory_efficient': memory_efficient,
-            'attention_as_float32': attention_as_float32,
-        }
-        self.self_attn: StreamingMultiheadAttention = StreamingMultiheadAttention(
-            causal=causal, past_context=past_context, rope=rope, qk_layer_norm=qk_layer_norm,
-            kv_repeat=kv_repeat, **attn_kwargs, **factory_kwargs)  # type: ignore
-        # Redefine feedforward layers to expose bias parameter
-        self.linear1 = nn.Linear(d_model, dim_feedforward, bias=bias_ff, **factory_kwargs)
-        self.linear2 = nn.Linear(dim_feedforward, d_model, bias=bias_ff, **factory_kwargs)
-
-        self.layer_scale_1: nn.Module
-        self.layer_scale_2: nn.Module
-        if layer_scale is None:
-            self.layer_scale_1 = nn.Identity()
-            self.layer_scale_2 = nn.Identity()
-        else:
-            self.layer_scale_1 = LayerScale(d_model, layer_scale, **factory_kwargs)
-            self.layer_scale_2 = LayerScale(d_model, layer_scale, **factory_kwargs)
-
-        self.cross_attention: tp.Optional[nn.Module] = None
-        if cross_attention:
-            self.cross_attention = StreamingMultiheadAttention(
-                cross_attention=True, qk_layer_norm=qk_layer_norm_cross,
-                **attn_kwargs, **factory_kwargs)
-            # Norm and dropout
-            self.dropout_cross = nn.Dropout(dropout)
-            # eps value matching that used in PyTorch reference implementation.
-            self.norm_cross = nn.LayerNorm(d_model, eps=1e-5, **factory_kwargs)
-            self.layer_scale_cross: nn.Module
-            if layer_scale is None:
-                self.layer_scale_cross = nn.Identity()
-            else:
-                self.layer_scale_cross = LayerScale(d_model, layer_scale, **factory_kwargs)
-        self.norm1 = create_norm_fn(norm, d_model, **factory_kwargs)  # type: ignore
-        self.norm2 = create_norm_fn(norm, d_model, **factory_kwargs)  # type: ignore
-
-    def _cross_attention_block(self, src: torch.Tensor,
-                               cross_attention_src: torch.Tensor) -> torch.Tensor:
-        assert self.cross_attention is not None
-        # queries are from src, keys and values from cross_attention_src.
-        x = self.cross_attention(
-            src, cross_attention_src, cross_attention_src, need_weights=False)[0]
-        return self.dropout_cross(x)  # type: ignore
-
-    def forward(self, src: torch.Tensor, src_mask: tp.Optional[torch.Tensor] = None,  # type: ignore
-                src_key_padding_mask: tp.Optional[torch.Tensor] = None,
-                cross_attention_src: tp.Optional[torch.Tensor] = None):
-        if self.cross_attention is None:
-            assert cross_attention_src is None
-        else:
-            assert cross_attention_src is not None
-        x = src
-        if self.norm_first:
-            x = x + self.layer_scale_1(
-                self._sa_block(self.norm1(x), src_mask, src_key_padding_mask))
-            if cross_attention_src is not None:
-                x = x + self.layer_scale_cross(
-                    self._cross_attention_block(
-                        self.norm_cross(x), cross_attention_src))
-            x = x + self.layer_scale_2(self._ff_block(self.norm2(x)))
-        else:
-            x = self.norm1(x + self.layer_scale_1(
-                self._sa_block(x, src_mask, src_key_padding_mask)))
-            if cross_attention_src is not None:
-                x = self.norm_cross(
-                    x + self.layer_scale_cross(
-                        self._cross_attention_block(src, cross_attention_src)))
-            x = self.norm2(x + self.layer_scale_2(self._ff_block(x)))
-        return x
-
-
-class StreamingTransformer(StreamingModule):
-    """Transformer with Streaming / Causal support.
-
-    Args:
-        d_model (int): Dimension of the data.
-        num_heads (int): Number of heads.
-        dim_feedforward (int): Intermediate dimension of FF module.
-        dropout (float): Dropout both for MHA and FF.
-        bias_ff (bool): Use bias for FF.
-        bias_attn (bool): Use bias for MHA.
-        causal (bool): Causal mask applied automatically.
-        past_context (int, optional): Receptive field for the causal mask, infinite if None.
-        custom (bool): Use custom MHA implementation, for testing / benchmarking.
-        memory_efficient (bool): Use xformers based memory efficient attention.
-        attention_as_float32 (bool): Perform the attention as float32
-            (especially important with memory_efficient as autocast won't do this automatically).
-        cross_attention (bool): If True, expect to get secondary input for cross-attention.
-        layer_scale (float, optional): If not None, LayerScale will be used
-            with the given value as initial scale.
-        positional_embedding (str): Positional embedding strategy (sin, rope, or sin_rope).
-        max_period (float): Maximum period of the time embedding.
-        positional_scale (float): Scale of positional embedding, set to 0 to deactivate.
-        xpos (bool): Apply xpos exponential decay to positional embedding (rope only).
-        lr (float, optional): learning rate override through the `make_optim_group` API.
-        weight_decay (float, optional): Weight_decay override through the `make_optim_group` API.
-        layer_class: (subclass of `StreamingTransformerLayer): class to use
-            to initialize the layers, allowing further customization outside of AudioCraft.
-        checkpointing (str): Checkpointing strategy to reduce memory usage.
-            No checkpointing if set to 'none'. Per layer checkpointing using PyTorch
-            if set to 'torch' (entire layer checkpointed, i.e. linears are evaluated twice,
-            minimal memory usage, but maximal runtime). Finally, `xformers_default` provide
-            a policy for opting-out some operations of the checkpointing like
-            linear layers and attention, providing a middle ground between speed and memory.
-        device (torch.device, optional): Device on which to initialize.
-        dtype (torch.dtype, optional): dtype to use.
-        **kwargs: See `nn.TransformerEncoderLayer`.
-    """
-    def __init__(self, d_model: int, num_heads: int, num_layers: int, dim_feedforward: int = 2048,
-                 dropout: float = 0.1, bias_ff: bool = True, bias_attn: bool = True,
-                 causal: bool = False, past_context: tp.Optional[int] = None,
-                 custom: bool = False, memory_efficient: bool = False, attention_as_float32: bool = False,
-                 cross_attention: bool = False, layer_scale: tp.Optional[float] = None,
-                 positional_embedding: str = 'sin', max_period: float = 10_000, positional_scale: float = 1.,
-                 xpos: bool = False, lr: tp.Optional[float] = None, weight_decay: tp.Optional[float] = None,
-                 layer_class: tp.Type[StreamingTransformerLayer] = StreamingTransformerLayer,
-                 checkpointing: str = 'none', device=None, dtype=None, **kwargs):
-        super().__init__()
-        assert d_model % num_heads == 0
-
-        self.positional_embedding = positional_embedding
-        self.max_period = max_period
-        self.positional_scale = positional_scale
-        self.weight_decay = weight_decay
-        self.lr = lr
-
-        assert positional_embedding in ['sin', 'rope', 'sin_rope']
-        self.rope: tp.Optional[RotaryEmbedding] = None
-        if self.positional_embedding in ['rope', 'sin_rope']:
-            assert _is_custom(custom, memory_efficient)
-            self.rope = RotaryEmbedding(d_model // num_heads, max_period=max_period,
-                                        xpos=xpos, scale=positional_scale, device=device)
-
-        self.checkpointing = checkpointing
-
-        assert checkpointing in ['none', 'torch', 'xformers_default', 'xformers_mm']
-        if self.checkpointing.startswith('xformers'):
-            _verify_xformers_internal_compat()
-
-        self.layers = nn.ModuleList()
-        for idx in range(num_layers):
-            self.layers.append(
-                layer_class(
-                    d_model=d_model, num_heads=num_heads, dim_feedforward=dim_feedforward,
-                    dropout=dropout, bias_ff=bias_ff, bias_attn=bias_attn,
-                    causal=causal, past_context=past_context, custom=custom,
-                    memory_efficient=memory_efficient, attention_as_float32=attention_as_float32,
-                    cross_attention=cross_attention, layer_scale=layer_scale, rope=self.rope,
-                    device=device, dtype=dtype, **kwargs))
-
-        if self.checkpointing != 'none':
-            for layer in self.layers:
-                # see audiocraft/optim/fsdp.py, magic signal to indicate this requires fixing the
-                # backward hook inside of FSDP...
-                layer._magma_checkpointed = True  # type: ignore
-                assert layer.layer_drop == 0., "Need further checking"  # type: ignore
-
-    def _apply_layer(self, layer, *args, **kwargs):
-        method = self.checkpointing
-        if method == 'none':
-            return layer(*args, **kwargs)
-        elif method == 'torch':
-            return torch_checkpoint(layer, *args, use_reentrant=False, **kwargs)
-        elif method.startswith('xformers'):
-            from xformers.checkpoint_fairinternal import checkpoint, _get_default_policy
-            if method == 'xformers_default':
-                # those operations will be saved, and not recomputed.
-                # According to Francisco we can get smarter policies but this is a good start.
-                allow_list = [
-                    "xformers.efficient_attention_forward_cutlass.default",
-                    "xformers_flash.flash_fwd.default",
-                    "aten.addmm.default",
-                    "aten.mm.default",
-                ]
-            elif method == 'xformers_mm':
-                # those operations will be saved, and not recomputed.
-                # According to Francisco we can get smarter policies but this is a good start.
-                allow_list = [
-                    "aten.addmm.default",
-                    "aten.mm.default",
-                ]
-            else:
-                raise ValueError(f"xformers checkpointing xformers policy {method} is not known.")
-            policy_fn = _get_default_policy(allow_list)
-            return checkpoint(layer, *args, policy_fn=policy_fn, **kwargs)
-        else:
-            raise ValueError(f"Checkpointing method {method} is unknown.")
-
-    def forward(self, x: torch.Tensor, *args, **kwargs):
-        B, T, C = x.shape
-
-        if 'offsets' in self._streaming_state:
-            offsets = self._streaming_state['offsets']
-        else:
-            offsets = torch.zeros(B, dtype=torch.long, device=x.device)
-
-        if self.positional_embedding in ['sin', 'sin_rope']:
-            positions = torch.arange(T, device=x.device).view(1, -1, 1)
-            positions = positions + offsets.view(-1, 1, 1)
-            pos_emb = create_sin_embedding(positions, C, max_period=self.max_period, dtype=x.dtype)
-            x = x + self.positional_scale * pos_emb
-
-        for layer in self.layers:
-            x = self._apply_layer(layer, x, *args, **kwargs)
-
-        if self._is_streaming:
-            self._streaming_state['offsets'] = offsets + T
-
-        return x
-
-    def make_optim_group(self):
-        group = {"params": list(self.parameters())}
-        if self.lr is not None:
-            group["lr"] = self.lr
-        if self.weight_decay is not None:
-            group["weight_decay"] = self.weight_decay
-        return group
-
-
-# special attention related function
-
-def _verify_xformers_memory_efficient_compat():
-    try:
-        from xformers.ops import memory_efficient_attention, LowerTriangularMask  # noqa
-    except ImportError:
-        raise ImportError(
-            "xformers is not installed. Please install it and try again.\n"
-            "To install on AWS and Azure, run \n"
-            "FORCE_CUDA=1 TORCH_CUDA_ARCH_LIST='8.0'\\\n"
-            "pip install -U git+https://[email protected]/fairinternal/xformers.git#egg=xformers\n"
-            "To install on FAIR Cluster, run \n"
-            "FORCE_CUDA=1 TORCH_CUDA_ARCH_LIST='6.0;7.0'\\\n"
-            "pip install -U git+https://[email protected]/fairinternal/xformers.git#egg=xformers\n")
-
-
-def _verify_xformers_internal_compat():
-    try:
-        from xformers.checkpoint_fairinternal import checkpoint, _get_default_policy  # noqa
-    except ImportError:
-        raise ImportError(
-            "Francisco's fairinternal xformers is not installed. Please install it and try again.\n"
-            "To install on AWS and Azure, run \n"
-            "FORCE_CUDA=1 TORCH_CUDA_ARCH_LIST='8.0'\\\n"
-            "pip install -U git+https://[email protected]/fairinternal/xformers.git#egg=xformers\n"
-            "To install on FAIR Cluster, run \n"
-            "FORCE_CUDA=1 TORCH_CUDA_ARCH_LIST='6.0;7.0'\\\n"
-            "pip install -U git+https://[email protected]/fairinternal/xformers.git#egg=xformers\n")
-
-
-def _is_custom(custom: bool, memory_efficient: bool):
-    return custom or memory_efficient

spaces/AbandonedMuse/UnlimitedMusicGen/audiocraft/utils/export.py

@@ -1,56 +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.
-
-"""
-Utility to export a training checkpoint to a lightweight release checkpoint.
-"""
-
-from pathlib import Path
-import typing as tp
-
-from omegaconf import OmegaConf, DictConfig
-import torch
-
-
-def _clean_lm_cfg(cfg: DictConfig):
-    OmegaConf.set_struct(cfg, False)
-    # This used to be set automatically in the LM solver, need a more robust solution
-    # for the future.
-    cfg['transformer_lm']['card'] = 2048
-    cfg['transformer_lm']['n_q'] = 4
-    # Experimental params no longer supported.
-    bad_params = ['spectral_norm_attn_iters', 'spectral_norm_ff_iters',
-                  'residual_balancer_attn', 'residual_balancer_ff', 'layer_drop']
-    for name in bad_params:
-        del cfg['transformer_lm'][name]
-    OmegaConf.set_struct(cfg, True)
-    return cfg
-
-
-def export_encodec(checkpoint_path: tp.Union[Path, str], out_folder: tp.Union[Path, str]):
-    sig = Path(checkpoint_path).parent.name
-    assert len(sig) == 8, "Not a valid Dora signature"
-    pkg = torch.load(checkpoint_path, 'cpu')
-    new_pkg = {
-        'best_state': pkg['ema']['state']['model'],
-        'xp.cfg': OmegaConf.to_yaml(pkg['xp.cfg']),
-    }
-    out_file = Path(out_folder) / f'{sig}.th'
-    torch.save(new_pkg, out_file)
-    return out_file
-
-
-def export_lm(checkpoint_path: tp.Union[Path, str], out_folder: tp.Union[Path, str]):
-    sig = Path(checkpoint_path).parent.name
-    assert len(sig) == 8, "Not a valid Dora signature"
-    pkg = torch.load(checkpoint_path, 'cpu')
-    new_pkg = {
-        'best_state': pkg['fsdp_best_state']['model'],
-        'xp.cfg': OmegaConf.to_yaml(_clean_lm_cfg(pkg['xp.cfg']))
-    }
-    out_file = Path(out_folder) / f'{sig}.th'
-    torch.save(new_pkg, out_file)
-    return out_file

spaces/AbandonedMuse/UnlimitedMusicGen/audiocraft/utils/extend.py

@@ -1,332 +0,0 @@
-from tabnanny import verbose
-import torch
-import math
-from audiocraft.models import MusicGen
-import numpy as np
-from PIL import Image, ImageDraw, ImageFont, ImageColor
-import string
-import tempfile
-import os
-import textwrap
-import requests
-from io import BytesIO
-from huggingface_hub import hf_hub_download
-import librosa
-
-
-INTERRUPTING = False
-
-def separate_audio_segments(audio, segment_duration=30, overlap=1):
-    sr, audio_data = audio[0], audio[1]
-    
-    segment_samples = sr * segment_duration
-    total_samples = max(min((len(audio_data) // segment_samples), 25), 0)
-    overlap_samples = sr * overlap
-
-    segments = []
-    start_sample = 0
-    # handle the case where the audio is shorter than the segment duration
-    if total_samples == 0:
-        total_samples = 1
-        segment_samples = len(audio_data)
-        overlap_samples = 0
-    while total_samples >= segment_samples:
-        # Collect the segment
-        # the end sample is the start sample plus the segment samples, 
-        # the start sample, after 0, is minus the overlap samples to account for the overlap        
-        end_sample = start_sample + segment_samples
-        segment = audio_data[start_sample:end_sample]
-        segments.append((sr, segment))
-
-        start_sample += segment_samples - overlap_samples
-        total_samples -= segment_samples
-
-    # Collect the final segment
-    if total_samples > 0:
-        segment = audio_data[-segment_samples:]
-        segments.append((sr, segment))
-    print(f"separate_audio_segments: {len(segments)} segments of length {segment_samples // sr} seconds")
-    return segments
-
-def generate_music_segments(text, melody, seed, MODEL, duration:int=10, overlap:int=1, segment_duration:int=30, prompt_index:int=0, harmony_only:bool= False):
-    # generate audio segments
-    melody_segments = separate_audio_segments(melody, segment_duration, 0) 
-    
-    # Create lists to store the melody tensors for each segment
-    melodys = []
-    output_segments = []
-    last_chunk = []
-    text += ", seed=" + str(seed)
-    prompt_segment = None
-    # prevent hacking
-    duration = min(duration, 720)
-    overlap =  min(overlap, 15)
-    
-    # Calculate the total number of segments
-    total_segments = max(math.ceil(duration / segment_duration),1)
-    #calculate duration loss from segment overlap
-    duration_loss = max(total_segments - 1,0) * math.ceil(overlap / 2)
-    #calc excess duration
-    excess_duration = segment_duration - (total_segments * segment_duration - duration)
-    print(f"total Segments to Generate: {total_segments} for {duration} seconds. Each segment is {segment_duration} seconds. Excess {excess_duration} Overlap Loss {duration_loss}")
-    duration += duration_loss
-    while excess_duration + duration_loss > segment_duration:
-        total_segments += 1
-        #calculate duration loss from segment overlap
-        duration_loss += math.ceil(overlap / 2)
-        #calc excess duration
-        excess_duration = segment_duration - (total_segments * segment_duration - duration)
-        print(f"total Segments to Generate: {total_segments} for {duration} seconds. Each segment is {segment_duration} seconds. Excess {excess_duration} Overlap Loss {duration_loss}")
-        if excess_duration + duration_loss > segment_duration:
-            duration += duration_loss
-            duration_loss = 0
-    total_segments = min(total_segments, (720 // segment_duration))
-
-    # If melody_segments is shorter than total_segments, repeat the segments until the total_segments is reached
-    if len(melody_segments) < total_segments:
-        #fix melody_segments
-        for i in range(total_segments - len(melody_segments)):
-            segment = melody_segments[i]
-            melody_segments.append(segment)
-        print(f"melody_segments: {len(melody_segments)} fixed")
-
-    # Iterate over the segments to create list of Meldoy tensors
-    for segment_idx in range(total_segments):
-        if INTERRUPTING:
-            return [], duration
-        print(f"segment {segment_idx + 1} of {total_segments} \r")
-
-        if harmony_only:
-            # REMOVE PERCUSION FROM MELODY
-            # Apply HPSS using librosa
-            verse_harmonic, verse_percussive = librosa.effects.hpss(melody_segments[segment_idx][1])
-            # Convert the separated components back to torch.Tensor
-            #harmonic_tensor = torch.from_numpy(verse_harmonic)
-            #percussive_tensor = torch.from_numpy(verse_percussive)
-            sr, verse = melody_segments[segment_idx][0], torch.from_numpy(verse_harmonic).to(MODEL.device).float().t().unsqueeze(0)
-        else:
-            sr, verse = melody_segments[segment_idx][0], torch.from_numpy(melody_segments[segment_idx][1]).to(MODEL.device).float().t().unsqueeze(0)
-
-        print(f"shape:{verse.shape} dim:{verse.dim()}")
-        if verse.dim() == 2:
-            verse = verse[None]
-        verse = verse[..., :int(sr * MODEL.lm.cfg.dataset.segment_duration)]
-
-        # Append the segment to the melodys list
-        melodys.append(verse)
-
-    torch.manual_seed(seed)
-
-    # If user selects a prompt segment, generate a new prompt segment to use on all segments
-    #default to the first segment for prompt conditioning
-    prompt_verse = melodys[0]
-    if prompt_index > 0:
-        # Get a prompt segment from the selected verse, normally the first verse
-        prompt_verse = melodys[prompt_index if prompt_index <= (total_segments - 1) else (total_segments -1)]
-       
-    # set the prompt segment MODEL generation params
-    MODEL.set_generation_params(
-        use_sampling=True,
-        top_k=MODEL.generation_params["top_k"],
-        top_p=MODEL.generation_params["top_p"],
-        temperature=MODEL.generation_params["temp"],
-        cfg_coef=MODEL.generation_params["cfg_coef"],
-        duration=segment_duration,
-        two_step_cfg=False,
-        rep_penalty=0.5
-    )
-    # Generate a new prompt segment. This will be applied to all segments for consistency
-    print(f"Generating New Prompt Segment: {text} from verse {prompt_index}\r")
-    prompt_segment = MODEL.generate_with_all(
-        descriptions=[text],
-        melody_wavs=prompt_verse,
-        sample_rate=sr,
-        progress=False,
-        prompt=None,
-    )       
-
-    for idx, verse in enumerate(melodys):
-        if INTERRUPTING:
-            return output_segments, duration
-
-        print(f'Segment duration: {segment_duration}, duration: {duration}, overlap: {overlap} Overlap Loss: {duration_loss}')
-        # Compensate for the length of final segment
-        if ((idx + 1) == len(melodys)) or (duration < segment_duration):
-            mod_duration = max(min(duration, segment_duration),1)
-            print(f'Modify verse length, duration: {duration}, overlap: {overlap} Overlap Loss: {duration_loss} to mod duration: {mod_duration}')
-            MODEL.set_generation_params(
-                use_sampling=True,
-                top_k=MODEL.generation_params["top_k"],
-                top_p=MODEL.generation_params["top_p"],
-                temperature=MODEL.generation_params["temp"],
-                cfg_coef=MODEL.generation_params["cfg_coef"],
-                duration=mod_duration,
-                two_step_cfg=False,
-                rep_penalty=0.5
-            )
-            try:
-                # get last chunk
-                verse = verse[:, :, -mod_duration*MODEL.sample_rate:]
-                prompt_segment = prompt_segment[:, :, -mod_duration*MODEL.sample_rate:]
-            except:
-                # get first chunk
-                verse = verse[:, :, :mod_duration*MODEL.sample_rate] 
-                prompt_segment = prompt_segment[:, :, :mod_duration*MODEL.sample_rate]
-      
-            
-        print(f"Generating New Melody Segment {idx + 1}: {text}\r")
-        output = MODEL.generate_with_all(
-            descriptions=[text],
-            melody_wavs=verse,
-            sample_rate=sr,
-            progress=False,
-            prompt=prompt_segment,
-        )
-        # If user selects a prompt segment, use the prompt segment for all segments
-        # Otherwise, use the previous segment as the prompt
-        if prompt_index < 0:
-            prompt_segment = output
-
-        # Append the generated output to the list of segments
-        #output_segments.append(output[:, :segment_duration])
-        output_segments.append(output)
-        print(f"output_segments: {len(output_segments)}: shape: {output.shape} dim {output.dim()}")
-        #track duration
-        if duration > segment_duration:
-            duration -= segment_duration
-    return output_segments, excess_duration
-
-def save_image(image):
-    """
-    Saves a PIL image to a temporary file and returns the file path.
-
-    Parameters:
-    - image: PIL.Image
-        The PIL image object to be saved.
-
-    Returns:
-    - str or None: The file path where the image was saved,
-        or None if there was an error saving the image.
-
-    """
-    temp_dir = tempfile.gettempdir()
-    temp_file = tempfile.NamedTemporaryFile(suffix=".png", dir=temp_dir, delete=False)
-    temp_file.close()
-    file_path = temp_file.name
-
-    try:
-        image.save(file_path)
-        
-    except Exception as e:
-        print("Unable to save image:", str(e))
-        return None
-    finally:
-        return file_path
-
-def hex_to_rgba(hex_color):
-    try:
-        # Convert hex color to RGBA tuple
-        rgba = ImageColor.getcolor(hex_color, "RGBA")
-    except ValueError:
-        # If the hex color is invalid, default to yellow
-        rgba = (255,255,0,255)
-    return rgba
-
-def load_font(font_name, font_size=16):
-    """
-    Load a font using the provided font name and font size.
-
-    Parameters:
-        font_name (str): The name of the font to load. Can be a font name recognized by the system, a URL to download the font file,
-            a local file path, or a Hugging Face model hub identifier.
-        font_size (int, optional): The size of the font. Default is 16.
-
-    Returns:
-        ImageFont.FreeTypeFont: The loaded font object.
-
-    Notes:
-        This function attempts to load the font using various methods until a suitable font is found. If the provided font_name
-        cannot be loaded, it falls back to a default font.
-
-        The font_name can be one of the following:
-        - A font name recognized by the system, which can be loaded using ImageFont.truetype.
-        - A URL pointing to the font file, which is downloaded using requests and then loaded using ImageFont.truetype.
-        - A local file path to the font file, which is loaded using ImageFont.truetype.
-        - A Hugging Face model hub identifier, which downloads the font file from the Hugging Face model hub using hf_hub_download
-          and then loads it using ImageFont.truetype.
-
-    Example:
-        font = load_font("Arial.ttf", font_size=20)
-    """
-    font = None
-    if not "http" in font_name:
-        try:
-            font = ImageFont.truetype(font_name, font_size)
-        except (FileNotFoundError, OSError):
-            print("Font not found. Using Hugging Face download..\n")
-
-        if font is None:
-            try:
-                font_path = ImageFont.truetype(hf_hub_download(repo_id=os.environ.get('SPACE_ID', ''), filename="assets/" + font_name, repo_type="space"), encoding="UTF-8")        
-                font = ImageFont.truetype(font_path, font_size)
-            except (FileNotFoundError, OSError):
-                print("Font not found. Trying to download from local assets folder...\n")
-        if font is None:
-            try:
-                font = ImageFont.truetype("assets/" + font_name, font_size)
-            except (FileNotFoundError, OSError):
-                print("Font not found. Trying to download from URL...\n")
-
-    if font is None:
-        try:
-            req = requests.get(font_name)
-            font = ImageFont.truetype(BytesIO(req.content), font_size)  
-        except (FileNotFoundError, OSError):            
-            print(f"Font not found: {font_name} Using default font\n")
-    if font:
-        print(f"Font loaded {font.getname()}")
-    else:
-        font = ImageFont.load_default()
-    return font
-
-
-def add_settings_to_image(title: str = "title", description: str = "", width: int = 768, height: int = 512, background_path: str = "", font: str = "arial.ttf", font_color: str = "#ffffff"):
-    # Create a new RGBA image with the specified dimensions
-    image = Image.new("RGBA", (width, height), (255, 255, 255, 0))
-    # If a background image is specified, open it and paste it onto the image
-    if background_path == "":
-        background = Image.new("RGBA", (width, height), (255, 255, 255, 255))
-    else:
-        background = Image.open(background_path).convert("RGBA")
-
-    #Convert font color to RGBA tuple
-    font_color = hex_to_rgba(font_color)
-
-    # Calculate the center coordinates for placing the text
-    text_x = width // 2
-    text_y = height // 2
-    # Draw the title text at the center top
-    title_font = load_font(font, 26)  # Replace with your desired font and size
-
-    title_text = '\n'.join(textwrap.wrap(title, width // 12))
-    title_x, title_y, title_text_width, title_text_height = title_font.getbbox(title_text)
-    title_x = max(text_x - (title_text_width // 2), title_x, 0)
-    title_y = text_y - (height // 2) + 10  # 10 pixels padding from the top
-    title_draw = ImageDraw.Draw(image)
-    title_draw.multiline_text((title_x, title_y), title, fill=font_color, font=title_font, align="center")
-    # Draw the description text two lines below the title
-    description_font = load_font(font, 16)  # Replace with your desired font and size
-    description_text = '\n'.join(textwrap.wrap(description, width // 12))
-    description_x, description_y, description_text_width, description_text_height = description_font.getbbox(description_text)
-    description_x = max(text_x - (description_text_width // 2), description_x, 0)
-    description_y = title_y + title_text_height + 20  # 20 pixels spacing between title and description
-    description_draw = ImageDraw.Draw(image)
-    description_draw.multiline_text((description_x, description_y), description_text, fill=font_color, font=description_font, align="center")
-    # Calculate the offset to center the image on the background
-    bg_w, bg_h = background.size
-    offset = ((bg_w - width) // 2, (bg_h - height) // 2)
-    # Paste the image onto the background
-    background.paste(image, offset, mask=image)
-
-    # Save the image and return the file path
-    return save_image(background)

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

@@ -1,28 +0,0 @@
-import type { Message } from "$lib/types/Message";
-import type { LegacyParamatersTemplateInput } from "$lib/types/Template";
-import Handlebars from "handlebars";
-
-Handlebars.registerHelper("ifUser", function (this: Pick<Message, "from" | "content">, options) {
-	if (this.from == "user") return options.fn(this);
-});
-
-Handlebars.registerHelper(
-	"ifAssistant",
-	function (this: Pick<Message, "from" | "content">, options) {
-		if (this.from == "assistant") return options.fn(this);
-	}
-);
-
-export function compileTemplate<T>(input: string, model: LegacyParamatersTemplateInput) {
-	const template = Handlebars.compile<T & LegacyParamatersTemplateInput>(input, {
-		knownHelpers: { ifUser: true, ifAssistant: true },
-		knownHelpersOnly: true,
-		noEscape: true,
-		strict: true,
-		preventIndent: true,
-	});
-
-	return function render(inputs: T, options?: RuntimeOptions) {
-		return template({ ...model, ...inputs }, options);
-	};
-}

spaces/AchyuthGamer/OpenGPT/g4f/models.py

@@ -1,274 +0,0 @@
-from __future__  import annotations
-from dataclasses import dataclass
-from .typing     import Union
-from .Provider   import BaseProvider, RetryProvider
-from .Provider   import (
-    AItianhuSpace,
-    ChatgptLogin,
-    ChatgptDemo,
-    ChatgptDuo,
-    Vitalentum,
-    ChatgptAi,
-    ChatForAi,
-    AItianhu,
-    ChatBase,
-    Liaobots,
-    Yqcloud,
-    Myshell,
-    FreeGpt,
-    Vercel, 
-    DeepAi,
-    Aichat,
-    GPTalk,
-    GptGod,
-    AiAsk,
-    GptGo,
-    Ylokh,
-    Bard, 
-    Aibn,
-    Bing,
-    You,
-    H2o
-)
-
-@dataclass(unsafe_hash=True)
-class Model:
-    name: str
-    base_provider: str
-    best_provider: Union[type[BaseProvider], RetryProvider] = None
-
-default = Model(
-    name          = "",
-    base_provider = "",
-    best_provider = RetryProvider([
-        Bing,         # Not fully GPT 3 or 4
-        Yqcloud,      # Answers short questions in chinese
-        ChatBase,     # Don't want to answer creatively
-        ChatgptDuo,   # Include search results
-        Aibn, Aichat, ChatForAi, ChatgptAi, ChatgptLogin, DeepAi, FreeGpt, GptGo, Myshell, Ylokh,
-    ])
-)
-
-# GPT-3.5 too, but all providers supports long responses and a custom timeouts
-gpt_35_long = Model(
-    name          = 'gpt-3.5-turbo',
-    base_provider = 'openai',
-    best_provider = RetryProvider([
-        AiAsk, Aibn, Aichat, ChatForAi, ChatgptAi, ChatgptDemo, ChatgptDuo,
-        FreeGpt, GptGo, Liaobots, Myshell, Vitalentum, Ylokh, You, Yqcloud,
-        GPTalk, GptGod
-    ])
-)
-
-# GPT-3.5 / GPT-4
-gpt_35_turbo = Model(
-    name          = 'gpt-3.5-turbo',
-    base_provider = 'openai',
-    best_provider = RetryProvider([
-        DeepAi, ChatgptLogin, ChatgptAi, GptGo, AItianhu, Aichat, AItianhuSpace, Myshell, Aibn, ChatForAi, FreeGpt, Ylokh
-    ])
-)
-
-gpt_4 = Model(
-    name          = 'gpt-4',
-    base_provider = 'openai',
-    best_provider = Bing
-)
-
-# Bard
-palm = Model(
-    name          = 'palm',
-    base_provider = 'google',
-    best_provider = Bard)
-
-# H2o
-falcon_7b = Model(
-    name          = 'h2oai/h2ogpt-gm-oasst1-en-2048-falcon-7b-v3',
-    base_provider = 'huggingface',
-    best_provider = H2o)
-
-falcon_40b = Model(
-    name          = 'h2oai/h2ogpt-gm-oasst1-en-2048-falcon-40b-v1',
-    base_provider = 'huggingface',
-    best_provider = H2o)
-
-llama_13b = Model(
-    name          = 'h2oai/h2ogpt-gm-oasst1-en-2048-open-llama-13b',
-    base_provider = 'huggingface',
-    best_provider = H2o)
-
-# Vercel
-claude_instant_v1 = Model(
-    name          = 'claude-instant-v1',
-    base_provider = 'anthropic',
-    best_provider = Vercel)
-
-claude_v1 = Model(
-    name          = 'claude-v1',
-    base_provider = 'anthropic',
-    best_provider = Vercel)
-
-claude_v2 = Model(
-    name          = 'claude-v2',
-    base_provider = 'anthropic',
-    best_provider = Vercel)
-
-command_light_nightly = Model(
-    name          = 'command-light-nightly',
-    base_provider = 'cohere',
-    best_provider = Vercel)
-
-command_nightly = Model(
-    name          = 'command-nightly',
-    base_provider = 'cohere',
-    best_provider = Vercel)
-
-gpt_neox_20b = Model(
-    name          = 'EleutherAI/gpt-neox-20b',
-    base_provider = 'huggingface',
-    best_provider = Vercel)
-
-oasst_sft_1_pythia_12b = Model(
-    name          = 'OpenAssistant/oasst-sft-1-pythia-12b',
-    base_provider = 'huggingface',
-    best_provider = Vercel)
-
-oasst_sft_4_pythia_12b_epoch_35 = Model(
-    name          = 'OpenAssistant/oasst-sft-4-pythia-12b-epoch-3.5',
-    base_provider = 'huggingface',
-    best_provider = Vercel)
-
-santacoder = Model(
-    name          = 'bigcode/santacoder',
-    base_provider = 'huggingface',
-    best_provider = Vercel)
-
-bloom = Model(
-    name          = 'bigscience/bloom',
-    base_provider = 'huggingface',
-    best_provider = Vercel)
-
-flan_t5_xxl = Model(
-    name          = 'google/flan-t5-xxl',
-    base_provider = 'huggingface',
-    best_provider = Vercel)
-
-code_davinci_002 = Model(
-    name          = 'code-davinci-002',
-    base_provider = 'openai',
-    best_provider = Vercel)
-
-gpt_35_turbo_16k = Model(
-    name          = 'gpt-3.5-turbo-16k',
-    base_provider = 'openai',
-    best_provider = Vercel)
-
-gpt_35_turbo_16k_0613 = Model(
-    name          = 'gpt-3.5-turbo-16k-0613',
-    base_provider = 'openai')
-
-gpt_35_turbo_0613 = Model(
-    name          = 'gpt-3.5-turbo-0613',
-    base_provider = 'openai'
-)
-
-gpt_4_0613 = Model(
-    name          = 'gpt-4-0613',
-    base_provider = 'openai'
-)
-
-gpt_4_32k = Model(
-    name          = 'gpt-4-32k',
-    base_provider = 'openai'
-)
-
-gpt_4_32k_0613 = Model(
-    name          = 'gpt-4-32k-0613',
-    base_provider = 'openai'
-)
-
-text_ada_001 = Model(
-    name          = 'text-ada-001',
-    base_provider = 'openai',
-    best_provider = Vercel)
-
-text_babbage_001 = Model(
-    name          = 'text-babbage-001',
-    base_provider = 'openai',
-    best_provider = Vercel)
-
-text_curie_001 = Model(
-    name          = 'text-curie-001',
-    base_provider = 'openai',
-    best_provider = Vercel)
-
-text_davinci_002 = Model(
-    name          = 'text-davinci-002',
-    base_provider = 'openai',
-    best_provider = Vercel)
-
-text_davinci_003 = Model(
-    name          = 'text-davinci-003',
-    base_provider = 'openai',
-    best_provider = Vercel)
-
-llama13b_v2_chat = Model(
-    name          = 'replicate:a16z-infra/llama13b-v2-chat',
-    base_provider = 'replicate',
-    best_provider = Vercel)
-
-llama7b_v2_chat = Model(
-    name          = 'replicate:a16z-infra/llama7b-v2-chat',
-    base_provider = 'replicate',
-    best_provider = Vercel)
-
-
-class ModelUtils:
-    convert: dict[str, Model] = {
-        # gpt-3.5
-        'gpt-3.5-turbo'          : gpt_35_turbo,
-        'gpt-3.5-turbo-0613'     : gpt_35_turbo_0613,
-        'gpt-3.5-turbo-16k'      : gpt_35_turbo_16k,
-        'gpt-3.5-turbo-16k-0613' : gpt_35_turbo_16k_0613,
-        
-        # gpt-4
-        'gpt-4'          : gpt_4,
-        'gpt-4-0613'     : gpt_4_0613,
-        'gpt-4-32k'      : gpt_4_32k,
-        'gpt-4-32k-0613' : gpt_4_32k_0613,
-        
-        # Bard
-        'palm2'       : palm,
-        'palm'        : palm,
-        'google'      : palm,
-        'google-bard' : palm,
-        'google-palm' : palm,
-        'bard'        : palm,
-        
-        # H2o
-        'falcon-40b' : falcon_40b,
-        'falcon-7b'  : falcon_7b,
-        'llama-13b'  : llama_13b,
-        
-        # Vercel
-        'claude-instant-v1' : claude_instant_v1,
-        'claude-v1'         : claude_v1,
-        'claude-v2'         : claude_v2,
-        'command-nightly'   : command_nightly,
-        'gpt-neox-20b'      : gpt_neox_20b,
-        'santacoder'        : santacoder,
-        'bloom'             : bloom,
-        'flan-t5-xxl'       : flan_t5_xxl,
-        'code-davinci-002'  : code_davinci_002,
-        'text-ada-001'      : text_ada_001,
-        'text-babbage-001'  : text_babbage_001,
-        'text-curie-001'    : text_curie_001,
-        'text-davinci-002'  : text_davinci_002,
-        'text-davinci-003'  : text_davinci_003,
-        'llama13b-v2-chat'  : llama13b_v2_chat,
-        'llama7b-v2-chat'   : llama7b_v2_chat,
-        
-        'oasst-sft-1-pythia-12b'           : oasst_sft_1_pythia_12b,
-        'oasst-sft-4-pythia-12b-epoch-3.5' : oasst_sft_4_pythia_12b_epoch_35,
-        'command-light-nightly'            : command_light_nightly,
-    }

spaces/AfrodreamsAI/afrodreams/ex_app.py

@@ -1,95 +0,0 @@
-import neural_style
-import streamlit as st
-import os 
-import random
-import numpy as np
-from  PIL import Image, ImageEnhance
-from io import BytesIO
-#import streamlit_ext as ste #for download button not to rerun
-from huggingface_hub import upload_file
-
-HF_TOKEN = os.environ.get("HF_TOKEN")
-
-st.set_page_config(layout="wide")
-#Create two columns with different width
-col1, col2 = st.columns( [0.8, 0.2])
-with col1:               # To display the header text using css style
-    st.markdown(""" <style> .font {
-    font-size:35px ; font-family: 'Cooper Black'; color: #FF9633;} 
-    </style> """, unsafe_allow_html=True)
-    st.markdown('<p class="font">Upload your photo here...</p>', unsafe_allow_html=True)
-    st.subheader("This app takes in your image and styles it with a unique african art.")
-    
-#Add a header and expander in side bar
-st.sidebar.markdown('<p class="font">Afrodreams.AI</p>', unsafe_allow_html=True)
-with st.sidebar.expander("About the App"):
-     st.write("""
-        This app takes in your image and styles it with a unique african art.""")
-
-
-#Add file uploader to allow users to upload photos
-uploaded_file = st.file_uploader("", type=['jpg','png','jpeg'])
-
-# add slider to side bar
-style_weight = st.slider("Select Style Weight", min_value=10, max_value=100, value=12)
-
-#Add 'before' and 'after' columns
-if uploaded_file is not None:
-    image = Image.open(uploaded_file)
-    
-    col1, col2 = st.columns( [0.5, 0.5])
-    with col1:
-        st.markdown('<p style="text-align: center;">Before</p>',unsafe_allow_html=True)
-        st.image(image,width=300)  
-
-    with col2:
-        st.markdown('<p style="text-align: center;">After</p>',unsafe_allow_html=True)
-        
-    # add a button
-    run = st.button('Generate Art')
-    my_bar = st.progress(0)
-    params = neural_style.TransferParams()
-    params.gpu = 0#"c"
-    params.backend = "mkl"
-    params.image_size = 400
-    params.content_image = uploaded_file
-    params.style_weight = style_weight
-    keep_style = False
-    if run==True:
-        # run image selection if keep style is false
-        if keep_style==False:
-            path = 'stylesv2'
-            styles = os.listdir(path)
-            params.style_image = path + '/' + random.choice(styles)
-            
-        st.session_state.submitted = True   
-        with st.spinner('Wait for it...'): 
-            neural_style.transfer(params)
-
-        #display image when done.
-        with col2:
-            if 'submitted' in st.session_state:
-                result = Image.open('out.png')
-                st.image(result, width=300)
-                buf = BytesIO()
-                result.save(buf, format="png")
-                if len(os.listdir('generated_samples')) <= 10:
-                    img_file_name = f"generated_samples/{str(len(os.listdir('generated_samples')))}.png"
-                
-                    _ = upload_file(path_or_fileobj = 'out.png',
-                            path_in_repo = img_file_name,
-                            repo_id='AfrodreamsAI/afrodreams',
-                            repo_type='space',
-                            token=HF_TOKEN
-                        ) 
-                    
-                byte_im = buf.getvalue()
-                #run =ste.download_button(button_text="Download Image", data=byte_im, download_filename='afrodreams.jpg', mime="image/png")
-        #keeping the current style by update the weight 
-        keep_style = st.sidebar.checkbox("Keep current style")
-        
-    
-    
-
-
-

spaces/AlexWortega/food_calories/app.py

@@ -1,50 +0,0 @@
-import torch
-from rudalle import get_tokenizer, get_vae
-from rudalle.utils import seed_everything
-
-import sys
-from rudolph.model.utils import get_i2t_attention_mask, get_t2t_attention_mask
-from rudolph.model import get_rudolph_model, ruDolphModel, FP16Module
-from rudolph.pipelines import generate_codebooks, self_reranking_by_image, self_reranking_by_text, show, generate_captions, generate_texts 
-from rudolph.pipelines import  zs_clf
-
-import gradio as gr
-from rudolph import utils
-from PIL import Image
-
-device = 'cpu'
-if device=='cuda':
-  half = True
-else:
-  half = False
-model = get_rudolph_model('350M',  fp16=half, device=device)
-model.load_state_dict(torch.load("awesomemodel__dalle_1500.pt",map_location=torch.device('cpu')))
-tokenizer = get_tokenizer()
-vae = get_vae(dwt=False).to(device)
-
-
-template = 'белков: ' 
-
-
-
-# Download human-readable labels for ImageNet.
-
-
-
-def classify_image(inp):
-  print(type(inp))
-  inp =  Image.fromarray(inp)
-  texts = generate_captions(inp, tokenizer, model, vae, template=template,  top_k=16, captions_num=1, bs=16, top_p=0.6, seed=43,       temperature=0.8)
-  rp = texts[0].replace('белков','protein').replace('жиров','fat').replace('углеводов','carbs').replace('calories','ккал') 
-  print(rp)
-
-  
-  return rp
-
-image = gr.inputs.Image(shape=(128, 128))
-label = gr.outputs.Label(num_top_classes=3)
-
-
-iface = gr.Interface(fn=classify_image, description="https://github.com/sberbank-ai/ru-dolph RuDoplh by SBER AI finetuned for a image2text task to predict food calories by https://t.me/lovedeathtransformers Alex Wortega", inputs=image, outputs="text",examples=[
-  ['b9c277a3.jpeg']])
-iface.launch()

spaces/AllAideas/SegmentacionVideo/utils/predict.py

@@ -1,104 +0,0 @@
-#from .custom_layers import TransformerEncoder, PositionalEmbedding
-from .constants import MAX_SEQ_LENGTH, NUM_FEATURES, IMG_SIZE, CLASS_VOCAB
-from huggingface_hub import from_pretrained_keras
-from tensorflow import keras
-from keras import layers
-import numpy as np
-import imageio
-import cv2
-
-#model = from_pretrained_keras("shivi/video-classification",custom_objects={"PositionalEmbedding":PositionalEmbedding,"TransformerEncoder": TransformerEncoder})
-
-model = from_pretrained_keras("keras-io/video-transformers")
-
-"""
-Below code is taken from the Video-Transformers example on keras-io by Sayak Paul
-"""
-def build_feature_extractor():
-    feature_extractor = keras.applications.DenseNet121(
-        weights="imagenet",
-        include_top=False,
-        pooling="avg",
-        input_shape=(IMG_SIZE, IMG_SIZE, 3),
-    )
-    preprocess_input = keras.applications.densenet.preprocess_input
-
-    inputs = keras.Input((IMG_SIZE, IMG_SIZE, 3))
-    preprocessed = preprocess_input(inputs)
-
-    outputs = feature_extractor(preprocessed)
-    return keras.Model(inputs, outputs, name="feature_extractor")
-
-
-feature_extractor = build_feature_extractor()
-
-
-
-def crop_center(frame):
-    center_crop_layer = layers.CenterCrop(IMG_SIZE, IMG_SIZE)
-    cropped = center_crop_layer(frame[None, ...])
-    cropped = cropped.numpy().squeeze()
-    return cropped
-
-def load_video(path, max_frames=0):
-    cap = cv2.VideoCapture(path)
-    frames = []
-    try:
-        while True:
-            ret, frame = cap.read()
-            if not ret:
-                break
-            frame = crop_center(frame)
-            frame = frame[:, :, [2, 1, 0]]
-            frames.append(frame)
-
-            if len(frames) == max_frames:
-                break
-    finally:
-        cap.release()
-    return np.array(frames)
-
-def prepare_single_video(frames):
-    frame_features = np.zeros(shape=(1, MAX_SEQ_LENGTH, NUM_FEATURES), dtype="float32")
-
-    # Pad shorter videos.
-    if len(frames) < MAX_SEQ_LENGTH:
-        diff = MAX_SEQ_LENGTH - len(frames)
-        padding = np.zeros((diff, IMG_SIZE, IMG_SIZE, 3))
-        frames = np.concatenate(frames, padding)
-
-    frames = frames[None, ...]
-
-    # Extract features from the frames of the current video.
-    for i, batch in enumerate(frames):
-        video_length = batch.shape[0]
-        length = min(MAX_SEQ_LENGTH, video_length)
-        for j in range(length):
-            if np.mean(batch[j, :]) > 0.0:
-                frame_features[i, j, :] = feature_extractor.predict(batch[None, j, :])
-            else:
-                frame_features[i, j, :] = 0.0
-
-    return frame_features
-
-
-def predict_action(path):
-    frames = load_video(path)
-    frame_features = prepare_single_video(frames)
-    probabilities = model.predict(frame_features)[0]
-    confidences = {}
-
-    for i in np.argsort(probabilities)[::-1]:
-        confidences[CLASS_VOCAB[i]] = float(probabilities[i])
-
-    gif_out = to_gif(frames[:MAX_SEQ_LENGTH])
-
-    print(confidences)
-    return confidences, gif_out
-
-
-def to_gif(images):
-    converted_images = images.astype(np.uint8)
-    imageio.mimsave("animation.gif", converted_images, fps=10)
-    return "animation.gif"
-

spaces/Aloento/9Nine-PITS/app.py

@@ -1,186 +0,0 @@
-import argparse
-
-import gradio as gr
-import torch
-
-import commons
-import utils
-from models import SynthesizerTrn
-from text import cleaned_text_to_sequence
-from text.cleaners import clean_text
-from text.symbols import symbols
-
-
-# we use Kyubyong/g2p for demo instead of our internal g2p
-# https://github.com/Kyubyong/g2p
-def get_text(text, hps):
-  cleaned_text, lang = clean_text(text)
-  text_norm = cleaned_text_to_sequence(cleaned_text)
-  if hps.data.add_blank:
-    text_norm, lang = commons.intersperse_with_language_id(text_norm, lang, 0)
-  text_norm = torch.LongTensor(text_norm)
-  lang = torch.LongTensor(lang)
-  return text_norm, lang, cleaned_text
-
-
-class GradioApp:
-
-  def __init__(self, args):
-    self.hps = utils.get_hparams_from_file(args.config)
-    self.device = "cpu"
-
-    self.net_g = SynthesizerTrn(
-      len(symbols),
-      self.hps.data.filter_length // 2 + 1,
-      self.hps.train.segment_size //
-      self.hps.data.hop_length,
-      midi_start=-5,
-      midi_end=75,
-      octave_range=24,
-      n_speakers=len(self.hps.data.speakers),
-      **self.hps.model
-    ).to(self.device)
-
-    _ = self.net_g.eval()
-    _ = utils.load_checkpoint(args.checkpoint_path, model_g=self.net_g)
-    self.interface = self._gradio_interface()
-
-  def get_phoneme(self, text):
-    cleaned_text, lang = clean_text(text)
-    text_norm = cleaned_text_to_sequence(cleaned_text)
-
-    if self.hps.data.add_blank:
-      text_norm, lang = commons.intersperse_with_language_id(text_norm, lang, 0)
-
-    text_norm = torch.LongTensor(text_norm)
-    lang = torch.LongTensor(lang)
-
-    return text_norm, lang, cleaned_text
-
-  def inference(self, text, speaker_id_val, seed, scope_shift, duration):
-    seed = int(seed)
-    scope_shift = int(scope_shift)
-    torch.manual_seed(seed)
-    text_norm, tone, phones = self.get_phoneme(text)
-    x_tst = text_norm.to(self.device).unsqueeze(0)
-    t_tst = tone.to(self.device).unsqueeze(0)
-    x_tst_lengths = torch.LongTensor([text_norm.size(0)]).to(self.device)
-    speaker_id = torch.LongTensor([speaker_id_val]).to(self.device)
-
-    decoder_inputs, *_ = self.net_g.infer_pre_decoder(
-      x_tst,
-      t_tst,
-      x_tst_lengths,
-      sid=speaker_id,
-      noise_scale=0.667,
-      noise_scale_w=0.8,
-      length_scale=duration,
-      scope_shift=scope_shift
-    )
-
-    audio = self.net_g.infer_decode_chunk(
-      decoder_inputs, sid=speaker_id
-    )[0, 0].data.cpu().float().numpy()
-
-    del decoder_inputs,
-
-    return phones, (self.hps.data.sampling_rate, audio)
-
-  def _gradio_interface(self):
-    title = "9Nine - PITS"
-
-    self.inputs = [
-      gr.Textbox(
-        label="Text (150 words limitation)",
-        value="[JA]そんなわけないじゃない。どうしてこうなるだろう。始めて好きな人ができた。一生ものの友达ができた。嬉しいことが二つ重なて。"
-              "その二つの嬉しさがまたたくさんの嬉しさをつれて来てくれて。梦のように幸せの时间を手に入れたはずなのに。なのにどうして、こうなちょうだろう。[JA]",
-        elem_id="tts-input"
-      ),
-      gr.Dropdown(
-        list(self.hps.data.speakers),
-        value=self.hps.data.speakers[1],
-        label="Speaker Identity",
-        type="index"
-      ),
-      gr.Slider(
-        0, 65536, value=0, step=1, label="random seed"
-      ),
-      gr.Slider(
-        -15, 15, value=0, step=1, label="scope-shift"
-      ),
-      gr.Slider(
-        0.5, 2., value=1., step=0.1, label="duration multiplier"
-      ),
-    ]
-
-    self.outputs = [
-      gr.Textbox(label="Phonemes"),
-      gr.Audio(type="numpy", label="Output audio")
-    ]
-
-    description = "9Nine - PITS"
-    article = "Github: https://github.com/Aloento/VariTTS"
-    examples = [["[JA]こんにちは、私は綾地寧々です。[JA]"]]
-
-    return gr.Interface(
-      fn=self.inference,
-      inputs=self.inputs,
-      outputs=self.outputs,
-      title=title,
-      description=description,
-      article=article,
-      cache_examples=False,
-      examples=examples,
-    )
-
-  def launch(self):
-    return self.interface.launch(share=False)
-
-
-def parsearg():
-  parser = argparse.ArgumentParser()
-  parser.add_argument(
-    '-c',
-    '--config',
-    type=str,
-    default="./configs/config_cje.yaml",
-    help='Path to configuration file'
-  )
-  parser.add_argument(
-    '-m',
-    '--model',
-    type=str,
-    default='9Nine',
-    help='Model name'
-  )
-  parser.add_argument(
-    '-r',
-    '--checkpoint_path',
-    type=str,
-    default='./9Nine_Eval_71200.pth',
-    help='Path to checkpoint for resume'
-  )
-  parser.add_argument(
-    '-f',
-    '--force_resume',
-    type=str,
-    help='Path to checkpoint for force resume'
-  )
-  parser.add_argument(
-    '-d',
-    '--dir',
-    type=str,
-    default='/DATA/audio/pits_samples',
-    help='root dir'
-  )
-  args = parser.parse_args()
-  return args
-
-
-if __name__ == "__main__":
-  import nltk
-  nltk.download('cmudict')
-
-  args = parsearg()
-  app = GradioApp(args)
-  app.launch()

spaces/Amon1/ChatGPTForAcadamic/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/Andy1621/uniformer_image_segmentation/configs/pspnet/pspnet_r50-d8_769x769_80k_cityscapes.py

@@ -1,9 +0,0 @@
-_base_ = [
-    '../_base_/models/pspnet_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-model = dict(
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))

spaces/Andy1621/uniformer_light/app.py

@@ -1,173 +0,0 @@
-import os
-
-import torch
-import torch.nn as nn
-import numpy as np
-import torch.nn.functional as F
-import torchvision.transforms as T
-from PIL import Image
-from decord import VideoReader
-from decord import cpu
-from uniformer_light_video import uniformer_xxs_video
-from uniformer_light_image import uniformer_xxs_image
-from kinetics_class_index import kinetics_classnames
-from imagenet_class_index import imagenet_classnames
-from transforms import (
-    GroupNormalize, GroupScale, GroupCenterCrop, 
-    Stack, ToTorchFormatTensor
-)
-
-import gradio as gr
-from huggingface_hub import hf_hub_download
-
-
-# Device on which to run the model
-# Set to cuda to load on GPU
-device = "cpu"
-model_video_path = hf_hub_download(repo_id="Andy1621/uniformer_light", filename="uniformer_xxs16_160_k400.pth")
-model_image_path = hf_hub_download(repo_id="Andy1621/uniformer_light", filename="uniformer_xxs_160_in1k.pth")
-# Pick a pretrained model 
-model_video = uniformer_xxs_video()
-model_video.load_state_dict(torch.load(model_video_path, map_location='cpu'))
-model_image = uniformer_xxs_image()
-model_image.load_state_dict(torch.load(model_image_path, map_location='cpu'))
-# Set to eval mode and move to desired device
-model_video = model_video.to(device).eval()
-model_image = model_image.to(device).eval()
-
-# Create an id to label name mapping
-kinetics_id_to_classname = {}
-for k, v in kinetics_classnames.items():
-    kinetics_id_to_classname[k] = v
-imagenet_id_to_classname = {}
-for k, v in imagenet_classnames.items():
-    imagenet_id_to_classname[k] = v[1] 
-
-
-def get_index(num_frames, num_segments=8):
-    seg_size = float(num_frames - 1) / num_segments
-    start = int(seg_size / 2)
-    offsets = np.array([
-        start + int(np.round(seg_size * idx)) for idx in range(num_segments)
-    ])
-    return offsets
-
-
-def load_video(video_path):
-    vr = VideoReader(video_path, ctx=cpu(0))
-    num_frames = len(vr)
-    frame_indices = get_index(num_frames, 16)
-
-    # transform
-    crop_size = 160
-    scale_size = 160
-    input_mean = [0.485, 0.456, 0.406]
-    input_std = [0.229, 0.224, 0.225]
-
-    transform = T.Compose([
-        GroupScale(int(scale_size)),
-        GroupCenterCrop(crop_size),
-        Stack(),
-        ToTorchFormatTensor(),
-        GroupNormalize(input_mean, input_std) 
-    ])
-
-    images_group = list()
-    for frame_index in frame_indices:
-        img = Image.fromarray(vr[frame_index].asnumpy())
-        images_group.append(img)
-    torch_imgs = transform(images_group)
-    return torch_imgs
-    
-
-def inference_video(video):
-    vid = load_video(video)
-    
-    # The model expects inputs of shape: B x C x H x W
-    TC, H, W = vid.shape
-    inputs = vid.reshape(1, TC//3, 3, H, W).permute(0, 2, 1, 3, 4)
-    
-    with torch.no_grad():
-        prediction = model_video(inputs)
-        prediction = F.softmax(prediction, dim=1).flatten()
-
-    return {kinetics_id_to_classname[str(i)]: float(prediction[i]) for i in range(400)}
-    
-
-def set_example_video(example: list) -> dict:
-    return gr.Video.update(value=example[0])
-
-
-def inference_image(img):
-    image = img
-    image_transform = T.Compose(
-    [
-        T.Resize(224),
-        T.CenterCrop(224),
-        T.ToTensor(),
-        T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
-    ]
-    )
-    image = image_transform(image)
-    
-    # The model expects inputs of shape: B x C x H x W
-    image = image.unsqueeze(0)
-    
-    with torch.no_grad():
-        prediction = model_image(image)
-        prediction = F.softmax(prediction, dim=1).flatten()
-
-    return {imagenet_id_to_classname[str(i)]: float(prediction[i]) for i in range(1000)}
-
-
-def set_example_image(example: list) -> dict:
-    return gr.Image.update(value=example[0])
-
-
-demo = gr.Blocks()
-with demo:
-    gr.Markdown(
-        """
-        # UniFormer Light
-        Gradio demo for <a href='https://github.com/Sense-X/UniFormer' target='_blank'>UniFormer</a>: To use it, simply upload your video, or click one of the examples to load them. Read more at the links below.
-        """
-    )
-
-    with gr.Tab("Video"):
-        with gr.Box():
-            with gr.Row():
-                with gr.Column():
-                    with gr.Row():
-                        input_video = gr.Video(label='Input Video').style(height=360)
-                    with gr.Row():
-                        submit_video_button = gr.Button('Submit')
-                with gr.Column():
-                        label_video = gr.Label(num_top_classes=5)
-            with gr.Row():
-                example_videos = gr.Dataset(components=[input_video], samples=[['./videos/hitting_baseball.mp4'], ['./videos/hoverboarding.mp4'], ['./videos/yoga.mp4']])
-        
-    with gr.Tab("Image"):
-        with gr.Box():
-            with gr.Row():
-                with gr.Column():
-                    with gr.Row():
-                        input_image = gr.Image(label='Input Image', type='pil').style(height=360)
-                    with gr.Row():
-                        submit_image_button = gr.Button('Submit')
-                with gr.Column():
-                    label_image = gr.Label(num_top_classes=5)
-            with gr.Row():
-                example_images = gr.Dataset(components=[input_image], samples=[['./images/cat.png'], ['./images/dog.png'], ['./images/panda.png']])
-
-    gr.Markdown(
-        """
-        <p style='text-align: center'><a href='https://arxiv.org/abs/2201.09450' target='_blank'>[TPAMI] UniFormer: Unifying Convolution and Self-attention for Visual Recognition</a> | <a href='https://github.com/Sense-X/UniFormer' target='_blank'>Github Repo</a></p>
-        """
-    )
-
-    submit_video_button.click(fn=inference_video, inputs=input_video, outputs=label_video)
-    example_videos.click(fn=set_example_video, inputs=example_videos, outputs=example_videos.components)
-    submit_image_button.click(fn=inference_image, inputs=input_image, outputs=label_image)
-    example_images.click(fn=set_example_image, inputs=example_images, outputs=example_images.components)
-
-demo.launch(enable_queue=True)

spaces/AngoHF/ANGO-Leaderboard/assets/evaluation.py

@@ -1,185 +0,0 @@
-import os
-import json
-import re
-import argparse
-import torch
-import gc
-from tqdm import tqdm
-
-from transformers import AutoModelForCausalLM, AutoModel, AutoTokenizer
-
-os.environ['CUDA_VISIBLE_DEVICES'] = '1'
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(description='Validation')
-    parser.add_argument('--model_path', dest="model_path")
-    parser.add_argument('--dataset_path', dest="dataset_path")
-    parser.add_argument('--save_path', dest='save_path')
-    parser.add_argument('--max_length', dest="max_length", default=2000)
-    parser.add_argument('--max_new_tokens', dest="max_new_tokens", default=48)
-    parser.add_argument('--input_template', dest="input_template",
-                        default="材料：{material}\n问题：{question}\n{options}\n答案：{response}")
-    parser.add_argument('--query_template', dest="query_template", default="问题：{question}\n{options}\n答案：{response}")
-    parser.add_argument('--system_prompt', dest="system_prompt",
-                        default="你是一名考生，请回答问题的正确选项，比如C。如果有多个正确选项，请按顺序回答所有正确选项，比如ABD。")
-    parser.add_argument('--level_delimiter', dest="level_delimiter", default="|")
-    args = parser.parse_args()
-    return args
-
-
-class Validator:
-    def __init__(self, args):
-        self.load_model(args.model_path)
-        self.load_dataset(args.dataset_path)
-        self.save_dir = os.path.join(args.save_path, os.path.split(model_path)[-1])
-        if not os.path.exists(self.save_dir):
-            os.makedirs(self.save_dir)
-
-        self.max_length = args.max_length
-        self.max_new_tokens = args.max_new_tokens
-        self.input_template = args.input_template
-        self.query_template = args.query_template
-        self.system_prompt = args.system_prompt
-        self.level_delimiter = args.level_delimiter
-
-    def load_model(self, model_path):
-        self.tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
-
-        self.model = AutoModelForCausalLM.from_pretrained(model_path, device_map={"": 0}, trust_remote_code=True)
-        self.model.eval()
-
-    def load_dataset(self, dataset_path):
-        self.dataset = json.load(open(dataset_path, encoding="utf-8"))
-
-    def format_prompt(self, material, question, options, response):
-        if material:
-            return self.input_template.format(material=material, question=question, options=options,
-                                              response=response).strip()
-        return self.query_template.format(question=question, options=options, response=response).strip()
-
-    def build_prompt(self, item):
-        query_prompt = self.format_prompt(item['material'], item['question'], item['options'], "")
-        history_prompts = []
-        for sub in item['history']:
-            history_prompts.append(self.format_prompt(sub['material'], sub['question'], sub['options'], sub['choice']))
-
-            final_prompt = self.system_prompt + "\n" + "\n".join(history_prompts) + "\n" + query_prompt
-
-            if len(self.tokenizer.tokenize(final_prompt)) > self.max_length:
-                history_prompts.pop()
-                break
-        return self.system_prompt + "\n" + "\n".join(history_prompts) + "\n" + query_prompt
-
-    def get_predict(self, prompt):
-        gen_kwargs = {"do_sample": False, "max_new_tokens": self.max_new_tokens}
-        inputs = self.tokenizer([prompt], return_tensors="pt")
-        inputs = inputs.to(self.model.device)
-        with torch.no_grad():
-            outputs = self.model.generate(**inputs, return_dict_in_generate=True, **gen_kwargs)
-        predict = self.tokenizer.decode(outputs.sequences[0], skip_special_tokens=True)[len(prompt):]
-        return predict
-
-    def extract_answer(self, results):
-        predict_result = {"acc": 0, "wrong_value": 0, "human_acc": 0, "hit": 0, "total": 0, "wrong_hit": 0,
-                          "wrong_total": 0, 'detail': []}
-        for result in results:
-            answer = result['item']['choice']
-            most_wrong = result['item']['most_wrong']
-            human_acc = result['item']['human_acc'] * 0.01
-
-            predict = ""
-            for e in re.split(r'[、,.，和\s]\s*', result['predict']):
-                if not e.isascii():
-                    break
-                predict += e
-            result['predict'] = predict
-            predict_result['detail'].append(
-                {"answer": answer, "most_wrong": most_wrong, "predict": predict, "human_acc": human_acc})
-            predict_result['hit'] += 1 if answer == predict else 0
-            predict_result['wrong_hit'] += 1 if most_wrong == predict else 0
-            predict_result['wrong_value'] += 1 - human_acc if most_wrong == predict else 0
-            predict_result['human_acc'] += human_acc
-            predict_result['total'] += 1
-        predict_result['acc'] = predict_result['hit'] / predict_result['total']
-        predict_result['wrong_total'] = predict_result['total'] - predict_result['hit']
-        predict_result['wrong_value'] = predict_result['wrong_value'] / predict_result['wrong_total']
-        predict_result['human_acc'] = predict_result['human_acc'] / len(results)
-
-        json.dump(predict_result, open(os.path.join(self.save_dir, "acc_result.json"), "w", encoding="utf-8"),
-                  ensure_ascii=False)
-
-    def category_summary(self, results):
-        category_result = {"总计": {"hit": 0, "all": 0, "difficulty": {}, "human_acc": 0}}
-        for result in results:
-            hit = 1 if result['item']['choice'] == result['predict'] else 0
-            categories_list = result['item']['categories']
-            difficulty = result['item']['difficulty']
-            human_acc = result['item']['human_acc']
-            for categories in categories_list:
-                if difficulty not in category_result["总计"]["difficulty"]:
-                    category_result["总计"]["difficulty"][difficulty] = {"hit": 0, "all": 0}
-                category_result["总计"]["difficulty"][difficulty]['hit'] += hit
-                category_result["总计"]["difficulty"][difficulty]['all'] += 1
-                category_result["总计"]['hit'] += hit
-                category_result["总计"]['all'] += 1
-                category_result["总计"]['human_acc'] += human_acc
-                category_subset = []
-                for category in categories:
-                    category_subset.append(category)
-                    category_name = self.level_delimiter.join(category_subset)
-                    if not category_name:
-                        category_name = "未分类"
-                    if category_name not in category_result:
-                        category_result[category_name] = {"hit": 0, "all": 0, "difficulty": {}, "human_acc": 0}
-                    if difficulty not in category_result[category_name]["difficulty"]:
-                        category_result[category_name]["difficulty"][difficulty] = {"hit": 0, "all": 0}
-                    category_result[category_name]["difficulty"][difficulty]['hit'] += hit
-                    category_result[category_name]["difficulty"][difficulty]['all'] += 1
-                    category_result[category_name]['hit'] += hit
-                    category_result[category_name]['all'] += 1
-                    category_result[category_name]['human_acc'] += human_acc
-
-        for k, v in category_result.items():
-            v['acc'] = v['hit'] / v['all']
-            v['human_acc'] = v['human_acc'] / v['all']
-            for d, sub_v in v['difficulty'].items():
-                sub_v['acc'] = sub_v['hit'] / sub_v['all']
-        json.dump(category_result, open(os.path.join(self.save_dir, "category_result.json"), "w", encoding="utf-8"),
-                  ensure_ascii=False)
-
-    def difficulty_summary(self, results):
-        difficulty_result = {"总计": {"hit": 0, "all": 0}}
-        for result in results:
-            hit = 1 if result['item']['choice'] == result['predict'] else 0
-            difficulty = result['item']['difficulty']
-            if difficulty not in difficulty_result:
-                difficulty_result[difficulty] = {"hit": 0, "all": 0}
-            difficulty_result[difficulty]['hit'] += hit
-            difficulty_result[difficulty]['all'] += 1
-            difficulty_result["总计"]['hit'] += hit
-            difficulty_result["总计"]['all'] += 1
-
-        for k in difficulty_result:
-            difficulty_result[k]['acc'] = difficulty_result[k]['hit'] / difficulty_result[k]['all']
-
-        json.dump(difficulty_result, open(os.path.join(self.save_dir, "difficulty_result.json"), "w", encoding="utf-8"),
-                  ensure_ascii=False)
-
-    def __call__(self):
-        results = []
-        for item in tqdm(self.dataset):
-            prompt = self.build_prompt(item)
-            predict = self.get_predict(prompt)
-            results.append({"item": item, "predict": predict})
-            gc.collect()
-
-        json.dump(results, open(os.path.join(self.save_dir, "raw.json"), "w", encoding="utf-8"), ensure_ascii=False)
-        self.extract_answer(results)
-        self.category_summary(results)
-        self.difficulty_summary(results)
-
-
-if __name__ == "__main__":
-    args = parse_args()
-    Validator(args)()

spaces/AnishKumbhar/ChatBot/text-generation-webui-main/api-examples/api-example.py

@@ -1,63 +0,0 @@
-import requests
-
-# For local streaming, the websockets are hosted without ssl - http://
-HOST = 'localhost:5000'
-URI = f'http://{HOST}/api/v1/generate'
-
-# For reverse-proxied streaming, the remote will likely host with ssl - https://
-# URI = 'https://your-uri-here.trycloudflare.com/api/v1/generate'
-
-
-def run(prompt):
-    request = {
-        'prompt': prompt,
-        'max_new_tokens': 250,
-        'auto_max_new_tokens': False,
-        'max_tokens_second': 0,
-
-        # Generation params. If 'preset' is set to different than 'None', the values
-        # in presets/preset-name.yaml are used instead of the individual numbers.
-        'preset': 'None',
-        'do_sample': True,
-        'temperature': 0.7,
-        'top_p': 0.1,
-        'typical_p': 1,
-        'epsilon_cutoff': 0,  # In units of 1e-4
-        'eta_cutoff': 0,  # In units of 1e-4
-        'tfs': 1,
-        'top_a': 0,
-        'repetition_penalty': 1.18,
-        'repetition_penalty_range': 0,
-        'top_k': 40,
-        'min_length': 0,
-        'no_repeat_ngram_size': 0,
-        'num_beams': 1,
-        'penalty_alpha': 0,
-        'length_penalty': 1,
-        'early_stopping': False,
-        'mirostat_mode': 0,
-        'mirostat_tau': 5,
-        'mirostat_eta': 0.1,
-        'grammar_string': '',
-        'guidance_scale': 1,
-        'negative_prompt': '',
-
-        'seed': -1,
-        'add_bos_token': True,
-        'truncation_length': 2048,
-        'ban_eos_token': False,
-        'custom_token_bans': '',
-        'skip_special_tokens': True,
-        'stopping_strings': []
-    }
-
-    response = requests.post(URI, json=request)
-
-    if response.status_code == 200:
-        result = response.json()['results'][0]['text']
-        print(prompt + result)
-
-
-if __name__ == '__main__':
-    prompt = "In order to make homemade bread, follow these steps:\n1)"
-    run(prompt)

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

@@ -1,236 +0,0 @@
-"""
-Helpers to train with 16-bit precision.
-"""
-
-import numpy as np
-import torch as th
-import torch.nn as nn
-from torch._utils import _flatten_dense_tensors, _unflatten_dense_tensors
-
-from . import logger
-
-INITIAL_LOG_LOSS_SCALE = 20.0
-
-
-def convert_module_to_f16(l):
-    """
-    Convert primitive modules to float16.
-    """
-    if isinstance(l, (nn.Conv1d, nn.Conv2d, nn.Conv3d)):
-        l.weight.data = l.weight.data.half()
-        if l.bias is not None:
-            l.bias.data = l.bias.data.half()
-
-
-def convert_module_to_f32(l):
-    """
-    Convert primitive modules to float32, undoing convert_module_to_f16().
-    """
-    if isinstance(l, (nn.Conv1d, nn.Conv2d, nn.Conv3d)):
-        l.weight.data = l.weight.data.float()
-        if l.bias is not None:
-            l.bias.data = l.bias.data.float()
-
-
-def make_master_params(param_groups_and_shapes):
-    """
-    Copy model parameters into a (differently-shaped) list of full-precision
-    parameters.
-    """
-    master_params = []
-    for param_group, shape in param_groups_and_shapes:
-        master_param = nn.Parameter(
-            _flatten_dense_tensors(
-                [param.detach().float() for (_, param) in param_group]
-            ).view(shape)
-        )
-        master_param.requires_grad = True
-        master_params.append(master_param)
-    return master_params
-
-
-def model_grads_to_master_grads(param_groups_and_shapes, master_params):
-    """
-    Copy the gradients from the model parameters into the master parameters
-    from make_master_params().
-    """
-    for master_param, (param_group, shape) in zip(
-        master_params, param_groups_and_shapes
-    ):
-        master_param.grad = _flatten_dense_tensors(
-            [param_grad_or_zeros(param) for (_, param) in param_group]
-        ).view(shape)
-
-
-def master_params_to_model_params(param_groups_and_shapes, master_params):
-    """
-    Copy the master parameter data back into the model parameters.
-    """
-    # Without copying to a list, if a generator is passed, this will
-    # silently not copy any parameters.
-    for master_param, (param_group, _) in zip(master_params, param_groups_and_shapes):
-        for (_, param), unflat_master_param in zip(
-            param_group, unflatten_master_params(param_group, master_param.view(-1))
-        ):
-            param.detach().copy_(unflat_master_param)
-
-
-def unflatten_master_params(param_group, master_param):
-    return _unflatten_dense_tensors(master_param, [param for (_, param) in param_group])
-
-
-def get_param_groups_and_shapes(named_model_params):
-    named_model_params = list(named_model_params)
-    scalar_vector_named_params = (
-        [(n, p) for (n, p) in named_model_params if p.ndim <= 1],
-        (-1),
-    )
-    matrix_named_params = (
-        [(n, p) for (n, p) in named_model_params if p.ndim > 1],
-        (1, -1),
-    )
-    return [scalar_vector_named_params, matrix_named_params]
-
-
-def master_params_to_state_dict(
-    model, param_groups_and_shapes, master_params, use_fp16
-):
-    if use_fp16:
-        state_dict = model.state_dict()
-        for master_param, (param_group, _) in zip(
-            master_params, param_groups_and_shapes
-        ):
-            for (name, _), unflat_master_param in zip(
-                param_group, unflatten_master_params(param_group, master_param.view(-1))
-            ):
-                assert name in state_dict
-                state_dict[name] = unflat_master_param
-    else:
-        state_dict = model.state_dict()
-        for i, (name, _value) in enumerate(model.named_parameters()):
-            assert name in state_dict
-            state_dict[name] = master_params[i]
-    return state_dict
-
-
-def state_dict_to_master_params(model, state_dict, use_fp16):
-    if use_fp16:
-        named_model_params = [
-            (name, state_dict[name]) for name, _ in model.named_parameters()
-        ]
-        param_groups_and_shapes = get_param_groups_and_shapes(named_model_params)
-        master_params = make_master_params(param_groups_and_shapes)
-    else:
-        master_params = [state_dict[name] for name, _ in model.named_parameters()]
-    return master_params
-
-
-def zero_master_grads(master_params):
-    for param in master_params:
-        param.grad = None
-
-
-def zero_grad(model_params):
-    for param in model_params:
-        # Taken from https://pytorch.org/docs/stable/_modules/torch/optim/optimizer.html#Optimizer.add_param_group
-        if param.grad is not None:
-            param.grad.detach_()
-            param.grad.zero_()
-
-
-def param_grad_or_zeros(param):
-    if param.grad is not None:
-        return param.grad.data.detach()
-    else:
-        return th.zeros_like(param)
-
-
-class MixedPrecisionTrainer:
-    def __init__(
-        self,
-        *,
-        model,
-        use_fp16=False,
-        fp16_scale_growth=1e-3,
-        initial_lg_loss_scale=INITIAL_LOG_LOSS_SCALE,
-    ):
-        self.model = model
-        self.use_fp16 = use_fp16
-        self.fp16_scale_growth = fp16_scale_growth
-
-        self.model_params = list(self.model.parameters())
-        self.master_params = self.model_params
-        self.param_groups_and_shapes = None
-        self.lg_loss_scale = initial_lg_loss_scale
-
-        if self.use_fp16:
-            self.param_groups_and_shapes = get_param_groups_and_shapes(
-                self.model.named_parameters()
-            )
-            self.master_params = make_master_params(self.param_groups_and_shapes)
-            self.model.convert_to_fp16()
-
-    def zero_grad(self):
-        zero_grad(self.model_params)
-
-    def backward(self, loss: th.Tensor):
-        if self.use_fp16:
-            loss_scale = 2 ** self.lg_loss_scale
-            (loss * loss_scale).backward()
-        else:
-            loss.backward()
-
-    def optimize(self, opt: th.optim.Optimizer):
-        if self.use_fp16:
-            return self._optimize_fp16(opt)
-        else:
-            return self._optimize_normal(opt)
-
-    def _optimize_fp16(self, opt: th.optim.Optimizer):
-        logger.logkv_mean("lg_loss_scale", self.lg_loss_scale)
-        model_grads_to_master_grads(self.param_groups_and_shapes, self.master_params)
-        grad_norm, param_norm = self._compute_norms(grad_scale=2 ** self.lg_loss_scale)
-        if check_overflow(grad_norm):
-            self.lg_loss_scale -= 1
-            logger.log(f"Found NaN, decreased lg_loss_scale to {self.lg_loss_scale}")
-            zero_master_grads(self.master_params)
-            return False
-
-        logger.logkv_mean("grad_norm", grad_norm)
-        logger.logkv_mean("param_norm", param_norm)
-
-        self.master_params[0].grad.mul_(1.0 / (2 ** self.lg_loss_scale))
-        opt.step()
-        zero_master_grads(self.master_params)
-        master_params_to_model_params(self.param_groups_and_shapes, self.master_params)
-        self.lg_loss_scale += self.fp16_scale_growth
-        return True
-
-    def _optimize_normal(self, opt: th.optim.Optimizer):
-        grad_norm, param_norm = self._compute_norms()
-        logger.logkv_mean("grad_norm", grad_norm)
-        logger.logkv_mean("param_norm", param_norm)
-        opt.step()
-        return True
-
-    def _compute_norms(self, grad_scale=1.0):
-        grad_norm = 0.0
-        param_norm = 0.0
-        for p in self.master_params:
-            with th.no_grad():
-                param_norm += th.norm(p, p=2, dtype=th.float32).item() ** 2
-                if p.grad is not None:
-                    grad_norm += th.norm(p.grad, p=2, dtype=th.float32).item() ** 2
-        return np.sqrt(grad_norm) / grad_scale, np.sqrt(param_norm)
-
-    def master_params_to_state_dict(self, master_params):
-        return master_params_to_state_dict(
-            self.model, self.param_groups_and_shapes, master_params, self.use_fp16
-        )
-
-    def state_dict_to_master_params(self, state_dict):
-        return state_dict_to_master_params(self.model, state_dict, self.use_fp16)
-
-
-def check_overflow(value):
-    return (value == float("inf")) or (value == -float("inf")) or (value != value)

spaces/Anonymous-sub/Rerender/gmflow_module/main.py

@@ -1,557 +0,0 @@
-import torch
-from torch.utils.data import DataLoader
-from torch.utils.tensorboard import SummaryWriter
-
-import argparse
-import numpy as np
-import os
-
-from data import build_train_dataset
-from gmflow.gmflow import GMFlow
-from loss import flow_loss_func
-from evaluate import (validate_chairs, validate_things, validate_sintel, validate_kitti,
-                      create_sintel_submission, create_kitti_submission, inference_on_dir)
-
-from utils.logger import Logger
-from utils import misc
-from utils.dist_utils import get_dist_info, init_dist, setup_for_distributed
-
-
-def get_args_parser():
-    parser = argparse.ArgumentParser()
-
-    # dataset
-    parser.add_argument('--checkpoint_dir', default='tmp', type=str,
-                        help='where to save the training log and models')
-    parser.add_argument('--stage', default='chairs', type=str,
-                        help='training stage')
-    parser.add_argument('--image_size', default=[384, 512], type=int, nargs='+',
-                        help='image size for training')
-    parser.add_argument('--padding_factor', default=16, type=int,
-                        help='the input should be divisible by padding_factor, otherwise do padding')
-
-    parser.add_argument('--max_flow', default=400, type=int,
-                        help='exclude very large motions during training')
-    parser.add_argument('--val_dataset', default=['chairs'], type=str, nargs='+',
-                        help='validation dataset')
-    parser.add_argument('--with_speed_metric', action='store_true',
-                        help='with speed metric when evaluation')
-
-    # training
-    parser.add_argument('--lr', default=4e-4, type=float)
-    parser.add_argument('--batch_size', default=12, type=int)
-    parser.add_argument('--num_workers', default=4, type=int)
-    parser.add_argument('--weight_decay', default=1e-4, type=float)
-    parser.add_argument('--grad_clip', default=1.0, type=float)
-    parser.add_argument('--num_steps', default=100000, type=int)
-    parser.add_argument('--seed', default=326, type=int)
-    parser.add_argument('--summary_freq', default=100, type=int)
-    parser.add_argument('--val_freq', default=10000, type=int)
-    parser.add_argument('--save_ckpt_freq', default=10000, type=int)
-    parser.add_argument('--save_latest_ckpt_freq', default=1000, type=int)
-
-    # resume pretrained model or resume training
-    parser.add_argument('--resume', default=None, type=str,
-                        help='resume from pretrain model for finetuing or resume from terminated training')
-    parser.add_argument('--strict_resume', action='store_true')
-    parser.add_argument('--no_resume_optimizer', action='store_true')
-
-    # GMFlow model
-    parser.add_argument('--num_scales', default=1, type=int,
-                        help='basic gmflow model uses a single 1/8 feature, the refinement uses 1/4 feature')
-    parser.add_argument('--feature_channels', default=128, type=int)
-    parser.add_argument('--upsample_factor', default=8, type=int)
-    parser.add_argument('--num_transformer_layers', default=6, type=int)
-    parser.add_argument('--num_head', default=1, type=int)
-    parser.add_argument('--attention_type', default='swin', type=str)
-    parser.add_argument('--ffn_dim_expansion', default=4, type=int)
-
-    parser.add_argument('--attn_splits_list', default=[2], type=int, nargs='+',
-                        help='number of splits in attention')
-    parser.add_argument('--corr_radius_list', default=[-1], type=int, nargs='+',
-                        help='correlation radius for matching, -1 indicates global matching')
-    parser.add_argument('--prop_radius_list', default=[-1], type=int, nargs='+',
-                        help='self-attention radius for flow propagation, -1 indicates global attention')
-
-    # loss
-    parser.add_argument('--gamma', default=0.9, type=float,
-                        help='loss weight')
-
-    # evaluation
-    parser.add_argument('--eval', action='store_true')
-    parser.add_argument('--save_eval_to_file', action='store_true')
-    parser.add_argument('--evaluate_matched_unmatched', action='store_true')
-
-    # inference on a directory
-    parser.add_argument('--inference_dir', default=None, type=str)
-    parser.add_argument('--inference_size', default=None, type=int, nargs='+',
-                        help='can specify the inference size')
-    parser.add_argument('--dir_paired_data', action='store_true',
-                        help='Paired data in a dir instead of a sequence')
-    parser.add_argument('--save_flo_flow', action='store_true')
-    parser.add_argument('--pred_bidir_flow', action='store_true',
-                        help='predict bidirectional flow')
-    parser.add_argument('--fwd_bwd_consistency_check', action='store_true',
-                        help='forward backward consistency check with bidirection flow')
-
-    # predict on sintel and kitti test set for submission
-    parser.add_argument('--submission', action='store_true',
-                        help='submission to sintel or kitti test sets')
-    parser.add_argument('--output_path', default='output', type=str,
-                        help='where to save the prediction results')
-    parser.add_argument('--save_vis_flow', action='store_true',
-                        help='visualize flow prediction as .png image')
-    parser.add_argument('--no_save_flo', action='store_true',
-                        help='not save flow as .flo')
-
-    # distributed training
-    parser.add_argument('--local_rank', default=0, type=int)
-    parser.add_argument('--distributed', action='store_true')
-    parser.add_argument('--launcher', default='none', type=str, choices=['none', 'pytorch'])
-    parser.add_argument('--gpu_ids', default=0, type=int, nargs='+')
-
-    parser.add_argument('--count_time', action='store_true',
-                        help='measure the inference time on sintel')
-
-    return parser
-
-
-def main(args):
-    if not args.eval and not args.submission and args.inference_dir is None:
-        if args.local_rank == 0:
-            print('pytorch version:', torch.__version__)
-            print(args)
-            misc.save_args(args)
-            misc.check_path(args.checkpoint_dir)
-            misc.save_command(args.checkpoint_dir)
-
-    seed = args.seed
-    torch.manual_seed(seed)
-    np.random.seed(seed)
-
-    torch.backends.cudnn.benchmark = True
-
-    if args.launcher == 'none':
-        args.distributed = False
-        device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-    else:
-        args.distributed = True
-
-        # adjust batch size for each gpu
-        assert args.batch_size % torch.cuda.device_count() == 0
-        args.batch_size = args.batch_size // torch.cuda.device_count()
-
-        dist_params = dict(backend='nccl')
-        init_dist(args.launcher, **dist_params)
-        # re-set gpu_ids with distributed training mode
-        _, world_size = get_dist_info()
-        args.gpu_ids = range(world_size)
-        device = torch.device('cuda:{}'.format(args.local_rank))
-
-        setup_for_distributed(args.local_rank == 0)
-
-    # model
-    model = GMFlow(feature_channels=args.feature_channels,
-                   num_scales=args.num_scales,
-                   upsample_factor=args.upsample_factor,
-                   num_head=args.num_head,
-                   attention_type=args.attention_type,
-                   ffn_dim_expansion=args.ffn_dim_expansion,
-                   num_transformer_layers=args.num_transformer_layers,
-                   ).to(device)
-
-    if not args.eval and not args.submission and not args.inference_dir:
-        print('Model definition:')
-        print(model)
-
-    if args.distributed:
-        model = torch.nn.parallel.DistributedDataParallel(
-            model.to(device),
-            device_ids=[args.local_rank],
-            output_device=args.local_rank)
-        model_without_ddp = model.module
-    else:
-        if torch.cuda.device_count() > 1:
-            print('Use %d GPUs' % torch.cuda.device_count())
-            model = torch.nn.DataParallel(model)
-
-            model_without_ddp = model.module
-        else:
-            model_without_ddp = model
-
-    num_params = sum(p.numel() for p in model.parameters())
-    print('Number of params:', num_params)
-    if not args.eval and not args.submission and args.inference_dir is None:
-        save_name = '%d_parameters' % num_params
-        open(os.path.join(args.checkpoint_dir, save_name), 'a').close()
-
-    optimizer = torch.optim.AdamW(model_without_ddp.parameters(), lr=args.lr,
-                                  weight_decay=args.weight_decay)
-
-    start_epoch = 0
-    start_step = 0
-    # resume checkpoints
-    if args.resume:
-        print('Load checkpoint: %s' % args.resume)
-
-        loc = 'cuda:{}'.format(args.local_rank)
-        checkpoint = torch.load(args.resume, map_location=loc)
-
-        weights = checkpoint['model'] if 'model' in checkpoint else checkpoint
-
-        model_without_ddp.load_state_dict(weights, strict=args.strict_resume)
-
-        if 'optimizer' in checkpoint and 'step' in checkpoint and 'epoch' in checkpoint and not \
-                args.no_resume_optimizer:
-            print('Load optimizer')
-            optimizer.load_state_dict(checkpoint['optimizer'])
-            start_epoch = checkpoint['epoch']
-            start_step = checkpoint['step']
-
-        print('start_epoch: %d, start_step: %d' % (start_epoch, start_step))
-
-    # evaluate
-    if args.eval:
-        val_results = {}
-
-        if 'chairs' in args.val_dataset:
-            results_dict = validate_chairs(model_without_ddp,
-                                           with_speed_metric=args.with_speed_metric,
-                                           attn_splits_list=args.attn_splits_list,
-                                           corr_radius_list=args.corr_radius_list,
-                                           prop_radius_list=args.prop_radius_list,
-                                           )
-
-            val_results.update(results_dict)
-
-        if 'things' in args.val_dataset:
-            results_dict = validate_things(model_without_ddp,
-                                           padding_factor=args.padding_factor,
-                                           with_speed_metric=args.with_speed_metric,
-                                           attn_splits_list=args.attn_splits_list,
-                                           corr_radius_list=args.corr_radius_list,
-                                           prop_radius_list=args.prop_radius_list,
-                                           )
-            val_results.update(results_dict)
-
-        if 'sintel' in args.val_dataset:
-            results_dict = validate_sintel(model_without_ddp,
-                                           count_time=args.count_time,
-                                           padding_factor=args.padding_factor,
-                                           with_speed_metric=args.with_speed_metric,
-                                           evaluate_matched_unmatched=args.evaluate_matched_unmatched,
-                                           attn_splits_list=args.attn_splits_list,
-                                           corr_radius_list=args.corr_radius_list,
-                                           prop_radius_list=args.prop_radius_list,
-                                           )
-            val_results.update(results_dict)
-
-        if 'kitti' in args.val_dataset:
-            results_dict = validate_kitti(model_without_ddp,
-                                          padding_factor=args.padding_factor,
-                                          with_speed_metric=args.with_speed_metric,
-                                          attn_splits_list=args.attn_splits_list,
-                                          corr_radius_list=args.corr_radius_list,
-                                          prop_radius_list=args.prop_radius_list,
-                                          )
-            val_results.update(results_dict)
-
-        if args.save_eval_to_file:
-            misc.check_path(args.checkpoint_dir)
-            val_file = os.path.join(args.checkpoint_dir, 'val_results.txt')
-            with open(val_file, 'a') as f:
-                f.write('\neval results after training done\n\n')
-                metrics = ['chairs_epe', 'chairs_s0_10', 'chairs_s10_40', 'chairs_s40+',
-                           'things_clean_epe', 'things_clean_s0_10', 'things_clean_s10_40', 'things_clean_s40+',
-                           'things_final_epe', 'things_final_s0_10', 'things_final_s10_40', 'things_final_s40+',
-                           'sintel_clean_epe', 'sintel_clean_s0_10', 'sintel_clean_s10_40', 'sintel_clean_s40+',
-                           'sintel_final_epe', 'sintel_final_s0_10', 'sintel_final_s10_40', 'sintel_final_s40+',
-                           'kitti_epe', 'kitti_f1', 'kitti_s0_10', 'kitti_s10_40', 'kitti_s40+',
-                           ]
-                eval_metrics = []
-                for metric in metrics:
-                    if metric in val_results.keys():
-                        eval_metrics.append(metric)
-
-                metrics_values = [val_results[metric] for metric in eval_metrics]
-
-                num_metrics = len(eval_metrics)
-
-                # save as markdown format
-                f.write(("| {:>20} " * num_metrics + '\n').format(*eval_metrics))
-                f.write(("| {:20.3f} " * num_metrics).format(*metrics_values))
-
-                f.write('\n\n')
-
-        return
-
-    # Sintel and KITTI submission
-    if args.submission:
-        # NOTE: args.val_dataset is a list
-        if args.val_dataset[0] == 'sintel':
-            create_sintel_submission(model_without_ddp,
-                                     output_path=args.output_path,
-                                     padding_factor=args.padding_factor,
-                                     save_vis_flow=args.save_vis_flow,
-                                     no_save_flo=args.no_save_flo,
-                                     attn_splits_list=args.attn_splits_list,
-                                     corr_radius_list=args.corr_radius_list,
-                                     prop_radius_list=args.prop_radius_list,
-                                     )
-        elif args.val_dataset[0] == 'kitti':
-            create_kitti_submission(model_without_ddp,
-                                    output_path=args.output_path,
-                                    padding_factor=args.padding_factor,
-                                    save_vis_flow=args.save_vis_flow,
-                                    attn_splits_list=args.attn_splits_list,
-                                    corr_radius_list=args.corr_radius_list,
-                                    prop_radius_list=args.prop_radius_list,
-                                    )
-        else:
-            raise ValueError(f'Not supported dataset for submission')
-
-        return
-
-    # inferece on a dir
-    if args.inference_dir is not None:
-        inference_on_dir(model_without_ddp,
-                         inference_dir=args.inference_dir,
-                         output_path=args.output_path,
-                         padding_factor=args.padding_factor,
-                         inference_size=args.inference_size,
-                         paired_data=args.dir_paired_data,
-                         save_flo_flow=args.save_flo_flow,
-                         attn_splits_list=args.attn_splits_list,
-                         corr_radius_list=args.corr_radius_list,
-                         prop_radius_list=args.prop_radius_list,
-                         pred_bidir_flow=args.pred_bidir_flow,
-                         fwd_bwd_consistency_check=args.fwd_bwd_consistency_check,
-                         )
-
-        return
-
-    # training datset
-    train_dataset = build_train_dataset(args)
-    print('Number of training images:', len(train_dataset))
-
-    # Multi-processing
-    if args.distributed:
-        train_sampler = torch.utils.data.distributed.DistributedSampler(
-            train_dataset,
-            num_replicas=torch.cuda.device_count(),
-            rank=args.local_rank)
-    else:
-        train_sampler = None
-
-    shuffle = False if args.distributed else True
-    train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=args.batch_size,
-                                               shuffle=shuffle, num_workers=args.num_workers,
-                                               pin_memory=True, drop_last=True,
-                                               sampler=train_sampler)
-
-    last_epoch = start_step if args.resume and start_step > 0 else -1
-    lr_scheduler = torch.optim.lr_scheduler.OneCycleLR(
-        optimizer, args.lr,
-        args.num_steps + 10,
-        pct_start=0.05,
-        cycle_momentum=False,
-        anneal_strategy='cos',
-        last_epoch=last_epoch,
-    )
-
-    if args.local_rank == 0:
-        summary_writer = SummaryWriter(args.checkpoint_dir)
-        logger = Logger(lr_scheduler, summary_writer, args.summary_freq,
-                        start_step=start_step)
-
-    total_steps = start_step
-    epoch = start_epoch
-    print('Start training')
-
-    while total_steps < args.num_steps:
-        model.train()
-
-        # mannual change random seed for shuffling every epoch
-        if args.distributed:
-            train_sampler.set_epoch(epoch)
-
-        for i, sample in enumerate(train_loader):
-            img1, img2, flow_gt, valid = [x.to(device) for x in sample]
-
-            results_dict = model(img1, img2,
-                                 attn_splits_list=args.attn_splits_list,
-                                 corr_radius_list=args.corr_radius_list,
-                                 prop_radius_list=args.prop_radius_list,
-                                 )
-
-            flow_preds = results_dict['flow_preds']
-
-            loss, metrics = flow_loss_func(flow_preds, flow_gt, valid,
-                                           gamma=args.gamma,
-                                           max_flow=args.max_flow,
-                                           )
-
-            if isinstance(loss, float):
-                continue
-
-            if torch.isnan(loss):
-                continue
-
-            metrics.update({'total_loss': loss.item()})
-
-            # more efficient zero_grad
-            for param in model_without_ddp.parameters():
-                param.grad = None
-
-            loss.backward()
-
-            # Gradient clipping
-            torch.nn.utils.clip_grad_norm_(model.parameters(), args.grad_clip)
-
-            optimizer.step()
-
-            lr_scheduler.step()
-
-            if args.local_rank == 0:
-                logger.push(metrics)
-
-                logger.add_image_summary(img1, img2, flow_preds, flow_gt)
-
-            total_steps += 1
-
-            if total_steps % args.save_ckpt_freq == 0 or total_steps == args.num_steps:
-                if args.local_rank == 0:
-                    checkpoint_path = os.path.join(args.checkpoint_dir, 'step_%06d.pth' % total_steps)
-                    torch.save({
-                        'model': model_without_ddp.state_dict()
-                    }, checkpoint_path)
-
-            if total_steps % args.save_latest_ckpt_freq == 0:
-                checkpoint_path = os.path.join(args.checkpoint_dir, 'checkpoint_latest.pth')
-
-                if args.local_rank == 0:
-                    torch.save({
-                        'model': model_without_ddp.state_dict(),
-                        'optimizer': optimizer.state_dict(),
-                        'step': total_steps,
-                        'epoch': epoch,
-                    }, checkpoint_path)
-
-            if total_steps % args.val_freq == 0:
-                print('Start validation')
-
-                val_results = {}
-                # support validation on multiple datasets
-                if 'chairs' in args.val_dataset:
-                    results_dict = validate_chairs(model_without_ddp,
-                                                   with_speed_metric=args.with_speed_metric,
-                                                   attn_splits_list=args.attn_splits_list,
-                                                   corr_radius_list=args.corr_radius_list,
-                                                   prop_radius_list=args.prop_radius_list,
-                                                   )
-                    if args.local_rank == 0:
-                        val_results.update(results_dict)
-
-                if 'things' in args.val_dataset:
-                    results_dict = validate_things(model_without_ddp,
-                                                   padding_factor=args.padding_factor,
-                                                   with_speed_metric=args.with_speed_metric,
-                                                   attn_splits_list=args.attn_splits_list,
-                                                   corr_radius_list=args.corr_radius_list,
-                                                   prop_radius_list=args.prop_radius_list,
-                                                   )
-                    if args.local_rank == 0:
-                        val_results.update(results_dict)
-
-                if 'sintel' in args.val_dataset:
-                    results_dict = validate_sintel(model_without_ddp,
-                                                   count_time=args.count_time,
-                                                   padding_factor=args.padding_factor,
-                                                   with_speed_metric=args.with_speed_metric,
-                                                   evaluate_matched_unmatched=args.evaluate_matched_unmatched,
-                                                   attn_splits_list=args.attn_splits_list,
-                                                   corr_radius_list=args.corr_radius_list,
-                                                   prop_radius_list=args.prop_radius_list,
-                                                   )
-                    if args.local_rank == 0:
-                        val_results.update(results_dict)
-
-                if 'kitti' in args.val_dataset:
-                    results_dict = validate_kitti(model_without_ddp,
-                                                  padding_factor=args.padding_factor,
-                                                  with_speed_metric=args.with_speed_metric,
-                                                  attn_splits_list=args.attn_splits_list,
-                                                  corr_radius_list=args.corr_radius_list,
-                                                  prop_radius_list=args.prop_radius_list,
-                                                  )
-                    if args.local_rank == 0:
-                        val_results.update(results_dict)
-
-                if args.local_rank == 0:
-                    logger.write_dict(val_results)
-
-                    # Save validation results
-                    val_file = os.path.join(args.checkpoint_dir, 'val_results.txt')
-                    with open(val_file, 'a') as f:
-                        f.write('step: %06d\n' % total_steps)
-                        if args.evaluate_matched_unmatched:
-                            metrics = ['chairs_epe',
-                                       'chairs_s0_10', 'chairs_s10_40', 'chairs_s40+',
-                                       'things_clean_epe', 'things_clean_s0_10', 'things_clean_s10_40',
-                                       'things_clean_s40+',
-                                       'sintel_clean_epe', 'sintel_clean_matched', 'sintel_clean_unmatched',
-                                       'sintel_clean_s0_10', 'sintel_clean_s10_40',
-                                       'sintel_clean_s40+',
-                                       'sintel_final_epe', 'sintel_final_matched', 'sintel_final_unmatched',
-                                       'sintel_final_s0_10', 'sintel_final_s10_40',
-                                       'sintel_final_s40+',
-                                       'kitti_epe', 'kitti_f1', 'kitti_s0_10', 'kitti_s10_40', 'kitti_s40+',
-                                       ]
-                        else:
-                            metrics = ['chairs_epe', 'chairs_s0_10', 'chairs_s10_40', 'chairs_s40+',
-                                       'things_clean_epe', 'things_clean_s0_10', 'things_clean_s10_40',
-                                       'things_clean_s40+',
-                                       'sintel_clean_epe', 'sintel_clean_s0_10', 'sintel_clean_s10_40',
-                                       'sintel_clean_s40+',
-                                       'sintel_final_epe', 'sintel_final_s0_10', 'sintel_final_s10_40',
-                                       'sintel_final_s40+',
-                                       'kitti_epe', 'kitti_f1', 'kitti_s0_10', 'kitti_s10_40', 'kitti_s40+',
-                                       ]
-
-                        eval_metrics = []
-                        for metric in metrics:
-                            if metric in val_results.keys():
-                                eval_metrics.append(metric)
-
-                        metrics_values = [val_results[metric] for metric in eval_metrics]
-
-                        num_metrics = len(eval_metrics)
-
-                        # save as markdown format
-                        if args.evaluate_matched_unmatched:
-                            f.write(("| {:>25} " * num_metrics + '\n').format(*eval_metrics))
-                            f.write(("| {:25.3f} " * num_metrics).format(*metrics_values))
-                        else:
-                            f.write(("| {:>20} " * num_metrics + '\n').format(*eval_metrics))
-                            f.write(("| {:20.3f} " * num_metrics).format(*metrics_values))
-
-                        f.write('\n\n')
-
-                model.train()
-
-            if total_steps >= args.num_steps:
-                print('Training done')
-
-                return
-
-        epoch += 1
-
-
-if __name__ == '__main__':
-    parser = get_args_parser()
-    args = parser.parse_args()
-
-    if 'LOCAL_RANK' not in os.environ:
-        os.environ['LOCAL_RANK'] = str(args.local_rank)
-
-    main(args)

spaces/AriaMei/TTSdemo/mel_processing.py

@@ -1,119 +0,0 @@
-import math
-import os
-import random
-import torch
-from torch import nn
-import torch.nn.functional as F
-import torch.utils.data
-import numpy as np
-
-import logging
-
-numba_logger = logging.getLogger('numba')
-numba_logger.setLevel(logging.WARNING)
-import warnings
-warnings.filterwarnings('ignore')
-import librosa
-import librosa.util as librosa_util
-from librosa.util import normalize, pad_center, tiny
-from scipy.signal import get_window
-from scipy.io.wavfile import read
-from librosa.filters import mel as librosa_mel_fn
-
-MAX_WAV_VALUE = 32768.0
-
-
-def dynamic_range_compression_torch(x, C=1, clip_val=1e-5):
-    """
-    PARAMS
-    ------
-    C: compression factor
-    """
-    return torch.log(torch.clamp(x, min=clip_val) * C)
-
-
-def dynamic_range_decompression_torch(x, C=1):
-    """
-    PARAMS
-    ------
-    C: compression factor used to compress
-    """
-    return torch.exp(x) / C
-
-
-def spectral_normalize_torch(magnitudes):
-    output = dynamic_range_compression_torch(magnitudes)
-    return output
-
-
-def spectral_de_normalize_torch(magnitudes):
-    output = dynamic_range_decompression_torch(magnitudes)
-    return output
-
-
-mel_basis = {}
-hann_window = {}
-
-
-def spectrogram_torch(y, n_fft, sampling_rate, hop_size, win_size, center=False):
-    if torch.min(y) < -1.:
-        print('min value is ', torch.min(y))
-    if torch.max(y) > 1.:
-        print('max value is ', torch.max(y))
-
-    global hann_window
-    dtype_device = str(y.dtype) + '_' + str(y.device)
-    wnsize_dtype_device = str(win_size) + '_' + dtype_device
-    if wnsize_dtype_device not in hann_window:
-        hann_window[wnsize_dtype_device] = torch.hann_window(win_size).to(dtype=y.dtype, device=y.device)
-
-    y = torch.nn.functional.pad(y.unsqueeze(1), (int((n_fft-hop_size)/2), int((n_fft-hop_size)/2)), mode='reflect')
-    y = y.squeeze(1)
-
-    spec = torch.stft(y, n_fft, hop_length=hop_size, win_length=win_size, window=hann_window[wnsize_dtype_device],
-                      center=center, pad_mode='reflect', normalized=False, onesided=True)
-
-    spec = torch.sqrt(spec.pow(2).sum(-1) + 1e-6)
-    return spec
-
-
-def spec_to_mel_torch(spec, n_fft, num_mels, sampling_rate, fmin, fmax):
-    global mel_basis
-    dtype_device = str(spec.dtype) + '_' + str(spec.device)
-    fmax_dtype_device = str(fmax) + '_' + dtype_device
-    if fmax_dtype_device not in mel_basis:
-        mel = librosa_mel_fn(sampling_rate, n_fft, num_mels, fmin, fmax)
-        mel_basis[fmax_dtype_device] = torch.from_numpy(mel).to(dtype=spec.dtype, device=spec.device)
-    spec = torch.matmul(mel_basis[fmax_dtype_device], spec)
-    spec = spectral_normalize_torch(spec)
-    return spec
-
-
-def mel_spectrogram_torch(y, n_fft, num_mels, sampling_rate, hop_size, win_size, fmin, fmax, center=False):
-    if torch.min(y) < -1.:
-        print('min value is ', torch.min(y))
-    if torch.max(y) > 1.:
-        print('max value is ', torch.max(y))
-
-    global mel_basis, hann_window
-    dtype_device = str(y.dtype) + '_' + str(y.device)
-    fmax_dtype_device = str(fmax) + '_' + dtype_device
-    wnsize_dtype_device = str(win_size) + '_' + dtype_device
-    if fmax_dtype_device not in mel_basis:
-        mel = librosa_mel_fn(sampling_rate, n_fft, num_mels, fmin, fmax)
-        mel_basis[fmax_dtype_device] = torch.from_numpy(mel).to(dtype=y.dtype, device=y.device)
-    if wnsize_dtype_device not in hann_window:
-        hann_window[wnsize_dtype_device] = torch.hann_window(win_size).to(dtype=y.dtype, device=y.device)
-
-    y = torch.nn.functional.pad(y.unsqueeze(1), (int((n_fft-hop_size)/2), int((n_fft-hop_size)/2)), mode='reflect')
-    y = y.squeeze(1)
-
-    spec = torch.stft(y, n_fft, hop_length=hop_size, win_length=win_size, window=hann_window[wnsize_dtype_device],
-                      center=center, pad_mode='reflect', normalized=False, onesided=True)
-
-    spec = torch.sqrt(spec.pow(2).sum(-1) + 1e-6)
-
-    spec = torch.matmul(mel_basis[fmax_dtype_device], spec)
-    spec = spectral_normalize_torch(spec)
-
-    return spec

spaces/Arnx/MusicGenXvAKN/audiocraft/models/loaders.py

@@ -1,94 +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.
-
-"""
-Utility functions to load from the checkpoints.
-Each checkpoint is a torch.saved dict with the following keys:
-- 'xp.cfg': the hydra config as dumped during training. This should be used
-    to rebuild the object using the audiocraft.models.builders functions,
-- 'model_best_state': a readily loadable best state for the model, including
-    the conditioner. The model obtained from `xp.cfg` should be compatible
-    with this state dict. In the case of a LM, the encodec model would not be
-    bundled along but instead provided separately.
-
-Those functions also support loading from a remote location with the Torch Hub API.
-They also support overriding some parameters, in particular the device and dtype
-of the returned model.
-"""
-
-from pathlib import Path
-from huggingface_hub import hf_hub_download
-import typing as tp
-import os
-
-from omegaconf import OmegaConf
-import torch
-
-from . import builders
-
-
-HF_MODEL_CHECKPOINTS_MAP = {
-    "small": "facebook/musicgen-small",
-    "medium": "facebook/musicgen-medium",
-    "large": "facebook/musicgen-large",
-    "melody": "facebook/musicgen-melody",
-}
-
-
-def _get_state_dict(
-    file_or_url_or_id: tp.Union[Path, str],
-    filename: tp.Optional[str] = None,
-    device='cpu',
-    cache_dir: tp.Optional[str] = None,
-):
-    # Return the state dict either from a file or url
-    file_or_url_or_id = str(file_or_url_or_id)
-    assert isinstance(file_or_url_or_id, str)
-
-    if os.path.isfile(file_or_url_or_id):
-        return torch.load(file_or_url_or_id, map_location=device)
-
-    if os.path.isdir(file_or_url_or_id):
-        file = f"{file_or_url_or_id}/{filename}"
-        return torch.load(file, map_location=device)
-
-    elif file_or_url_or_id.startswith('https://'):
-        return torch.hub.load_state_dict_from_url(file_or_url_or_id, map_location=device, check_hash=True)
-
-    elif file_or_url_or_id in HF_MODEL_CHECKPOINTS_MAP:
-        assert filename is not None, "filename needs to be defined if using HF checkpoints"
-
-        repo_id = HF_MODEL_CHECKPOINTS_MAP[file_or_url_or_id]
-        file = hf_hub_download(repo_id=repo_id, filename=filename, cache_dir=cache_dir)
-        return torch.load(file, map_location=device)
-
-    else:
-        raise ValueError(f"{file_or_url_or_id} is not a valid name, path or link that can be loaded.")
-
-
-def load_compression_model(file_or_url_or_id: tp.Union[Path, str], device='cpu', cache_dir: tp.Optional[str] = None):
-    pkg = _get_state_dict(file_or_url_or_id, filename="compression_state_dict.bin", cache_dir=cache_dir)
-    cfg = OmegaConf.create(pkg['xp.cfg'])
-    cfg.device = str(device)
-    model = builders.get_compression_model(cfg)
-    model.load_state_dict(pkg['best_state'])
-    model.eval()
-    return model
-
-
-def load_lm_model(file_or_url_or_id: tp.Union[Path, str], device='cpu', cache_dir: tp.Optional[str] = None):
-    pkg = _get_state_dict(file_or_url_or_id, filename="state_dict.bin", cache_dir=cache_dir)
-    cfg = OmegaConf.create(pkg['xp.cfg'])
-    cfg.device = str(device)
-    if cfg.device == 'cpu':
-        cfg.dtype = 'float32'
-    else:
-        cfg.dtype = 'float16'
-    model = builders.get_lm_model(cfg)
-    model.load_state_dict(pkg['best_state'])
-    model.eval()
-    model.cfg = cfg
-    return model

spaces/Artrajz/vits-simple-api/bert_vits2/utils.py

@@ -1,70 +0,0 @@
-import os
-import sys
-import logging
-import torch
-
-MATPLOTLIB_FLAG = False
-
-logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
-logger = logging
-
-
-def load_checkpoint(checkpoint_path, model, optimizer=None, skip_optimizer=False, version=None):
-    assert os.path.isfile(checkpoint_path)
-    checkpoint_dict = torch.load(checkpoint_path, map_location='cpu')
-    iteration = checkpoint_dict['iteration']
-    learning_rate = checkpoint_dict['learning_rate']
-    if optimizer is not None and not skip_optimizer and checkpoint_dict['optimizer'] is not None:
-        optimizer.load_state_dict(checkpoint_dict['optimizer'])
-    elif optimizer is None and not skip_optimizer:
-        # else: #Disable this line if Infer ,and enable the line upper
-        new_opt_dict = optimizer.state_dict()
-        new_opt_dict_params = new_opt_dict['param_groups'][0]['params']
-        new_opt_dict['param_groups'] = checkpoint_dict['optimizer']['param_groups']
-        new_opt_dict['param_groups'][0]['params'] = new_opt_dict_params
-        optimizer.load_state_dict(new_opt_dict)
-    saved_state_dict = checkpoint_dict['model']
-    if hasattr(model, 'module'):
-        state_dict = model.module.state_dict()
-    else:
-        state_dict = model.state_dict()
-    new_state_dict = {}
-    for k, v in state_dict.items():
-        try:
-            # assert "emb_g" not in k
-            # print("load", k)
-            new_state_dict[k] = saved_state_dict[k]
-            assert saved_state_dict[k].shape == v.shape, (saved_state_dict[k].shape, v.shape)
-        except:
-            # Handle legacy model versions and provide appropriate warnings
-            if "ja_bert_proj" in k:
-                v = torch.zeros_like(v)
-                if version is None:
-                    logger.error(f"{k} is not in the checkpoint")
-                    logger.warning(
-                        f"If you're using an older version of the model, consider adding the \"version\" parameter to the model's config.json under the \"data\" section. For instance: \"legacy_version\": \"1.0.1\"")
-            elif "flow.flows.0.enc.attn_layers.3" in k:
-                logger.error(f"{k} is not in the checkpoint")
-                logger.warning(
-                    f"If you're using a transitional version, please add the \"version\": \"1.1.0-transition\" parameter within the \"data\" section of the model's config.json.")
-            else:
-                logger.error(f"{k} is not in the checkpoint")
-
-            new_state_dict[k] = v
-    if hasattr(model, 'module'):
-        model.module.load_state_dict(new_state_dict, strict=False)
-    else:
-        model.load_state_dict(new_state_dict, strict=False)
-    # print("load ")
-    logger.info("Loaded checkpoint '{}' (iteration {})".format(
-        checkpoint_path, iteration))
-    return model, optimizer, learning_rate, iteration
-
-
-def process_legacy_versions(hps):
-    version = getattr(hps, "version", getattr(hps.data, "version", None))
-    if version:
-        prefix = version[0].lower()
-        if prefix == "v":
-            version = version[1:]
-    return version

spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/layers/rotated_boxes.py

@@ -1,21 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-from __future__ import absolute_import, division, print_function, unicode_literals
-import torch
-
-
-def pairwise_iou_rotated(boxes1, boxes2):
-    """
-    Return intersection-over-union (Jaccard index) of boxes.
-
-    Both sets of boxes are expected to be in
-    (x_center, y_center, width, height, angle) format.
-
-    Arguments:
-        boxes1 (Tensor[N, 5])
-        boxes2 (Tensor[M, 5])
-
-    Returns:
-        iou (Tensor[N, M]): the NxM matrix containing the pairwise
-            IoU values for every element in boxes1 and boxes2
-    """
-    return torch.ops.detectron2.box_iou_rotated(boxes1, boxes2)

spaces/Benson/text-generation/Examples/Descargar Facebook Lite Apk Versin Antigua.md

@@ -1,118 +0,0 @@
-
-<h1>Cómo descargar Facebook Lite APK versión anterior</h1>
-<p>Facebook Lite es una aplicación popular que te permite usar Facebook en tu dispositivo Android sin consumir demasiados datos o espacio de almacenamiento. Sin embargo, a veces es posible que tenga que descargar una versión antigua de Facebook Lite por varias razones, como problemas de compatibilidad, problemas de rendimiento o preferencias personales. En este artículo, le mostraremos cómo encontrar y descargar la versión antigua de Facebook Lite APK de diferentes fuentes, y cómo instalarlo en su dispositivo Android. </p>
- <h2>¿Qué es Facebook Lite y por qué es posible que necesite una versión antigua</h2>
-<p>Facebook Lite es una versión de Facebook diseñada para trabajar más rápido y usar menos datos en dispositivos de gama baja o lenta. Tiene muchas características y beneficios que lo convierten en una gran alternativa a la aplicación regular de Facebook, como:</p>
-<h2>descargar facebook lite apk versión antigua</h2><br /><p><b><b>Download</b> &#9675; <a href="https://bltlly.com/2v6Lhe">https://bltlly.com/2v6Lhe</a></b></p><br /><br />
-<ul>
-<li>Utiliza menos de 2 MB de espacio de almacenamiento en su dispositivo. </li>
-<li>Se carga rápidamente y funciona sin problemas en redes 2G y áreas con mala conexión a Internet. </li>
-<li>Guarda sus datos mostrando solo características básicas e imágenes de baja resolución. </li>
-<li>Soporta la mayoría de las funciones de Facebook, como mensajería, publicación, me gusta, comentarios, compartir, etc.</li>
-<li>Funciona en casi cualquier dispositivo Android, incluso aquellos con versiones anteriores de Android OS.</li>
-</ul>
-<p>Sin embargo, puede haber algunas situaciones en las que prefieras usar una versión antigua de Facebook Lite en lugar de la última, como:</p>
-<ul>
-<li>Tienes un dispositivo muy antiguo que no soporta la última versión de Facebook Lite.</li>
-<li>Usted experimenta errores o problemas técnicos con la última versión de Facebook Lite que afectan a su experiencia de usuario. </li>
-<li>Prefieres la interfaz o características de una versión antigua de Facebook Lite sobre la nueva. </li>
-<li>Desea evitar actualizaciones que puedan cambiar sus ajustes o preferencias. </li>
-</ul>
- <h2>Cómo encontrar y descargar Facebook Lite APK versión anterior</h2>
-
- <h3>Uso del sitio web de Uptodown</h3>
-<p>Uptodown es un sitio web que proporciona descargas gratuitas de aplicaciones y juegos para Android, iOS, Windows, Mac y Linux. Tiene una gran colección de versiones antiguas de Facebook Lite, que se remonta a 2015. Para descargar una versión antigua de Facebook Lite de Uptodown, sigue estos pasos:</p>
-<ol>
-<li>Ir a <a href="( 1 )">https://facebook-lite.en.uptodown.com/android/versions</a>. </li>
-<li>Desplácese hacia abajo y encuentre la versión de Facebook Lite que desea descargar. Puede ver la fecha de lanzamiento, el tamaño y la compatibilidad con Android de cada versión. </li>
-<li>Haga clic en el botón verde "Descargar" junto a la versión que desee. </li>
-<li>Espere a que termine la descarga. El archivo se guardará en la carpeta "Descargas" de su dispositivo. </li>
-</ol>
- <h3>Uso del sitio web de APKPure</h3>
-<p>APKPure es otro sitio web que ofrece descargas gratuitas de aplicaciones y juegos para dispositivos Android. También tiene una amplia gama de versiones antiguas de Facebook Lite, que se remonta a 2015. Para descargar una versión antigua de Facebook Lite desde APKPure, sigue estos pasos:</p>
-<ol>
-<li>Ir a <a href=">https://apkpure.com/facebook-lite/com.facebook.lit.lite/versions</a>. </li>
-<li <li>Desplácese hacia abajo y encuentre la versión de Facebook Lite que desea descargar. Puede ver la fecha de lanzamiento, el tamaño y la compatibilidad con Android de cada versión. </li>
-<li>Haga clic en el botón azul "Descargar APK" junto a la versión que desee. </li>
-<li>Espere a que termine la descarga. El archivo se guardará en la carpeta "Descargas" de su dispositivo. </li>
-</ol>
- <h3>Uso del sitio web de APKMirror</h3>
-<p>APKMirror es otro sitio web que ofrece descargas gratuitas de aplicaciones y juegos para dispositivos Android. También tiene un enorme archivo de versiones antiguas de Facebook Lite, que se remonta a 2015. Para descargar una versión antigua de Facebook Lite desde APKMirror, sigue estos pasos:</p>
-<ol>
-<li>Ir a <a href=">https://www.apkmirror.com/apk/facebook-2/lite/</a>. </li>
-
-<li>Haga clic en la versión que desee. Será redirigido a una nueva página con más detalles sobre la aplicación. </li>
-<li>Haga clic en el botón rojo "Descargar APK" en la parte inferior de la página. </li>
-<li>Espere a que termine la descarga. El archivo se guardará en la carpeta "Descargas" de su dispositivo. </li>
-</ol>
- <h2>Cómo instalar Facebook Lite APK versión antigua en su dispositivo Android</h2>
-<p>Una vez que haya descargado el archivo de versión antigua de Facebook Lite APK de una de las fuentes anteriores, tendrá que instalarlo en su dispositivo Android. Para ello, deberá seguir estos pasos:</p>
- <h3>Habilitar la opción de fuentes desconocidas</h3>
-<p>De forma predeterminada, tu dispositivo Android no te permitirá instalar aplicaciones desde fuentes distintas de Google Play Store. Esta es una medida de seguridad para evitar que malware y virus infecten tu dispositivo. Sin embargo, si confías en la fuente del archivo APK, puedes habilitar la opción de instalar aplicaciones de fuentes desconocidas. Para hacerlo, sigue estos pasos:</p>
-<ol>
-<li>Ir a la aplicación "Configuración" de su dispositivo. </li>
-<li>Toque en "Seguridad" o "Privacidad" dependiendo del modelo de su dispositivo. </li>
-<li> Buscar y alternar en la opción que dice "Fuentes desconocidas" o "Permitir la instalación de aplicaciones de fuentes desconocidas". </li>
-<li> Aparecerá un mensaje de advertencia. Toque en "OK" o "Permitir" para confirmar. </li>
-</ol>
- <h3>Localizar y abrir el archivo descargado</h3>
-<p>Siguiente, tendrá que encontrar y abrir el archivo de versión antigua de Facebook Lite APK que ha descargado. Para hacer eso, siga estos pasos:</p>
-<p></p>
-<ol>
-<li>Vaya a la aplicación "Administrador de archivos" de su dispositivo o a cualquier otra aplicación que pueda acceder a sus archivos. </li>
-<li>Vaya a la carpeta "Descargas" de su dispositivo o donde quiera que haya guardado el archivo. </li>
-<li>Encuentre y toque en el archivo que tiene el nombre "Facebook Lite" y el número de versión que ha descargado. </li>
-</ol>
- <h3>Siguiendo los pasos de instalación</h3>
-<p>Finalmente, tendrá que seguir los pasos de instalación para completar el proceso. Para ello, siga estos pasos:</p>
-<ol>
-
-<li> La instalación comenzará y tomará unos segundos o minutos dependiendo del tamaño del dispositivo y del archivo. </li>
-<li> Aparecerá una pantalla diciendo que la aplicación ha sido instalada. Toque en "Abrir" para iniciar la aplicación o "Hecho" para salir. </li>
-</ol>
- <h2>Conclusión</h2>
-<p>En este artículo, le hemos mostrado cómo descargar la versión antigua de Facebook Lite APK de diferentes fuentes, y cómo instalarlo en su dispositivo Android. Esperamos que esta guía haya sido útil e informativa para usted. Si tiene alguna pregunta o comentario, no dude en dejar un comentario a continuación. </p>
- <h2>Preguntas frecuentes</h2>
-<ul>
-<li><b>Q: ¿Es seguro descargar e instalar Facebook Lite APK versión antigua? </b></li>
-<li>A: Depende de dónde descargue el archivo. Algunos sitios web pueden ofrecer archivos falsos o maliciosos que pueden dañar su dispositivo o robar sus datos. Por lo tanto, es importante descargar solo de fuentes confiables y de buena reputación, como las que hemos mencionado en este artículo. Además, asegúrese de escanear el archivo con una aplicación antivirus antes de instalarlo. </li>
- <li><b>Q: ¿Cuáles son las ventajas y desventajas de usar la versión antigua de Facebook Lite APK? </b></li>
-<li>A: Algunas de las ventajas de usar Facebook Lite APK versión antigua son:   <ul>
-  <li>Puede usarlo en dispositivos que no admiten la última versión de Facebook Lite <li>Puede evitar errores o problemas técnicos que puedan ocurrir con la última versión de Facebook Lite</li>
-<li>Puedes disfrutar de la interfaz o características de una versión antigua de Facebook Lite que prefieras sobre la nueva</li>
-<li> Puede guardar sus datos y espacio de almacenamiento no actualizando la aplicación</li>
-  </ul>
-Algunas de las desventajas de usar Facebook Lite APK versión antigua son:   <ul>
-<li>Es posible que se pierda algunas nuevas características o mejoras que se agregan a la última versión de Facebook Lite</li>
-<li>Es posible que tenga problemas de compatibilidad con algunos dispositivos u otras aplicaciones que requieren la última versión de Facebook Lite</li>
-
-  </ul>
-</li>
- <li><b>Q: ¿Cómo puedo actualizar la versión antigua de Facebook Lite APK a la última versión? </b></li>
-<li>A: Si desea actualizar la versión antigua de Facebook Lite APK a la última versión, tiene dos opciones:   <ol>
-  <li>Desinstalar la versión anterior e instalar la última versión de la Google Play Store o cualquiera de las fuentes mencionadas en este artículo. </li>
-  <li>Descargar e instalar la última versión sobre la versión anterior sin desinstalarlo. Esto mantendrá sus datos y configuraciones intactos, pero podría causar algunos errores o conflictos. </li>
-  </ol>
-</li>
- <li><b>Q: ¿Cómo puedo eliminar la versión antigua de Facebook Lite APK de mi dispositivo? </b></li>
-<li>A: Si desea eliminar la versión antigua de Facebook Lite APK de su dispositivo, puede seguir estos pasos:   <ol>
-  <li>Ir a la aplicación "Configuración" de su dispositivo. </li>
-  <li>Toque en "Aplicaciones" o "Aplicaciones" dependiendo del modelo de su dispositivo. </li>
-  <li>Encuentra y toca "Facebook Lite". </li>
-  <li>Toque en "Desinstalar". </li>
-  <li>Aparecerá un mensaje de confirmación. Toca "OK" o "Desinstalar" para confirmar. </li>
-  </ol>
-</li>
- <li><b>Q: ¿Cómo puedo contactar al soporte de Facebook Lite si tengo algún problema o pregunta? </b></li>
-<li>A: Si tiene algún problema o pregunta con respecto a Facebook Lite, puede ponerse en contacto con el soporte de Facebook Lite siguiendo estos pasos:   <ol>
-  <li>Abra la aplicación Facebook Lite en su dispositivo. </li>
-  <li>Toque en el icono del menú (tres líneas horizontales) en la esquina superior derecha de la pantalla. </li>
-  <li>Desplácese hacia abajo y toque en "Ayuda y soporte". </li>
-  <li>Toque en "Informar de un problema". </li>
-  <li>Seleccione el tipo de problema que desea reportar, como "Algo no está funcionando", "Contenido abusivo" o "Comentarios generales". </li>
-  <li>Rellene los detalles de su problema, como una descripción, capturas de pantalla o registros. </li>
-  <li>Toque en "Enviar". </li>
-  </ol>
-También puede visitar el Centro de ayuda de Facebook Lite en <a href="">https://www.facebook.com/help/lite/</a> para obtener más información y preguntas frecuentes. </ul></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Big-Web/MMSD/env/Lib/site-packages/s3transfer/copies.py

@@ -1,382 +0,0 @@
-# Copyright 2016 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.
-import copy
-import math
-
-from s3transfer.tasks import (
-    CompleteMultipartUploadTask,
-    CreateMultipartUploadTask,
-    SubmissionTask,
-    Task,
-)
-from s3transfer.utils import (
-    ChunksizeAdjuster,
-    calculate_range_parameter,
-    get_callbacks,
-    get_filtered_dict,
-)
-
-
-class CopySubmissionTask(SubmissionTask):
-    """Task for submitting tasks to execute a copy"""
-
-    EXTRA_ARGS_TO_HEAD_ARGS_MAPPING = {
-        'CopySourceIfMatch': 'IfMatch',
-        'CopySourceIfModifiedSince': 'IfModifiedSince',
-        'CopySourceIfNoneMatch': 'IfNoneMatch',
-        'CopySourceIfUnmodifiedSince': 'IfUnmodifiedSince',
-        'CopySourceSSECustomerKey': 'SSECustomerKey',
-        'CopySourceSSECustomerAlgorithm': 'SSECustomerAlgorithm',
-        'CopySourceSSECustomerKeyMD5': 'SSECustomerKeyMD5',
-        'RequestPayer': 'RequestPayer',
-        'ExpectedBucketOwner': 'ExpectedBucketOwner',
-    }
-
-    UPLOAD_PART_COPY_ARGS = [
-        'CopySourceIfMatch',
-        'CopySourceIfModifiedSince',
-        'CopySourceIfNoneMatch',
-        'CopySourceIfUnmodifiedSince',
-        'CopySourceSSECustomerKey',
-        'CopySourceSSECustomerAlgorithm',
-        'CopySourceSSECustomerKeyMD5',
-        'SSECustomerKey',
-        'SSECustomerAlgorithm',
-        'SSECustomerKeyMD5',
-        'RequestPayer',
-        'ExpectedBucketOwner',
-    ]
-
-    CREATE_MULTIPART_ARGS_BLACKLIST = [
-        'CopySourceIfMatch',
-        'CopySourceIfModifiedSince',
-        'CopySourceIfNoneMatch',
-        'CopySourceIfUnmodifiedSince',
-        'CopySourceSSECustomerKey',
-        'CopySourceSSECustomerAlgorithm',
-        'CopySourceSSECustomerKeyMD5',
-        'MetadataDirective',
-        'TaggingDirective',
-    ]
-
-    COMPLETE_MULTIPART_ARGS = ['RequestPayer', 'ExpectedBucketOwner']
-
-    def _submit(
-        self, client, config, osutil, request_executor, transfer_future
-    ):
-        """
-        :param client: The client associated with the transfer manager
-
-        :type config: s3transfer.manager.TransferConfig
-        :param config: The transfer config associated with the transfer
-            manager
-
-        :type osutil: s3transfer.utils.OSUtil
-        :param osutil: The os utility associated to the transfer manager
-
-        :type request_executor: s3transfer.futures.BoundedExecutor
-        :param request_executor: The request executor associated with the
-            transfer manager
-
-        :type transfer_future: s3transfer.futures.TransferFuture
-        :param transfer_future: The transfer future associated with the
-            transfer request that tasks are being submitted for
-        """
-        # Determine the size if it was not provided
-        if transfer_future.meta.size is None:
-            # If a size was not provided figure out the size for the
-            # user. Note that we will only use the client provided to
-            # the TransferManager. If the object is outside of the region
-            # of the client, they may have to provide the file size themselves
-            # with a completely new client.
-            call_args = transfer_future.meta.call_args
-            head_object_request = (
-                self._get_head_object_request_from_copy_source(
-                    call_args.copy_source
-                )
-            )
-            extra_args = call_args.extra_args
-
-            # Map any values that may be used in the head object that is
-            # used in the copy object
-            for param, value in extra_args.items():
-                if param in self.EXTRA_ARGS_TO_HEAD_ARGS_MAPPING:
-                    head_object_request[
-                        self.EXTRA_ARGS_TO_HEAD_ARGS_MAPPING[param]
-                    ] = value
-
-            response = call_args.source_client.head_object(
-                **head_object_request
-            )
-            transfer_future.meta.provide_transfer_size(
-                response['ContentLength']
-            )
-
-        # If it is greater than threshold do a multipart copy, otherwise
-        # do a regular copy object.
-        if transfer_future.meta.size < config.multipart_threshold:
-            self._submit_copy_request(
-                client, config, osutil, request_executor, transfer_future
-            )
-        else:
-            self._submit_multipart_request(
-                client, config, osutil, request_executor, transfer_future
-            )
-
-    def _submit_copy_request(
-        self, client, config, osutil, request_executor, transfer_future
-    ):
-        call_args = transfer_future.meta.call_args
-
-        # Get the needed progress callbacks for the task
-        progress_callbacks = get_callbacks(transfer_future, 'progress')
-
-        # Submit the request of a single copy.
-        self._transfer_coordinator.submit(
-            request_executor,
-            CopyObjectTask(
-                transfer_coordinator=self._transfer_coordinator,
-                main_kwargs={
-                    'client': client,
-                    'copy_source': call_args.copy_source,
-                    'bucket': call_args.bucket,
-                    'key': call_args.key,
-                    'extra_args': call_args.extra_args,
-                    'callbacks': progress_callbacks,
-                    'size': transfer_future.meta.size,
-                },
-                is_final=True,
-            ),
-        )
-
-    def _submit_multipart_request(
-        self, client, config, osutil, request_executor, transfer_future
-    ):
-        call_args = transfer_future.meta.call_args
-
-        # Submit the request to create a multipart upload and make sure it
-        # does not include any of the arguments used for copy part.
-        create_multipart_extra_args = {}
-        for param, val in call_args.extra_args.items():
-            if param not in self.CREATE_MULTIPART_ARGS_BLACKLIST:
-                create_multipart_extra_args[param] = val
-
-        create_multipart_future = self._transfer_coordinator.submit(
-            request_executor,
-            CreateMultipartUploadTask(
-                transfer_coordinator=self._transfer_coordinator,
-                main_kwargs={
-                    'client': client,
-                    'bucket': call_args.bucket,
-                    'key': call_args.key,
-                    'extra_args': create_multipart_extra_args,
-                },
-            ),
-        )
-
-        # Determine how many parts are needed based on filesize and
-        # desired chunksize.
-        part_size = config.multipart_chunksize
-        adjuster = ChunksizeAdjuster()
-        part_size = adjuster.adjust_chunksize(
-            part_size, transfer_future.meta.size
-        )
-        num_parts = int(
-            math.ceil(transfer_future.meta.size / float(part_size))
-        )
-
-        # Submit requests to upload the parts of the file.
-        part_futures = []
-        progress_callbacks = get_callbacks(transfer_future, 'progress')
-
-        for part_number in range(1, num_parts + 1):
-            extra_part_args = self._extra_upload_part_args(
-                call_args.extra_args
-            )
-            # The part number for upload part starts at 1 while the
-            # range parameter starts at zero, so just subtract 1 off of
-            # the part number
-            extra_part_args['CopySourceRange'] = calculate_range_parameter(
-                part_size,
-                part_number - 1,
-                num_parts,
-                transfer_future.meta.size,
-            )
-            # Get the size of the part copy as well for the progress
-            # callbacks.
-            size = self._get_transfer_size(
-                part_size,
-                part_number - 1,
-                num_parts,
-                transfer_future.meta.size,
-            )
-            # Get the checksum algorithm of the multipart request.
-            checksum_algorithm = call_args.extra_args.get("ChecksumAlgorithm")
-            part_futures.append(
-                self._transfer_coordinator.submit(
-                    request_executor,
-                    CopyPartTask(
-                        transfer_coordinator=self._transfer_coordinator,
-                        main_kwargs={
-                            'client': client,
-                            'copy_source': call_args.copy_source,
-                            'bucket': call_args.bucket,
-                            'key': call_args.key,
-                            'part_number': part_number,
-                            'extra_args': extra_part_args,
-                            'callbacks': progress_callbacks,
-                            'size': size,
-                            'checksum_algorithm': checksum_algorithm,
-                        },
-                        pending_main_kwargs={
-                            'upload_id': create_multipart_future
-                        },
-                    ),
-                )
-            )
-
-        complete_multipart_extra_args = self._extra_complete_multipart_args(
-            call_args.extra_args
-        )
-        # Submit the request to complete the multipart upload.
-        self._transfer_coordinator.submit(
-            request_executor,
-            CompleteMultipartUploadTask(
-                transfer_coordinator=self._transfer_coordinator,
-                main_kwargs={
-                    'client': client,
-                    'bucket': call_args.bucket,
-                    'key': call_args.key,
-                    'extra_args': complete_multipart_extra_args,
-                },
-                pending_main_kwargs={
-                    'upload_id': create_multipart_future,
-                    'parts': part_futures,
-                },
-                is_final=True,
-            ),
-        )
-
-    def _get_head_object_request_from_copy_source(self, copy_source):
-        if isinstance(copy_source, dict):
-            return copy.copy(copy_source)
-        else:
-            raise TypeError(
-                'Expecting dictionary formatted: '
-                '{"Bucket": bucket_name, "Key": key} '
-                'but got %s or type %s.' % (copy_source, type(copy_source))
-            )
-
-    def _extra_upload_part_args(self, extra_args):
-        # Only the args in COPY_PART_ARGS actually need to be passed
-        # onto the upload_part_copy calls.
-        return get_filtered_dict(extra_args, self.UPLOAD_PART_COPY_ARGS)
-
-    def _extra_complete_multipart_args(self, extra_args):
-        return get_filtered_dict(extra_args, self.COMPLETE_MULTIPART_ARGS)
-
-    def _get_transfer_size(
-        self, part_size, part_index, num_parts, total_transfer_size
-    ):
-        if part_index == num_parts - 1:
-            # The last part may be different in size then the rest of the
-            # parts.
-            return total_transfer_size - (part_index * part_size)
-        return part_size
-
-
-class CopyObjectTask(Task):
-    """Task to do a nonmultipart copy"""
-
-    def _main(
-        self, client, copy_source, bucket, key, extra_args, callbacks, size
-    ):
-        """
-        :param client: The client to use when calling PutObject
-        :param copy_source: The CopySource parameter to use
-        :param bucket: The name of the bucket to copy to
-        :param key: The name of the key to copy to
-        :param extra_args: A dictionary of any extra arguments that may be
-            used in the upload.
-        :param callbacks: List of callbacks to call after copy
-        :param size: The size of the transfer. This value is passed into
-            the callbacks
-
-        """
-        client.copy_object(
-            CopySource=copy_source, Bucket=bucket, Key=key, **extra_args
-        )
-        for callback in callbacks:
-            callback(bytes_transferred=size)
-
-
-class CopyPartTask(Task):
-    """Task to upload a part in a multipart copy"""
-
-    def _main(
-        self,
-        client,
-        copy_source,
-        bucket,
-        key,
-        upload_id,
-        part_number,
-        extra_args,
-        callbacks,
-        size,
-        checksum_algorithm=None,
-    ):
-        """
-        :param client: The client to use when calling PutObject
-        :param copy_source: The CopySource parameter to use
-        :param bucket: The name of the bucket to upload to
-        :param key: The name of the key to upload to
-        :param upload_id: The id of the upload
-        :param part_number: The number representing the part of the multipart
-            upload
-        :param extra_args: A dictionary of any extra arguments that may be
-            used in the upload.
-        :param callbacks: List of callbacks to call after copy part
-        :param size: The size of the transfer. This value is passed into
-            the callbacks
-        :param checksum_algorithm: The algorithm that was used to create the multipart
-            upload
-
-        :rtype: dict
-        :returns: A dictionary representing a part::
-
-            {'Etag': etag_value, 'PartNumber': part_number}
-
-            This value can be appended to a list to be used to complete
-            the multipart upload. If a checksum is in the response,
-            it will also be included.
-        """
-        response = client.upload_part_copy(
-            CopySource=copy_source,
-            Bucket=bucket,
-            Key=key,
-            UploadId=upload_id,
-            PartNumber=part_number,
-            **extra_args,
-        )
-        for callback in callbacks:
-            callback(bytes_transferred=size)
-        etag = response['CopyPartResult']['ETag']
-        part_metadata = {'ETag': etag, 'PartNumber': part_number}
-        if checksum_algorithm:
-            checksum_member = f'Checksum{checksum_algorithm.upper()}'
-            if checksum_member in response['CopyPartResult']:
-                part_metadata[checksum_member] = response['CopyPartResult'][
-                    checksum_member
-                ]
-        return part_metadata

spaces/Big-Web/MMSD/env/Lib/site-packages/setuptools/_distutils/unixccompiler.py

@@ -1,401 +0,0 @@
-"""distutils.unixccompiler
-
-Contains the UnixCCompiler class, a subclass of CCompiler that handles
-the "typical" Unix-style command-line C compiler:
-  * macros defined with -Dname[=value]
-  * macros undefined with -Uname
-  * include search directories specified with -Idir
-  * libraries specified with -lllib
-  * library search directories specified with -Ldir
-  * compile handled by 'cc' (or similar) executable with -c option:
-    compiles .c to .o
-  * link static library handled by 'ar' command (possibly with 'ranlib')
-  * link shared library handled by 'cc -shared'
-"""
-
-import os
-import sys
-import re
-import shlex
-import itertools
-
-from distutils import sysconfig
-from distutils.dep_util import newer
-from distutils.ccompiler import CCompiler, gen_preprocess_options, gen_lib_options
-from distutils.errors import DistutilsExecError, CompileError, LibError, LinkError
-from distutils import log
-from ._macos_compat import compiler_fixup
-
-# XXX Things not currently handled:
-#   * optimization/debug/warning flags; we just use whatever's in Python's
-#     Makefile and live with it.  Is this adequate?  If not, we might
-#     have to have a bunch of subclasses GNUCCompiler, SGICCompiler,
-#     SunCCompiler, and I suspect down that road lies madness.
-#   * even if we don't know a warning flag from an optimization flag,
-#     we need some way for outsiders to feed preprocessor/compiler/linker
-#     flags in to us -- eg. a sysadmin might want to mandate certain flags
-#     via a site config file, or a user might want to set something for
-#     compiling this module distribution only via the setup.py command
-#     line, whatever.  As long as these options come from something on the
-#     current system, they can be as system-dependent as they like, and we
-#     should just happily stuff them into the preprocessor/compiler/linker
-#     options and carry on.
-
-
-def _split_env(cmd):
-    """
-    For macOS, split command into 'env' portion (if any)
-    and the rest of the linker command.
-
-    >>> _split_env(['a', 'b', 'c'])
-    ([], ['a', 'b', 'c'])
-    >>> _split_env(['/usr/bin/env', 'A=3', 'gcc'])
-    (['/usr/bin/env', 'A=3'], ['gcc'])
-    """
-    pivot = 0
-    if os.path.basename(cmd[0]) == "env":
-        pivot = 1
-        while '=' in cmd[pivot]:
-            pivot += 1
-    return cmd[:pivot], cmd[pivot:]
-
-
-def _split_aix(cmd):
-    """
-    AIX platforms prefix the compiler with the ld_so_aix
-    script, so split that from the linker command.
-
-    >>> _split_aix(['a', 'b', 'c'])
-    ([], ['a', 'b', 'c'])
-    >>> _split_aix(['/bin/foo/ld_so_aix', 'gcc'])
-    (['/bin/foo/ld_so_aix'], ['gcc'])
-    """
-    pivot = os.path.basename(cmd[0]) == 'ld_so_aix'
-    return cmd[:pivot], cmd[pivot:]
-
-
-def _linker_params(linker_cmd, compiler_cmd):
-    """
-    The linker command usually begins with the compiler
-    command (possibly multiple elements), followed by zero or more
-    params for shared library building.
-
-    If the LDSHARED env variable overrides the linker command,
-    however, the commands may not match.
-
-    Return the best guess of the linker parameters by stripping
-    the linker command. If the compiler command does not
-    match the linker command, assume the linker command is
-    just the first element.
-
-    >>> _linker_params('gcc foo bar'.split(), ['gcc'])
-    ['foo', 'bar']
-    >>> _linker_params('gcc foo bar'.split(), ['other'])
-    ['foo', 'bar']
-    >>> _linker_params('ccache gcc foo bar'.split(), 'ccache gcc'.split())
-    ['foo', 'bar']
-    >>> _linker_params(['gcc'], ['gcc'])
-    []
-    """
-    c_len = len(compiler_cmd)
-    pivot = c_len if linker_cmd[:c_len] == compiler_cmd else 1
-    return linker_cmd[pivot:]
-
-
-class UnixCCompiler(CCompiler):
-
-    compiler_type = 'unix'
-
-    # These are used by CCompiler in two places: the constructor sets
-    # instance attributes 'preprocessor', 'compiler', etc. from them, and
-    # 'set_executable()' allows any of these to be set.  The defaults here
-    # are pretty generic; they will probably have to be set by an outsider
-    # (eg. using information discovered by the sysconfig about building
-    # Python extensions).
-    executables = {
-        'preprocessor': None,
-        'compiler': ["cc"],
-        'compiler_so': ["cc"],
-        'compiler_cxx': ["cc"],
-        'linker_so': ["cc", "-shared"],
-        'linker_exe': ["cc"],
-        'archiver': ["ar", "-cr"],
-        'ranlib': None,
-    }
-
-    if sys.platform[:6] == "darwin":
-        executables['ranlib'] = ["ranlib"]
-
-    # Needed for the filename generation methods provided by the base
-    # class, CCompiler.  NB. whoever instantiates/uses a particular
-    # UnixCCompiler instance should set 'shared_lib_ext' -- we set a
-    # reasonable common default here, but it's not necessarily used on all
-    # Unices!
-
-    src_extensions = [".c", ".C", ".cc", ".cxx", ".cpp", ".m"]
-    obj_extension = ".o"
-    static_lib_extension = ".a"
-    shared_lib_extension = ".so"
-    dylib_lib_extension = ".dylib"
-    xcode_stub_lib_extension = ".tbd"
-    static_lib_format = shared_lib_format = dylib_lib_format = "lib%s%s"
-    xcode_stub_lib_format = dylib_lib_format
-    if sys.platform == "cygwin":
-        exe_extension = ".exe"
-
-    def preprocess(
-        self,
-        source,
-        output_file=None,
-        macros=None,
-        include_dirs=None,
-        extra_preargs=None,
-        extra_postargs=None,
-    ):
-        fixed_args = self._fix_compile_args(None, macros, include_dirs)
-        ignore, macros, include_dirs = fixed_args
-        pp_opts = gen_preprocess_options(macros, include_dirs)
-        pp_args = self.preprocessor + pp_opts
-        if output_file:
-            pp_args.extend(['-o', output_file])
-        if extra_preargs:
-            pp_args[:0] = extra_preargs
-        if extra_postargs:
-            pp_args.extend(extra_postargs)
-        pp_args.append(source)
-
-        # reasons to preprocess:
-        # - force is indicated
-        # - output is directed to stdout
-        # - source file is newer than the target
-        preprocess = self.force or output_file is None or newer(source, output_file)
-        if not preprocess:
-            return
-
-        if output_file:
-            self.mkpath(os.path.dirname(output_file))
-
-        try:
-            self.spawn(pp_args)
-        except DistutilsExecError as msg:
-            raise CompileError(msg)
-
-    def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
-        compiler_so = compiler_fixup(self.compiler_so, cc_args + extra_postargs)
-        try:
-            self.spawn(compiler_so + cc_args + [src, '-o', obj] + extra_postargs)
-        except DistutilsExecError as msg:
-            raise CompileError(msg)
-
-    def create_static_lib(
-        self, objects, output_libname, output_dir=None, debug=0, target_lang=None
-    ):
-        objects, output_dir = self._fix_object_args(objects, output_dir)
-
-        output_filename = self.library_filename(output_libname, output_dir=output_dir)
-
-        if self._need_link(objects, output_filename):
-            self.mkpath(os.path.dirname(output_filename))
-            self.spawn(self.archiver + [output_filename] + objects + self.objects)
-
-            # Not many Unices required ranlib anymore -- SunOS 4.x is, I
-            # think the only major Unix that does.  Maybe we need some
-            # platform intelligence here to skip ranlib if it's not
-            # needed -- or maybe Python's configure script took care of
-            # it for us, hence the check for leading colon.
-            if self.ranlib:
-                try:
-                    self.spawn(self.ranlib + [output_filename])
-                except DistutilsExecError as msg:
-                    raise LibError(msg)
-        else:
-            log.debug("skipping %s (up-to-date)", output_filename)
-
-    def link(
-        self,
-        target_desc,
-        objects,
-        output_filename,
-        output_dir=None,
-        libraries=None,
-        library_dirs=None,
-        runtime_library_dirs=None,
-        export_symbols=None,
-        debug=0,
-        extra_preargs=None,
-        extra_postargs=None,
-        build_temp=None,
-        target_lang=None,
-    ):
-        objects, output_dir = self._fix_object_args(objects, output_dir)
-        fixed_args = self._fix_lib_args(libraries, library_dirs, runtime_library_dirs)
-        libraries, library_dirs, runtime_library_dirs = fixed_args
-
-        lib_opts = gen_lib_options(self, library_dirs, runtime_library_dirs, libraries)
-        if not isinstance(output_dir, (str, type(None))):
-            raise TypeError("'output_dir' must be a string or None")
-        if output_dir is not None:
-            output_filename = os.path.join(output_dir, output_filename)
-
-        if self._need_link(objects, output_filename):
-            ld_args = objects + self.objects + lib_opts + ['-o', output_filename]
-            if debug:
-                ld_args[:0] = ['-g']
-            if extra_preargs:
-                ld_args[:0] = extra_preargs
-            if extra_postargs:
-                ld_args.extend(extra_postargs)
-            self.mkpath(os.path.dirname(output_filename))
-            try:
-                # Select a linker based on context: linker_exe when
-                # building an executable or linker_so (with shared options)
-                # when building a shared library.
-                building_exe = target_desc == CCompiler.EXECUTABLE
-                linker = (self.linker_exe if building_exe else self.linker_so)[:]
-
-                if target_lang == "c++" and self.compiler_cxx:
-                    env, linker_ne = _split_env(linker)
-                    aix, linker_na = _split_aix(linker_ne)
-                    _, compiler_cxx_ne = _split_env(self.compiler_cxx)
-                    _, linker_exe_ne = _split_env(self.linker_exe)
-
-                    params = _linker_params(linker_na, linker_exe_ne)
-                    linker = env + aix + compiler_cxx_ne + params
-
-                linker = compiler_fixup(linker, ld_args)
-
-                self.spawn(linker + ld_args)
-            except DistutilsExecError as msg:
-                raise LinkError(msg)
-        else:
-            log.debug("skipping %s (up-to-date)", output_filename)
-
-    # -- Miscellaneous methods -----------------------------------------
-    # These are all used by the 'gen_lib_options() function, in
-    # ccompiler.py.
-
-    def library_dir_option(self, dir):
-        return "-L" + dir
-
-    def _is_gcc(self):
-        cc_var = sysconfig.get_config_var("CC")
-        compiler = os.path.basename(shlex.split(cc_var)[0])
-        return "gcc" in compiler or "g++" in compiler
-
-    def runtime_library_dir_option(self, dir):
-        # XXX Hackish, at the very least.  See Python bug #445902:
-        # http://sourceforge.net/tracker/index.php
-        #   ?func=detail&aid=445902&group_id=5470&atid=105470
-        # Linkers on different platforms need different options to
-        # specify that directories need to be added to the list of
-        # directories searched for dependencies when a dynamic library
-        # is sought.  GCC on GNU systems (Linux, FreeBSD, ...) has to
-        # be told to pass the -R option through to the linker, whereas
-        # other compilers and gcc on other systems just know this.
-        # Other compilers may need something slightly different.  At
-        # this time, there's no way to determine this information from
-        # the configuration data stored in the Python installation, so
-        # we use this hack.
-        if sys.platform[:6] == "darwin":
-            from distutils.util import get_macosx_target_ver, split_version
-
-            macosx_target_ver = get_macosx_target_ver()
-            if macosx_target_ver and split_version(macosx_target_ver) >= [10, 5]:
-                return "-Wl,-rpath," + dir
-            else:  # no support for -rpath on earlier macOS versions
-                return "-L" + dir
-        elif sys.platform[:7] == "freebsd":
-            return "-Wl,-rpath=" + dir
-        elif sys.platform[:5] == "hp-ux":
-            return [
-                "-Wl,+s" if self._is_gcc() else "+s",
-                "-L" + dir,
-            ]
-
-        # For all compilers, `-Wl` is the presumed way to
-        # pass a compiler option to the linker and `-R` is
-        # the way to pass an RPATH.
-        if sysconfig.get_config_var("GNULD") == "yes":
-            # GNU ld needs an extra option to get a RUNPATH
-            # instead of just an RPATH.
-            return "-Wl,--enable-new-dtags,-R" + dir
-        else:
-            return "-Wl,-R" + dir
-
-    def library_option(self, lib):
-        return "-l" + lib
-
-    @staticmethod
-    def _library_root(dir):
-        """
-        macOS users can specify an alternate SDK using'-isysroot'.
-        Calculate the SDK root if it is specified.
-
-        Note that, as of Xcode 7, Apple SDKs may contain textual stub
-        libraries with .tbd extensions rather than the normal .dylib
-        shared libraries installed in /.  The Apple compiler tool
-        chain handles this transparently but it can cause problems
-        for programs that are being built with an SDK and searching
-        for specific libraries.  Callers of find_library_file need to
-        keep in mind that the base filename of the returned SDK library
-        file might have a different extension from that of the library
-        file installed on the running system, for example:
-          /Applications/Xcode.app/Contents/Developer/Platforms/
-              MacOSX.platform/Developer/SDKs/MacOSX10.11.sdk/
-              usr/lib/libedit.tbd
-        vs
-          /usr/lib/libedit.dylib
-        """
-        cflags = sysconfig.get_config_var('CFLAGS')
-        match = re.search(r'-isysroot\s*(\S+)', cflags)
-
-        apply_root = (
-            sys.platform == 'darwin'
-            and match
-            and (
-                dir.startswith('/System/')
-                or (dir.startswith('/usr/') and not dir.startswith('/usr/local/'))
-            )
-        )
-
-        return os.path.join(match.group(1), dir[1:]) if apply_root else dir
-
-    def find_library_file(self, dirs, lib, debug=0):
-        r"""
-        Second-guess the linker with not much hard
-        data to go on: GCC seems to prefer the shared library, so
-        assume that *all* Unix C compilers do,
-        ignoring even GCC's "-static" option.
-
-        >>> compiler = UnixCCompiler()
-        >>> compiler._library_root = lambda dir: dir
-        >>> monkeypatch = getfixture('monkeypatch')
-        >>> monkeypatch.setattr(os.path, 'exists', lambda d: 'existing' in d)
-        >>> dirs = ('/foo/bar/missing', '/foo/bar/existing')
-        >>> compiler.find_library_file(dirs, 'abc').replace('\\', '/')
-        '/foo/bar/existing/libabc.dylib'
-        >>> compiler.find_library_file(reversed(dirs), 'abc').replace('\\', '/')
-        '/foo/bar/existing/libabc.dylib'
-        >>> monkeypatch.setattr(os.path, 'exists',
-        ...     lambda d: 'existing' in d and '.a' in d)
-        >>> compiler.find_library_file(dirs, 'abc').replace('\\', '/')
-        '/foo/bar/existing/libabc.a'
-        >>> compiler.find_library_file(reversed(dirs), 'abc').replace('\\', '/')
-        '/foo/bar/existing/libabc.a'
-        """
-        lib_names = (
-            self.library_filename(lib, lib_type=type)
-            for type in 'dylib xcode_stub shared static'.split()
-        )
-
-        roots = map(self._library_root, dirs)
-
-        searched = (
-            os.path.join(root, lib_name)
-            for root, lib_name in itertools.product(roots, lib_names)
-        )
-
-        found = filter(os.path.exists, searched)
-
-        # Return None if it could not be found in any dir.
-        return next(found, None)

spaces/BigSalmon/TestAnyGPTModel/README.md

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

spaces/Billyosoro/ESRGAN/FAQ.md

@@ -1,9 +0,0 @@
-# FAQ
-
-1. **What is the difference of `--netscale` and `outscale`?**
-
-A: TODO.
-
-1. **How to select models?**
-
-A: TODO.

spaces/Brainclub5000/wesley7137-Llama-2-13B-Nous-Hermes-vicuna-uncensored-mastermod-spych/app.py

@@ -1,3 +0,0 @@
-import gradio as gr
-
-gr.Interface.load("models/wesley7137/Llama-2-13B-Nous-Hermes-vicuna-uncensored-mastermod-spych").launch()

spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/detectron2/data/datasets/builtin.py

@@ -1,220 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-
-
-"""
-This file registers pre-defined datasets at hard-coded paths, and their metadata.
-
-We hard-code metadata for common datasets. This will enable:
-1. Consistency check when loading the datasets
-2. Use models on these standard datasets directly and run demos,
-   without having to download the dataset annotations
-
-We hard-code some paths to the dataset that's assumed to
-exist in "./datasets/".
-
-Users SHOULD NOT use this file to create new dataset / metadata for new dataset.
-To add new dataset, refer to the tutorial "docs/DATASETS.md".
-"""
-
-import os
-
-from detectron2.data import DatasetCatalog, MetadataCatalog
-
-from .builtin_meta import _get_builtin_metadata
-from .cityscapes import load_cityscapes_instances, load_cityscapes_semantic
-from .lvis import get_lvis_instances_meta, register_lvis_instances
-from .pascal_voc import register_pascal_voc
-from .register_coco import register_coco_instances, register_coco_panoptic_separated
-
-# ==== Predefined datasets and splits for COCO ==========
-
-_PREDEFINED_SPLITS_COCO = {}
-_PREDEFINED_SPLITS_COCO["coco"] = {
-    "coco_2014_train": ("coco/train2014", "coco/annotations/instances_train2014.json"),
-    "coco_2014_val": ("coco/val2014", "coco/annotations/instances_val2014.json"),
-    "coco_2014_minival": ("coco/val2014", "coco/annotations/instances_minival2014.json"),
-    "coco_2014_minival_100": ("coco/val2014", "coco/annotations/instances_minival2014_100.json"),
-    "coco_2014_valminusminival": (
-        "coco/val2014",
-        "coco/annotations/instances_valminusminival2014.json",
-    ),
-    "coco_2017_train": ("coco/train2017", "coco/annotations/instances_train2017.json"),
-    "coco_2017_val": ("coco/val2017", "coco/annotations/instances_val2017.json"),
-    "coco_2017_test": ("coco/test2017", "coco/annotations/image_info_test2017.json"),
-    "coco_2017_test-dev": ("coco/test2017", "coco/annotations/image_info_test-dev2017.json"),
-    "coco_2017_val_100": ("coco/val2017", "coco/annotations/instances_val2017_100.json"),
-}
-
-_PREDEFINED_SPLITS_COCO["coco_person"] = {
-    "keypoints_coco_2014_train": (
-        "coco/train2014",
-        "coco/annotations/person_keypoints_train2014.json",
-    ),
-    "keypoints_coco_2014_val": ("coco/val2014", "coco/annotations/person_keypoints_val2014.json"),
-    "keypoints_coco_2014_minival": (
-        "coco/val2014",
-        "coco/annotations/person_keypoints_minival2014.json",
-    ),
-    "keypoints_coco_2014_valminusminival": (
-        "coco/val2014",
-        "coco/annotations/person_keypoints_valminusminival2014.json",
-    ),
-    "keypoints_coco_2014_minival_100": (
-        "coco/val2014",
-        "coco/annotations/person_keypoints_minival2014_100.json",
-    ),
-    "keypoints_coco_2017_train": (
-        "coco/train2017",
-        "coco/annotations/person_keypoints_train2017.json",
-    ),
-    "keypoints_coco_2017_val": ("coco/val2017", "coco/annotations/person_keypoints_val2017.json"),
-    "keypoints_coco_2017_val_100": (
-        "coco/val2017",
-        "coco/annotations/person_keypoints_val2017_100.json",
-    ),
-}
-
-
-_PREDEFINED_SPLITS_COCO_PANOPTIC = {
-    "coco_2017_train_panoptic": (
-        # This is the original panoptic annotation directory
-        "coco/panoptic_train2017",
-        "coco/annotations/panoptic_train2017.json",
-        # This directory contains semantic annotations that are
-        # converted from panoptic annotations.
-        # It is used by PanopticFPN.
-        # You can use the script at detectron2/datasets/prepare_panoptic_fpn.py
-        # to create these directories.
-        "coco/panoptic_stuff_train2017",
-    ),
-    "coco_2017_val_panoptic": (
-        "coco/panoptic_val2017",
-        "coco/annotations/panoptic_val2017.json",
-        "coco/panoptic_stuff_val2017",
-    ),
-    "coco_2017_val_100_panoptic": (
-        "coco/panoptic_val2017_100",
-        "coco/annotations/panoptic_val2017_100.json",
-        "coco/panoptic_stuff_val2017_100",
-    ),
-}
-
-
-def register_all_coco(root):
-    for dataset_name, splits_per_dataset in _PREDEFINED_SPLITS_COCO.items():
-        for key, (image_root, json_file) in splits_per_dataset.items():
-            # Assume pre-defined datasets live in `./datasets`.
-            register_coco_instances(
-                key,
-                _get_builtin_metadata(dataset_name),
-                os.path.join(root, json_file) if "://" not in json_file else json_file,
-                os.path.join(root, image_root),
-            )
-
-    for (
-        prefix,
-        (panoptic_root, panoptic_json, semantic_root),
-    ) in _PREDEFINED_SPLITS_COCO_PANOPTIC.items():
-        prefix_instances = prefix[: -len("_panoptic")]
-        instances_meta = MetadataCatalog.get(prefix_instances)
-        image_root, instances_json = instances_meta.image_root, instances_meta.json_file
-        register_coco_panoptic_separated(
-            prefix,
-            _get_builtin_metadata("coco_panoptic_separated"),
-            image_root,
-            os.path.join(root, panoptic_root),
-            os.path.join(root, panoptic_json),
-            os.path.join(root, semantic_root),
-            instances_json,
-        )
-
-
-# ==== Predefined datasets and splits for LVIS ==========
-
-
-_PREDEFINED_SPLITS_LVIS = {
-    "lvis_v0.5": {
-        "lvis_v0.5_train": ("coco/train2017", "lvis/lvis_v0.5_train.json"),
-        "lvis_v0.5_val": ("coco/val2017", "lvis/lvis_v0.5_val.json"),
-        "lvis_v0.5_val_rand_100": ("coco/val2017", "lvis/lvis_v0.5_val_rand_100.json"),
-        "lvis_v0.5_test": ("coco/test2017", "lvis/lvis_v0.5_image_info_test.json"),
-    },
-    "lvis_v0.5_cocofied": {
-        "lvis_v0.5_train_cocofied": ("coco/train2017", "lvis/lvis_v0.5_train_cocofied.json"),
-        "lvis_v0.5_val_cocofied": ("coco/val2017", "lvis/lvis_v0.5_val_cocofied.json"),
-    },
-}
-
-
-def register_all_lvis(root):
-    for dataset_name, splits_per_dataset in _PREDEFINED_SPLITS_LVIS.items():
-        for key, (image_root, json_file) in splits_per_dataset.items():
-            # Assume pre-defined datasets live in `./datasets`.
-            register_lvis_instances(
-                key,
-                get_lvis_instances_meta(dataset_name),
-                os.path.join(root, json_file) if "://" not in json_file else json_file,
-                os.path.join(root, image_root),
-            )
-
-
-# ==== Predefined splits for raw cityscapes images ===========
-
-
-_RAW_CITYSCAPES_SPLITS = {
-    "cityscapes_fine_{task}_train": ("cityscapes/leftImg8bit/train", "cityscapes/gtFine/train"),
-    "cityscapes_fine_{task}_val": ("cityscapes/leftImg8bit/val", "cityscapes/gtFine/val"),
-    "cityscapes_fine_{task}_test": ("cityscapes/leftImg8bit/test", "cityscapes/gtFine/test"),
-}
-
-
-def register_all_cityscapes(root):
-    for key, (image_dir, gt_dir) in _RAW_CITYSCAPES_SPLITS.items():
-        meta = _get_builtin_metadata("cityscapes")
-        image_dir = os.path.join(root, image_dir)
-        gt_dir = os.path.join(root, gt_dir)
-
-        inst_key = key.format(task="instance_seg")
-        DatasetCatalog.register(
-            inst_key,
-            lambda x=image_dir, y=gt_dir: load_cityscapes_instances(
-                x, y, from_json=True, to_polygons=True
-            ),
-        )
-        MetadataCatalog.get(inst_key).set(
-            image_dir=image_dir, gt_dir=gt_dir, evaluator_type="cityscapes", **meta
-        )
-
-        sem_key = key.format(task="sem_seg")
-        DatasetCatalog.register(
-            sem_key, lambda x=image_dir, y=gt_dir: load_cityscapes_semantic(x, y)
-        )
-        MetadataCatalog.get(sem_key).set(
-            image_dir=image_dir, gt_dir=gt_dir, evaluator_type="sem_seg", **meta
-        )
-
-
-# ==== Predefined splits for PASCAL VOC ===========
-def register_all_pascal_voc(root):
-    SPLITS = [
-        ("voc_2007_trainval", "VOC2007", "trainval"),
-        ("voc_2007_train", "VOC2007", "train"),
-        ("voc_2007_val", "VOC2007", "val"),
-        ("voc_2007_test", "VOC2007", "test"),
-        ("voc_2012_trainval", "VOC2012", "trainval"),
-        ("voc_2012_train", "VOC2012", "train"),
-        ("voc_2012_val", "VOC2012", "val"),
-    ]
-    for name, dirname, split in SPLITS:
-        year = 2007 if "2007" in name else 2012
-        register_pascal_voc(name, os.path.join(root, dirname), split, year)
-        MetadataCatalog.get(name).evaluator_type = "pascal_voc"
-
-
-# Register them all under "./datasets"
-_root = os.getenv("DETECTRON2_DATASETS", "datasets")
-register_all_coco(_root)
-register_all_lvis(_root)
-register_all_cityscapes(_root)
-register_all_pascal_voc(_root)

spaces/CVPR/LIVE/LIVE/colab.py

@@ -1,687 +0,0 @@
-"""
-Here are some use cases:
-python main.py --config config/all.yaml --experiment experiment_8x1 --signature demo1 --target data/demo1.png
-"""
-import pydiffvg
-import torch
-import cv2
-import matplotlib.pyplot as plt
-import random
-import argparse
-import math
-import errno
-from tqdm import tqdm
-from torch.optim.lr_scheduler import CosineAnnealingLR, LambdaLR
-from torch.nn.functional import adaptive_avg_pool2d
-import warnings
-warnings.filterwarnings("ignore")
-
-import PIL
-import PIL.Image
-import os
-import os.path as osp
-import numpy as np
-import numpy.random as npr
-import shutil
-import copy
-# import skfmm
-from xing_loss import xing_loss
-
-import yaml
-from easydict import EasyDict as edict
-
-
-pydiffvg.set_print_timing(False)
-gamma = 1.0
-
-##########
-# helper #
-##########
-
-from utils import \
-    get_experiment_id, \
-    get_path_schedule, \
-    edict_2_dict, \
-    check_and_create_dir
-
-def get_bezier_circle(radius=1, segments=4, bias=None):
-    points = []
-    if bias is None:
-        bias = (random.random(), random.random())
-    avg_degree = 360 / (segments*3)
-    for i in range(0, segments*3):
-        point = (np.cos(np.deg2rad(i * avg_degree)),
-                    np.sin(np.deg2rad(i * avg_degree)))
-        points.append(point)
-    points = torch.tensor(points)
-    points = (points)*radius + torch.tensor(bias).unsqueeze(dim=0)
-    points = points.type(torch.FloatTensor)
-    return points
-
-def get_sdf(phi, method='skfmm', **kwargs):
-    if method == 'skfmm':
-        import skfmm
-        phi = (phi-0.5)*2
-        if (phi.max() <= 0) or (phi.min() >= 0):
-            return np.zeros(phi.shape).astype(np.float32)
-        sd = skfmm.distance(phi, dx=1)
-
-        flip_negative = kwargs.get('flip_negative', True)
-        if flip_negative:
-            sd = np.abs(sd)
-
-        truncate = kwargs.get('truncate', 10)
-        sd = np.clip(sd, -truncate, truncate)
-        # print(f"max sd value is: {sd.max()}")
-
-        zero2max = kwargs.get('zero2max', True)
-        if zero2max and flip_negative:
-            sd = sd.max() - sd
-        elif zero2max:
-            raise ValueError
-
-        normalize = kwargs.get('normalize', 'sum')
-        if normalize == 'sum':
-            sd /= sd.sum()
-        elif normalize == 'to1':
-            sd /= sd.max()
-        return sd
-
-def parse_args():
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--debug', action='store_true', default=False)
-    parser.add_argument("--config", type=str)
-    parser.add_argument("--experiment", type=str)
-    parser.add_argument("--seed", type=int)
-    parser.add_argument("--target", type=str, help="target image path")
-    parser.add_argument('--log_dir', metavar='DIR', default="log/debug")
-    parser.add_argument('--initial', type=str, default="random", choices=['random', 'circle'])
-    parser.add_argument('--signature', nargs='+', type=str)
-    parser.add_argument('--seginit', nargs='+', type=str)
-    parser.add_argument("--num_segments", type=int, default=4)
-    # parser.add_argument("--num_paths", type=str, default="1,1,1")
-    # parser.add_argument("--num_iter", type=int, default=500)
-    # parser.add_argument('--free', action='store_true')
-    # Please ensure that image resolution is divisible by pool_size; otherwise the performance would drop a lot.
-    # parser.add_argument('--pool_size', type=int, default=40, help="the pooled image size for next path initialization")
-    # parser.add_argument('--save_loss', action='store_true')
-    # parser.add_argument('--save_init', action='store_true')
-    # parser.add_argument('--save_image', action='store_true')
-    # parser.add_argument('--save_video', action='store_true')
-    # parser.add_argument('--print_weight', action='store_true')
-    # parser.add_argument('--circle_init_radius',  type=float)
-    cfg = edict()
-    args = parser.parse_args()
-    cfg.debug = args.debug
-    cfg.config = args.config
-    cfg.experiment = args.experiment
-    cfg.seed = args.seed
-    cfg.target = args.target
-    cfg.log_dir = args.log_dir
-    cfg.initial = args.initial
-    cfg.signature = args.signature
-    # set cfg num_segments in command
-    cfg.num_segments = args.num_segments
-    if args.seginit is not None:
-        cfg.seginit = edict()
-        cfg.seginit.type = args.seginit[0]
-        if cfg.seginit.type == 'circle':
-            cfg.seginit.radius = float(args.seginit[1])
-    return cfg
-
-def ycrcb_conversion(im, format='[bs x 3 x 2D]', reverse=False):
-    mat = torch.FloatTensor([
-        [ 65.481/255, 128.553/255,  24.966/255], # ranged_from [0, 219/255]
-        [-37.797/255, -74.203/255, 112.000/255], # ranged_from [-112/255, 112/255]
-        [112.000/255, -93.786/255, -18.214/255], # ranged_from [-112/255, 112/255]
-    ]).to(im.device)
-
-    if reverse:
-        mat = mat.inverse()
-
-    if format == '[bs x 3 x 2D]':
-        im = im.permute(0, 2, 3, 1)
-        im = torch.matmul(im, mat.T)
-        im = im.permute(0, 3, 1, 2).contiguous()
-        return im
-    elif format == '[2D x 3]':
-        im = torch.matmul(im, mat.T)
-        return im
-    else:
-        raise ValueError
-
-class random_coord_init():
-    def __init__(self, canvas_size):
-        self.canvas_size = canvas_size
-    def __call__(self):
-        h, w = self.canvas_size
-        return [npr.uniform(0, 1)*w, npr.uniform(0, 1)*h]
-
-class naive_coord_init():
-    def __init__(self, pred, gt, format='[bs x c x 2D]', replace_sampling=True):
-        if isinstance(pred, torch.Tensor):
-            pred = pred.detach().cpu().numpy()
-        if isinstance(gt, torch.Tensor):
-            gt = gt.detach().cpu().numpy()
-
-        if format == '[bs x c x 2D]':
-            self.map = ((pred[0] - gt[0])**2).sum(0)
-        elif format == ['[2D x c]']:
-            self.map = ((pred - gt)**2).sum(-1)
-        else:
-            raise ValueError
-        self.replace_sampling = replace_sampling
-
-    def __call__(self):
-        coord = np.where(self.map == self.map.max())
-        coord_h, coord_w = coord[0][0], coord[1][0]
-        if self.replace_sampling:
-            self.map[coord_h, coord_w] = -1
-        return [coord_w, coord_h]
-
-
-class sparse_coord_init():
-    def __init__(self, pred, gt, format='[bs x c x 2D]', quantile_interval=200, nodiff_thres=0.1):
-        if isinstance(pred, torch.Tensor):
-            pred = pred.detach().cpu().numpy()
-        if isinstance(gt, torch.Tensor):
-            gt = gt.detach().cpu().numpy()
-        if format == '[bs x c x 2D]':
-            self.map = ((pred[0] - gt[0])**2).sum(0)
-            self.reference_gt = copy.deepcopy(
-                np.transpose(gt[0], (1, 2, 0)))
-        elif format == ['[2D x c]']:
-            self.map = (np.abs(pred - gt)).sum(-1)
-            self.reference_gt = copy.deepcopy(gt[0])
-        else:
-            raise ValueError
-        # OptionA: Zero too small errors to avoid the error too small deadloop
-        self.map[self.map < nodiff_thres] = 0
-        quantile_interval = np.linspace(0., 1., quantile_interval)
-        quantized_interval = np.quantile(self.map, quantile_interval)
-        # remove redundant
-        quantized_interval = np.unique(quantized_interval)
-        quantized_interval = sorted(quantized_interval[1:-1])
-        self.map = np.digitize(self.map, quantized_interval, right=False)
-        self.map = np.clip(self.map, 0, 255).astype(np.uint8)
-        self.idcnt = {}
-        for idi in sorted(np.unique(self.map)):
-            self.idcnt[idi] = (self.map==idi).sum()
-        self.idcnt.pop(min(self.idcnt.keys()))
-        # remove smallest one to remove the correct region
-    def __call__(self):
-        if len(self.idcnt) == 0:
-            h, w = self.map.shape
-            return [npr.uniform(0, 1)*w, npr.uniform(0, 1)*h]
-        target_id = max(self.idcnt, key=self.idcnt.get)
-        _, component, cstats, ccenter = cv2.connectedComponentsWithStats(
-            (self.map==target_id).astype(np.uint8), connectivity=4)
-        # remove cid = 0, it is the invalid area
-        csize = [ci[-1] for ci in cstats[1:]]
-        target_cid = csize.index(max(csize))+1
-        center = ccenter[target_cid][::-1]
-        coord = np.stack(np.where(component == target_cid)).T
-        dist = np.linalg.norm(coord-center, axis=1)
-        target_coord_id = np.argmin(dist)
-        coord_h, coord_w = coord[target_coord_id]
-        # replace_sampling
-        self.idcnt[target_id] -= max(csize)
-        if self.idcnt[target_id] == 0:
-            self.idcnt.pop(target_id)
-        self.map[component == target_cid] = 0
-        return [coord_w, coord_h]
-
-
-def init_shapes(num_paths,
-                num_segments,
-                canvas_size,
-                seginit_cfg,
-                shape_cnt,
-                pos_init_method=None,
-                trainable_stroke=False,
-                **kwargs):
-    shapes = []
-    shape_groups = []
-    h, w = canvas_size
-
-    # change path init location
-    if pos_init_method is None:
-        pos_init_method = random_coord_init(canvas_size=canvas_size)
-
-    for i in range(num_paths):
-        num_control_points = [2] * num_segments
-
-        if seginit_cfg.type=="random":
-            points = []
-            p0 = pos_init_method()
-            color_ref = copy.deepcopy(p0)
-            points.append(p0)
-            for j in range(num_segments):
-                radius = seginit_cfg.radius
-                p1 = (p0[0] + radius * npr.uniform(-0.5, 0.5),
-                      p0[1] + radius * npr.uniform(-0.5, 0.5))
-                p2 = (p1[0] + radius * npr.uniform(-0.5, 0.5),
-                      p1[1] + radius * npr.uniform(-0.5, 0.5))
-                p3 = (p2[0] + radius * npr.uniform(-0.5, 0.5),
-                      p2[1] + radius * npr.uniform(-0.5, 0.5))
-                points.append(p1)
-                points.append(p2)
-                if j < num_segments - 1:
-                    points.append(p3)
-                    p0 = p3
-            points = torch.FloatTensor(points)
-
-        # circle points initialization
-        elif seginit_cfg.type=="circle":
-            radius = seginit_cfg.radius
-            if radius is None:
-                radius = npr.uniform(0.5, 1)
-            center = pos_init_method()
-            color_ref = copy.deepcopy(center)
-            points = get_bezier_circle(
-                radius=radius, segments=num_segments,
-                bias=center)
-
-        path = pydiffvg.Path(num_control_points = torch.LongTensor(num_control_points),
-                             points = points,
-                             stroke_width = torch.tensor(0.0),
-                             is_closed = True)
-        shapes.append(path)
-        # !!!!!!problem is here. the shape group shape_ids is wrong
-
-        if 'gt' in kwargs:
-            wref, href = color_ref
-            wref = max(0, min(int(wref), w-1))
-            href = max(0, min(int(href), h-1))
-            fill_color_init = list(gt[0, :, href, wref]) + [1.]
-            fill_color_init = torch.FloatTensor(fill_color_init)
-            stroke_color_init = torch.FloatTensor(npr.uniform(size=[4]))
-        else:
-            fill_color_init = torch.FloatTensor(npr.uniform(size=[4]))
-            stroke_color_init = torch.FloatTensor(npr.uniform(size=[4]))
-
-        path_group = pydiffvg.ShapeGroup(
-            shape_ids = torch.LongTensor([shape_cnt+i]),
-            fill_color = fill_color_init,
-            stroke_color = stroke_color_init,
-        )
-        shape_groups.append(path_group)
-
-    point_var = []
-    color_var = []
-
-    for path in shapes:
-        path.points.requires_grad = True
-        point_var.append(path.points)
-    for group in shape_groups:
-        group.fill_color.requires_grad = True
-        color_var.append(group.fill_color)
-
-    if trainable_stroke:
-        stroke_width_var = []
-        stroke_color_var = []
-        for path in shapes:
-            path.stroke_width.requires_grad = True
-            stroke_width_var.append(path.stroke_width)
-        for group in shape_groups:
-            group.stroke_color.requires_grad = True
-            stroke_color_var.append(group.stroke_color)
-        return shapes, shape_groups, point_var, color_var, stroke_width_var, stroke_color_var
-    else:
-        return shapes, shape_groups, point_var, color_var
-
-class linear_decay_lrlambda_f(object):
-    def __init__(self, decay_every, decay_ratio):
-        self.decay_every = decay_every
-        self.decay_ratio = decay_ratio
-
-    def __call__(self, n):
-        decay_time = n//self.decay_every
-        decay_step = n %self.decay_every
-        lr_s = self.decay_ratio**decay_time
-        lr_e = self.decay_ratio**(decay_time+1)
-        r = decay_step/self.decay_every
-        lr = lr_s * (1-r) + lr_e * r
-        return lr
-
-
-if __name__ == "__main__":
-
-    ###############
-    # make config #
-    ###############
-
-    cfg_arg = parse_args()
-    with open(cfg_arg.config, 'r') as f:
-        cfg = yaml.load(f, Loader=yaml.FullLoader)
-    cfg_default = edict(cfg['default'])
-    cfg = edict(cfg[cfg_arg.experiment])
-    cfg.update(cfg_default)
-    cfg.update(cfg_arg)
-    cfg.exid = get_experiment_id(cfg.debug)
-
-    cfg.experiment_dir = \
-        osp.join(cfg.log_dir, '{}_{}'.format(cfg.exid, '_'.join(cfg.signature)))
-    configfile = osp.join(cfg.experiment_dir, 'config.yaml')
-    check_and_create_dir(configfile)
-    with open(osp.join(configfile), 'w') as f:
-        yaml.dump(edict_2_dict(cfg), f)
-
-    # Use GPU if available
-    pydiffvg.set_use_gpu(torch.cuda.is_available())
-    device = pydiffvg.get_device()
-
-    gt = np.array(PIL.Image.open(cfg.target))
-    print(f"Input image shape is: {gt.shape}")
-    if len(gt.shape) == 2:
-        print("Converting the gray-scale image to RGB.")
-        gt = gt.unsqueeze(dim=-1).repeat(1,1,3)
-    if gt.shape[2] == 4:
-        print("Input image includes alpha channel, simply dropout alpha channel.")
-        gt = gt[:, :, :3]
-    gt = (gt/255).astype(np.float32)
-    gt = torch.FloatTensor(gt).permute(2, 0, 1)[None].to(device)
-    if cfg.use_ycrcb:
-        gt = ycrcb_conversion(gt)
-    h, w = gt.shape[2:]
-
-    path_schedule = get_path_schedule(**cfg.path_schedule)
-
-    if cfg.seed is not None:
-        random.seed(cfg.seed)
-        npr.seed(cfg.seed)
-        torch.manual_seed(cfg.seed)
-    render = pydiffvg.RenderFunction.apply
-
-    shapes_record, shape_groups_record = [], []
-
-    region_loss = None
-    loss_matrix = []
-
-    para_point, para_color = {}, {}
-    if cfg.trainable.stroke:
-        para_stroke_width, para_stroke_color = {}, {}
-
-    pathn_record = []
-    # Background
-    if cfg.trainable.bg:
-        # meancolor = gt.mean([2, 3])[0]
-        para_bg = torch.tensor([1., 1., 1.], requires_grad=True, device=device)
-    else:
-        if cfg.use_ycrcb:
-            para_bg = torch.tensor([219/255, 0, 0], requires_grad=False, device=device)
-        else:
-            para_bg = torch.tensor([1., 1., 1.], requires_grad=False, device=device)
-
-    ##################
-    # start_training #
-    ##################
-
-    loss_weight = None
-    loss_weight_keep = 0
-    if cfg.coord_init.type == 'naive':
-        pos_init_method = naive_coord_init(
-            para_bg.view(1, -1, 1, 1).repeat(1, 1, h, w), gt)
-    elif cfg.coord_init.type == 'sparse':
-        pos_init_method = sparse_coord_init(
-            para_bg.view(1, -1, 1, 1).repeat(1, 1, h, w), gt)
-    elif cfg.coord_init.type == 'random':
-        pos_init_method = random_coord_init([h, w])
-    else:
-        raise ValueError
-
-    lrlambda_f = linear_decay_lrlambda_f(cfg.num_iter, 0.4)
-    optim_schedular_dict = {}
-
-    for path_idx, pathn in enumerate(path_schedule):
-        loss_list = []
-        print("=> Adding [{}] paths, [{}] ...".format(pathn, cfg.seginit.type))
-        pathn_record.append(pathn)
-        pathn_record_str = '-'.join([str(i) for i in pathn_record])
-
-        # initialize new shapes related stuffs.
-        if cfg.trainable.stroke:
-            shapes, shape_groups, point_var, color_var, stroke_width_var, stroke_color_var = init_shapes(
-                pathn, cfg.num_segments, (h, w),
-                cfg.seginit, len(shapes_record),
-                pos_init_method,
-                trainable_stroke=True,
-                gt=gt, )
-            para_stroke_width[path_idx] = stroke_width_var
-            para_stroke_color[path_idx] = stroke_color_var
-        else:
-            shapes, shape_groups, point_var, color_var = init_shapes(
-                pathn, cfg.num_segments, (h, w),
-                cfg.seginit, len(shapes_record),
-                pos_init_method,
-                trainable_stroke=False,
-                gt=gt, )
-
-        shapes_record += shapes
-        shape_groups_record += shape_groups
-
-        if cfg.save.init:
-            filename = os.path.join(
-                cfg.experiment_dir, "svg-init",
-                "{}-init.svg".format(pathn_record_str))
-            check_and_create_dir(filename)
-            pydiffvg.save_svg(
-                filename, w, h,
-                shapes_record, shape_groups_record)
-
-        para = {}
-        if (cfg.trainable.bg) and (path_idx == 0):
-            para['bg'] = [para_bg]
-        para['point'] = point_var
-        para['color'] = color_var
-        if cfg.trainable.stroke:
-            para['stroke_width'] = stroke_width_var
-            para['stroke_color'] = stroke_color_var
-
-        pg = [{'params' : para[ki], 'lr' : cfg.lr_base[ki]} for ki in sorted(para.keys())]
-        optim = torch.optim.Adam(pg)
-
-        if cfg.trainable.record:
-            scheduler = LambdaLR(
-                optim, lr_lambda=lrlambda_f, last_epoch=-1)
-        else:
-            scheduler = LambdaLR(
-                optim, lr_lambda=lrlambda_f, last_epoch=cfg.num_iter)
-        optim_schedular_dict[path_idx] = (optim, scheduler)
-
-        # Inner loop training
-        t_range = tqdm(range(cfg.num_iter))
-        for t in t_range:
-
-            for _, (optim, _) in optim_schedular_dict.items():
-                optim.zero_grad()
-
-            # Forward pass: render the image.
-            scene_args = pydiffvg.RenderFunction.serialize_scene(
-                w, h, shapes_record, shape_groups_record)
-            img = render(w, h, 2, 2, t, None, *scene_args)
-
-            # Compose img with white background
-            img = img[:, :, 3:4] * img[:, :, :3] + \
-                para_bg * (1 - img[:, :, 3:4])
-
-            if cfg.save.video:
-                filename = os.path.join(
-                    cfg.experiment_dir, "video-png",
-                    "{}-iter{}.png".format(pathn_record_str, t))
-                check_and_create_dir(filename)
-                if cfg.use_ycrcb:
-                    imshow = ycrcb_conversion(
-                        img, format='[2D x 3]', reverse=True).detach().cpu()
-                else:
-                    imshow = img.detach().cpu()
-                pydiffvg.imwrite(imshow, filename, gamma=gamma)
-
-            x = img.unsqueeze(0).permute(0, 3, 1, 2) # HWC -> NCHW
-
-            if cfg.use_ycrcb:
-                color_reweight = torch.FloatTensor([255/219, 255/224, 255/255]).to(device)
-                loss = ((x-gt)*(color_reweight.view(1, -1, 1, 1)))**2
-            else:
-                loss = ((x-gt)**2)
-
-            if cfg.loss.use_l1_loss:
-                loss = abs(x-gt)
-
-            if cfg.loss.use_distance_weighted_loss:
-                if cfg.use_ycrcb:
-                    raise ValueError
-                shapes_forsdf = copy.deepcopy(shapes)
-                shape_groups_forsdf = copy.deepcopy(shape_groups)
-                for si in shapes_forsdf:
-                    si.stroke_width = torch.FloatTensor([0]).to(device)
-                for sg_idx, sgi in enumerate(shape_groups_forsdf):
-                    sgi.fill_color = torch.FloatTensor([1, 1, 1, 1]).to(device)
-                    sgi.shape_ids = torch.LongTensor([sg_idx]).to(device)
-
-                sargs_forsdf = pydiffvg.RenderFunction.serialize_scene(
-                    w, h, shapes_forsdf, shape_groups_forsdf)
-                with torch.no_grad():
-                    im_forsdf = render(w, h, 2, 2, 0, None, *sargs_forsdf)
-                # use alpha channel is a trick to get 0-1 image
-                im_forsdf = (im_forsdf[:, :, 3]).detach().cpu().numpy()
-                loss_weight = get_sdf(im_forsdf, normalize='to1')
-                loss_weight += loss_weight_keep
-                loss_weight = np.clip(loss_weight, 0, 1)
-                loss_weight = torch.FloatTensor(loss_weight).to(device)
-
-            if cfg.save.loss:
-                save_loss = loss.squeeze(dim=0).mean(dim=0,keepdim=False).cpu().detach().numpy()
-                save_weight = loss_weight.cpu().detach().numpy()
-                save_weighted_loss = save_loss*save_weight
-                # normalize to [0,1]
-                save_loss = (save_loss - np.min(save_loss))/np.ptp(save_loss)
-                save_weight = (save_weight - np.min(save_weight))/np.ptp(save_weight)
-                save_weighted_loss = (save_weighted_loss - np.min(save_weighted_loss))/np.ptp(save_weighted_loss)
-
-                # save
-                plt.imshow(save_loss, cmap='Reds')
-                plt.axis('off')
-                # plt.colorbar()
-                filename = os.path.join(cfg.experiment_dir, "loss", "{}-iter{}-mseloss.png".format(pathn_record_str, t))
-                check_and_create_dir(filename)
-                plt.savefig(filename, dpi=800)
-                plt.close()
-
-                plt.imshow(save_weight, cmap='Greys')
-                plt.axis('off')
-                # plt.colorbar()
-                filename = os.path.join(cfg.experiment_dir, "loss", "{}-iter{}-sdfweight.png".format(pathn_record_str, t))
-                plt.savefig(filename, dpi=800)
-                plt.close()
-
-                plt.imshow(save_weighted_loss, cmap='Reds')
-                plt.axis('off')
-                # plt.colorbar()
-                filename = os.path.join(cfg.experiment_dir, "loss", "{}-iter{}-weightedloss.png".format(pathn_record_str, t))
-                plt.savefig(filename, dpi=800)
-                plt.close()
-
-
-
-
-
-            if loss_weight is None:
-                loss = loss.sum(1).mean()
-            else:
-                loss = (loss.sum(1)*loss_weight).mean()
-
-            # if (cfg.loss.bis_loss_weight is not None)  and (cfg.loss.bis_loss_weight > 0):
-            #     loss_bis = bezier_intersection_loss(point_var[0]) * cfg.loss.bis_loss_weight
-            #     loss = loss + loss_bis
-            if (cfg.loss.xing_loss_weight is not None) \
-                    and (cfg.loss.xing_loss_weight > 0):
-                loss_xing = xing_loss(point_var) * cfg.loss.xing_loss_weight
-                loss = loss + loss_xing
-
-
-            loss_list.append(loss.item())
-            t_range.set_postfix({'loss': loss.item()})
-            loss.backward()
-
-            # step
-            for _, (optim, scheduler) in optim_schedular_dict.items():
-                optim.step()
-                scheduler.step()
-
-            for group in shape_groups_record:
-                group.fill_color.data.clamp_(0.0, 1.0)
-
-        if cfg.loss.use_distance_weighted_loss:
-            loss_weight_keep = loss_weight.detach().cpu().numpy() * 1
-
-        if not cfg.trainable.record:
-            for _, pi in pg.items():
-                for ppi in pi:
-                    pi.require_grad = False
-            optim_schedular_dict = {}
-
-        if cfg.save.image:
-            filename = os.path.join(
-                cfg.experiment_dir, "demo-png", "{}.png".format(pathn_record_str))
-            check_and_create_dir(filename)
-            if cfg.use_ycrcb:
-                imshow = ycrcb_conversion(
-                    img, format='[2D x 3]', reverse=True).detach().cpu()
-            else:
-                imshow = img.detach().cpu()
-            pydiffvg.imwrite(imshow, filename, gamma=gamma)
-
-        if cfg.save.output:
-            filename = os.path.join(
-                cfg.experiment_dir, "output-svg", "{}.svg".format(pathn_record_str))
-            check_and_create_dir(filename)
-            pydiffvg.save_svg(filename, w, h, shapes_record, shape_groups_record)
-
-        loss_matrix.append(loss_list)
-
-        # calculate the pixel loss
-        # pixel_loss = ((x-gt)**2).sum(dim=1, keepdim=True).sqrt_() # [N,1,H, W]
-        # region_loss = adaptive_avg_pool2d(pixel_loss, cfg.region_loss_pool_size)
-        # loss_weight = torch.softmax(region_loss.reshape(1, 1, -1), dim=-1)\
-        #     .reshape_as(region_loss)
-
-        pos_init_method = naive_coord_init(x, gt)
-
-        if cfg.coord_init.type == 'naive':
-            pos_init_method = naive_coord_init(x, gt)
-        elif cfg.coord_init.type == 'sparse':
-            pos_init_method = sparse_coord_init(x, gt)
-        elif cfg.coord_init.type == 'random':
-            pos_init_method = random_coord_init([h, w])
-        else:
-            raise ValueError
-
-        if cfg.save.video:
-            print("saving iteration video...")
-            img_array = []
-            for ii in range(0, cfg.num_iter):
-                filename = os.path.join(
-                    cfg.experiment_dir, "video-png", 
-                    "{}-iter{}.png".format(pathn_record_str, ii))
-                img = cv2.imread(filename)
-                # cv2.putText(
-                #     img, "Path:{} \nIteration:{}".format(pathn_record_str, ii), 
-                #     (10, 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 1)
-                img_array.append(img)
-
-            videoname = os.path.join(
-                cfg.experiment_dir, "video-mp4",
-                "{}.mp4".format(pathn_record_str))
-            check_and_create_dir(videoname)
-            out = cv2.VideoWriter(
-                videoname, 
-                cv2.VideoWriter_fourcc(*'mp4v'),
-                # cv2.VideoWriter_fourcc(*'FFV1'),
-                20.0, (w, h))
-            for iii in range(len(img_array)):
-                out.write(img_array[iii])
-            out.release()
-            # shutil.rmtree(os.path.join(cfg.experiment_dir, "video-png"))
-
-    print("The last loss is: {}".format(loss.item()))

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

@@ -1,697 +0,0 @@
-# -*- coding: utf-8 -*-
-import pytest
-from pybind11_tests import ConstructorStats
-
-np = pytest.importorskip("numpy")
-m = pytest.importorskip("pybind11_tests.eigen")
-
-
-ref = np.array([[ 0.,  3,  0,  0,  0, 11],
-                [22,  0,  0,  0, 17, 11],
-                [ 7,  5,  0,  1,  0, 11],
-                [ 0,  0,  0,  0,  0, 11],
-                [ 0,  0, 14,  0,  8, 11]])
-
-
-def assert_equal_ref(mat):
-    np.testing.assert_array_equal(mat, ref)
-
-
-def assert_sparse_equal_ref(sparse_mat):
-    assert_equal_ref(sparse_mat.toarray())
-
-
-def test_fixed():
-    assert_equal_ref(m.fixed_c())
-    assert_equal_ref(m.fixed_r())
-    assert_equal_ref(m.fixed_copy_r(m.fixed_r()))
-    assert_equal_ref(m.fixed_copy_c(m.fixed_c()))
-    assert_equal_ref(m.fixed_copy_r(m.fixed_c()))
-    assert_equal_ref(m.fixed_copy_c(m.fixed_r()))
-
-
-def test_dense():
-    assert_equal_ref(m.dense_r())
-    assert_equal_ref(m.dense_c())
-    assert_equal_ref(m.dense_copy_r(m.dense_r()))
-    assert_equal_ref(m.dense_copy_c(m.dense_c()))
-    assert_equal_ref(m.dense_copy_r(m.dense_c()))
-    assert_equal_ref(m.dense_copy_c(m.dense_r()))
-
-
-def test_partially_fixed():
-    ref2 = np.array([[0., 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11], [12, 13, 14, 15]])
-    np.testing.assert_array_equal(m.partial_copy_four_rm_r(ref2), ref2)
-    np.testing.assert_array_equal(m.partial_copy_four_rm_c(ref2), ref2)
-    np.testing.assert_array_equal(m.partial_copy_four_rm_r(ref2[:, 1]), ref2[:, [1]])
-    np.testing.assert_array_equal(m.partial_copy_four_rm_c(ref2[0, :]), ref2[[0], :])
-    np.testing.assert_array_equal(m.partial_copy_four_rm_r(ref2[:, (0, 2)]), ref2[:, (0, 2)])
-    np.testing.assert_array_equal(
-        m.partial_copy_four_rm_c(ref2[(3, 1, 2), :]), ref2[(3, 1, 2), :])
-
-    np.testing.assert_array_equal(m.partial_copy_four_cm_r(ref2), ref2)
-    np.testing.assert_array_equal(m.partial_copy_four_cm_c(ref2), ref2)
-    np.testing.assert_array_equal(m.partial_copy_four_cm_r(ref2[:, 1]), ref2[:, [1]])
-    np.testing.assert_array_equal(m.partial_copy_four_cm_c(ref2[0, :]), ref2[[0], :])
-    np.testing.assert_array_equal(m.partial_copy_four_cm_r(ref2[:, (0, 2)]), ref2[:, (0, 2)])
-    np.testing.assert_array_equal(
-        m.partial_copy_four_cm_c(ref2[(3, 1, 2), :]), ref2[(3, 1, 2), :])
-
-    # TypeError should be raise for a shape mismatch
-    functions = [m.partial_copy_four_rm_r, m.partial_copy_four_rm_c,
-                 m.partial_copy_four_cm_r, m.partial_copy_four_cm_c]
-    matrix_with_wrong_shape = [[1, 2],
-                               [3, 4]]
-    for f in functions:
-        with pytest.raises(TypeError) as excinfo:
-            f(matrix_with_wrong_shape)
-        assert "incompatible function arguments" in str(excinfo.value)
-
-
-def test_mutator_descriptors():
-    zr = np.arange(30, dtype='float32').reshape(5, 6)  # row-major
-    zc = zr.reshape(6, 5).transpose()  # column-major
-
-    m.fixed_mutator_r(zr)
-    m.fixed_mutator_c(zc)
-    m.fixed_mutator_a(zr)
-    m.fixed_mutator_a(zc)
-    with pytest.raises(TypeError) as excinfo:
-        m.fixed_mutator_r(zc)
-    assert ('(arg0: numpy.ndarray[numpy.float32[5, 6],'
-            ' flags.writeable, flags.c_contiguous]) -> None'
-            in str(excinfo.value))
-    with pytest.raises(TypeError) as excinfo:
-        m.fixed_mutator_c(zr)
-    assert ('(arg0: numpy.ndarray[numpy.float32[5, 6],'
-            ' flags.writeable, flags.f_contiguous]) -> None'
-            in str(excinfo.value))
-    with pytest.raises(TypeError) as excinfo:
-        m.fixed_mutator_a(np.array([[1, 2], [3, 4]], dtype='float32'))
-    assert ('(arg0: numpy.ndarray[numpy.float32[5, 6], flags.writeable]) -> None'
-            in str(excinfo.value))
-    zr.flags.writeable = False
-    with pytest.raises(TypeError):
-        m.fixed_mutator_r(zr)
-    with pytest.raises(TypeError):
-        m.fixed_mutator_a(zr)
-
-
-def test_cpp_casting():
-    assert m.cpp_copy(m.fixed_r()) == 22.
-    assert m.cpp_copy(m.fixed_c()) == 22.
-    z = np.array([[5., 6], [7, 8]])
-    assert m.cpp_copy(z) == 7.
-    assert m.cpp_copy(m.get_cm_ref()) == 21.
-    assert m.cpp_copy(m.get_rm_ref()) == 21.
-    assert m.cpp_ref_c(m.get_cm_ref()) == 21.
-    assert m.cpp_ref_r(m.get_rm_ref()) == 21.
-    with pytest.raises(RuntimeError) as excinfo:
-        # Can't reference m.fixed_c: it contains floats, m.cpp_ref_any wants doubles
-        m.cpp_ref_any(m.fixed_c())
-    assert 'Unable to cast Python instance' in str(excinfo.value)
-    with pytest.raises(RuntimeError) as excinfo:
-        # Can't reference m.fixed_r: it contains floats, m.cpp_ref_any wants doubles
-        m.cpp_ref_any(m.fixed_r())
-    assert 'Unable to cast Python instance' in str(excinfo.value)
-    assert m.cpp_ref_any(m.ReturnTester.create()) == 1.
-
-    assert m.cpp_ref_any(m.get_cm_ref()) == 21.
-    assert m.cpp_ref_any(m.get_cm_ref()) == 21.
-
-
-def test_pass_readonly_array():
-    z = np.full((5, 6), 42.0)
-    z.flags.writeable = False
-    np.testing.assert_array_equal(z, m.fixed_copy_r(z))
-    np.testing.assert_array_equal(m.fixed_r_const(), m.fixed_r())
-    assert not m.fixed_r_const().flags.writeable
-    np.testing.assert_array_equal(m.fixed_copy_r(m.fixed_r_const()), m.fixed_r_const())
-
-
-def test_nonunit_stride_from_python():
-    counting_mat = np.arange(9.0, dtype=np.float32).reshape((3, 3))
-    second_row = counting_mat[1, :]
-    second_col = counting_mat[:, 1]
-    np.testing.assert_array_equal(m.double_row(second_row), 2.0 * second_row)
-    np.testing.assert_array_equal(m.double_col(second_row), 2.0 * second_row)
-    np.testing.assert_array_equal(m.double_complex(second_row), 2.0 * second_row)
-    np.testing.assert_array_equal(m.double_row(second_col), 2.0 * second_col)
-    np.testing.assert_array_equal(m.double_col(second_col), 2.0 * second_col)
-    np.testing.assert_array_equal(m.double_complex(second_col), 2.0 * second_col)
-
-    counting_3d = np.arange(27.0, dtype=np.float32).reshape((3, 3, 3))
-    slices = [counting_3d[0, :, :], counting_3d[:, 0, :], counting_3d[:, :, 0]]
-    for ref_mat in slices:
-        np.testing.assert_array_equal(m.double_mat_cm(ref_mat), 2.0 * ref_mat)
-        np.testing.assert_array_equal(m.double_mat_rm(ref_mat), 2.0 * ref_mat)
-
-    # Mutator:
-    m.double_threer(second_row)
-    m.double_threec(second_col)
-    np.testing.assert_array_equal(counting_mat, [[0., 2, 2], [6, 16, 10], [6, 14, 8]])
-
-
-def test_negative_stride_from_python(msg):
-    """Eigen doesn't support (as of yet) negative strides. When a function takes an Eigen matrix by
-    copy or const reference, we can pass a numpy array that has negative strides.  Otherwise, an
-    exception will be thrown as Eigen will not be able to map the numpy array."""
-
-    counting_mat = np.arange(9.0, dtype=np.float32).reshape((3, 3))
-    counting_mat = counting_mat[::-1, ::-1]
-    second_row = counting_mat[1, :]
-    second_col = counting_mat[:, 1]
-    np.testing.assert_array_equal(m.double_row(second_row), 2.0 * second_row)
-    np.testing.assert_array_equal(m.double_col(second_row), 2.0 * second_row)
-    np.testing.assert_array_equal(m.double_complex(second_row), 2.0 * second_row)
-    np.testing.assert_array_equal(m.double_row(second_col), 2.0 * second_col)
-    np.testing.assert_array_equal(m.double_col(second_col), 2.0 * second_col)
-    np.testing.assert_array_equal(m.double_complex(second_col), 2.0 * second_col)
-
-    counting_3d = np.arange(27.0, dtype=np.float32).reshape((3, 3, 3))
-    counting_3d = counting_3d[::-1, ::-1, ::-1]
-    slices = [counting_3d[0, :, :], counting_3d[:, 0, :], counting_3d[:, :, 0]]
-    for ref_mat in slices:
-        np.testing.assert_array_equal(m.double_mat_cm(ref_mat), 2.0 * ref_mat)
-        np.testing.assert_array_equal(m.double_mat_rm(ref_mat), 2.0 * ref_mat)
-
-    # Mutator:
-    with pytest.raises(TypeError) as excinfo:
-        m.double_threer(second_row)
-    assert msg(excinfo.value) == """
-        double_threer(): incompatible function arguments. The following argument types are supported:
-            1. (arg0: numpy.ndarray[numpy.float32[1, 3], flags.writeable]) -> None
-
-        Invoked with: """ + repr(np.array([ 5.,  4.,  3.], dtype='float32'))  # noqa: E501 line too long
-
-    with pytest.raises(TypeError) as excinfo:
-        m.double_threec(second_col)
-    assert msg(excinfo.value) == """
-        double_threec(): incompatible function arguments. The following argument types are supported:
-            1. (arg0: numpy.ndarray[numpy.float32[3, 1], flags.writeable]) -> None
-
-        Invoked with: """ + repr(np.array([ 7.,  4.,  1.], dtype='float32'))  # noqa: E501 line too long
-
-
-def test_nonunit_stride_to_python():
-    assert np.all(m.diagonal(ref) == ref.diagonal())
-    assert np.all(m.diagonal_1(ref) == ref.diagonal(1))
-    for i in range(-5, 7):
-        assert np.all(m.diagonal_n(ref, i) == ref.diagonal(i)), "m.diagonal_n({})".format(i)
-
-    assert np.all(m.block(ref, 2, 1, 3, 3) == ref[2:5, 1:4])
-    assert np.all(m.block(ref, 1, 4, 4, 2) == ref[1:, 4:])
-    assert np.all(m.block(ref, 1, 4, 3, 2) == ref[1:4, 4:])
-
-
-def test_eigen_ref_to_python():
-    chols = [m.cholesky1, m.cholesky2, m.cholesky3, m.cholesky4]
-    for i, chol in enumerate(chols, start=1):
-        mymat = chol(np.array([[1., 2, 4], [2, 13, 23], [4, 23, 77]]))
-        assert np.all(mymat == np.array([[1, 0, 0], [2, 3, 0], [4, 5, 6]])), "cholesky{}".format(i)
-
-
-def assign_both(a1, a2, r, c, v):
-    a1[r, c] = v
-    a2[r, c] = v
-
-
-def array_copy_but_one(a, r, c, v):
-    z = np.array(a, copy=True)
-    z[r, c] = v
-    return z
-
-
-def test_eigen_return_references():
-    """Tests various ways of returning references and non-referencing copies"""
-
-    master = np.ones((10, 10))
-    a = m.ReturnTester()
-    a_get1 = a.get()
-    assert not a_get1.flags.owndata and a_get1.flags.writeable
-    assign_both(a_get1, master, 3, 3, 5)
-    a_get2 = a.get_ptr()
-    assert not a_get2.flags.owndata and a_get2.flags.writeable
-    assign_both(a_get1, master, 2, 3, 6)
-
-    a_view1 = a.view()
-    assert not a_view1.flags.owndata and not a_view1.flags.writeable
-    with pytest.raises(ValueError):
-        a_view1[2, 3] = 4
-    a_view2 = a.view_ptr()
-    assert not a_view2.flags.owndata and not a_view2.flags.writeable
-    with pytest.raises(ValueError):
-        a_view2[2, 3] = 4
-
-    a_copy1 = a.copy_get()
-    assert a_copy1.flags.owndata and a_copy1.flags.writeable
-    np.testing.assert_array_equal(a_copy1, master)
-    a_copy1[7, 7] = -44  # Shouldn't affect anything else
-    c1want = array_copy_but_one(master, 7, 7, -44)
-    a_copy2 = a.copy_view()
-    assert a_copy2.flags.owndata and a_copy2.flags.writeable
-    np.testing.assert_array_equal(a_copy2, master)
-    a_copy2[4, 4] = -22  # Shouldn't affect anything else
-    c2want = array_copy_but_one(master, 4, 4, -22)
-
-    a_ref1 = a.ref()
-    assert not a_ref1.flags.owndata and a_ref1.flags.writeable
-    assign_both(a_ref1, master, 1, 1, 15)
-    a_ref2 = a.ref_const()
-    assert not a_ref2.flags.owndata and not a_ref2.flags.writeable
-    with pytest.raises(ValueError):
-        a_ref2[5, 5] = 33
-    a_ref3 = a.ref_safe()
-    assert not a_ref3.flags.owndata and a_ref3.flags.writeable
-    assign_both(a_ref3, master, 0, 7, 99)
-    a_ref4 = a.ref_const_safe()
-    assert not a_ref4.flags.owndata and not a_ref4.flags.writeable
-    with pytest.raises(ValueError):
-        a_ref4[7, 0] = 987654321
-
-    a_copy3 = a.copy_ref()
-    assert a_copy3.flags.owndata and a_copy3.flags.writeable
-    np.testing.assert_array_equal(a_copy3, master)
-    a_copy3[8, 1] = 11
-    c3want = array_copy_but_one(master, 8, 1, 11)
-    a_copy4 = a.copy_ref_const()
-    assert a_copy4.flags.owndata and a_copy4.flags.writeable
-    np.testing.assert_array_equal(a_copy4, master)
-    a_copy4[8, 4] = 88
-    c4want = array_copy_but_one(master, 8, 4, 88)
-
-    a_block1 = a.block(3, 3, 2, 2)
-    assert not a_block1.flags.owndata and a_block1.flags.writeable
-    a_block1[0, 0] = 55
-    master[3, 3] = 55
-    a_block2 = a.block_safe(2, 2, 3, 2)
-    assert not a_block2.flags.owndata and a_block2.flags.writeable
-    a_block2[2, 1] = -123
-    master[4, 3] = -123
-    a_block3 = a.block_const(6, 7, 4, 3)
-    assert not a_block3.flags.owndata and not a_block3.flags.writeable
-    with pytest.raises(ValueError):
-        a_block3[2, 2] = -44444
-
-    a_copy5 = a.copy_block(2, 2, 2, 3)
-    assert a_copy5.flags.owndata and a_copy5.flags.writeable
-    np.testing.assert_array_equal(a_copy5, master[2:4, 2:5])
-    a_copy5[1, 1] = 777
-    c5want = array_copy_but_one(master[2:4, 2:5], 1, 1, 777)
-
-    a_corn1 = a.corners()
-    assert not a_corn1.flags.owndata and a_corn1.flags.writeable
-    a_corn1 *= 50
-    a_corn1[1, 1] = 999
-    master[0, 0] = 50
-    master[0, 9] = 50
-    master[9, 0] = 50
-    master[9, 9] = 999
-    a_corn2 = a.corners_const()
-    assert not a_corn2.flags.owndata and not a_corn2.flags.writeable
-    with pytest.raises(ValueError):
-        a_corn2[1, 0] = 51
-
-    # All of the changes made all the way along should be visible everywhere
-    # now (except for the copies, of course)
-    np.testing.assert_array_equal(a_get1, master)
-    np.testing.assert_array_equal(a_get2, master)
-    np.testing.assert_array_equal(a_view1, master)
-    np.testing.assert_array_equal(a_view2, master)
-    np.testing.assert_array_equal(a_ref1, master)
-    np.testing.assert_array_equal(a_ref2, master)
-    np.testing.assert_array_equal(a_ref3, master)
-    np.testing.assert_array_equal(a_ref4, master)
-    np.testing.assert_array_equal(a_block1, master[3:5, 3:5])
-    np.testing.assert_array_equal(a_block2, master[2:5, 2:4])
-    np.testing.assert_array_equal(a_block3, master[6:10, 7:10])
-    np.testing.assert_array_equal(a_corn1, master[0::master.shape[0] - 1, 0::master.shape[1] - 1])
-    np.testing.assert_array_equal(a_corn2, master[0::master.shape[0] - 1, 0::master.shape[1] - 1])
-
-    np.testing.assert_array_equal(a_copy1, c1want)
-    np.testing.assert_array_equal(a_copy2, c2want)
-    np.testing.assert_array_equal(a_copy3, c3want)
-    np.testing.assert_array_equal(a_copy4, c4want)
-    np.testing.assert_array_equal(a_copy5, c5want)
-
-
-def assert_keeps_alive(cl, method, *args):
-    cstats = ConstructorStats.get(cl)
-    start_with = cstats.alive()
-    a = cl()
-    assert cstats.alive() == start_with + 1
-    z = method(a, *args)
-    assert cstats.alive() == start_with + 1
-    del a
-    # Here's the keep alive in action:
-    assert cstats.alive() == start_with + 1
-    del z
-    # Keep alive should have expired:
-    assert cstats.alive() == start_with
-
-
-def test_eigen_keepalive():
-    a = m.ReturnTester()
-    cstats = ConstructorStats.get(m.ReturnTester)
-    assert cstats.alive() == 1
-    unsafe = [a.ref(), a.ref_const(), a.block(1, 2, 3, 4)]
-    copies = [a.copy_get(), a.copy_view(), a.copy_ref(), a.copy_ref_const(),
-              a.copy_block(4, 3, 2, 1)]
-    del a
-    assert cstats.alive() == 0
-    del unsafe
-    del copies
-
-    for meth in [m.ReturnTester.get, m.ReturnTester.get_ptr, m.ReturnTester.view,
-                 m.ReturnTester.view_ptr, m.ReturnTester.ref_safe, m.ReturnTester.ref_const_safe,
-                 m.ReturnTester.corners, m.ReturnTester.corners_const]:
-        assert_keeps_alive(m.ReturnTester, meth)
-
-    for meth in [m.ReturnTester.block_safe, m.ReturnTester.block_const]:
-        assert_keeps_alive(m.ReturnTester, meth, 4, 3, 2, 1)
-
-
-def test_eigen_ref_mutators():
-    """Tests Eigen's ability to mutate numpy values"""
-
-    orig = np.array([[1., 2, 3], [4, 5, 6], [7, 8, 9]])
-    zr = np.array(orig)
-    zc = np.array(orig, order='F')
-    m.add_rm(zr, 1, 0, 100)
-    assert np.all(zr == np.array([[1., 2, 3], [104, 5, 6], [7, 8, 9]]))
-    m.add_cm(zc, 1, 0, 200)
-    assert np.all(zc == np.array([[1., 2, 3], [204, 5, 6], [7, 8, 9]]))
-
-    m.add_any(zr, 1, 0, 20)
-    assert np.all(zr == np.array([[1., 2, 3], [124, 5, 6], [7, 8, 9]]))
-    m.add_any(zc, 1, 0, 10)
-    assert np.all(zc == np.array([[1., 2, 3], [214, 5, 6], [7, 8, 9]]))
-
-    # Can't reference a col-major array with a row-major Ref, and vice versa:
-    with pytest.raises(TypeError):
-        m.add_rm(zc, 1, 0, 1)
-    with pytest.raises(TypeError):
-        m.add_cm(zr, 1, 0, 1)
-
-    # Overloads:
-    m.add1(zr, 1, 0, -100)
-    m.add2(zr, 1, 0, -20)
-    assert np.all(zr == orig)
-    m.add1(zc, 1, 0, -200)
-    m.add2(zc, 1, 0, -10)
-    assert np.all(zc == orig)
-
-    # a non-contiguous slice (this won't work on either the row- or
-    # column-contiguous refs, but should work for the any)
-    cornersr = zr[0::2, 0::2]
-    cornersc = zc[0::2, 0::2]
-
-    assert np.all(cornersr == np.array([[1., 3], [7, 9]]))
-    assert np.all(cornersc == np.array([[1., 3], [7, 9]]))
-
-    with pytest.raises(TypeError):
-        m.add_rm(cornersr, 0, 1, 25)
-    with pytest.raises(TypeError):
-        m.add_cm(cornersr, 0, 1, 25)
-    with pytest.raises(TypeError):
-        m.add_rm(cornersc, 0, 1, 25)
-    with pytest.raises(TypeError):
-        m.add_cm(cornersc, 0, 1, 25)
-    m.add_any(cornersr, 0, 1, 25)
-    m.add_any(cornersc, 0, 1, 44)
-    assert np.all(zr == np.array([[1., 2, 28], [4, 5, 6], [7, 8, 9]]))
-    assert np.all(zc == np.array([[1., 2, 47], [4, 5, 6], [7, 8, 9]]))
-
-    # You shouldn't be allowed to pass a non-writeable array to a mutating Eigen method:
-    zro = zr[0:4, 0:4]
-    zro.flags.writeable = False
-    with pytest.raises(TypeError):
-        m.add_rm(zro, 0, 0, 0)
-    with pytest.raises(TypeError):
-        m.add_any(zro, 0, 0, 0)
-    with pytest.raises(TypeError):
-        m.add1(zro, 0, 0, 0)
-    with pytest.raises(TypeError):
-        m.add2(zro, 0, 0, 0)
-
-    # integer array shouldn't be passable to a double-matrix-accepting mutating func:
-    zi = np.array([[1, 2], [3, 4]])
-    with pytest.raises(TypeError):
-        m.add_rm(zi)
-
-
-def test_numpy_ref_mutators():
-    """Tests numpy mutating Eigen matrices (for returned Eigen::Ref<...>s)"""
-
-    m.reset_refs()  # In case another test already changed it
-
-    zc = m.get_cm_ref()
-    zcro = m.get_cm_const_ref()
-    zr = m.get_rm_ref()
-    zrro = m.get_rm_const_ref()
-
-    assert [zc[1, 2], zcro[1, 2], zr[1, 2], zrro[1, 2]] == [23] * 4
-
-    assert not zc.flags.owndata and zc.flags.writeable
-    assert not zr.flags.owndata and zr.flags.writeable
-    assert not zcro.flags.owndata and not zcro.flags.writeable
-    assert not zrro.flags.owndata and not zrro.flags.writeable
-
-    zc[1, 2] = 99
-    expect = np.array([[11., 12, 13], [21, 22, 99], [31, 32, 33]])
-    # We should have just changed zc, of course, but also zcro and the original eigen matrix
-    assert np.all(zc == expect)
-    assert np.all(zcro == expect)
-    assert np.all(m.get_cm_ref() == expect)
-
-    zr[1, 2] = 99
-    assert np.all(zr == expect)
-    assert np.all(zrro == expect)
-    assert np.all(m.get_rm_ref() == expect)
-
-    # Make sure the readonly ones are numpy-readonly:
-    with pytest.raises(ValueError):
-        zcro[1, 2] = 6
-    with pytest.raises(ValueError):
-        zrro[1, 2] = 6
-
-    # We should be able to explicitly copy like this (and since we're copying,
-    # the const should drop away)
-    y1 = np.array(m.get_cm_const_ref())
-
-    assert y1.flags.owndata and y1.flags.writeable
-    # We should get copies of the eigen data, which was modified above:
-    assert y1[1, 2] == 99
-    y1[1, 2] += 12
-    assert y1[1, 2] == 111
-    assert zc[1, 2] == 99  # Make sure we aren't referencing the original
-
-
-def test_both_ref_mutators():
-    """Tests a complex chain of nested eigen/numpy references"""
-
-    m.reset_refs()  # In case another test already changed it
-
-    z = m.get_cm_ref()  # numpy -> eigen
-    z[0, 2] -= 3
-    z2 = m.incr_matrix(z, 1)  # numpy -> eigen -> numpy -> eigen
-    z2[1, 1] += 6
-    z3 = m.incr_matrix(z, 2)  # (numpy -> eigen)^3
-    z3[2, 2] += -5
-    z4 = m.incr_matrix(z, 3)  # (numpy -> eigen)^4
-    z4[1, 1] -= 1
-    z5 = m.incr_matrix(z, 4)  # (numpy -> eigen)^5
-    z5[0, 0] = 0
-    assert np.all(z == z2)
-    assert np.all(z == z3)
-    assert np.all(z == z4)
-    assert np.all(z == z5)
-    expect = np.array([[0., 22, 20], [31, 37, 33], [41, 42, 38]])
-    assert np.all(z == expect)
-
-    y = np.array(range(100), dtype='float64').reshape(10, 10)
-    y2 = m.incr_matrix_any(y, 10)  # np -> eigen -> np
-    y3 = m.incr_matrix_any(y2[0::2, 0::2], -33)  # np -> eigen -> np slice -> np -> eigen -> np
-    y4 = m.even_rows(y3)  # numpy -> eigen slice -> (... y3)
-    y5 = m.even_cols(y4)  # numpy -> eigen slice -> (... y4)
-    y6 = m.incr_matrix_any(y5, 1000)  # numpy -> eigen -> (... y5)
-
-    # Apply same mutations using just numpy:
-    yexpect = np.array(range(100), dtype='float64').reshape(10, 10)
-    yexpect += 10
-    yexpect[0::2, 0::2] -= 33
-    yexpect[0::4, 0::4] += 1000
-    assert np.all(y6 == yexpect[0::4, 0::4])
-    assert np.all(y5 == yexpect[0::4, 0::4])
-    assert np.all(y4 == yexpect[0::4, 0::2])
-    assert np.all(y3 == yexpect[0::2, 0::2])
-    assert np.all(y2 == yexpect)
-    assert np.all(y == yexpect)
-
-
-def test_nocopy_wrapper():
-    # get_elem requires a column-contiguous matrix reference, but should be
-    # callable with other types of matrix (via copying):
-    int_matrix_colmajor = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], order='F')
-    dbl_matrix_colmajor = np.array(int_matrix_colmajor, dtype='double', order='F', copy=True)
-    int_matrix_rowmajor = np.array(int_matrix_colmajor, order='C', copy=True)
-    dbl_matrix_rowmajor = np.array(int_matrix_rowmajor, dtype='double', order='C', copy=True)
-
-    # All should be callable via get_elem:
-    assert m.get_elem(int_matrix_colmajor) == 8
-    assert m.get_elem(dbl_matrix_colmajor) == 8
-    assert m.get_elem(int_matrix_rowmajor) == 8
-    assert m.get_elem(dbl_matrix_rowmajor) == 8
-
-    # All but the second should fail with m.get_elem_nocopy:
-    with pytest.raises(TypeError) as excinfo:
-        m.get_elem_nocopy(int_matrix_colmajor)
-    assert ('get_elem_nocopy(): incompatible function arguments.' in str(excinfo.value) and
-            ', flags.f_contiguous' in str(excinfo.value))
-    assert m.get_elem_nocopy(dbl_matrix_colmajor) == 8
-    with pytest.raises(TypeError) as excinfo:
-        m.get_elem_nocopy(int_matrix_rowmajor)
-    assert ('get_elem_nocopy(): incompatible function arguments.' in str(excinfo.value) and
-            ', flags.f_contiguous' in str(excinfo.value))
-    with pytest.raises(TypeError) as excinfo:
-        m.get_elem_nocopy(dbl_matrix_rowmajor)
-    assert ('get_elem_nocopy(): incompatible function arguments.' in str(excinfo.value) and
-            ', flags.f_contiguous' in str(excinfo.value))
-
-    # For the row-major test, we take a long matrix in row-major, so only the third is allowed:
-    with pytest.raises(TypeError) as excinfo:
-        m.get_elem_rm_nocopy(int_matrix_colmajor)
-    assert ('get_elem_rm_nocopy(): incompatible function arguments.' in str(excinfo.value) and
-            ', flags.c_contiguous' in str(excinfo.value))
-    with pytest.raises(TypeError) as excinfo:
-        m.get_elem_rm_nocopy(dbl_matrix_colmajor)
-    assert ('get_elem_rm_nocopy(): incompatible function arguments.' in str(excinfo.value) and
-            ', flags.c_contiguous' in str(excinfo.value))
-    assert m.get_elem_rm_nocopy(int_matrix_rowmajor) == 8
-    with pytest.raises(TypeError) as excinfo:
-        m.get_elem_rm_nocopy(dbl_matrix_rowmajor)
-    assert ('get_elem_rm_nocopy(): incompatible function arguments.' in str(excinfo.value) and
-            ', flags.c_contiguous' in str(excinfo.value))
-
-
-def test_eigen_ref_life_support():
-    """Ensure the lifetime of temporary arrays created by the `Ref` caster
-
-    The `Ref` caster sometimes creates a copy which needs to stay alive. This needs to
-    happen both for directs casts (just the array) or indirectly (e.g. list of arrays).
-    """
-
-    a = np.full(shape=10, fill_value=8, dtype=np.int8)
-    assert m.get_elem_direct(a) == 8
-
-    list_of_a = [a]
-    assert m.get_elem_indirect(list_of_a) == 8
-
-
-def test_special_matrix_objects():
-    assert np.all(m.incr_diag(7) == np.diag([1., 2, 3, 4, 5, 6, 7]))
-
-    asymm = np.array([[ 1.,  2,  3,  4],
-                      [ 5,  6,  7,  8],
-                      [ 9, 10, 11, 12],
-                      [13, 14, 15, 16]])
-    symm_lower = np.array(asymm)
-    symm_upper = np.array(asymm)
-    for i in range(4):
-        for j in range(i + 1, 4):
-            symm_lower[i, j] = symm_lower[j, i]
-            symm_upper[j, i] = symm_upper[i, j]
-
-    assert np.all(m.symmetric_lower(asymm) == symm_lower)
-    assert np.all(m.symmetric_upper(asymm) == symm_upper)
-
-
-def test_dense_signature(doc):
-    assert doc(m.double_col) == """
-        double_col(arg0: numpy.ndarray[numpy.float32[m, 1]]) -> numpy.ndarray[numpy.float32[m, 1]]
-    """
-    assert doc(m.double_row) == """
-        double_row(arg0: numpy.ndarray[numpy.float32[1, n]]) -> numpy.ndarray[numpy.float32[1, n]]
-    """
-    assert doc(m.double_complex) == ("""
-        double_complex(arg0: numpy.ndarray[numpy.complex64[m, 1]])"""
-                                     """ -> numpy.ndarray[numpy.complex64[m, 1]]
-    """)
-    assert doc(m.double_mat_rm) == ("""
-        double_mat_rm(arg0: numpy.ndarray[numpy.float32[m, n]])"""
-                                    """ -> numpy.ndarray[numpy.float32[m, n]]
-    """)
-
-
-def test_named_arguments():
-    a = np.array([[1.0, 2], [3, 4], [5, 6]])
-    b = np.ones((2, 1))
-
-    assert np.all(m.matrix_multiply(a, b) == np.array([[3.], [7], [11]]))
-    assert np.all(m.matrix_multiply(A=a, B=b) == np.array([[3.], [7], [11]]))
-    assert np.all(m.matrix_multiply(B=b, A=a) == np.array([[3.], [7], [11]]))
-
-    with pytest.raises(ValueError) as excinfo:
-        m.matrix_multiply(b, a)
-    assert str(excinfo.value) == 'Nonconformable matrices!'
-
-    with pytest.raises(ValueError) as excinfo:
-        m.matrix_multiply(A=b, B=a)
-    assert str(excinfo.value) == 'Nonconformable matrices!'
-
-    with pytest.raises(ValueError) as excinfo:
-        m.matrix_multiply(B=a, A=b)
-    assert str(excinfo.value) == 'Nonconformable matrices!'
-
-
-def test_sparse():
-    pytest.importorskip("scipy")
-    assert_sparse_equal_ref(m.sparse_r())
-    assert_sparse_equal_ref(m.sparse_c())
-    assert_sparse_equal_ref(m.sparse_copy_r(m.sparse_r()))
-    assert_sparse_equal_ref(m.sparse_copy_c(m.sparse_c()))
-    assert_sparse_equal_ref(m.sparse_copy_r(m.sparse_c()))
-    assert_sparse_equal_ref(m.sparse_copy_c(m.sparse_r()))
-
-
-def test_sparse_signature(doc):
-    pytest.importorskip("scipy")
-    assert doc(m.sparse_copy_r) == """
-        sparse_copy_r(arg0: scipy.sparse.csr_matrix[numpy.float32]) -> scipy.sparse.csr_matrix[numpy.float32]
-    """  # noqa: E501 line too long
-    assert doc(m.sparse_copy_c) == """
-        sparse_copy_c(arg0: scipy.sparse.csc_matrix[numpy.float32]) -> scipy.sparse.csc_matrix[numpy.float32]
-    """  # noqa: E501 line too long
-
-
-def test_issue738():
-    """Ignore strides on a length-1 dimension (even if they would be incompatible length > 1)"""
-    assert np.all(m.iss738_f1(np.array([[1., 2, 3]])) == np.array([[1., 102, 203]]))
-    assert np.all(m.iss738_f1(np.array([[1.], [2], [3]])) == np.array([[1.], [12], [23]]))
-
-    assert np.all(m.iss738_f2(np.array([[1., 2, 3]])) == np.array([[1., 102, 203]]))
-    assert np.all(m.iss738_f2(np.array([[1.], [2], [3]])) == np.array([[1.], [12], [23]]))
-
-
-def test_issue1105():
-    """Issue 1105: 1xN or Nx1 input arrays weren't accepted for eigen
-    compile-time row vectors or column vector"""
-    assert m.iss1105_row(np.ones((1, 7)))
-    assert m.iss1105_col(np.ones((7, 1)))
-
-    # These should still fail (incompatible dimensions):
-    with pytest.raises(TypeError) as excinfo:
-        m.iss1105_row(np.ones((7, 1)))
-    assert "incompatible function arguments" in str(excinfo.value)
-    with pytest.raises(TypeError) as excinfo:
-        m.iss1105_col(np.ones((1, 7)))
-    assert "incompatible function arguments" in str(excinfo.value)
-
-
-def test_custom_operator_new():
-    """Using Eigen types as member variables requires a class-specific
-    operator new with proper alignment"""
-
-    o = m.CustomOperatorNew()
-    np.testing.assert_allclose(o.a, 0.0)
-    np.testing.assert_allclose(o.b.diagonal(), 1.0)

spaces/CVPR/LIVE/shape.cpp

@@ -1,22 +0,0 @@
-#include "shape.h"
-
-void Path::copy_to(ptr<float> points, ptr<float> thickness) const {
-    float *p = points.get();
-    for (int i = 0; i < 2 * num_points; i++) {
-        p[i] = this->points[i];
-    }
-    if (this->thickness != nullptr) {
-        float *t = thickness.get();
-        for (int i = 0; i < num_points; i++) {
-            t[i] = this->thickness[i];
-        }
-    }
-}
-
-void ShapeGroup::copy_to(ptr<float> shape_to_canvas) const {
-    for (int i = 0; i < 3; i++) {
-        for (int j = 0; j < 3; j++) {
-            shape_to_canvas.get()[i * 3 + j] = this->shape_to_canvas(i, j);
-        }
-    }
-}

spaces/CVPR/WALT/mmdet/core/evaluation/eval_hooks.py

@@ -1,303 +0,0 @@
-import os.path as osp
-import warnings
-from math import inf
-
-import mmcv
-import torch.distributed as dist
-from mmcv.runner import Hook
-from torch.nn.modules.batchnorm import _BatchNorm
-from torch.utils.data import DataLoader
-
-from mmdet.utils import get_root_logger
-
-
-class EvalHook(Hook):
-    """Evaluation hook.
-
-    Notes:
-        If new arguments are added for EvalHook, tools/test.py,
-        tools/analysis_tools/eval_metric.py may be effected.
-
-    Attributes:
-        dataloader (DataLoader): A PyTorch dataloader.
-        start (int, optional): Evaluation starting epoch. It enables evaluation
-            before the training starts if ``start`` <= the resuming epoch.
-            If None, whether to evaluate is merely decided by ``interval``.
-            Default: None.
-        interval (int): Evaluation interval (by epochs). Default: 1.
-        save_best (str, optional): If a metric is specified, it would measure
-            the best checkpoint during evaluation. The information about best
-            checkpoint would be save in best.json.
-            Options are the evaluation metrics to the test dataset. e.g.,
-            ``bbox_mAP``, ``segm_mAP`` for bbox detection and instance
-            segmentation. ``AR@100`` for proposal recall. If ``save_best`` is
-            ``auto``, the first key will be used. The interval of
-            ``CheckpointHook`` should device EvalHook. Default: None.
-        rule (str, optional): Comparison rule for best score. If set to None,
-            it will infer a reasonable rule. Keys such as 'mAP' or 'AR' will
-            be inferred by 'greater' rule. Keys contain 'loss' will be inferred
-             by 'less' rule. Options are 'greater', 'less'. Default: None.
-        **eval_kwargs: Evaluation arguments fed into the evaluate function of
-            the dataset.
-    """
-
-    rule_map = {'greater': lambda x, y: x > y, 'less': lambda x, y: x < y}
-    init_value_map = {'greater': -inf, 'less': inf}
-    greater_keys = ['mAP', 'AR']
-    less_keys = ['loss']
-
-    def __init__(self,
-                 dataloader,
-                 start=None,
-                 interval=1,
-                 by_epoch=True,
-                 save_best=None,
-                 rule=None,
-                 **eval_kwargs):
-        if not isinstance(dataloader, DataLoader):
-            raise TypeError('dataloader must be a pytorch DataLoader, but got'
-                            f' {type(dataloader)}')
-        if not interval > 0:
-            raise ValueError(f'interval must be positive, but got {interval}')
-        if start is not None and start < 0:
-            warnings.warn(
-                f'The evaluation start epoch {start} is smaller than 0, '
-                f'use 0 instead', UserWarning)
-            start = 0
-        self.dataloader = dataloader
-        self.interval = interval
-        self.by_epoch = by_epoch
-        self.start = start
-        assert isinstance(save_best, str) or save_best is None
-        self.save_best = save_best
-        self.eval_kwargs = eval_kwargs
-        self.initial_epoch_flag = True
-
-        self.logger = get_root_logger()
-
-        if self.save_best is not None:
-            self._init_rule(rule, self.save_best)
-
-    def _init_rule(self, rule, key_indicator):
-        """Initialize rule, key_indicator, comparison_func, and best score.
-
-        Args:
-            rule (str | None): Comparison rule for best score.
-            key_indicator (str | None): Key indicator to determine the
-                comparison rule.
-        """
-        if rule not in self.rule_map and rule is not None:
-            raise KeyError(f'rule must be greater, less or None, '
-                           f'but got {rule}.')
-
-        if rule is None:
-            if key_indicator != 'auto':
-                if any(key in key_indicator for key in self.greater_keys):
-                    rule = 'greater'
-                elif any(key in key_indicator for key in self.less_keys):
-                    rule = 'less'
-                else:
-                    raise ValueError(f'Cannot infer the rule for key '
-                                     f'{key_indicator}, thus a specific rule '
-                                     f'must be specified.')
-        self.rule = rule
-        self.key_indicator = key_indicator
-        if self.rule is not None:
-            self.compare_func = self.rule_map[self.rule]
-
-    def before_run(self, runner):
-        if self.save_best is not None:
-            if runner.meta is None:
-                warnings.warn('runner.meta is None. Creating a empty one.')
-                runner.meta = dict()
-            runner.meta.setdefault('hook_msgs', dict())
-
-    def before_train_epoch(self, runner):
-        """Evaluate the model only at the start of training."""
-        if not self.initial_epoch_flag:
-            return
-        if self.start is not None and runner.epoch >= self.start:
-            self.after_train_epoch(runner)
-        self.initial_epoch_flag = False
-
-    def evaluation_flag(self, runner):
-        """Judge whether to perform_evaluation after this epoch.
-
-        Returns:
-            bool: The flag indicating whether to perform evaluation.
-        """
-        if self.start is None:
-            if not self.every_n_epochs(runner, self.interval):
-                # No evaluation during the interval epochs.
-                return False
-        elif (runner.epoch + 1) < self.start:
-            # No evaluation if start is larger than the current epoch.
-            return False
-        else:
-            # Evaluation only at epochs 3, 5, 7... if start==3 and interval==2
-            if (runner.epoch + 1 - self.start) % self.interval:
-                return False
-        return True
-
-    def after_train_epoch(self, runner):
-        if not self.by_epoch or not self.evaluation_flag(runner):
-            return
-        from mmdet.apis import single_gpu_test
-        results = single_gpu_test(runner.model, self.dataloader, show=False)
-        key_score = self.evaluate(runner, results)
-        if self.save_best:
-            self.save_best_checkpoint(runner, key_score)
-
-    def after_train_iter(self, runner):
-        if self.by_epoch or not self.every_n_iters(runner, self.interval):
-            return
-        from mmdet.apis import single_gpu_test
-        results = single_gpu_test(runner.model, self.dataloader, show=False)
-        key_score = self.evaluate(runner, results)
-        if self.save_best:
-            self.save_best_checkpoint(runner, key_score)
-
-    def save_best_checkpoint(self, runner, key_score):
-        best_score = runner.meta['hook_msgs'].get(
-            'best_score', self.init_value_map[self.rule])
-        if self.compare_func(key_score, best_score):
-            best_score = key_score
-            runner.meta['hook_msgs']['best_score'] = best_score
-            last_ckpt = runner.meta['hook_msgs']['last_ckpt']
-            runner.meta['hook_msgs']['best_ckpt'] = last_ckpt
-            mmcv.symlink(
-                last_ckpt,
-                osp.join(runner.work_dir, f'best_{self.key_indicator}.pth'))
-            time_stamp = runner.epoch + 1 if self.by_epoch else runner.iter + 1
-            self.logger.info(f'Now best checkpoint is epoch_{time_stamp}.pth.'
-                             f'Best {self.key_indicator} is {best_score:0.4f}')
-
-    def evaluate(self, runner, results):
-        eval_res = self.dataloader.dataset.evaluate(
-            results, logger=runner.logger, **self.eval_kwargs)
-        for name, val in eval_res.items():
-            runner.log_buffer.output[name] = val
-        runner.log_buffer.ready = True
-        if self.save_best is not None:
-            if self.key_indicator == 'auto':
-                # infer from eval_results
-                self._init_rule(self.rule, list(eval_res.keys())[0])
-            return eval_res[self.key_indicator]
-        else:
-            return None
-
-
-class DistEvalHook(EvalHook):
-    """Distributed evaluation hook.
-
-    Notes:
-        If new arguments are added, tools/test.py may be effected.
-
-    Attributes:
-        dataloader (DataLoader): A PyTorch dataloader.
-        start (int, optional): Evaluation starting epoch. It enables evaluation
-            before the training starts if ``start`` <= the resuming epoch.
-            If None, whether to evaluate is merely decided by ``interval``.
-            Default: None.
-        interval (int): Evaluation interval (by epochs). Default: 1.
-        tmpdir (str | None): Temporary directory to save the results of all
-            processes. Default: None.
-        gpu_collect (bool): Whether to use gpu or cpu to collect results.
-            Default: False.
-        save_best (str, optional): If a metric is specified, it would measure
-            the best checkpoint during evaluation. The information about best
-            checkpoint would be save in best.json.
-            Options are the evaluation metrics to the test dataset. e.g.,
-            ``bbox_mAP``, ``segm_mAP`` for bbox detection and instance
-            segmentation. ``AR@100`` for proposal recall. If ``save_best`` is
-            ``auto``, the first key will be used. The interval of
-            ``CheckpointHook`` should device EvalHook. Default: None.
-        rule (str | None): Comparison rule for best score. If set to None,
-            it will infer a reasonable rule. Default: 'None'.
-        broadcast_bn_buffer (bool): Whether to broadcast the
-            buffer(running_mean and running_var) of rank 0 to other rank
-            before evaluation. Default: True.
-        **eval_kwargs: Evaluation arguments fed into the evaluate function of
-            the dataset.
-    """
-
-    def __init__(self,
-                 dataloader,
-                 start=None,
-                 interval=1,
-                 by_epoch=True,
-                 tmpdir=None,
-                 gpu_collect=False,
-                 save_best=None,
-                 rule=None,
-                 broadcast_bn_buffer=True,
-                 **eval_kwargs):
-        super().__init__(
-            dataloader,
-            start=start,
-            interval=interval,
-            by_epoch=by_epoch,
-            save_best=save_best,
-            rule=rule,
-            **eval_kwargs)
-        self.broadcast_bn_buffer = broadcast_bn_buffer
-        self.tmpdir = tmpdir
-        self.gpu_collect = gpu_collect
-
-    def _broadcast_bn_buffer(self, runner):
-        # Synchronization of BatchNorm's buffer (running_mean
-        # and running_var) is not supported in the DDP of pytorch,
-        # which may cause the inconsistent performance of models in
-        # different ranks, so we broadcast BatchNorm's buffers
-        # of rank 0 to other ranks to avoid this.
-        if self.broadcast_bn_buffer:
-            model = runner.model
-            for name, module in model.named_modules():
-                if isinstance(module,
-                              _BatchNorm) and module.track_running_stats:
-                    dist.broadcast(module.running_var, 0)
-                    dist.broadcast(module.running_mean, 0)
-
-    def after_train_epoch(self, runner):
-        if not self.by_epoch or not self.evaluation_flag(runner):
-            return
-
-        if self.broadcast_bn_buffer:
-            self._broadcast_bn_buffer(runner)
-
-        from mmdet.apis import multi_gpu_test
-        tmpdir = self.tmpdir
-        if tmpdir is None:
-            tmpdir = osp.join(runner.work_dir, '.eval_hook')
-        results = multi_gpu_test(
-            runner.model,
-            self.dataloader,
-            tmpdir=tmpdir,
-            gpu_collect=self.gpu_collect)
-        if runner.rank == 0:
-            print('\n')
-            key_score = self.evaluate(runner, results)
-            if self.save_best:
-                self.save_best_checkpoint(runner, key_score)
-
-    def after_train_iter(self, runner):
-        if self.by_epoch or not self.every_n_iters(runner, self.interval):
-            return
-
-        if self.broadcast_bn_buffer:
-            self._broadcast_bn_buffer(runner)
-
-        from mmdet.apis import multi_gpu_test
-        tmpdir = self.tmpdir
-        if tmpdir is None:
-            tmpdir = osp.join(runner.work_dir, '.eval_hook')
-        results = multi_gpu_test(
-            runner.model,
-            self.dataloader,
-            tmpdir=tmpdir,
-            gpu_collect=self.gpu_collect)
-        if runner.rank == 0:
-            print('\n')
-            key_score = self.evaluate(runner, results)
-            if self.save_best:
-                self.save_best_checkpoint(runner, key_score)

spaces/CVPR/transfiner/configs/common/train.py

@@ -1,18 +0,0 @@
-# Common training-related configs that are designed for "tools/lazyconfig_train_net.py"
-# You can use your own instead, together with your own train_net.py
-train = dict(
-    output_dir="./output",
-    init_checkpoint="detectron2://ImageNetPretrained/MSRA/R-50.pkl",
-    max_iter=90000,
-    amp=dict(enabled=False),  # options for Automatic Mixed Precision
-    ddp=dict(  # options for DistributedDataParallel
-        broadcast_buffers=False,
-        find_unused_parameters=False,
-        fp16_compression=False,
-    ),
-    checkpointer=dict(period=5000, max_to_keep=100),  # options for PeriodicCheckpointer
-    eval_period=5000,
-    log_period=20,
-    device="cuda"
-    # ...
-)

spaces/ChrisPreston/diff-svc_minato_aqua/modules/nsf_hifigan/nvSTFT.py

@@ -1,120 +0,0 @@
-import os
-
-os.environ["LRU_CACHE_CAPACITY"] = "3"
-import torch
-import torch.utils.data
-import numpy as np
-import librosa
-from librosa.filters import mel as librosa_mel_fn
-import soundfile as sf
-
-
-def load_wav_to_torch(full_path, target_sr=None, return_empty_on_exception=False):
-    sampling_rate = None
-    try:
-        data, sampling_rate = sf.read(full_path, always_2d=True)  # than soundfile.
-    except Exception as ex:
-        print(f"'{full_path}' failed to load.\nException:")
-        print(ex)
-        if return_empty_on_exception:
-            return [], sampling_rate or target_sr or 48000
-        else:
-            raise Exception(ex)
-
-    if len(data.shape) > 1:
-        data = data[:, 0]
-        assert len(
-            data) > 2  # check duration of audio file is > 2 samples (because otherwise the slice operation was on the wrong dimension)
-
-    if np.issubdtype(data.dtype, np.integer):  # if audio data is type int
-        max_mag = -np.iinfo(data.dtype).min  # maximum magnitude = min possible value of intXX
-    else:  # if audio data is type fp32
-        max_mag = max(np.amax(data), -np.amin(data))
-        max_mag = (2 ** 31) + 1 if max_mag > (2 ** 15) else ((
-                                                                         2 ** 15) + 1 if max_mag > 1.01 else 1.0)  # data should be either 16-bit INT, 32-bit INT or [-1 to 1] float32
-
-    data = torch.FloatTensor(data.astype(np.float32)) / max_mag
-
-    if (torch.isinf(data) | torch.isnan(
-            data)).any() and return_empty_on_exception:  # resample will crash with inf/NaN inputs. return_empty_on_exception will return empty arr instead of except
-        return [], sampling_rate or target_sr or 48000
-    if target_sr is not None and sampling_rate != target_sr:
-        data = torch.from_numpy(librosa.core.resample(data.numpy(), orig_sr=sampling_rate, target_sr=target_sr))
-        sampling_rate = target_sr
-
-    return data, sampling_rate
-
-
-def dynamic_range_compression(x, C=1, clip_val=1e-5):
-    return np.log(np.clip(x, a_min=clip_val, a_max=None) * C)
-
-
-def dynamic_range_decompression(x, C=1):
-    return np.exp(x) / C
-
-
-def dynamic_range_compression_torch(x, C=1, clip_val=1e-5):
-    return torch.log(torch.clamp(x, min=clip_val) * C)
-
-
-def dynamic_range_decompression_torch(x, C=1):
-    return torch.exp(x) / C
-
-
-class STFT():
-    def __init__(self, sr=22050, n_mels=80, n_fft=1024, win_size=1024, hop_length=256, fmin=20, fmax=11025,
-                 clip_val=1e-5):
-        self.target_sr = sr
-
-        self.n_mels = n_mels
-        self.n_fft = n_fft
-        self.win_size = win_size
-        self.hop_length = hop_length
-        self.fmin = fmin
-        self.fmax = fmax
-        self.clip_val = clip_val
-        self.mel_basis = {}
-        self.hann_window = {}
-
-    def get_mel(self, y, center=False):
-        sampling_rate = self.target_sr
-        n_mels = self.n_mels
-        n_fft = self.n_fft
-        win_size = self.win_size
-        hop_length = self.hop_length
-        fmin = self.fmin
-        fmax = self.fmax
-        clip_val = self.clip_val
-
-        if torch.min(y) < -1.:
-            print('min value is ', torch.min(y))
-        if torch.max(y) > 1.:
-            print('max value is ', torch.max(y))
-
-        if fmax not in self.mel_basis:
-            mel = librosa_mel_fn(sr=sampling_rate, n_fft=n_fft, n_mels=n_mels, fmin=fmin, fmax=fmax)
-            self.mel_basis[str(fmax) + '_' + str(y.device)] = torch.from_numpy(mel).float().to(y.device)
-            self.hann_window[str(y.device)] = torch.hann_window(self.win_size).to(y.device)
-
-        y = torch.nn.functional.pad(y.unsqueeze(1), (int((n_fft - hop_length) / 2), int((n_fft - hop_length) / 2)),
-                                    mode='reflect')
-        y = y.squeeze(1)
-
-        spec = torch.stft(y, n_fft, hop_length=hop_length, win_length=win_size, window=self.hann_window[str(y.device)],
-                          center=center, pad_mode='reflect', normalized=False, onesided=True)
-        # print(111,spec)
-        spec = torch.sqrt(spec.pow(2).sum(-1) + (1e-9))
-        # print(222,spec)
-        spec = torch.matmul(self.mel_basis[str(fmax) + '_' + str(y.device)], spec)
-        # print(333,spec)
-        spec = dynamic_range_compression_torch(spec, clip_val=clip_val)
-        # print(444,spec)
-        return spec
-
-    def __call__(self, audiopath):
-        audio, sr = load_wav_to_torch(audiopath, target_sr=self.target_sr)
-        spect = self.get_mel(audio.unsqueeze(0)).squeeze(0)
-        return spect
-
-
-stft = STFT()

spaces/CikeyQI/Yunzai/Yunzai/lib/config/log.js

@@ -1,98 +0,0 @@
-import log4js from 'log4js'
-import chalk from 'chalk'
-import cfg from './config.js'
-import fs from 'node:fs'
-
-/**
-* 设置日志样式
-*/
-export default function setLog () {
-  let file = './logs'
-  if (!fs.existsSync(file)) {
-    fs.mkdirSync(file)
-  }
-
-  /** 调整error日志等级 */
-  // log4js.levels.levels[5].level = Number.MAX_VALUE
-  // log4js.levels.levels.sort((a, b) => a.level - b.level)
-
-  log4js.configure({
-    appenders: {
-      console: {
-        type: 'console',
-        layout: {
-          type: 'pattern',
-          pattern: '%[[TRSSYz][%d{hh:mm:ss.SSS}][%4.4p]%] %m'
-        }
-      },
-      command: {
-        type: 'dateFile', // 可以是console,dateFile,file,Logstash等
-        filename: 'logs/command', // 将会按照filename和pattern拼接文件名
-        pattern: 'yyyy-MM-dd.log',
-        numBackups: 15,
-        alwaysIncludePattern: true,
-        layout: {
-          type: 'pattern',
-          pattern: '[%d{hh:mm:ss.SSS}][%4.4p] %m'
-        }
-      },
-      error: {
-        type: 'file',
-        filename: 'logs/error.log',
-        alwaysIncludePattern: true,
-        layout: {
-          type: 'pattern',
-          pattern: '[%d{hh:mm:ss.SSS}][%4.4p] %m'
-        }
-      }
-    },
-    categories: {
-      default: { appenders: ['console'], level: cfg.bot.log_level },
-      command: { appenders: ['console', 'command'], level: 'warn' },
-      error: { appenders: ['console', 'command', 'error'], level: 'error' }
-    }
-  })
-
-  const defaultLogger = log4js.getLogger('message')
-  const commandLogger = log4js.getLogger('command')
-  const errorLogger = log4js.getLogger('error')
-
-  /* eslint-disable no-useless-call */
-  /** 全局变量 logger */
-  global.logger = {
-    trace () {
-      defaultLogger.trace.call(defaultLogger, ...arguments)
-    },
-    debug () {
-      defaultLogger.debug.call(defaultLogger, ...arguments)
-    },
-    info () {
-      defaultLogger.info.call(defaultLogger, ...arguments)
-    },
-    // warn及以上的日志采用error策略
-    warn () {
-      commandLogger.warn.call(defaultLogger, ...arguments)
-    },
-    error () {
-      errorLogger.error.call(errorLogger, ...arguments)
-    },
-    fatal () {
-      errorLogger.fatal.call(errorLogger, ...arguments)
-    },
-    mark () {
-      errorLogger.mark.call(commandLogger, ...arguments)
-    }
-  }
-
-  logColor()
-}
-
-function logColor () {
-  logger.chalk = chalk
-  logger.red = chalk.red
-  logger.green = chalk.green
-  logger.yellow = chalk.yellow
-  logger.blue = chalk.blue
-  logger.magenta = chalk.magenta
-  logger.cyan = chalk.cyan
-}

spaces/CikeyQI/Yunzai/Yunzai/plugins/ws-plugin/resources/common/common.css

@@ -1,458 +0,0 @@
-@font-face {
-  font-family: 'Number';
-  src: url("./font/tttgbnumber.woff") format('woff'), url("./font/tttgbnumber.ttf") format('truetype');
-}
-@font-face {
-  font-family: 'NZBZ';
-  src: url("./font/NZBZ.woff") format('woff'), url("./font/NZBZ.ttf") format('truetype');
-}
-@font-face {
-  font-family: 'YS';
-  src: url("./font/HYWH-65W.woff") format('woff'), url("./font/HYWH-65W.ttf") format('truetype');
-}
-.font-YS {
-  font-family: Number, "汉仪文黑-65W", YS, PingFangSC-Medium, "PingFang SC", sans-serif;
-}
-.font-NZBZ {
-  font-family: Number, "印品南征北战NZBZ体", NZBZ, "汉仪文黑-65W", YS, PingFangSC-Medium, "PingFang SC", sans-serif;
-}
-* {
-  margin: 0;
-  padding: 0;
-  box-sizing: border-box;
-  -webkit-user-select: none;
-  user-select: none;
-}
-body {
-  font-size: 18px;
-  color: #1e1f20;
-  font-family: Number, "汉仪文黑-65W", YS, PingFangSC-Medium, "PingFang SC", sans-serif;
-  transform: scale(1.4);
-  transform-origin: 0 0;
-  width: 600px;
-}
-.container {
-  width: 600px;
-  padding: 20px 15px 10px 15px;
-  background-size: contain;
-}
-.head-box {
-  border-radius: 15px;
-  padding: 10px 20px;
-  position: relative;
-  color: #fff;
-  margin-top: 30px;
-}
-.head-box .title {
-  font-family: Number, "印品南征北战NZBZ体", NZBZ, "汉仪文黑-65W", YS, PingFangSC-Medium, "PingFang SC", sans-serif;
-  font-size: 36px;
-  text-shadow: 0 0 1px #000, 1px 1px 3px rgba(0, 0, 0, 0.9);
-}
-.head-box .title .label {
-  display: inline-block;
-  margin-left: 10px;
-}
-.head-box .genshin_logo {
-  position: absolute;
-  top: 1px;
-  right: 15px;
-  width: 97px;
-}
-.head-box .label {
-  font-size: 16px;
-  text-shadow: 0 0 1px #000, 1px 1px 3px rgba(0, 0, 0, 0.9);
-}
-.head-box .label span {
-  color: #d3bc8e;
-  padding: 0 2px;
-}
-.notice {
-  color: #888;
-  font-size: 12px;
-  text-align: right;
-  padding: 12px 5px 5px;
-}
-.notice-center {
-  color: #fff;
-  text-align: center;
-  margin-bottom: 10px;
-  text-shadow: 1px 1px 1px #333;
-}
-.copyright {
-  font-size: 14px;
-  text-align: center;
-  color: #fff;
-  position: relative;
-  padding-left: 10px;
-  text-shadow: 1px 1px 1px #000;
-  margin: 10px 0;
-}
-.copyright .version {
-  color: #d3bc8e;
-  display: inline-block;
-  padding: 0 3px;
-}
-/*  */
-.cons {
-  display: inline-block;
-  vertical-align: middle;
-  padding: 0 5px;
-  border-radius: 4px;
-}
-.cons-0 {
-  background: #666;
-  color: #fff;
-}
-.cons-n0 {
-  background: #404949;
-  color: #fff;
-}
-.cons-1 {
-  background: #5cbac2;
-  color: #fff;
-}
-.cons-2 {
-  background: #339d61;
-  color: #fff;
-}
-.cons-3 {
-  background: #3e95b9;
-  color: #fff;
-}
-.cons-4 {
-  background: #3955b7;
-  color: #fff;
-}
-.cons-5 {
-  background: #531ba9cf;
-  color: #fff;
-}
-.cons-6 {
-  background: #ff5722;
-  color: #fff;
-}
-.cons2-0 {
-  border-radius: 4px;
-  background: #666;
-  color: #fff;
-}
-.cons2-1 {
-  border-radius: 4px;
-  background: #71b1b7;
-  color: #fff;
-}
-.cons2-2 {
-  border-radius: 4px;
-  background: #369961;
-  color: #fff;
-}
-.cons2-3 {
-  border-radius: 4px;
-  background: #4596b9;
-  color: #fff;
-}
-.cons2-4 {
-  border-radius: 4px;
-  background: #4560b9;
-  color: #fff;
-}
-.cons2-5 {
-  border-radius: 4px;
-  background: #531ba9cf;
-  color: #fff;
-}
-.cons2-6 {
-  border-radius: 4px;
-  background: #ff5722;
-  color: #fff;
-}
-/********  Fetter  ********/
-.fetter {
-  width: 50px;
-  height: 50px;
-  display: inline-block;
-  background: url('./item/fetter.png');
-  background-size: auto 100%;
-}
-.fetter.fetter1 {
-  background-position: 0% 0;
-}
-.fetter.fetter2 {
-  background-position: 11.11111111% 0;
-}
-.fetter.fetter3 {
-  background-position: 22.22222222% 0;
-}
-.fetter.fetter4 {
-  background-position: 33.33333333% 0;
-}
-.fetter.fetter5 {
-  background-position: 44.44444444% 0;
-}
-.fetter.fetter6 {
-  background-position: 55.55555556% 0;
-}
-.fetter.fetter7 {
-  background-position: 66.66666667% 0;
-}
-.fetter.fetter8 {
-  background-position: 77.77777778% 0;
-}
-.fetter.fetter9 {
-  background-position: 88.88888889% 0;
-}
-.fetter.fetter10 {
-  background-position: 100% 0;
-}
-/********  ELEM  ********/
-.elem-hydro .talent-icon {
-  background-image: url("./bg/talent-hydro.png");
-}
-.elem-hydro .elem-bg,
-.hydro-bg {
-  background-image: url("./bg/bg-hydro.jpg");
-}
-.elem-anemo .talent-icon {
-  background-image: url("./bg/talent-anemo.png");
-}
-.elem-anemo .elem-bg,
-.anemo-bg {
-  background-image: url("./bg/bg-anemo.jpg");
-}
-.elem-cryo .talent-icon {
-  background-image: url("./bg/talent-cryo.png");
-}
-.elem-cryo .elem-bg,
-.cryo-bg {
-  background-image: url("./bg/bg-cryo.jpg");
-}
-.elem-electro .talent-icon {
-  background-image: url("./bg/talent-electro.png");
-}
-.elem-electro .elem-bg,
-.electro-bg {
-  background-image: url("./bg/bg-electro.jpg");
-}
-.elem-geo .talent-icon {
-  background-image: url("./bg/talent-geo.png");
-}
-.elem-geo .elem-bg,
-.geo-bg {
-  background-image: url("./bg/bg-geo.jpg");
-}
-.elem-pyro .talent-icon {
-  background-image: url("./bg/talent-pyro.png");
-}
-.elem-pyro .elem-bg,
-.pyro-bg {
-  background-image: url("./bg/bg-pyro.jpg");
-}
-.elem-dendro .talent-icon {
-  background-image: url("./bg/talent-dendro.png");
-}
-.elem-dendro .elem-bg,
-.dendro-bg {
-  background-image: url("./bg/bg-dendro.jpg");
-}
-/* cont */
-.cont {
-  border-radius: 10px;
-  background: url("../common/cont/card-bg.png") top left repeat-x;
-  background-size: auto 100%;
-  margin: 5px 15px 5px 10px;
-  position: relative;
-  box-shadow: 0 0 1px 0 #ccc, 2px 2px 4px 0 rgba(50, 50, 50, 0.8);
-  overflow: hidden;
-  color: #fff;
-  font-size: 16px;
-}
-.cont-title {
-  background: rgba(0, 0, 0, 0.4);
-  box-shadow: 0 0 1px 0 #fff;
-  color: #d3bc8e;
-  padding: 10px 20px;
-  text-align: left;
-  border-radius: 10px 10px 0 0;
-}
-.cont-title span {
-  font-size: 12px;
-  color: #aaa;
-  margin-left: 10px;
-  font-weight: normal;
-}
-.cont-title.border-less {
-  background: linear-gradient(rgba(0, 0, 0, 0.5), rgba(0, 0, 0, 0));
-  box-shadow: none;
-  padding-bottom: 5px;
-}
-.cont-body {
-  padding: 10px 15px;
-  font-size: 12px;
-  background: rgba(0, 0, 0, 0.5);
-  box-shadow: 0 0 1px 0 #fff;
-  font-weight: normal;
-}
-.cont-footer {
-  padding: 10px 15px;
-  font-size: 12px;
-  background: rgba(0, 0, 0, 0.5);
-  font-weight: normal;
-}
-.cont > ul.cont-msg {
-  display: block;
-  padding: 5px 10px;
-  background: rgba(0, 0, 0, 0.5);
-}
-ul.cont-msg,
-.cont-footer ul {
-  padding-left: 15px;
-}
-ul.cont-msg li,
-.cont-footer ul li {
-  margin: 5px 0;
-  margin-left: 15px;
-}
-ul.cont-msg li strong,
-.cont-footer ul li strong {
-  font-weight: normal;
-  margin: 0 2px;
-  color: #d3bc8e;
-}
-.cont-table {
-  display: table;
-  width: 100%;
-}
-.cont-table .tr {
-  display: table-row;
-}
-.cont-table .tr:nth-child(even) {
-  background: rgba(0, 0, 0, 0.4);
-}
-.cont-table .tr:nth-child(odd) {
-  background: rgba(50, 50, 50, 0.4);
-}
-.cont-table .tr > div,
-.cont-table .tr > td {
-  display: table-cell;
-  box-shadow: 0 0 1px 0 #fff;
-}
-.cont-table .tr > div.value-full {
-  display: table;
-  width: 200%;
-}
-.cont-table .tr > div.value-none {
-  box-shadow: none;
-}
-.cont-table .thead {
-  text-align: center;
-}
-.cont-table .thead > div,
-.cont-table .thead > td {
-  color: #d3bc8e;
-  background: rgba(0, 0, 0, 0.4);
-  line-height: 40px;
-  height: 40px;
-}
-.cont-table .title,
-.cont-table .th {
-  color: #d3bc8e;
-  padding-right: 15px;
-  text-align: right;
-  background: rgba(0, 0, 0, 0.4);
-  min-width: 100px;
-  vertical-align: middle;
-}
-.logo {
-  font-size: 18px;
-  text-align: center;
-  color: #fff;
-  margin: 20px 0 10px 0;
-}
-/* item-icon */
-.item-icon {
-  width: 100%;
-  height: 100%;
-  border-radius: 4px;
-  position: relative;
-  overflow: hidden;
-}
-.item-icon .img {
-  width: 100%;
-  height: 100%;
-  display: block;
-  background-size: contain;
-  background-position: center;
-  background-repeat: no-repeat;
-}
-.item-icon.artis .img {
-  width: 84%;
-  height: 84%;
-  margin: 8%;
-}
-.item-icon.star1 {
-  background-image: url("../common/item/bg1.png");
-}
-.item-icon.opacity-bg.star1 {
-  background-image: url("../common/item/bg1-o.png");
-}
-.item-icon.star2 {
-  background-image: url("../common/item/bg2.png");
-}
-.item-icon.opacity-bg.star2 {
-  background-image: url("../common/item/bg2-o.png");
-}
-.item-icon.star3 {
-  background-image: url("../common/item/bg3.png");
-}
-.item-icon.opacity-bg.star3 {
-  background-image: url("../common/item/bg3-o.png");
-}
-.item-icon.star4 {
-  background-image: url("../common/item/bg4.png");
-}
-.item-icon.opacity-bg.star4 {
-  background-image: url("../common/item/bg4-o.png");
-}
-.item-icon.star5 {
-  background-image: url("../common/item/bg5.png");
-}
-.item-icon.opacity-bg.star5 {
-  background-image: url("../common/item/bg5-o.png");
-}
-.item-icon.star-w {
-  background: #fff;
-}
-.item-list {
-  display: flex;
-}
-.item-list .item-card {
-  width: 70px;
-  background: #e7e5d9;
-}
-.item-list .item-icon {
-  border-bottom-left-radius: 0;
-  border-bottom-right-radius: 12px;
-}
-.item-list .item-title {
-  color: #222;
-  font-size: 13px;
-  text-align: center;
-  padding: 2px;
-  white-space: nowrap;
-  overflow: hidden;
-}
-.item-list .item-icon {
-  height: initial;
-}
-.item-list .item-badge {
-  position: absolute;
-  display: block;
-  left: 0;
-  top: 0;
-  background: rgba(0, 0, 0, 0.6);
-  font-size: 12px;
-  color: #fff;
-  padding: 4px 5px 3px;
-  border-radius: 0 0 6px 0;
-}
-/*# sourceMappingURL=common.css.map */

spaces/CikeyQI/meme-api/meme_generator/memes/jiji_king/__init__.py

@@ -1,103 +0,0 @@
-import math
-from pathlib import Path
-from typing import List
-
-from pil_utils import BuildImage
-from pydantic import Field
-
-from meme_generator import MemeArgsModel, MemeArgsParser, MemeArgsType, add_meme
-from meme_generator.exception import TextOverLength
-
-img_dir = Path(__file__).parent / "images"
-
-help = "是否将图片变为圆形"
-
-parser = MemeArgsParser(prefix_chars="-/")
-parser.add_argument("--circle", "/圆", action="store_true", help=help)
-
-
-class Model(MemeArgsModel):
-    circle: bool = Field(False, description=help)
-
-
-def jiji_king(images: List[BuildImage], texts: List[str], args: Model):
-    block_num = 5
-    if len(images) >= 7 or len(texts) >= 7:
-        block_num = max(len(images), len(texts)) - 1
-
-    chars = ["急"]
-    text = "我是急急国王"
-
-    if len(texts) == 1:
-        if len(images) == 1:
-            chars = [texts[0]] * block_num
-            text = f"我是{texts[0]*2}国王"
-        else:
-            text = texts[0]
-    elif len(texts) == 2:
-        chars = [texts[0]] * block_num
-        text = texts[1]
-    elif texts:
-        chars = sum(
-            [[arg] * math.ceil(block_num / len(texts[:-1])) for arg in texts[:-1]], []
-        )
-        text = texts[-1]
-
-    frame = BuildImage.new("RGBA", (10 + 100 * block_num, 400), "white")
-    king = BuildImage.open(img_dir / "0.png")
-    head = images[0].convert("RGBA").square().resize((125, 125))
-    if args.circle:
-        head = head.circle()
-    king.paste(head, (237, 5), alpha=True)
-    frame.paste(king, ((frame.width - king.width) // 2, 0))
-
-    if len(images) > 1:
-        imgs = images[1:]
-        imgs = [img.convert("RGBA").square().resize((90, 90)) for img in imgs]
-    else:
-        imgs = []
-        for char in chars:
-            block = BuildImage.new("RGBA", (90, 90), "black")
-            try:
-                block.draw_text(
-                    (0, 0, 90, 90),
-                    char,
-                    lines_align="center",
-                    weight="bold",
-                    max_fontsize=60,
-                    min_fontsize=30,
-                    fill="white",
-                )
-            except ValueError:
-                raise TextOverLength(char)
-            imgs.append(block)
-
-    imgs = sum([[img] * math.ceil(block_num / len(imgs)) for img in imgs], [])
-    for i in range(block_num):
-        frame.paste(imgs[i], (10 + 100 * i, 200))
-
-    try:
-        frame.draw_text(
-            (10, 300, frame.width - 10, 390),
-            text,
-            lines_align="center",
-            weight="bold",
-            max_fontsize=100,
-            min_fontsize=30,
-        )
-    except ValueError:
-        raise TextOverLength(text)
-
-    return frame.save_jpg()
-
-
-add_meme(
-    "jiji_king",
-    jiji_king,
-    min_images=1,
-    max_images=11,
-    min_texts=0,
-    max_texts=11,
-    args_type=MemeArgsType(parser, Model, [Model(circle=False), Model(circle=True)]),
-    keywords=["急急国王"],
-)

spaces/CofAI/chat/client/js/theme-toggler.js

@@ -1,22 +0,0 @@
-var switch_theme_toggler = document.getElementById("theme-toggler");
-
-switch_theme_toggler.addEventListener("change", toggleTheme);
-
-function setTheme(themeName) {
-	localStorage.setItem("theme", themeName);
-	document.documentElement.className = themeName;
-}
-
-function toggleTheme() {
-	var currentTheme = localStorage.getItem("theme");
-	var newTheme = currentTheme === "theme-dark" ? "theme-light" : "theme-dark";
-
-	setTheme(newTheme);
-	switch_theme_toggler.checked = newTheme === "theme-dark";
-}
-
-(function () {
-	var currentTheme = localStorage.getItem("theme") || "theme-dark";
-	setTheme(currentTheme);
-	switch_theme_toggler.checked = currentTheme === "theme-dark";
-})();

spaces/CofAI/openjourney/midjourney.py

@@ -1,5 +0,0 @@
-#import libraries
-import gradio as gr
-
-#interface
-gr.Interface.load("models/prompthero/openjourney").launch()

spaces/CognitiveLabs/GPT-auto-webscraping/README.md

@@ -1,13 +0,0 @@
----
-title: GPT Auto Web scraping
-emoji: 🍧
-colorFrom: gray
-colorTo: purple
-sdk: streamlit
-sdk_version: 1.21.0
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/CompVis/text2img-latent-diffusion/app.py

@@ -1,34 +0,0 @@
-import os
-os.environ['CUDA_LAUNCH_BLOCKING'] = "1"
-from diffusers import LDMTextToImagePipeline
-import gradio as gr
-import PIL.Image
-import numpy as np
-import random
-import torch
-import subprocess
-
-ldm_pipeline = LDMTextToImagePipeline.from_pretrained("CompVis/ldm-text2im-large-256")
-
-def predict(prompt, steps=100, seed=42, guidance_scale=6.0):
-    #torch.cuda.empty_cache()
-    print(subprocess.check_output(["nvidia-smi"], stderr=subprocess.STDOUT).decode("utf8"))
-    generator = torch.manual_seed(seed)
-    images = ldm_pipeline([prompt], generator=generator, num_inference_steps=steps, eta=0.3, guidance_scale=guidance_scale)["images"]
-    print(subprocess.check_output(["nvidia-smi"], stderr=subprocess.STDOUT).decode("utf8"))
-    return images[0]
-
-random_seed = random.randint(0, 2147483647)
-gr.Interface(
-    predict,
-    inputs=[
-        gr.inputs.Textbox(label='Prompt', default='a chalk pastel drawing of a llama wearing a wizard hat'),
-        gr.inputs.Slider(1, 100, label='Inference Steps', default=50, step=1),
-        gr.inputs.Slider(0, 2147483647, label='Seed', default=random_seed, step=1),
-        gr.inputs.Slider(1.0, 20.0, label='Guidance Scale - how much the prompt will influence the results', default=6.0, step=0.1),
-    ],
-    outputs=gr.Image(shape=[256,256], type="pil", elem_id="output_image"),
-    css="#output_image{width: 256px}",
-    title="ldm-text2im-large-256 - 🧨 diffusers library",
-    description="This Spaces contains a text-to-image Latent Diffusion process for the <a href=\"https://huggingface.co/CompVis/ldm-text2im-large-256\">ldm-text2im-large-256</a> model by <a href=\"https://huggingface.co/CompVis\">CompVis</a> using the <a href=\"https://github.com/huggingface/diffusers\">diffusers library</a>. The goal of this demo is to showcase the diffusers library and you can check how the code works here. If you want the state-of-the-art experience with Latent Diffusion text-to-image check out the <a href=\"https://huggingface.co/spaces/multimodalart/latentdiffusion\">main Spaces</a>.",
-).launch()

spaces/Cran-May/Mistril-7b/README.md

@@ -1,12 +0,0 @@
----
-title: Mistril 7b
-emoji: 📈
-colorFrom: red
-colorTo: green
-sdk: streamlit
-sdk_version: 1.27.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference