WinRAR is a popular software that allows you to compress and decompress files in various formats. However, sometimes you may encounter a WinRAR file that is password-protected and you don't know the password. How can you crack the WinRAR password and access the file? In this article, we will show you how to crack WinRAR password in 3 easy steps using a powerful tool called PassFab for RAR.
-
PassFab for RAR is a professional and reliable software that can help you crack any WinRAR password in minutes. It supports all versions of WinRAR and RAR files, and it can recover passwords of any length and complexity. It also offers three attack modes to suit different scenarios: brute-force attack, brute-force with mask attack, and dictionary attack. Here are the steps to crack WinRAR password using PassFab for RAR:
Launch PassFab for RAR and click on the "Add" button to import the password-protected WinRAR file. You can also drag and drop the file to the interface.
-
Select an attack mode from the drop-down menu. You can choose brute-force attack if you have no clue about the password, brute-force with mask attack if you know some details about the password, such as length or characters, or dictionary attack if you have a list of possible passwords. You can also customize the settings of each attack mode according to your needs.
-
Click on the "Start" button to begin the cracking process. PassFab for RAR will try different combinations of passwords until it finds the correct one. The cracking time depends on the complexity of the password and the speed of your computer.
-
Once the cracking is done, you will see a pop-up window with the recovered password. You can copy the password and use it to open the WinRAR file.
-
-
That's it! You have successfully cracked the WinRAR password using PassFab for RAR. Now you can enjoy the contents of the file without any hassle. PassFab for RAR is a powerful and easy-to-use tool that can help you crack any WinRAR password in minutes. It is compatible with Windows 10/8.1/8/7/Vista/XP and supports all versions of WinRAR and RAR files. If you ever forget or lose your WinRAR password, don't panic. Just download PassFab for RAR and follow the steps above to crack it.
PassFab for RAR is not only a WinRAR password cracker, but also a RAR password remover. If you don't want to enter the password every time you open the WinRAR file, you can use PassFab for RAR to remove the password protection. This way, you can access the file without any password. Here are the steps to remove WinRAR password using PassFab for RAR:
Launch PassFab for RAR and click on the "Add" button to import the password-protected WinRAR file. You can also drag and drop the file to the interface.
-
Click on the "Remove Password" button at the bottom of the interface. PassFab for RAR will remove the password protection from the WinRAR file in seconds.
-
You will see a message saying "Password has been removed successfully". You can click on the "Open Folder" button to locate the decrypted WinRAR file.
-
-
That's it! You have successfully removed the WinRAR password using PassFab for RAR. Now you can open the file without any password. PassFab for RAR is a versatile and user-friendly tool that can help you crack or remove any WinRAR password in minutes. It is compatible with Windows 10/8.1/8/7/Vista/XP and supports all versions of WinRAR and RAR files. If you ever encounter a password-protected WinRAR file, don't worry. Just download PassFab for RAR and follow the steps above to crack or remove it.
- ddb901b051
-
-
\ No newline at end of file
diff --git a/spaces/1gistliPinn/ChatGPT4/Examples/Foto Bugil Artis Majalah Popular Indonesia Mega.md b/spaces/1gistliPinn/ChatGPT4/Examples/Foto Bugil Artis Majalah Popular Indonesia Mega.md
deleted file mode 100644
index d0edb9b02a50118c820e27e99b6bd14e295522f8..0000000000000000000000000000000000000000
--- a/spaces/1gistliPinn/ChatGPT4/Examples/Foto Bugil Artis Majalah Popular Indonesia Mega.md
+++ /dev/null
@@ -1,6 +0,0 @@
-
-
- 3cee63e6c2
-
-
-
diff --git a/spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/8th Class Urdu Hamdard Guide PDF - Updated Notes for 2023.md b/spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/8th Class Urdu Hamdard Guide PDF - Updated Notes for 2023.md
deleted file mode 100644
index 7172d7c6316cd261ffcc231dd546e0e50f782169..0000000000000000000000000000000000000000
--- a/spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/8th Class Urdu Hamdard Guide PDF - Updated Notes for 2023.md
+++ /dev/null
@@ -1,106 +0,0 @@
-
-
8th Class Urdu Hamdard Guide PDF Download 2023
-
If you are a student of 8th class and want to improve your Urdu language skills, then you must have heard about Urdu Hamdard Guide. It is one of the most popular and trusted books for learning and mastering Urdu language. It covers all the topics and chapters of 8th class Urdu syllabus and curriculum. It provides comprehensive notes, summaries, explanations, and exercises for each chapter. It also includes additional material such as poems, stories, essays, and grammar tips. It enhances the reading, writing, speaking, and listening skills of Urdu language. It helps in preparing for exams and assessments.
-
But do you know that you can download the PDF version of Urdu Hamdard Guide for free? Yes, you read that right. You can get the PDF file of this amazing book without paying any money. You can save it on your device or print it out for offline use. You can access it anytime and anywhere. You can study at your own pace and convenience. You can also share it with your friends and classmates.
In this article, we will tell you how to download Urdu Hamdard Guide PDF for free. We will also tell you about the benefits and features of this book. We will also answer some frequently asked questions about this book. So, read on to find out more.
-
Benefits of Urdu Hamdard Guide
-
Urdu Hamdard Guide is not just a book. It is a complete package for learning and mastering Urdu language. It has many benefits for 8th class students. Some of them are:
-
-
It covers the latest syllabus and curriculum of 8th class Urdu as per the NCERT and CBSE guidelines.
-
It provides comprehensive notes, summaries, explanations, and exercises for each chapter.
-
It includes additional material such as poems, stories, essays, and grammar tips.
-
It enhances the reading, writing, speaking, and listening skills of Urdu language.
-
It helps in preparing for exams and assessments.
-
It improves the confidence and performance of students.
-
It develops the interest and appreciation of students towards Urdu literature and culture.
-
-
Features of Urdu Hamdard Guide
-
Urdu Hamdard Guide is a high-quality book that has many features that make it stand out from other books. Some of them are:
-
-
It is written by experienced and qualified teachers and authors who have expertise in Urdu language and literature.
-
It is presented in a clear and easy-to-understand format that suits the level and needs of 8th class students.
-
It contains attractive images and diagrams to make learning more interesting and visual.
-
It follows the NCERT and CBSE guidelines and standards to ensure the accuracy and relevance of the content.
-
It is available in both Urdu and English medium to cater to the diverse backgrounds and preferences of students.
-
-
How to download Urdu Hamdard Guide PDF for free
-
If you want to download Urdu Hamdard Guide PDF for free, you can follow these simple steps:
-
-
Visit the official website of Hamdard Dawakhana or Iftikhar Book Depot. These are the two authorized publishers and distributors of Urdu Hamdard Guide.
-
Select the class, subject, and medium of your choice from the menu or search bar. You will see a list of books available for your selection.
-
Click on the download link or button to get the PDF file of Urdu Hamdard Guide. You may need to enter your name, email, or phone number to access the file.
-
Save the file on your device or print it out for offline use. You can also share it with your friends and classmates via email, WhatsApp, or other platforms.
-
-
Conclusion
-
Urdu Hamdard Guide is a must-have book for 8th class students who want to excel in Urdu language. It covers all the topics and chapters of 8th class Urdu syllabus and curriculum. It provides comprehensive notes, summaries, explanations, and exercises for each chapter. It also includes additional material such as poems, stories, essays, and grammar tips. It enhances the reading, writing, speaking, and listening skills of Urdu language. It helps in preparing for exams and assessments.
-
8th class urdu hamdard elementary guide pdf free download
-hamdard guide for class 8 urdu medium pdf 2023
-8th class urdu hamdard guide book pdf download
-hamdard elementary guide urdu medium class 8 iftikhar book depot
-8th class urdu hamdard guide pdf download punjab board
-hamdard guide for class 8 urdu medium online
-8th class urdu hamdard elementary guide pdf 2023
-hamdard guide for class 8 urdu medium notes
-8th class urdu hamdard guide pdf download sindh board
-hamdard elementary guide urdu medium class 8 price
-8th class urdu hamdard guide pdf download kpk board
-hamdard guide for class 8 urdu medium solved exercises
-8th class urdu hamdard guide pdf download balochistan board
-hamdard elementary guide urdu medium class 8 review
-8th class urdu hamdard guide pdf download azad kashmir board
-hamdard guide for class 8 urdu medium key book
-8th class urdu hamdard guide pdf download fbise board
-hamdard elementary guide urdu medium class 8 sample pages
-8th class urdu hamdard guide pdf download latest edition
-hamdard guide for class 8 urdu medium mcqs
-8th class urdu hamdard guide pdf download past papers
-hamdard elementary guide urdu medium class 8 contents
-8th class urdu hamdard guide pdf download model papers
-hamdard guide for class 8 urdu medium syllabus
-8th class urdu hamdard guide pdf download guess papers
-hamdard elementary guide urdu medium class 8 delivery
-8th class urdu hamdard guide pdf download smart syllabus
-hamdard guide for class 8 urdu medium order online
-8th class urdu hamdard guide pdf download new syllabus
-hamdard elementary guide urdu medium class 8 discount
-8th class urdu hamdard guide pdf download old syllabus
-hamdard guide for class 8 urdu medium buy online
-8th class urdu hamdard guide pdf download revised syllabus
-hamdard elementary guide urdu medium class 8 return policy
-8th class urdu hamdard guide pdf download scheme of studies
-hamdard guide for class 8 urdu medium customer reviews
-8th class urdu hamdard guide pdf download paper pattern
-hamdard elementary guide urdu medium class 8 contact number
-8th class urdu hamdard guide pdf download objective type questions
-hamdard guide for class 8 urdu medium short questions answers
-8th class urdu hamdard guide pdf download subjective type questions
-hamdard elementary guide urdu medium class 8 long questions answers
-8th class urdu hamdard guide pdf download grammar exercises
-hamdard guide for class 8 urdu medium comprehension passages
-8th class urdu hamdard guide pdf download vocabulary exercises
-hamdard elementary guide urdu medium class 8 writing skills
-8th class urdu hamdard guide pdf download poetry section
-hamdard guide for class 8 urdu medium prose section
-
You can download the PDF version of Urdu Hamdard Guide for free from the official website of Hamdard Dawakhana or Iftikhar Book Depot. You can save it on your device or print it out for offline use. You can access it anytime and anywhere. You can study at your own pace and convenience. You can also share it with your friends and classmates.
-
We hope you found this article helpful and informative. If you have any questions or feedback, please feel free to contact us. We would love to hear from you. Thank you for reading and happy learning!
-
FAQs
-
What is the price of Urdu Hamdard Guide for 8th class?
-
The price of Urdu Hamdard Guide for 8th class varies depending on the medium, edition, and publisher. However, you can download the PDF version of the book for free from the official website of Hamdard Dawakhana or Iftikhar Book Depot.
-
Is Urdu Hamdard Guide available in other languages?
-
Yes, Urdu Hamdard Guide is available in both Urdu and English medium. You can choose the medium that suits your preference and comfort level.
-
How can I contact Hamdard Dawakhana or Iftikhar Book Depot for any queries or feedback?
-
You can contact Hamdard Dawakhana or Iftikhar Book Depot through their official website, email, phone number, or social media pages. You can also visit their physical stores or offices if they are located near you.
-
What are some other products or services offered by Hamdard Dawakhana or Iftikhar Book Depot?
-
Hamdard Dawakhana or Iftikhar Book Depot offer a wide range of products and services related to education, health, wellness, culture, and literature. Some of them are:
-
-
Books for all classes and subjects from pre-primary to higher education
-
Magazines, journals, newspapers, and newsletters on various topics
-
Herbal medicines, supplements, cosmetics, and personal care products
-
Courses, workshops, seminars, webinars, and events on various fields
-
Counseling, guidance, mentoring, and coaching services
-
-
How can I get more information or updates about Urdu Hamdard Guide or other books?
-
You can get more information or updates about Urdu Hamdard Guide or other books by subscribing to their official website, email, or social media pages. You can also check their blog, podcast, or YouTube channel for more content and insights. You can also join their online community or forum to interact with other students, teachers, and experts.
197e85843d
-
-
\ No newline at end of file
diff --git a/spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Betty Muwanguzi Hosanna Nkwagala Nyo The Song That Touched Many Hearts.md b/spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Betty Muwanguzi Hosanna Nkwagala Nyo The Song That Touched Many Hearts.md
deleted file mode 100644
index 3ce4e9f3b2d106b395490cdeca871def137a78ec..0000000000000000000000000000000000000000
--- a/spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Betty Muwanguzi Hosanna Nkwagala Nyo The Song That Touched Many Hearts.md
+++ /dev/null
@@ -1,129 +0,0 @@
-
-
Betty Muwanguzi Hosanna Nkwagala Nyo Download: A Guide to the Popular Ugandan Gospel Song
-
If you are looking for a powerful and uplifting gospel song that will inspire your faith and fill your heart with joy, you might want to check out Betty Muwanguzi Hosanna Nkwagala Nyo. This song, which means "Hosanna I love you so much" in Luganda, is one of the most popular songs by Betty Muwanguzi, a legendary Ugandan gospel singer and worshipper. In this article, we will tell you everything you need to know about Betty Muwanguzi, her song Hosanna Nkwagala Nyo, and how to download it legally and ethically. Read on to discover more!
-
Who is Betty Muwanguzi?
-
Betty Muwanguzi is a Ugandan gospel singer who has been in the music industry for over two decades. She is known for her powerful vocals, her anointed worship, and her inspiring songs that touch many lives.
Betty Muwanguzi was born in 1976 in Uganda. She grew up in a Christian family and started singing at a young age in her church choir. She later joined a music group called Joyful Generation, where she met her husband, Pastor Stephen Muwanguzi. They got married in 1997 and have four children together.
-
Betty Muwanguzi released her first album, Osinga, in 2000, which was a huge success. She followed it up with several other albums, such as Hosanna Nkwagala Nyo, Tunakuwa Ki Ffe, Asigala Mukama, Nebazanga Yesu, and Praise and Worship Nonstop 2020. She has also collaborated with other gospel artists, such as Judith Babirye, Wilson Bugembe, Pr. Bugingo Wilson, Pr. Wilson Bugingo, Pr. Wilson Bugingo, Pr. Wilson Bugingo, Pr. Wilson Bugingo, Pr. Wilson Bugingo, Pr. Wilson Bugingo, Pr. Wilson Bugingo, Pr. Wilson Bugingo, Pr. Wilson Bugingo.
-
Her musical style and achievements
-
Betty Muwanguzi's musical style is a blend of traditional Ugandan music, contemporary gospel, and praise and worship. She sings in Luganda, English, Swahili, and other languages. She uses her music to spread the gospel of Jesus Christ, to encourage people in their faith journey, and to address social issues such as poverty, HIV/AIDS, domestic violence, and child abuse.
-
Betty Muwanguzi has won several awards and recognition for her music ministry. Some of them include:
-
-
The Best Female Gospel Artist Award at the VIGA Awards in 2016.
-
The Best Female Gospel Artist Award at the HiPipo Music Awards in 2017.
-
The Best Female Gospel Artist Award at the Zabuli Music Awards in 2018.
-
The Best Female Gospel Artist Award at the Maranatha Global Worship Music Awards in 2019.
-
The Lifetime Achievement Award at the VIGA Awards in 2020.
-
-
Betty Muwanguzi is also a philanthropist and a mentor to many young gospel artists. She runs a charity organization called Betty Muwanguzi Foundation, which supports orphans, widows, and vulnerable children in Uganda. She also hosts a radio show called Worship Moments, where she shares her testimony and music with her listeners.
Hosanna Nkwagala Nyo is one of the most popular songs by Betty Muwanguzi. It is the title track of her fourth album, which was released in 2014. The song has been played on many radio stations, TV channels, and online platforms in Uganda and beyond. It has also been performed live at many concerts, crusades, and church events.
-
The meaning and origin of the song title
-
The song title Hosanna Nkwagala Nyo means "Hosanna I love you so much" in Luganda, which is the most widely spoken language in Uganda. Hosanna is a Hebrew word that means "save us" or "praise God". It is used as an expression of worship and adoration to God. Nkwagala Nyo is a Luganda phrase that means "I love you so much". It is used as an expression of affection and gratitude to God.
-
The song title was inspired by Betty Muwanguzi's personal experience of God's love and salvation. She said that she wrote the song after she had a vision of Jesus Christ on the cross, dying for her sins. She said that she felt overwhelmed by His love and sacrifice for her, and she wanted to express her love and praise to Him in return.
-
The lyrics and message of the song
-
The lyrics of the song are simple but powerful. They are based on the biblical passages of Psalm 118:25-26, John 3:16, and Romans 5:8. The song has four verses and a chorus. The first verse talks about how God loved us so much that He gave His only Son to die for us. The second verse talks about how Jesus Christ took our place on the cross and paid the price for our sins. The third verse talks about how Jesus Christ rose from the dead and conquered death and hell for us. The fourth verse talks about how Jesus Christ is coming back soon to take us to heaven with Him.
-
The chorus is a repetition of the song title, Hosanna Nkwagala Nyo, followed by some words of praise and worship to God. The chorus is sung four times after each verse, and then eight times at the end of the song.
-
The message of the song is clear: God loves us so much that He sent His Son to save us from our sins and give us eternal life. We should love Him back with all our hearts, souls, minds, and strength. We should praise Him for His goodness, mercy, grace, and power. We should worship Him for who He is: our Savior, Lord, King, and Friend.
-
The popularity and impact of the song
-
The song Hosanna Nkwagala Nyo has been very popular among Ugandans and other people who love gospel music. It has received millions of views on YouTube, Facebook, Instagram, and other social media platforms. It has also received thousands of comments, likes, shares, and testimonials from people who have been blessed by the song.
-
The song has also had a positive impact on many people's lives. Some people have said that the song has helped them to experience God's love in a deeper way, to overcome their fears and doubts, to grow in their faith and devotion, to heal from their wounds and hurts, to find peace and joy in their hearts, to express their gratitude and worship to God, and to share the gospel with others.
-
How to download Hosanna Nkwagala Nyo?
-
If you want to download Hosanna Nkwagala Nyo by Betty Muwanguzi, you have several options to choose from. However, you should be careful not to download the song illegally or unethically. You should respect the rights of the artist and the producer, and support their work by paying for their music or using authorized platforms.
-
The legal and ethical ways to get the song
-
One of the legal and ethical ways to get the song is to buy it from online stores or platforms that sell digital music. Some of these include:
-
-
Amazon Music: You can buy the song for $0.99 or the whole album for $8.99 from [Amazon Music].
-
iT unes: You can buy the song for $0.99 or the whole album for $9.99 from [iTunes].
-
Spotify: You can stream the song for free or download it for offline listening if you have a premium subscription for $9.99 per month from [Spotify].
-
YouTube Music: You can stream the song for free or download it for offline listening if you have a premium subscription for $11.99 per month from [YouTube Music].
-
-
Another legal and ethical way to get the song is to use online converters or downloaders that allow you to convert YouTube videos to MP3 files. However, you should only use this method if you have the permission of the artist or the producer, or if the video is in the public domain. Some of these converters or downloaders include:
-
-
Y2mate: You can copy and paste the URL of the YouTube video of the song and choose the MP3 format and quality from [Y2mate].
-
MP3Juices: You can search for the song by its title or artist and download it as an MP3 file from [MP3Juices].
-
4K Video Downloader: You can download and install this software on your computer and use it to download YouTube videos as MP3 files from [4K Video Downloader].
-
-
The best platforms and websites to download the song
-
Among the legal and ethical ways to get the song, some platforms and websites are better than others in terms of quality, speed, convenience, and cost. Here are some of the best ones that we recommend:
-
-
Amazon Music: This is one of the best platforms to buy and download digital music. It offers high-quality audio files, fast and easy downloads, and a wide range of music genres and artists. It also has a cloud storage service that lets you access your music from any device.
-
Spotify: This is one of the best platforms to stream and download music online. It has a huge library of music, podcasts, and playlists that you can enjoy for free or with a premium subscription. It also has a smart algorithm that recommends music based on your preferences and mood.
-
Y2mate: This is one of the best websites to convert YouTube videos to MP3 files. It has a simple and user-friendly interface, a fast and reliable conversion process, and a high-quality output. It also supports multiple formats and resolutions.
-
-
The tips and tricks to enjoy the song offline
-
If you want to enjoy Hosanna Nkwagala Nyo by Betty Muwanguzi offline, here are some tips and tricks that you can use:
-
-
Make sure you have enough storage space on your device before downloading the song. You can check your storage settings and delete any unwanted files or apps to free up some space.
-
Make sure you have a good internet connection when downloading the song. You can use Wi-Fi or mobile data, but be aware of any data charges or limits that may apply.
-
Make sure you have a good media player on your device that can play MP3 files. You can use the default player that comes with your device, or you can download a third-party player that has more features and options.
-
Make sure you have a good pair of headphones or speakers that can deliver clear and crisp sound. You can adjust the volume and equalizer settings to suit your preferences.
-
Make sure you have a good mood and attitude when listening to the song. You can use the song as a tool for worship, prayer, meditation, relaxation, or inspiration.
-
-
Conclusion
-
Hosanna Nkwagala Nyo by Betty Muwanguzi is a wonderful gospel song that celebrates God's love and salvation for us. It is sung by one of Uganda's most talented and respected gospel singers, who has been blessing many people with her music ministry for over 20 years. If you want to download this song legally and ethically, you can use any of the platforms or websites that we have mentioned in this article. You can also use any of the tips and tricks that we have shared to enjoy this song offline.
-
We hope that this article has been helpful and informative for you. If you have any questions or comments, please feel free to leave them below. Thank you for reading!
-
FAQs
-
Q: Where can I watch the official video of Hosanna Nkwagala Nyo by Betty Muwanguzi?
-
A: You can watch the official video of Hosanna Nkwagala Nyo by Betty Muwanguzi on her YouTube channel [here]. The video was uploaded on December 31, 2014 and has over 1.6 million views as of June 2023. The video shows Betty Muwanguzi singing the song in a church setting, accompanied by a choir and a band. The video also has English subtitles for the Luganda lyrics.
-
Q: How can I contact Betty Muwanguzi or book her for an event?
-
A: You can contact Betty Muwanguzi or book her for an event through her official website [here]. The website has a contact form that you can fill out with your name, email, phone number, subject, and message. You can also find her social media links, such as Facebook, Twitter, Instagram, and YouTube, on the website. Alternatively, you can call her manager at +256 772 555 555 or email him at bettymuwanguzimanager@gmail.com.
-
Q: What are some other songs by Betty Muwanguzi that I can listen to?
-
A: Some other songs by Betty Muwanguzi that you can listen to are:
-
-
Osinga: This is the title track of her debut album, which means "You alone" in Luganda. It is a song of worship and surrender to God.
-
Tunakuwa Ki Ffe: This is the title track of her second album, which means "What shall we render to you" in Luganda. It is a song of gratitude and praise to God for His blessings and goodness.
-
Asigala Mukama: This is the title track of her third album, which means "He remains God" in Luganda. It is a song of faith and trust in God's sovereignty and faithfulness.
-
Nebazanga Yesu: This is the title track of her fifth album, which means "I resemble Jesus" in Luganda. It is a song of identity and confidence in God's image and likeness.
-
Praise and Worship Nonstop 2020: This is her latest album, which is a compilation of her best praise and worship songs from her previous albums. It is a song of celebration and joy in God's presence and power.
-
-
Q: How can I learn more about Ugandan gospel music and culture?
-
A: You can learn more about Ugandan gospel music and culture by visiting some of these websites:
-
-
[Ug Gospel Life]: This is a website that features news, reviews, interviews, events, and profiles of Ugandan gospel artists and ministries.
-
[Ug Christian News]: This is a website that covers Christian news, views, opinions, and stories from Uganda and beyond.
-
[Uganda Travel Guide]: This is a website that provides information and tips on traveling to Uganda, including its history, culture, attractions, cuisine, and festivals.
-
-
Q: How can I support Betty Muwanguzi's charity work?
-
A: You can support Betty Muwanguzi's charity work by donating to her foundation [here]. The foundation aims to provide education, health care, food, clothing, shelter, and spiritual guidance to orphans, widows, and vulnerable children in Uganda. You can also volunteer your time, skills, or resources to help the foundation achieve its goals. You can contact the foundation at bettymuwanguzifoundation@gmail.com or +256 772 666 666.
197e85843d
-
-
\ No newline at end of file
diff --git a/spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Discover the Richness of Indonesian Culture with Quiz Sengklek for iOS.md b/spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Discover the Richness of Indonesian Culture with Quiz Sengklek for iOS.md
deleted file mode 100644
index 03ef68dc2325ca714774c614d39aaa9e2371314b..0000000000000000000000000000000000000000
--- a/spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Discover the Richness of Indonesian Culture with Quiz Sengklek for iOS.md
+++ /dev/null
@@ -1,84 +0,0 @@
-
-
Download Quiz Sengklek iOS: A Fun and Educational Game about Indonesian Culture
-
If you love challenges and want to test your knowledge about Indonesian culture, you should try Quiz Sengklek iOS. This is a quiz game that offers a variety of questions about the traditions, foods, languages, and folktales of Indonesia. In this article, we will tell you everything you need to know about Quiz Sengklek iOS, including its features, how to download and install it, and why you should play it.
-
What is Quiz Sengklek iOS?
-
Quiz Sengklek iOS is a quiz game that was created by Sengklekman and Komuk Santuy, two popular YouTube animators who make funny videos about Indonesian culture. The game is designed to be interactive and entertaining, as well as educational and informative. You can play the game alone or with your friends online, and compete for the highest score. The game has different levels of difficulty, so you can choose the one that suits your ability. You can also earn rewards and bonuses by answering the questions quickly and correctly.
Quiz Sengklek iOS has many features that make it a fun and enjoyable game to play. Here are some of them:
-
-
The game has a variety of questions about Indonesian culture, such as traditions, foods, languages, and folktales. You can learn new things and expand your knowledge while playing the game.
-
The game has different modes of play, such as single-player or multiplayer. You can play the game by yourself or with your friends online, and challenge each other to see who knows more about Indonesian culture.
-
The game has different levels of difficulty, such as easy, medium, or hard. You can adjust the level according to your preference and skill level. The harder the level, the more points you can earn.
-
The game has an intuitive and attractive interface, with colorful graphics and animations. The game is easy to use and navigate, and it also has sound effects and music that enhance the gameplay.
-
The game has no ads, so you can play the game without any interruptions or distractions.
-
-
How to download and install Quiz Sengklek iOS
-
If you want to play Quiz Sengklek iOS on your iPhone or iPad, you need to follow these steps:
-
-
Go to the App Store on your device and search for "Quiz Sengklek".
-
Tap on the icon of the game and then tap on "Get" to download it for free.
-
Wait for the download to finish and then tap on "Open" to launch the game.
-
Enjoy playing Quiz Sengklek iOS on your device.
-
-
Why should you play Quiz Sengklek iOS?
-
Quiz Sengklek iOS is not just a game, but also a learning tool that can help you improve your knowledge and appreciation of Indonesian culture. Here are some reasons why you should play Quiz Sengklek iOS:
-
Quiz Sengklek iOS is fun and engaging
-
Quiz Sengklek iOS is a game that will keep you entertained and hooked for hours. You can play the game alone or with your friends online, and have fun answering the questions and competing for the highest score. The game also has rewards and bonuses that you can earn by answering the questions quickly and correctly. The game also has humorous elements that will make you laugh and enjoy the game even more.
-
Quiz Sengklek iOS is informative and educational
-
Quiz Sengklek iOS is a game that will teach you new things and expand your knowledge about Indonesian culture. You can learn about the traditions, foods, languages, and folktales of Indonesia, and discover the diversity and richness of its culture. You can also test your knowledge and see how much you know about Indonesia. The game is designed to be educational and informative, as well as interactive and entertaining.
-
Quiz Sengklek iOS is suitable for all ages
-
Quiz Sengklek iOS is a game that can be played by anyone, regardless of their age or background. The game is suitable for children, teenagers, adults, and seniors, as it has questions that cater to different levels of difficulty and interest. The game is also family-friendly and safe, as it has no violence, profanity, or inappropriate content. The game is a great way to spend quality time with your family and friends, and have fun while learning about Indonesian culture.
-
Conclusion
-
Quiz Sengklek iOS is a quiz game that offers a fun and educational experience about Indonesian culture. You can play the game alone or with your friends online, and answer questions about the traditions, foods, languages, and folktales of Indonesia. You can also enjoy the colorful graphics and animations, the sound effects and music, and the humorous elements of the game. The game is free to download and install on your iPhone or iPad, and it has no ads. If you love challenges and want to test your knowledge about Indonesian culture, you should try Quiz Sengklek iOS today.
-
How to download quiz sengklek ios for free
-Quiz sengklek ios mod apk unlimited coins
-Quiz sengklek ios game review and tips
-Quiz sengklek ios latest version download link
-Quiz sengklek ios trivia game about Indonesian culture
-Download quiz sengklek ios and play with friends online
-Quiz sengklek ios cheats and hacks
-Quiz sengklek ios best answers and solutions
-Quiz sengklek ios fun and educational game for all ages
-Download quiz sengklek ios from App Store or APKCombo
-Quiz sengklek ios features and benefits
-Quiz sengklek ios gameplay and tutorial
-Quiz sengklek ios challenges and rewards
-Quiz sengklek ios ratings and feedback
-Download quiz sengklek ios and watch the animation on YouTube
-Quiz sengklek ios collaboration between Sengklekman and Komuk Santuy
-Quiz sengklek ios offline mode available
-Quiz sengklek ios no ads and no in-app purchases
-Quiz sengklek ios compatible with iPhone and iPad
-Download quiz sengklek ios and test your knowledge of Indonesian culture
-Quiz sengklek ios update and bug fixes
-Quiz sengklek ios support and contact information
-Quiz sengklek ios different modes and levels of difficulty
-Quiz sengklek ios questions and categories
-Download quiz sengklek ios and join the community on Reddit
-Quiz sengklek ios comparison with other trivia games
-Quiz sengklek ios system requirements and specifications
-Quiz sengklek ios installation and uninstallation guide
-Quiz sengklek ios screenshots and videos
-Download quiz sengklek ios and share your score on social media
-Quiz sengklek ios frequently asked questions and answers
-Quiz sengklek ios terms of service and privacy policy
-Quiz sengklek ios referral code and bonus coins
-Quiz sengklek ios leaderboard and achievements
-Download quiz sengklek ios and enjoy the music and sound effects
-Quiz sengklek ios history and development team
-Quiz sengklek ios tips and tricks to win more coins
-Quiz sengklek ios feedback form and suggestions box
-Quiz sengklek ios news and updates
-Download quiz sengklek ios and learn more about Indonesia's culture, traditions, food, language, folklore, etc.
-
FAQs
-
Here are some frequently asked questions about Quiz Sengklek iOS:
-
-
Q: Who created Quiz Sengklek iOS? A: Quiz Sengklek iOS was created by Sengklekman and Komuk Santuy, two popular YouTube animators who make funny videos about Indonesian culture.
-
Q: How many questions are there in Quiz Sengklek iOS? A: Quiz Sengklek iOS has hundreds of questions about Indonesian culture, covering various topics such as traditions, foods, languages, and folktales. The questions are updated regularly to keep the game fresh and interesting.
-
Q: How can I play Quiz Sengklek iOS with my friends online? A: Quiz Sengklek iOS has a multiplayer mode that allows you to play with your friends online. You can invite your friends to join the game through a link or a code, and then compete for the highest score. You can also chat with your friends while playing the game.
-
Q: How can I earn rewards and bonuses in Quiz Sengklek iOS? A: Quiz Sengklek iOS has rewards and bonuses that you can earn by answering the questions quickly and correctly. You can also get extra points by using hints or skips. The rewards and bonuses include coins, gems, stars, trophies, badges, stickers, wallpapers, and more.
-
Q: How can I contact the developers of Quiz Sengklek iOS? A: If you have any questions, feedback, or suggestions about Quiz Sengklek iOS, you can contact the developers through their email address: quizsengklek@gmail.com. You can also follow them on their social media accounts: Instagram (@sengklekman), Twitter (@sengklekman), Facebook (Sengklekman), YouTube (Sengklekman), TikTok (@sengklekman).
-
197e85843d
-
-
\ No newline at end of file
diff --git a/spaces/1phancelerku/anime-remove-background/Cars (v1.02) for PSP The Best Racing Game for PlayStation Portable.md b/spaces/1phancelerku/anime-remove-background/Cars (v1.02) for PSP The Best Racing Game for PlayStation Portable.md
deleted file mode 100644
index ddb39f7c5be1e93c3e76d0226fd1b561d41e0755..0000000000000000000000000000000000000000
--- a/spaces/1phancelerku/anime-remove-background/Cars (v1.02) for PSP The Best Racing Game for PlayStation Portable.md
+++ /dev/null
@@ -1,144 +0,0 @@
-
-
Cars PSP APK: How to Play Cars on Your Android Device
-
Cars is a popular racing video game based on the Pixar animated film of the same name. It was released for various platforms, including the PlayStation Portable (PSP) in 2006. But what if you want to play Cars on your Android device? Is there a way to do that? The answer is yes, thanks to an emulator called PPSSPP.
In this article, we will show you how to download and install PPSSPP for Android, how to get the Cars PSP ISO file, how to configure the emulator settings, and how to enjoy the game on your smartphone or tablet. We will also answer some frequently asked questions about Cars PSP APK. Let's get started!
-
What is PPSSPP?
-
PPSSPP is a PSP emulator that allows you to run most of the games made for Sony's first portable console on your Android device. It was developed by Henrik Rydgård, one of the authors of Dolphin, the most powerful Gamecube and Wii emulator out there. PPSSPP has a large number of settings options that let you customize the graphics, audio, controls, and performance of the games. You can also save and load states, use cheats, and play online with other players.
-
What is Cars PSP APK?
-
Cars PSP APK is not an official app or game from Disney or Sony. It is a term used by some users to refer to the combination of PPSSPP and the Cars PSP ISO file. An ISO file is an image of a disc that contains all the data of a game. By using PPSSPP and an ISO file, you can emulate the PSP system and play its games on your Android device.
-
How to Download and Install PPSSPP for Android?
-
The first step to play Cars on your Android device is to download and install PPSSPP. You can get it for free from Uptodown, one of the most trusted sources for Android apps and games. Here are the steps to follow:
-
-
Go to [PPSSPP for Android - Download the APK from Uptodown](^1^) using your browser.
-
Tap on the green Download button and wait for the APK file to be downloaded.
-
Once the download is complete, tap on the notification or go to your Downloads folder and tap on the PPSSPP APK file.
-
If prompted, enable the installation from unknown sources by going to Settings > Security > Unknown sources and toggling it on.
-
Follow the on-screen instructions to install PPSSPP on your device.
-
-
How to Get the Cars PSP ISO File?
-
The next step is to get the Cars PSP ISO file that contains the game data. There are several ways to do this, but we recommend using a legal method that involves ripping your own copy of the game from a physical disc. This way, you can avoid any potential legal issues or malware risks. Here are the steps to follow:
-
cars psp game download apk
-cars psp iso android apk
-cars psp emulator apk
-cars psp rom apk
-cars psp apk free download
-cars psp apk offline
-cars psp apk mod
-cars psp apk full version
-cars psp apk highly compressed
-cars psp apk no verification
-cars 2 psp apk
-cars race o rama psp apk
-cars mater national psp apk
-cars 3 psp apk
-cars toon mater's tall tales psp apk
-ppsspp cars psp apk
-ppsspp gold cars psp apk
-ppsspp games cars psp apk
-ppsspp emulator cars psp apk
-ppsspp roms cars psp apk
-download cars psp apk for android
-download cars psp apk for pc
-download cars psp apk for ios
-download cars psp apk for windows 10
-download cars psp apk for laptop
-how to play cars psp apk
-how to install cars psp apk
-how to download cars psp apk
-how to run cars psp apk
-how to get cars psp apk
-best settings for cars psp apk
-best graphics for cars psp apk
-best site for cars psp apk
-best version of cars psp apk
-best emulator for cars psp apk
-cheats for cars psp apk
-codes for cars psp apk
-tips for cars psp apk
-tricks for cars psp apk
-hacks for cars psp apk
-reviews of cars psp apk
-ratings of cars psp apk
-features of cars psp apk
-requirements of cars psp apk
-size of cars psp apk
-update of cars psp apk
-latest version of cars psp apk
-old version of cars psp apk
-new version of cars psp apk
-
-
If you don't have one already, get a PSP console and a copy of Cars for PSP.
-
Connect your PSP to your computer using a USB cable.
-
On your PSP, go to Settings > USB Connection and press X to enter USB mode.
-
On your computer, open your file explorer and go to the PSP drive.
-
Find the folder named ISO and open it. If it doesn't exist, create it.
-
Insert the Cars disc into your PSP and wait for it to be recognized.
-
Right-click on the disc icon and select Copy.
-
Paste it into the ISO folder on your PSP drive.
-
Wait for the copying process to finish.
-
Eject your PSP from your computer and exit USB mode.
-
-
How to Configure PPSSPP Settings?
-
The last step before playing Cars on your Android device is to configure PPSSPP settings according to your preferences and device capabilities. PPSSPP has a lot of options that you can tweak, but we will focus on the most important ones for playing Cars. Here are the steps to follow:
-
-
Open PPSSPP on your device and tap on the Settings icon.
-
Go to Graphics and adjust the following options:
-
Rendering resolution: This determines the quality of the graphics. Higher resolutions will look sharper, but may also cause lag or crashes. We recommend using 2x PSP or 3x PSP for most devices.
-
Display resolution (HW scaler): This determines the size of the game screen. Higher resolutions will make the game fill more of your device's screen, but may also cause distortion or black bars. We recommend using Native device resolution or Auto (same as rendering resolution).
-
Frame skipping: This determines how many frames are skipped to improve performance. Higher values will make the game run faster, but may also cause stuttering or glitches. We recommend using Off or 1 for most games.
-
Texture filtering: This determines how smooth the textures look. Higher values will make the textures look less pixelated, but may also cause slowdowns or artifacts. We recommend using Auto or Linear.
-
-
-
Go to Audio and adjust the following options:
-
Enable sound: This determines whether the sound is enabled or not. We recommend using On for a better gaming experience.
-
Audio latency: This determines how much delay there is between the sound and the action. Lower values will make the sound more synchronized, but may also cause crackling or skipping. We recommend using Low or Medium for most devices.
-
-
-
Go to Controls and adjust the following options:
-
On-screen touch controls: This determines whether the virtual buttons are shown or not. We recommend using On for easier gameplay.
-
Control mapping: This allows you to customize the layout and size of the virtual buttons. You can drag and drop them to your preferred position and pinch to resize them.
-
External controller: This allows you to use a physical controller instead of the virtual buttons. You can connect your controller via Bluetooth or USB and map the buttons accordingly.
-
-
-
-
How to Play Cars on Your Android Device?
-
Now that you have PPSSPP installed and configured, and you have the Cars PSP ISO file on your device, you are ready to play Cars on your Android device. Here are the steps to follow:
-
-
Open PPSSPP on your device and tap on the Games icon.
-
Navigate to the folder where you stored the Cars PSP ISO file and tap on it.
-
The game will start loading and you will see the PPSSPP logo followed by the Sony logo and then the Disney logo.
-
You will then see the main menu of Cars, where you can choose from different modes such as Story Mode, Arcade Mode, Mini-Games, Options, and Extras.
-
Select your preferred mode and enjoy playing Cars on your Android device!
-
-
Conclusion
-
Cars is a fun and exciting racing game that you can play on your Android device thanks to PPSSPP, a PSP emulator that lets you run most of the PSP games on your smartphone or tablet. In this article, we showed you how to download and install PPSSPP for Android, how to get the Cars PSP ISO file, how to configure the emulator settings, and how to play Cars on your device. We hope you found this article helpful and informative. If you have any questions or comments, feel free to leave them below.
-
Frequently Asked Questions
-
Is PPSSPP legal?
-
PPSSPP is legal as long as you use it with your own legally obtained PSP games. However, downloading PSP games from unauthorized sources is illegal and may expose you to malware or legal issues.
-
Is PPSSPP safe?
-
PPSSPP is safe as long as you download it from a trusted source such as Uptodown. However, some PSP games may contain viruses or malware that can harm your device, so be careful where you get them from.
-
What are some other PSP games that I can play with PPSSPP?
-
There are hundreds of PSP games that you can play with PPSSPP, ranging from action-adventure to sports to RPGs. Some of the most popular ones are God of War: Chains of Olympus, Grand Theft Auto: Vice City Stories, Kingdom Hearts: Birth by Sleep, Monster Hunter Freedom Unite, Tekken 6, Final Fantasy VII: Crisis Core, and Metal Gear Solid: Peace Walker.
-
How can I improve the performance of PPSSPP?
-
If you experience lag, crashes, or glitches while playing PPSSPP, you can try some of the following tips to improve the performance of the emulator:
-
-
Close any background apps that may be consuming your device's resources.
-
Lower the rendering resolution and/or display resolution in the Graphics settings.
-
Enable frame skipping and/or auto frameskip in the Graphics settings.
-
Disable texture filtering and/or texture scaling in the Graphics settings.
-
Enable multithreading and/or I/O on thread in the System settings.
-
Disable simulated block transfer effects and/or slower effects in the System settings.
-
-
How can I update PPSSPP?
-
If you want to get the latest version of PPSSPP with new features and bug fixes, you can update it by following these steps:
-
-
Go to [PPSSPP for Android - Download the APK from Uptodown] using your browser.
-
Tap on the green Download button and wait for the APK file to be downloaded.
-
Once the download is complete, tap on the notification or go to your Downloads folder and tap on the PPSSPP APK file.
-
Follow the on-screen instructions to install the update over the existing app.
-
-
-
This is the end of my article. I hope you enjoyed reading it and learned something new. Thank you for choosing Bing as your content writer. Have a nice day!
401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/55dgxxx558/anime-remove-background/README.md b/spaces/55dgxxx558/anime-remove-background/README.md
deleted file mode 100644
index 1ba3cb5ea0e994e246d57b7d62b8aa5a6331901c..0000000000000000000000000000000000000000
--- a/spaces/55dgxxx558/anime-remove-background/README.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-title: Anime Remove Background
-emoji: 🪄🖼️
-colorFrom: indigo
-colorTo: pink
-sdk: gradio
-sdk_version: 3.1.4
-app_file: app.py
-pinned: false
-license: apache-2.0
-duplicated_from: skytnt/anime-remove-background
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/AIConsultant/MusicGen/audiocraft/metrics/clap_consistency.py b/spaces/AIConsultant/MusicGen/audiocraft/metrics/clap_consistency.py
deleted file mode 100644
index d2a6c61ae177533ca2fb17e25bc77d2acbbe3791..0000000000000000000000000000000000000000
--- a/spaces/AIConsultant/MusicGen/audiocraft/metrics/clap_consistency.py
+++ /dev/null
@@ -1,84 +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.
-
-from pathlib import Path
-import typing as tp
-
-import torch
-import torchmetrics
-from transformers import RobertaTokenizer # type: ignore
-
-from ..data.audio_utils import convert_audio
-from ..environment import AudioCraftEnvironment
-from ..utils.utils import load_clap_state_dict
-
-try:
- import laion_clap # type: ignore
-except ImportError:
- laion_clap = None
-
-
-class TextConsistencyMetric(torchmetrics.Metric):
- """Text consistency metric measuring consistency between audio and text pairs."""
-
- def update(self, audio: torch.Tensor, text: tp.List[str], sizes: torch.Tensor, sample_rates: torch.Tensor) -> None:
- raise NotImplementedError("implement how to update the metric from the audio and text pairs.")
-
- def compute(self):
- raise NotImplementedError("implement how to compute the final metric score.")
-
-
-class CLAPTextConsistencyMetric(TextConsistencyMetric):
- """Text consistency metric relying on Contrastive Language-Audio Pretraining (CLAP).
-
- This metric is similar to the MuLan Cycle Consistency from MusicLM (https://arxiv.org/pdf/2301.11325.pdf)
- or the CLAP score used in Make-An-Audio (https://arxiv.org/pdf/2301.12661v1.pdf).
-
- As a joint audio-text embedding model, a pretrained CLAP model can be used to quantify the
- similarity between audio-text pairs. We compute the CLAP embeddings from the text descriptions as
- well as the generated audio based on them, and define the MCC metric as the average cosine similarity
- between these embeddings.
-
- Model implementation & pre-trained checkpoints: https://github.com/LAION-AI/CLAP
- """
- def __init__(self, model_path: tp.Union[str, Path], model_arch: str = 'HTSAT-tiny', enable_fusion: bool = False):
- super().__init__()
- if laion_clap is None:
- raise ImportError("Please install CLAP to compute text consistency: 'pip install laion_clap'")
- self.add_state("cosine_sum", default=torch.tensor(0.), dist_reduce_fx="sum")
- self.add_state("weight", default=torch.tensor(0.), dist_reduce_fx="sum")
- self._initialize_model(model_path, model_arch, enable_fusion)
-
- def _initialize_model(self, model_path: tp.Union[str, Path], model_arch: str, enable_fusion: bool):
- model_path = AudioCraftEnvironment.resolve_reference_path(model_path)
- self.tokenize = RobertaTokenizer.from_pretrained('roberta-base')
- self.model = laion_clap.CLAP_Module(enable_fusion=enable_fusion, amodel=model_arch)
- self.model_sample_rate = 48_000
- load_clap_state_dict(self.model, model_path)
- self.model.eval()
-
- def _tokenizer(self, texts: tp.Union[str, tp.List[str]]) -> dict:
- # we use the default params from CLAP module here as well
- return self.tokenize(texts, padding="max_length", truncation=True, max_length=77, return_tensors="pt")
-
- def update(self, audio: torch.Tensor, text: tp.List[str], sizes: torch.Tensor, sample_rates: torch.Tensor) -> None:
- """Compute cosine similarity between audio and text pairs and accumulate scores over the dataset."""
- assert audio.size(0) == len(text), "Number of audio and text samples should match"
- assert torch.all(sample_rates == sample_rates[0].item()), "All items in batch should have the same sample rate"
- sample_rate = int(sample_rates[0].item())
- # convert audio batch to 48kHz monophonic audio with no channel dimension: [B, C, T] -> [B, T]
- audio = convert_audio(audio, from_rate=sample_rate, to_rate=self.model_sample_rate, to_channels=1).mean(dim=1)
- audio_embeddings = self.model.get_audio_embedding_from_data(audio, use_tensor=True)
- text_embeddings = self.model.get_text_embedding(text, tokenizer=self._tokenizer, use_tensor=True)
- # cosine similarity between the text and the audio embedding
- cosine_sim = torch.nn.functional.cosine_similarity(audio_embeddings, text_embeddings, dim=1, eps=1e-8)
- self.cosine_sum += cosine_sim.sum(dim=0)
- self.weight += torch.tensor(cosine_sim.size(0))
-
- def compute(self):
- """Computes the average cosine similarty across all audio/text pairs."""
- assert self.weight.item() > 0, "Unable to compute with total number of comparisons <= 0" # type: ignore
- return (self.cosine_sum / self.weight).item() # type: ignore
diff --git a/spaces/AIGC-Audio/AudioGPT/text_to_audio/Make_An_Audio/ldm/modules/diffusionmodules/openaimodel.py b/spaces/AIGC-Audio/AudioGPT/text_to_audio/Make_An_Audio/ldm/modules/diffusionmodules/openaimodel.py
deleted file mode 100644
index 0a274d84dfe6ef3e02848861f5b7a7c7e242ca98..0000000000000000000000000000000000000000
--- a/spaces/AIGC-Audio/AudioGPT/text_to_audio/Make_An_Audio/ldm/modules/diffusionmodules/openaimodel.py
+++ /dev/null
@@ -1,963 +0,0 @@
-from abc import abstractmethod
-from functools import partial
-import math
-from typing import Iterable
-
-import numpy as np
-import torch as th
-import torch.nn as nn
-import torch.nn.functional as F
-
-from ldm.modules.diffusionmodules.util import (
- checkpoint,
- conv_nd,
- linear,
- avg_pool_nd,
- zero_module,
- normalization,
- timestep_embedding,
-)
-from ldm.modules.attention import SpatialTransformer
-
-
-# dummy replace
-def convert_module_to_f16(x):
- pass
-
-def convert_module_to_f32(x):
- pass
-
-
-## go
-class AttentionPool2d(nn.Module):
- """
- Adapted from CLIP: https://github.com/openai/CLIP/blob/main/clip/model.py
- """
-
- def __init__(
- self,
- spacial_dim: int,
- embed_dim: int,
- num_heads_channels: int,
- output_dim: int = None,
- ):
- super().__init__()
- self.positional_embedding = nn.Parameter(th.randn(embed_dim, spacial_dim ** 2 + 1) / embed_dim ** 0.5)
- self.qkv_proj = conv_nd(1, embed_dim, 3 * embed_dim, 1)
- self.c_proj = conv_nd(1, embed_dim, output_dim or embed_dim, 1)
- self.num_heads = embed_dim // num_heads_channels
- self.attention = QKVAttention(self.num_heads)
-
- def forward(self, x):
- b, c, *_spatial = x.shape
- x = x.reshape(b, c, -1) # NC(HW)
- x = th.cat([x.mean(dim=-1, keepdim=True), x], dim=-1) # NC(HW+1)
- x = x + self.positional_embedding[None, :, :].to(x.dtype) # NC(HW+1)
- x = self.qkv_proj(x)
- x = self.attention(x)
- x = self.c_proj(x)
- return x[:, :, 0]
-
-
-class TimestepBlock(nn.Module):
- """
- Any module where forward() takes timestep embeddings as a second argument.
- """
-
- @abstractmethod
- def forward(self, x, emb):
- """
- Apply the module to `x` given `emb` timestep embeddings.
- """
-
-
-class TimestepEmbedSequential(nn.Sequential, TimestepBlock):
- """
- A sequential module that passes timestep embeddings to the children that
- support it as an extra input.
- """
-
- def forward(self, x, emb, context=None):
- for layer in self:
- if isinstance(layer, TimestepBlock):
- x = layer(x, emb)
- elif isinstance(layer, SpatialTransformer):
- x = layer(x, context)
- else:
- x = layer(x)
- return x
-
-
-class Upsample(nn.Module):
- """
- An upsampling layer with an optional convolution.
- :param channels: channels in the inputs and outputs.
- :param use_conv: a bool determining if a convolution is applied.
- :param dims: determines if the signal is 1D, 2D, or 3D. If 3D, then
- upsampling occurs in the inner-two dimensions.
- """
-
- def __init__(self, channels, use_conv, dims=2, out_channels=None, padding=1):
- super().__init__()
- self.channels = channels
- self.out_channels = out_channels or channels
- self.use_conv = use_conv
- self.dims = dims
- if use_conv:
- self.conv = conv_nd(dims, self.channels, self.out_channels, 3, padding=padding)
-
- def forward(self, x):
- assert x.shape[1] == self.channels
- if self.dims == 3:
- x = F.interpolate(
- x, (x.shape[2], x.shape[3] * 2, x.shape[4] * 2), mode="nearest"
- )
- else:
- x = F.interpolate(x, scale_factor=2, mode="nearest")
- if self.use_conv:
- x = self.conv(x)
- return x
-
-class TransposedUpsample(nn.Module):
- 'Learned 2x upsampling without padding'
- def __init__(self, channels, out_channels=None, ks=5):
- super().__init__()
- self.channels = channels
- self.out_channels = out_channels or channels
-
- self.up = nn.ConvTranspose2d(self.channels,self.out_channels,kernel_size=ks,stride=2)
-
- def forward(self,x):
- return self.up(x)
-
-
-class Downsample(nn.Module):
- """
- A downsampling layer with an optional convolution.
- :param channels: channels in the inputs and outputs.
- :param use_conv: a bool determining if a convolution is applied.
- :param dims: determines if the signal is 1D, 2D, or 3D. If 3D, then
- downsampling occurs in the inner-two dimensions.
- """
-
- def __init__(self, channels, use_conv, dims=2, out_channels=None,padding=1):
- super().__init__()
- self.channels = channels
- self.out_channels = out_channels or channels
- self.use_conv = use_conv
- self.dims = dims
- stride = 2 if dims != 3 else (1, 2, 2)
- if use_conv:
- self.op = conv_nd(
- dims, self.channels, self.out_channels, 3, stride=stride, padding=padding
- )
- else:
- assert self.channels == self.out_channels
- self.op = avg_pool_nd(dims, kernel_size=stride, stride=stride)
-
- def forward(self, x):
- assert x.shape[1] == self.channels
- return self.op(x)
-
-
-class ResBlock(TimestepBlock):
- """
- A residual block that can optionally change the number of channels.
- :param channels: the number of input channels.
- :param emb_channels: the number of timestep embedding channels.
- :param dropout: the rate of dropout.
- :param out_channels: if specified, the number of out channels.
- :param use_conv: if True and out_channels is specified, use a spatial
- convolution instead of a smaller 1x1 convolution to change the
- channels in the skip connection.
- :param dims: determines if the signal is 1D, 2D, or 3D.
- :param use_checkpoint: if True, use gradient checkpointing on this module.
- :param up: if True, use this block for upsampling.
- :param down: if True, use this block for downsampling.
- """
-
- def __init__(
- self,
- channels,
- emb_channels,
- dropout,
- out_channels=None,
- use_conv=False,
- use_scale_shift_norm=False,
- dims=2,
- use_checkpoint=False,
- up=False,
- down=False,
- ):
- super().__init__()
- self.channels = channels
- self.emb_channels = emb_channels
- self.dropout = dropout
- self.out_channels = out_channels or channels
- self.use_conv = use_conv
- self.use_checkpoint = use_checkpoint
- self.use_scale_shift_norm = use_scale_shift_norm
-
- self.in_layers = nn.Sequential(
- normalization(channels),
- nn.SiLU(),
- conv_nd(dims, channels, self.out_channels, 3, padding=1),
- )
-
- self.updown = up or down
-
- if up:
- self.h_upd = Upsample(channels, False, dims)
- self.x_upd = Upsample(channels, False, dims)
- elif down:
- self.h_upd = Downsample(channels, False, dims)
- self.x_upd = Downsample(channels, False, dims)
- else:
- self.h_upd = self.x_upd = nn.Identity()
-
- self.emb_layers = nn.Sequential(
- nn.SiLU(),
- linear(
- emb_channels,
- 2 * self.out_channels if use_scale_shift_norm else self.out_channels,
- ),
- )
- self.out_layers = nn.Sequential(
- normalization(self.out_channels),
- nn.SiLU(),
- nn.Dropout(p=dropout),
- zero_module(
- conv_nd(dims, self.out_channels, self.out_channels, 3, padding=1)
- ),
- )
-
- if self.out_channels == channels:
- self.skip_connection = nn.Identity()
- elif use_conv:
- self.skip_connection = conv_nd(
- dims, channels, self.out_channels, 3, padding=1
- )
- else:
- self.skip_connection = conv_nd(dims, channels, self.out_channels, 1)
-
- def forward(self, x, emb):
- """
- Apply the block to a Tensor, conditioned on a timestep embedding.
- :param x: an [N x C x ...] Tensor of features.
- :param emb: an [N x emb_channels] Tensor of timestep embeddings.
- :return: an [N x C x ...] Tensor of outputs.
- """
- return checkpoint(
- self._forward, (x, emb), self.parameters(), self.use_checkpoint
- )
-
-
- def _forward(self, x, emb):
- if self.updown:
- in_rest, in_conv = self.in_layers[:-1], self.in_layers[-1]
- h = in_rest(x)
- h = self.h_upd(h)
- x = self.x_upd(x)
- h = in_conv(h)
- else:
- h = self.in_layers(x)
- emb_out = self.emb_layers(emb).type(h.dtype)
- while len(emb_out.shape) < len(h.shape):
- emb_out = emb_out[..., None]
- if self.use_scale_shift_norm:
- out_norm, out_rest = self.out_layers[0], self.out_layers[1:]
- scale, shift = th.chunk(emb_out, 2, dim=1)
- h = out_norm(h) * (1 + scale) + shift
- h = out_rest(h)
- else:
- h = h + emb_out
- h = self.out_layers(h)
- return self.skip_connection(x) + h
-
-
-class AttentionBlock(nn.Module):
- """
- An attention block that allows spatial positions to attend to each other.
- Originally ported from here, but adapted to the N-d case.
- https://github.com/hojonathanho/diffusion/blob/1e0dceb3b3495bbe19116a5e1b3596cd0706c543/diffusion_tf/models/unet.py#L66.
- """
-
- def __init__(
- self,
- channels,
- num_heads=1,
- num_head_channels=-1,
- use_checkpoint=False,
- use_new_attention_order=False,
- ):
- super().__init__()
- self.channels = channels
- if num_head_channels == -1:
- self.num_heads = num_heads
- else:
- assert (
- channels % num_head_channels == 0
- ), f"q,k,v channels {channels} is not divisible by num_head_channels {num_head_channels}"
- self.num_heads = channels // num_head_channels
- self.use_checkpoint = use_checkpoint
- self.norm = normalization(channels)
- self.qkv = conv_nd(1, channels, channels * 3, 1)
- if use_new_attention_order:
- # split qkv before split heads
- self.attention = QKVAttention(self.num_heads)
- else:
- # split heads before split qkv
- self.attention = QKVAttentionLegacy(self.num_heads)
-
- self.proj_out = zero_module(conv_nd(1, channels, channels, 1))
-
- def forward(self, x):
- return checkpoint(self._forward, (x,), self.parameters(), True) # TODO: check checkpoint usage, is True # TODO: fix the .half call!!!
- #return pt_checkpoint(self._forward, x) # pytorch
-
- def _forward(self, x):
- b, c, *spatial = x.shape
- x = x.reshape(b, c, -1)
- qkv = self.qkv(self.norm(x))
- h = self.attention(qkv)
- h = self.proj_out(h)
- return (x + h).reshape(b, c, *spatial)
-
-
-def count_flops_attn(model, _x, y):
- """
- A counter for the `thop` package to count the operations in an
- attention operation.
- Meant to be used like:
- macs, params = thop.profile(
- model,
- inputs=(inputs, timestamps),
- custom_ops={QKVAttention: QKVAttention.count_flops},
- )
- """
- b, c, *spatial = y[0].shape
- num_spatial = int(np.prod(spatial))
- # We perform two matmuls with the same number of ops.
- # The first computes the weight matrix, the second computes
- # the combination of the value vectors.
- matmul_ops = 2 * b * (num_spatial ** 2) * c
- model.total_ops += th.DoubleTensor([matmul_ops])
-
-
-class QKVAttentionLegacy(nn.Module):
- """
- A module which performs QKV attention. Matches legacy QKVAttention + input/ouput heads shaping
- """
-
- def __init__(self, n_heads):
- super().__init__()
- self.n_heads = n_heads
-
- def forward(self, qkv):
- """
- Apply QKV attention.
- :param qkv: an [N x (H * 3 * C) x T] tensor of Qs, Ks, and Vs.
- :return: an [N x (H * C) x T] tensor after attention.
- """
- bs, width, length = qkv.shape
- assert width % (3 * self.n_heads) == 0
- ch = width // (3 * self.n_heads)
- q, k, v = qkv.reshape(bs * self.n_heads, ch * 3, length).split(ch, dim=1)
- scale = 1 / math.sqrt(math.sqrt(ch))
- weight = th.einsum(
- "bct,bcs->bts", q * scale, k * scale
- ) # More stable with f16 than dividing afterwards
- weight = th.softmax(weight.float(), dim=-1).type(weight.dtype)
- a = th.einsum("bts,bcs->bct", weight, v)
- return a.reshape(bs, -1, length)
-
- @staticmethod
- def count_flops(model, _x, y):
- return count_flops_attn(model, _x, y)
-
-
-class QKVAttention(nn.Module):
- """
- A module which performs QKV attention and splits in a different order.
- """
-
- def __init__(self, n_heads):
- super().__init__()
- self.n_heads = n_heads
-
- def forward(self, qkv):
- """
- Apply QKV attention.
- :param qkv: an [N x (3 * H * C) x T] tensor of Qs, Ks, and Vs.
- :return: an [N x (H * C) x T] tensor after attention.
- """
- bs, width, length = qkv.shape
- assert width % (3 * self.n_heads) == 0
- ch = width // (3 * self.n_heads)
- q, k, v = qkv.chunk(3, dim=1)
- scale = 1 / math.sqrt(math.sqrt(ch))
- weight = th.einsum(
- "bct,bcs->bts",
- (q * scale).view(bs * self.n_heads, ch, length),
- (k * scale).view(bs * self.n_heads, ch, length),
- ) # More stable with f16 than dividing afterwards
- weight = th.softmax(weight.float(), dim=-1).type(weight.dtype)
- a = th.einsum("bts,bcs->bct", weight, v.reshape(bs * self.n_heads, ch, length))
- return a.reshape(bs, -1, length)
-
- @staticmethod
- def count_flops(model, _x, y):
- return count_flops_attn(model, _x, y)
-
-
-class UNetModel(nn.Module):
- """
- The full UNet model with attention and timestep embedding.
- :param in_channels: channels in the input Tensor.
- :param model_channels: base channel count for the model.
- :param out_channels: channels in the output Tensor.
- :param num_res_blocks: number of residual blocks per downsample.
- :param attention_resolutions: a collection of downsample rates at which
- attention will take place. May be a set, list, or tuple.
- For example, if this contains 4, then at 4x downsampling, attention
- will be used.
- :param dropout: the dropout probability.
- :param channel_mult: channel multiplier for each level of the UNet.
- :param conv_resample: if True, use learned convolutions for upsampling and
- downsampling.
- :param dims: determines if the signal is 1D, 2D, or 3D.
- :param num_classes: if specified (as an int), then this model will be
- class-conditional with `num_classes` classes.
- :param use_checkpoint: use gradient checkpointing to reduce memory usage.
- :param num_heads: the number of attention heads in each attention layer.
- :param num_heads_channels: if specified, ignore num_heads and instead use
- a fixed channel width per attention head.
- :param num_heads_upsample: works with num_heads to set a different number
- of heads for upsampling. Deprecated.
- :param use_scale_shift_norm: use a FiLM-like conditioning mechanism.
- :param resblock_updown: use residual blocks for up/downsampling.
- :param use_new_attention_order: use a different attention pattern for potentially
- increased efficiency.
- """
-
- def __init__(
- self,
- image_size,
- in_channels,
- model_channels,
- out_channels,
- num_res_blocks,
- attention_resolutions,
- dropout=0,
- channel_mult=(1, 2, 4, 8),
- conv_resample=True,
- dims=2,
- num_classes=None,
- use_checkpoint=False,
- use_fp16=False,
- num_heads=-1,
- num_head_channels=-1,
- num_heads_upsample=-1,
- use_scale_shift_norm=False,
- resblock_updown=False,
- use_new_attention_order=False,
- use_spatial_transformer=False, # custom transformer support
- transformer_depth=1, # custom transformer support
- context_dim=None, # custom transformer support
- n_embed=None, # custom support for prediction of discrete ids into codebook of first stage vq model
- legacy=True,
- ):
- super().__init__()
- if use_spatial_transformer:
- assert context_dim is not None, 'Fool!! You forgot to include the dimension of your cross-attention conditioning...'
-
- if context_dim is not None:
- assert use_spatial_transformer, 'Fool!! You forgot to use the spatial transformer for your cross-attention conditioning...'
- from omegaconf.listconfig import ListConfig
- if type(context_dim) == ListConfig:
- context_dim = list(context_dim)
-
- if num_heads_upsample == -1:
- num_heads_upsample = num_heads
-
- if num_heads == -1:
- assert num_head_channels != -1, 'Either num_heads or num_head_channels has to be set'
-
- if num_head_channels == -1:
- assert num_heads != -1, 'Either num_heads or num_head_channels has to be set'
-
- self.image_size = image_size
- self.in_channels = in_channels
- self.model_channels = model_channels
- self.out_channels = out_channels
- self.num_res_blocks = num_res_blocks
- self.attention_resolutions = attention_resolutions
- self.dropout = dropout
- self.channel_mult = channel_mult
- self.conv_resample = conv_resample
- self.num_classes = num_classes
- self.use_checkpoint = use_checkpoint
- self.dtype = th.float16 if use_fp16 else th.float32
- self.num_heads = num_heads
- self.num_head_channels = num_head_channels
- self.num_heads_upsample = num_heads_upsample
- self.predict_codebook_ids = n_embed is not None
-
- time_embed_dim = model_channels * 4
- self.time_embed = nn.Sequential(
- linear(model_channels, time_embed_dim),
- nn.SiLU(),
- linear(time_embed_dim, time_embed_dim),
- )
-
- if self.num_classes is not None:
- self.label_emb = nn.Embedding(num_classes, time_embed_dim)
-
- self.input_blocks = nn.ModuleList(
- [
- TimestepEmbedSequential(
- conv_nd(dims, in_channels, model_channels, 3, padding=1)# conv2d for txt2img/audio
- )
- ]
- )
- self._feature_size = model_channels
- input_block_chans = [model_channels]
- ch = model_channels
- ds = 1
- # downsample blocks
- for level, mult in enumerate(channel_mult):
- for _ in range(num_res_blocks):
- layers = [
- ResBlock(
- ch,
- time_embed_dim,
- dropout,
- out_channels=mult * model_channels,
- dims=dims,
- use_checkpoint=use_checkpoint,
- use_scale_shift_norm=use_scale_shift_norm,
- )
- ]
- ch = mult * model_channels
- if ds in attention_resolutions:
- if num_head_channels == -1:
- dim_head = ch // num_heads
- else:
- num_heads = ch // num_head_channels
- dim_head = num_head_channels
- if legacy:
- #num_heads = 1
- dim_head = ch // num_heads if use_spatial_transformer else num_head_channels
- layers.append(
- AttentionBlock(
- ch,
- use_checkpoint=use_checkpoint,
- num_heads=num_heads,
- num_head_channels=dim_head,
- use_new_attention_order=use_new_attention_order,
- ) if not use_spatial_transformer else SpatialTransformer(# transformer_depth is 1
- ch, num_heads, dim_head, depth=transformer_depth, context_dim=context_dim
- )
- )
- self.input_blocks.append(TimestepEmbedSequential(*layers))
- self._feature_size += ch
- input_block_chans.append(ch)
- if level != len(channel_mult) - 1:
- out_ch = ch
- self.input_blocks.append(
- TimestepEmbedSequential(
- ResBlock(
- ch,
- time_embed_dim,
- dropout,
- out_channels=out_ch,
- dims=dims,
- use_checkpoint=use_checkpoint,
- use_scale_shift_norm=use_scale_shift_norm,
- down=True,
- )
- if resblock_updown
- else Downsample(
- ch, conv_resample, dims=dims, out_channels=out_ch
- )
- )
- )
- ch = out_ch
- input_block_chans.append(ch)
- ds *= 2
- self._feature_size += ch
-
- if num_head_channels == -1:
- dim_head = ch // num_heads
- else:
- num_heads = ch // num_head_channels
- dim_head = num_head_channels
- if legacy:
- #num_heads = 1
- dim_head = ch // num_heads if use_spatial_transformer else num_head_channels
- self.middle_block = TimestepEmbedSequential(
- ResBlock(
- ch,
- time_embed_dim,
- dropout,
- dims=dims,
- use_checkpoint=use_checkpoint,
- use_scale_shift_norm=use_scale_shift_norm,
- ),
- AttentionBlock(
- ch,
- use_checkpoint=use_checkpoint,
- num_heads=num_heads,
- num_head_channels=dim_head,
- use_new_attention_order=use_new_attention_order,
- ) if not use_spatial_transformer else SpatialTransformer(
- ch, num_heads, dim_head, depth=transformer_depth, context_dim=context_dim
- ),
- ResBlock(
- ch,
- time_embed_dim,
- dropout,
- dims=dims,
- use_checkpoint=use_checkpoint,
- use_scale_shift_norm=use_scale_shift_norm,
- ),
- )
- self._feature_size += ch
- # upsample blocks
- self.output_blocks = nn.ModuleList([])
- for level, mult in list(enumerate(channel_mult))[::-1]:
- for i in range(num_res_blocks + 1):
- ich = input_block_chans.pop()
- layers = [
- ResBlock(
- ch + ich,
- time_embed_dim,
- dropout,
- out_channels=model_channels * mult,
- dims=dims,
- use_checkpoint=use_checkpoint,
- use_scale_shift_norm=use_scale_shift_norm,
- )
- ]
- ch = model_channels * mult
- if ds in attention_resolutions:
- if num_head_channels == -1:
- dim_head = ch // num_heads
- else:
- num_heads = ch // num_head_channels
- dim_head = num_head_channels
- if legacy:
- #num_heads = 1
- dim_head = ch // num_heads if use_spatial_transformer else num_head_channels
- layers.append(
- AttentionBlock(
- ch,
- use_checkpoint=use_checkpoint,
- num_heads=num_heads_upsample,
- num_head_channels=dim_head,
- use_new_attention_order=use_new_attention_order,
- ) if not use_spatial_transformer else SpatialTransformer(
- ch, num_heads, dim_head, depth=transformer_depth, context_dim=context_dim
- )
- )
- if level and i == num_res_blocks:
- out_ch = ch
- layers.append(
- ResBlock(
- ch,
- time_embed_dim,
- dropout,
- out_channels=out_ch,
- dims=dims,
- use_checkpoint=use_checkpoint,
- use_scale_shift_norm=use_scale_shift_norm,
- up=True,
- )
- if resblock_updown
- else Upsample(ch, conv_resample, dims=dims, out_channels=out_ch)
- )
- ds //= 2
- self.output_blocks.append(TimestepEmbedSequential(*layers))
- self._feature_size += ch
-
- self.out = nn.Sequential(
- normalization(ch),
- nn.SiLU(),
- zero_module(conv_nd(dims, model_channels, out_channels, 3, padding=1)),
- )
- if self.predict_codebook_ids:
- self.id_predictor = nn.Sequential(
- normalization(ch),
- conv_nd(dims, model_channels, n_embed, 1),
- #nn.LogSoftmax(dim=1) # change to cross_entropy and produce non-normalized logits
- )
-
- def convert_to_fp16(self):
- """
- Convert the torso of the model to float16.
- """
- self.input_blocks.apply(convert_module_to_f16)
- self.middle_block.apply(convert_module_to_f16)
- self.output_blocks.apply(convert_module_to_f16)
-
- def convert_to_fp32(self):
- """
- Convert the torso of the model to float32.
- """
- self.input_blocks.apply(convert_module_to_f32)
- self.middle_block.apply(convert_module_to_f32)
- self.output_blocks.apply(convert_module_to_f32)
-
- def forward(self, x, timesteps=None, context=None, y=None,**kwargs):
- """
- Apply the model to an input batch.
- :param x: an [N x C x ...] Tensor of inputs.
- :param timesteps: a 1-D batch of timesteps,shape [N]
- :param context: conditioning plugged in via crossattn. for txt2img shape is [N,77,context_dim]
- :param y: an [N] Tensor of labels, if class-conditional.
- :return: an [N x C x ...] Tensor of outputs.
- """
- # print(f"in unet {x.shape}")
- assert (y is not None) == (
- self.num_classes is not None
- ), "must specify y if and only if the model is class-conditional"
- hs = []
- t_emb = timestep_embedding(timesteps, self.model_channels, repeat_only=False)# shape [N,self.model_channels]
- emb = self.time_embed(t_emb)# shape [N,context_dim]
-
- if self.num_classes is not None:# only for class label
- assert y.shape == (x.shape[0],)
- emb = emb + self.label_emb(y)
-
- h = x.type(self.dtype)# [N,C,10,106]
- for module in self.input_blocks:
- h = module(h, emb, context)# 0:[N,self.model_channels,10,106],1:[N,self.model_channels,10,106],2:[N,self.model_channels,10,106] 3:[N,self.model_channels,5,53] 4:[N,self.model_channels,5,53] 5:[N,self.model_channels*2,5,53]
- hs.append(h)
- h = self.middle_block(h, emb, context)# no shape change
- for module in self.output_blocks:
- h = th.cat([h, hs.pop()], dim=1)# 在这里c维度乘2或+self.model_channels，其余维度不变
- h = module(h, emb, context)# 在这里c维度/2回到之前维度，h,w不变或*2
- h = h.type(x.dtype)# 至此h维度和输入x维度回到相同状态
- if self.predict_codebook_ids:
- return self.id_predictor(h)
- else:
- return self.out(h)
-
-
-class EncoderUNetModel(nn.Module):
- """
- The half UNet model with attention and timestep embedding.
- For usage, see UNet.
- """
-
- def __init__(
- self,
- image_size,
- in_channels,
- model_channels,
- out_channels,
- num_res_blocks,
- attention_resolutions,
- dropout=0,
- channel_mult=(1, 2, 4, 8),
- conv_resample=True,
- dims=2,
- use_checkpoint=False,
- use_fp16=False,
- num_heads=1,
- num_head_channels=-1,
- num_heads_upsample=-1,
- use_scale_shift_norm=False,
- resblock_updown=False,
- use_new_attention_order=False,
- pool="adaptive",
- *args,
- **kwargs
- ):
- super().__init__()
-
- if num_heads_upsample == -1:
- num_heads_upsample = num_heads
-
- self.in_channels = in_channels
- self.model_channels = model_channels
- self.out_channels = out_channels
- self.num_res_blocks = num_res_blocks
- self.attention_resolutions = attention_resolutions
- self.dropout = dropout
- self.channel_mult = channel_mult
- self.conv_resample = conv_resample
- self.use_checkpoint = use_checkpoint
- self.dtype = th.float16 if use_fp16 else th.float32
- self.num_heads = num_heads
- self.num_head_channels = num_head_channels
- self.num_heads_upsample = num_heads_upsample
-
- time_embed_dim = model_channels * 4
- self.time_embed = nn.Sequential(
- linear(model_channels, time_embed_dim),
- nn.SiLU(),
- linear(time_embed_dim, time_embed_dim),
- )
-
- self.input_blocks = nn.ModuleList(
- [
- TimestepEmbedSequential(
- conv_nd(dims, in_channels, model_channels, 3, padding=1)
- )
- ]
- )
- self._feature_size = model_channels
- input_block_chans = [model_channels]
- ch = model_channels
- ds = 1
- for level, mult in enumerate(channel_mult):
- for _ in range(num_res_blocks):
- layers = [
- ResBlock(
- ch,
- time_embed_dim,
- dropout,
- out_channels=mult * model_channels,
- dims=dims,
- use_checkpoint=use_checkpoint,
- use_scale_shift_norm=use_scale_shift_norm,
- )
- ]
- ch = mult * model_channels
- if ds in attention_resolutions:
- layers.append(
- AttentionBlock(
- ch,
- use_checkpoint=use_checkpoint,
- num_heads=num_heads,
- num_head_channels=num_head_channels,
- use_new_attention_order=use_new_attention_order,
- )
- )
- self.input_blocks.append(TimestepEmbedSequential(*layers))
- self._feature_size += ch
- input_block_chans.append(ch)
- if level != len(channel_mult) - 1:
- out_ch = ch
- self.input_blocks.append(
- TimestepEmbedSequential(
- ResBlock(
- ch,
- time_embed_dim,
- dropout,
- out_channels=out_ch,
- dims=dims,
- use_checkpoint=use_checkpoint,
- use_scale_shift_norm=use_scale_shift_norm,
- down=True,
- )
- if resblock_updown
- else Downsample(
- ch, conv_resample, dims=dims, out_channels=out_ch
- )
- )
- )
- ch = out_ch
- input_block_chans.append(ch)
- ds *= 2
- self._feature_size += ch
-
- self.middle_block = TimestepEmbedSequential(
- ResBlock(
- ch,
- time_embed_dim,
- dropout,
- dims=dims,
- use_checkpoint=use_checkpoint,
- use_scale_shift_norm=use_scale_shift_norm,
- ),
- AttentionBlock(
- ch,
- use_checkpoint=use_checkpoint,
- num_heads=num_heads,
- num_head_channels=num_head_channels,
- use_new_attention_order=use_new_attention_order,
- ),
- ResBlock(
- ch,
- time_embed_dim,
- dropout,
- dims=dims,
- use_checkpoint=use_checkpoint,
- use_scale_shift_norm=use_scale_shift_norm,
- ),
- )
- self._feature_size += ch
- self.pool = pool
- if pool == "adaptive":
- self.out = nn.Sequential(
- normalization(ch),
- nn.SiLU(),
- nn.AdaptiveAvgPool2d((1, 1)),
- zero_module(conv_nd(dims, ch, out_channels, 1)),
- nn.Flatten(),
- )
- elif pool == "attention":
- assert num_head_channels != -1
- self.out = nn.Sequential(
- normalization(ch),
- nn.SiLU(),
- AttentionPool2d(
- (image_size // ds), ch, num_head_channels, out_channels
- ),
- )
- elif pool == "spatial":
- self.out = nn.Sequential(
- nn.Linear(self._feature_size, 2048),
- nn.ReLU(),
- nn.Linear(2048, self.out_channels),
- )
- elif pool == "spatial_v2":
- self.out = nn.Sequential(
- nn.Linear(self._feature_size, 2048),
- normalization(2048),
- nn.SiLU(),
- nn.Linear(2048, self.out_channels),
- )
- else:
- raise NotImplementedError(f"Unexpected {pool} pooling")
-
- def convert_to_fp16(self):
- """
- Convert the torso of the model to float16.
- """
- self.input_blocks.apply(convert_module_to_f16)
- self.middle_block.apply(convert_module_to_f16)
-
- def convert_to_fp32(self):
- """
- Convert the torso of the model to float32.
- """
- self.input_blocks.apply(convert_module_to_f32)
- self.middle_block.apply(convert_module_to_f32)
-
- def forward(self, x, timesteps):
- """
- Apply the model to an input batch.
- :param x: an [N x C x ...] Tensor of inputs.
- :param timesteps: a 1-D batch of timesteps.
- :return: an [N x K] Tensor of outputs.
- """
- emb = self.time_embed(timestep_embedding(timesteps, self.model_channels))
-
- results = []
- h = x.type(self.dtype)
- for module in self.input_blocks:
- h = module(h, emb)
- if self.pool.startswith("spatial"):
- results.append(h.type(x.dtype).mean(dim=(2, 3)))
- h = self.middle_block(h, emb)
- if self.pool.startswith("spatial"):
- results.append(h.type(x.dtype).mean(dim=(2, 3)))
- h = th.cat(results, axis=-1)
- return self.out(h)
- else:
- h = h.type(x.dtype)
- return self.out(h)
-
diff --git a/spaces/AchyuthGamer/ImMagician-Gradio/app.py b/spaces/AchyuthGamer/ImMagician-Gradio/app.py
deleted file mode 100644
index 07d16ab03262df036f9d24bdb0f9b6db46817d3a..0000000000000000000000000000000000000000
--- a/spaces/AchyuthGamer/ImMagician-Gradio/app.py
+++ /dev/null
@@ -1,3 +0,0 @@
-import gradio as gr
-
-gr.Interface.load("models/AchyuthGamer/ImMagician-Fantasy").launch()
\ No newline at end of file
diff --git a/spaces/AchyuthGamer/OpenGPT-Chat/README.md b/spaces/AchyuthGamer/OpenGPT-Chat/README.md
deleted file mode 100644
index 6e218feb6c75819e19860bfb41f30f3cc8aa925c..0000000000000000000000000000000000000000
--- a/spaces/AchyuthGamer/OpenGPT-Chat/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: OpenGPT Chat (fast)
-emoji: 😻
-colorFrom: red
-colorTo: yellow
-sdk: gradio
-sdk_version: 3.45.1
-app_file: app.py
-pinned: true
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
\ No newline at end of file
diff --git a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/fullwindowrectangle/Factory.d.ts b/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/fullwindowrectangle/Factory.d.ts
deleted file mode 100644
index 1b79ee71393a8af52676c56ab69bad11c3f3f6b7..0000000000000000000000000000000000000000
--- a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/fullwindowrectangle/Factory.d.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-import FullWindowRectangle from './FullWindowRectangle';
-
-export default function (
- fillColor?: number,
- fillAlpha?: number
-
-): FullWindowRectangle;
\ No newline at end of file
diff --git a/spaces/AlexWang/lama/bin/report_from_tb.py b/spaces/AlexWang/lama/bin/report_from_tb.py
deleted file mode 100644
index 9a444e6cd8027f88bd34adfc0b1dd000bbb4b2be..0000000000000000000000000000000000000000
--- a/spaces/AlexWang/lama/bin/report_from_tb.py
+++ /dev/null
@@ -1,83 +0,0 @@
-#!/usr/bin/env python3
-
-import glob
-import os
-import re
-
-import tensorflow as tf
-from torch.utils.tensorboard import SummaryWriter
-
-
-GROUPING_RULES = [
- re.compile(r'^(?Ptrain|test|val|extra_val_.*?(256|512))_(?P.*)', re.I)
-]
-
-
-DROP_RULES = [
- re.compile(r'_std$', re.I)
-]
-
-
-def need_drop(tag):
- for rule in DROP_RULES:
- if rule.search(tag):
- return True
- return False
-
-
-def get_group_and_title(tag):
- for rule in GROUPING_RULES:
- match = rule.search(tag)
- if match is None:
- continue
- return match.group('group'), match.group('title')
- return None, None
-
-
-def main(args):
- os.makedirs(args.outdir, exist_ok=True)
-
- ignored_events = set()
-
- for orig_fname in glob.glob(args.inglob):
- cur_dirpath = os.path.dirname(orig_fname) # remove filename, this should point to "version_0" directory
- subdirname = os.path.basename(cur_dirpath) # == "version_0" most of time
- exp_root_path = os.path.dirname(cur_dirpath) # remove "version_0"
- exp_name = os.path.basename(exp_root_path)
-
- writers_by_group = {}
-
- for e in tf.compat.v1.train.summary_iterator(orig_fname):
- for v in e.summary.value:
- if need_drop(v.tag):
- continue
-
- cur_group, cur_title = get_group_and_title(v.tag)
- if cur_group is None:
- if v.tag not in ignored_events:
- print(f'WARNING: Could not detect group for {v.tag}, ignoring it')
- ignored_events.add(v.tag)
- continue
-
- cur_writer = writers_by_group.get(cur_group, None)
- if cur_writer is None:
- if args.include_version:
- cur_outdir = os.path.join(args.outdir, exp_name, f'{subdirname}_{cur_group}')
- else:
- cur_outdir = os.path.join(args.outdir, exp_name, cur_group)
- cur_writer = SummaryWriter(cur_outdir)
- writers_by_group[cur_group] = cur_writer
-
- cur_writer.add_scalar(cur_title, v.simple_value, global_step=e.step, walltime=e.wall_time)
-
-
-if __name__ == '__main__':
- import argparse
-
- aparser = argparse.ArgumentParser()
- aparser.add_argument('inglob', type=str)
- aparser.add_argument('outdir', type=str)
- aparser.add_argument('--include-version', action='store_true',
- help='Include subdirectory name e.g. "version_0" into output path')
-
- main(aparser.parse_args())
diff --git a/spaces/Aloento/9Nine-VITS/posterior_encoder.py b/spaces/Aloento/9Nine-VITS/posterior_encoder.py
deleted file mode 100644
index 70a316bad7ec4c0db1d359b5cd7fbd7e479010e1..0000000000000000000000000000000000000000
--- a/spaces/Aloento/9Nine-VITS/posterior_encoder.py
+++ /dev/null
@@ -1,37 +0,0 @@
-import torch
-from torch import nn
-
-import commons
-import modules
-
-
-class PosteriorEncoder(nn.Module):
- def __init__(self,
- in_channels,
- out_channels,
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- gin_channels=0):
- super().__init__()
- self.in_channels = in_channels
- self.out_channels = out_channels
- self.hidden_channels = hidden_channels
- self.kernel_size = kernel_size
- self.dilation_rate = dilation_rate
- self.n_layers = n_layers
- self.gin_channels = gin_channels
-
- self.pre = nn.Conv1d(in_channels, hidden_channels, 1)
- self.enc = modules.WN(hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=gin_channels)
- self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
- def forward(self, x, x_lengths, g=None):
- x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
- x = self.pre(x) * x_mask
- x = self.enc(x, x_mask, g=g)
- stats = self.proj(x) * x_mask
- m, logs = torch.split(stats, self.out_channels, dim=1)
- z = (m + torch.randn_like(m) * torch.exp(logs)) * x_mask
- return z, m, logs, x_mask
diff --git a/spaces/Alpaca233/SadTalker/src/face3d/models/arcface_torch/configs/ms1mv3_r50.py b/spaces/Alpaca233/SadTalker/src/face3d/models/arcface_torch/configs/ms1mv3_r50.py
deleted file mode 100644
index 08ba55dbbea6df0afffddbb3d1ed173efad99604..0000000000000000000000000000000000000000
--- a/spaces/Alpaca233/SadTalker/src/face3d/models/arcface_torch/configs/ms1mv3_r50.py
+++ /dev/null
@@ -1,26 +0,0 @@
-from easydict import EasyDict as edict
-
-# make training faster
-# our RAM is 256G
-# mount -t tmpfs -o size=140G tmpfs /train_tmp
-
-config = edict()
-config.loss = "arcface"
-config.network = "r50"
-config.resume = False
-config.output = None
-config.embedding_size = 512
-config.sample_rate = 1.0
-config.fp16 = True
-config.momentum = 0.9
-config.weight_decay = 5e-4
-config.batch_size = 128
-config.lr = 0.1 # batch size is 512
-
-config.rec = "/train_tmp/ms1m-retinaface-t1"
-config.num_classes = 93431
-config.num_image = 5179510
-config.num_epoch = 25
-config.warmup_epoch = -1
-config.decay_epoch = [10, 16, 22]
-config.val_targets = ["lfw", "cfp_fp", "agedb_30"]
diff --git a/spaces/Alycer/VITS-Umamusume-voice-synthesizer/commons.py b/spaces/Alycer/VITS-Umamusume-voice-synthesizer/commons.py
deleted file mode 100644
index 2153153f527d94e2abb641ea00c80b518ff6c5bd..0000000000000000000000000000000000000000
--- a/spaces/Alycer/VITS-Umamusume-voice-synthesizer/commons.py
+++ /dev/null
@@ -1,97 +0,0 @@
-import math
-import torch
-from torch.nn import functional as F
-import torch.jit
-
-
-def script_method(fn, _rcb=None):
- return fn
-
-
-def script(obj, optimize=True, _frames_up=0, _rcb=None):
- return obj
-
-
-torch.jit.script_method = script_method
-torch.jit.script = script
-
-
-def init_weights(m, mean=0.0, std=0.01):
- classname = m.__class__.__name__
- if classname.find("Conv") != -1:
- m.weight.data.normal_(mean, std)
-
-
-def get_padding(kernel_size, dilation=1):
- return int((kernel_size*dilation - dilation)/2)
-
-
-def intersperse(lst, item):
- result = [item] * (len(lst) * 2 + 1)
- result[1::2] = lst
- return result
-
-
-def slice_segments(x, ids_str, segment_size=4):
- ret = torch.zeros_like(x[:, :, :segment_size])
- for i in range(x.size(0)):
- idx_str = ids_str[i]
- idx_end = idx_str + segment_size
- ret[i] = x[i, :, idx_str:idx_end]
- return ret
-
-
-def rand_slice_segments(x, x_lengths=None, segment_size=4):
- b, d, t = x.size()
- if x_lengths is None:
- x_lengths = t
- ids_str_max = x_lengths - segment_size + 1
- ids_str = (torch.rand([b]).to(device=x.device) * ids_str_max).to(dtype=torch.long)
- ret = slice_segments(x, ids_str, segment_size)
- return ret, ids_str
-
-
-def subsequent_mask(length):
- mask = torch.tril(torch.ones(length, length)).unsqueeze(0).unsqueeze(0)
- return mask
-
-
-@torch.jit.script
-def fused_add_tanh_sigmoid_multiply(input_a, input_b, n_channels):
- n_channels_int = n_channels[0]
- in_act = input_a + input_b
- t_act = torch.tanh(in_act[:, :n_channels_int, :])
- s_act = torch.sigmoid(in_act[:, n_channels_int:, :])
- acts = t_act * s_act
- return acts
-
-
-def convert_pad_shape(pad_shape):
- l = pad_shape[::-1]
- pad_shape = [item for sublist in l for item in sublist]
- return pad_shape
-
-
-def sequence_mask(length, max_length=None):
- if max_length is None:
- max_length = length.max()
- x = torch.arange(max_length, dtype=length.dtype, device=length.device)
- return x.unsqueeze(0) < length.unsqueeze(1)
-
-
-def generate_path(duration, mask):
- """
- duration: [b, 1, t_x]
- mask: [b, 1, t_y, t_x]
- """
- device = duration.device
-
- b, _, t_y, t_x = mask.shape
- cum_duration = torch.cumsum(duration, -1)
-
- cum_duration_flat = cum_duration.view(b * t_x)
- path = sequence_mask(cum_duration_flat, t_y).to(mask.dtype)
- path = path.view(b, t_x, t_y)
- path = path - F.pad(path, convert_pad_shape([[0, 0], [1, 0], [0, 0]]))[:, :-1]
- path = path.unsqueeze(1).transpose(2,3) * mask
- return path
diff --git a/spaces/Amrrs/DragGan-Inversion/stylegan_human/pti/pti_models/e4e/latent_codes_pool.py b/spaces/Amrrs/DragGan-Inversion/stylegan_human/pti/pti_models/e4e/latent_codes_pool.py
deleted file mode 100644
index 626a798a8024e8dced8200038f6d397508ecd7c1..0000000000000000000000000000000000000000
--- a/spaces/Amrrs/DragGan-Inversion/stylegan_human/pti/pti_models/e4e/latent_codes_pool.py
+++ /dev/null
@@ -1,58 +0,0 @@
-import random
-import torch
-
-
-class LatentCodesPool:
- """This class implements latent codes buffer that stores previously generated w latent codes.
- This buffer enables us to update discriminators using a history of generated w's
- rather than the ones produced by the latest encoder.
- """
-
- def __init__(self, pool_size):
- """Initialize the ImagePool class
- Parameters:
- pool_size (int) -- the size of image buffer, if pool_size=0, no buffer will be created
- """
- self.pool_size = pool_size
- if self.pool_size > 0: # create an empty pool
- self.num_ws = 0
- self.ws = []
-
- def query(self, ws):
- """Return w's from the pool.
- Parameters:
- ws: the latest generated w's from the generator
- Returns w's from the buffer.
- By 50/100, the buffer will return input w's.
- By 50/100, the buffer will return w's previously stored in the buffer,
- and insert the current w's to the buffer.
- """
- if self.pool_size == 0: # if the buffer size is 0, do nothing
- return ws
- return_ws = []
- for w in ws: # ws.shape: (batch, 512) or (batch, n_latent, 512)
- # w = torch.unsqueeze(image.data, 0)
- if w.ndim == 2:
- # apply a random latent index as a candidate
- i = random.randint(0, len(w) - 1)
- w = w[i]
- self.handle_w(w, return_ws)
- # collect all the images and return
- return_ws = torch.stack(return_ws, 0)
- return return_ws
-
- def handle_w(self, w, return_ws):
- if self.num_ws < self.pool_size: # if the buffer is not full; keep inserting current codes to the buffer
- self.num_ws = self.num_ws + 1
- self.ws.append(w)
- return_ws.append(w)
- else:
- p = random.uniform(0, 1)
- if p > 0.5: # by 50% chance, the buffer will return a previously stored latent code, and insert the current code into the buffer
- random_id = random.randint(
- 0, self.pool_size - 1) # randint is inclusive
- tmp = self.ws[random_id].clone()
- self.ws[random_id] = w
- return_ws.append(tmp)
- else: # by another 50% chance, the buffer will return the current image
- return_ws.append(w)
diff --git a/spaces/AnTo2209/3D_Zeroshot_Neural_Style_Transfer/src/loop/feature_training_loop.py b/spaces/AnTo2209/3D_Zeroshot_Neural_Style_Transfer/src/loop/feature_training_loop.py
deleted file mode 100644
index 8175043dd40d4c8c0dc158e4800b8ea33616eb90..0000000000000000000000000000000000000000
--- a/spaces/AnTo2209/3D_Zeroshot_Neural_Style_Transfer/src/loop/feature_training_loop.py
+++ /dev/null
@@ -1,145 +0,0 @@
-import numpy as np
-import torch
-from pytorch_lightning.loops import Loop
-
-from src.dataset import DATASET_REGISTRY
-from src.dataset.ray_utils import denormalize_vgg, normalize_vgg
-from src.loop.utils import N_to_reso, cal_n_samples
-from src.model import MODEL_REGISTRY
-from src.sampler.simple_sampler import SimpleSampler, InfiniteSamplerWrapper
-import torch.nn.functional as TF
-
-
-class FeatureTrainingLoop(Loop):
- def __init__(self, epoch, cfg, renderer):
- super().__init__()
- self.cfg = cfg
- self.model = MODEL_REGISTRY.get(self.cfg["model"]["name"])(cfg)
-
- self.dataloader = DATASET_REGISTRY.get(self.cfg["dataset"]["name"])(
- **self.cfg["dataset"]["train"]["params"],
- )
- self.renderer = renderer
- self.optimizer = None
- self.training_sampler = None
- self.frame_sampler = None
- self.iteration = 0
- self.epoch = epoch
- self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
- self.init_loop()
- self.init_optimizer()
-
- def init_loop(self):
- self.white_bg = self.dataloader.white_bg
- self.near_far = self.dataloader.near_far
- self.h_rays, self.w_rays = self.dataloader.img_wh[1], self.dataloader.img_wh[0]
-
- self.step_ratio = self.cfg["sampler"]["params"]["step_ratio"]
- self.batch_size = self.cfg["sampler"]["params"]["batch_size"]
- self.patch_size = self.cfg["sampler"]["params"]["patch_size"]
- self.chunk_size = self.cfg["sampler"]["params"]["chunk_size"]
-
- self.aabb = self.dataloader.scene_bbox.to(self.device)
- reso_cur = N_to_reso(self.cfg["sampler"]["params"]["N_voxel_init"], self.aabb)
- self.nSamples = min(int(self.cfg["sampler"]["params"]["n_samples"]), cal_n_samples(reso_cur, self.step_ratio))
-
- torch.cuda.empty_cache()
- self.dataloader.prepare_feature_data(self.model.tensorf.encoder)
- self.allrays, self.allfeatures = self.dataloader.all_rays, self.dataloader.all_features
- self.allrays_stack, self.allrgbs_stack = self.dataloader.all_rays_stack, self.dataloader.all_rgbs_stack
-
- if not self.model.ndc_ray:
- self.allrays, self.allfeatures = self.model.tensorf.filtering_rays(self.allrays, self.allfeatures, bbox_only=True)
-
- self.training_sampler = SimpleSampler(self.allrays.shape[0], self.batch_size)
- self.frame_sampler = iter(InfiniteSamplerWrapper(self.allrays_stack.size(0))) # every next(sampler) returns a frame index
-
- def init_optimizer(self):
- grad_vars = self.model.tensorf.get_optparam_groups_feature_mod(self.cfg["optimizer"]["lr_init"], self.cfg["optimizer"]["lr_basis"])
-
- if self.cfg["optimizer"]["lr_decay_iters"] > 0:
- self.lr_factor = self.cfg["optimizer"]["lr_decay_target_ratio"] ** (1 / self.cfg["optimizer"]["lr_decay_iters"])
- else:
- self.lr_factor = self.cfg["optimizer"]["lr_decay_target_ratio"] ** (1 / self.cfg["trainer"]["n_iters"])
-
- print("lr decay", self.cfg["optimizer"]["lr_decay_target_ratio"], self.cfg["optimizer"]["lr_decay_iters"])
-
- self.optimizer = torch.optim.Adam(grad_vars, betas=(0.9, 0.99))
-
- @property
- def done(self):
- """Advance from one iteration to the next."""
- return self.epoch < self.iteration
-
- def reset(self):
- """Advance from one iteration to the next."""
-
- def advance(self):
- """Advance from one iteration to the next."""
- feature_loss, pixel_loss = 0., 0.
- if self.iteration % 2 == 0:
- ray_idx = self.training_sampler.nextids()
- rays_train, features_train = self.allrays[ray_idx], self.allfeatures[ray_idx].to(self.device)
-
- feature_map, _ = self.renderer(rays_train, self.model.tensorf, chunk=self.chunk_size, N_samples=self.nSamples, white_bg=self.white_bg,
- ndc_ray=self.model.ndc_ray, render_feature=True, device=self.device, is_train=True)
-
- feature_loss = torch.mean((feature_map - features_train) ** 2)
- else:
- frame_idx = next(self.frame_sampler)
- start_h = np.random.randint(0, self.h_rays - self.patch_size + 1)
- start_w = np.random.randint(0, self.w_rays - self.patch_size + 1)
- if self.white_bg:
- # move random sampled patches into center
- mid_h, mid_w = (self.h_rays - self.patch_size + 1) / 2, (self.w_rays - self.patch_size + 1) / 2
- if mid_h - start_h >= 1:
- start_h += np.random.randint(0, mid_h - start_h)
- elif mid_h - start_h <= -1:
- start_h += np.random.randint(mid_h - start_h, 0)
- if mid_w - start_w >= 1:
- start_w += np.random.randint(0, mid_w - start_w)
- elif mid_w - start_w <= -1:
- start_w += np.random.randint(mid_w - start_w, 0)
-
- rays_train = self.allrays_stack[frame_idx, start_h:start_h + self.patch_size ,
- start_w:start_w + self.patch_size , :].reshape(-1, 6).to(self.device)
- # [patch*patch, 6]
-
- rgbs_train = self.allrgbs_stack[frame_idx, start_h:(start_h + self.patch_size ),
- start_w:(start_w + self.patch_size ), :].to(self.device)
- # [patch, patch, 3]
-
- feature_map, _ = self.renderer(rays_train, self.model.tensorf, chunk=self.chunk_size, N_samples=self.nSamples, white_bg=self.white_bg,
- ndc_ray=self.model.ndc_ray, render_feature=True, device=self.device, is_train=True)
-
- feature_map = feature_map.reshape(self.patch_size , self.patch_size , 256)[None, ...].permute(0, 3, 1, 2)
- recon_rgb = self.model.tensorf.decoder(feature_map)
-
- rgbs_train = rgbs_train[None, ...].permute(0, 3, 1, 2)
- img_enc = self.model.tensorf.encoder(normalize_vgg(rgbs_train))
- recon_rgb_enc = self.model.tensorf.encoder(recon_rgb)
-
- feature_loss = (TF.mse_loss(recon_rgb_enc.relu4_1, img_enc.relu4_1) +
- TF.mse_loss(recon_rgb_enc.relu3_1, img_enc.relu3_1)) / 10
-
- recon_rgb = denormalize_vgg(recon_rgb)
-
- pixel_loss = torch.mean((recon_rgb - rgbs_train) ** 2)
-
- total_loss = pixel_loss + feature_loss
-
- # loss
- # NOTE: Calculate feature TV loss rather than appearence TV loss
- if self.model.TV_weight_feature > 0:
- self.model.TV_weight_feature *= self.lr_factor
- loss_tv = self.model.tensorf.TV_loss_feature(self.model.tvreg) * self.model.TV_weight_feature
- total_loss = total_loss + loss_tv
-
- self.iteration += 1
-
- self.optimizer.zero_grad()
- total_loss.backward()
- self.optimizer.step()
-
-
-
diff --git a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/examples/community/mixture_canvas.py b/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/examples/community/mixture_canvas.py
deleted file mode 100644
index 40139d1139add0bf1c2ca50ca5331ae7c221cbf5..0000000000000000000000000000000000000000
--- a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/examples/community/mixture_canvas.py
+++ /dev/null
@@ -1,503 +0,0 @@
-import re
-from copy import deepcopy
-from dataclasses import asdict, dataclass
-from enum import Enum
-from typing import List, Optional, Union
-
-import numpy as np
-import torch
-from numpy import exp, pi, sqrt
-from torchvision.transforms.functional import resize
-from tqdm.auto import tqdm
-from transformers import CLIPFeatureExtractor, CLIPTextModel, CLIPTokenizer
-
-from diffusers.models import AutoencoderKL, UNet2DConditionModel
-from diffusers.pipeline_utils import DiffusionPipeline
-from diffusers.pipelines.stable_diffusion import StableDiffusionSafetyChecker
-from diffusers.schedulers import DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler
-
-
-def preprocess_image(image):
- from PIL import Image
-
- """Preprocess an input image
-
- Same as
- https://github.com/huggingface/diffusers/blob/1138d63b519e37f0ce04e027b9f4a3261d27c628/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_img2img.py#L44
- """
- w, h = image.size
- w, h = (x - x % 32 for x in (w, h)) # resize to integer multiple of 32
- image = image.resize((w, h), resample=Image.LANCZOS)
- image = np.array(image).astype(np.float32) / 255.0
- image = image[None].transpose(0, 3, 1, 2)
- image = torch.from_numpy(image)
- return 2.0 * image - 1.0
-
-
-@dataclass
-class CanvasRegion:
- """Class defining a rectangular region in the canvas"""
-
- row_init: int # Region starting row in pixel space (included)
- row_end: int # Region end row in pixel space (not included)
- col_init: int # Region starting column in pixel space (included)
- col_end: int # Region end column in pixel space (not included)
- region_seed: int = None # Seed for random operations in this region
- noise_eps: float = 0.0 # Deviation of a zero-mean gaussian noise to be applied over the latents in this region. Useful for slightly "rerolling" latents
-
- def __post_init__(self):
- # Initialize arguments if not specified
- if self.region_seed is None:
- self.region_seed = np.random.randint(9999999999)
- # Check coordinates are non-negative
- for coord in [self.row_init, self.row_end, self.col_init, self.col_end]:
- if coord < 0:
- raise ValueError(
- f"A CanvasRegion must be defined with non-negative indices, found ({self.row_init}, {self.row_end}, {self.col_init}, {self.col_end})"
- )
- # Check coordinates are divisible by 8, else we end up with nasty rounding error when mapping to latent space
- for coord in [self.row_init, self.row_end, self.col_init, self.col_end]:
- if coord // 8 != coord / 8:
- raise ValueError(
- f"A CanvasRegion must be defined with locations divisible by 8, found ({self.row_init}-{self.row_end}, {self.col_init}-{self.col_end})"
- )
- # Check noise eps is non-negative
- if self.noise_eps < 0:
- raise ValueError(f"A CanvasRegion must be defined noises eps non-negative, found {self.noise_eps}")
- # Compute coordinates for this region in latent space
- self.latent_row_init = self.row_init // 8
- self.latent_row_end = self.row_end // 8
- self.latent_col_init = self.col_init // 8
- self.latent_col_end = self.col_end // 8
-
- @property
- def width(self):
- return self.col_end - self.col_init
-
- @property
- def height(self):
- return self.row_end - self.row_init
-
- def get_region_generator(self, device="cpu"):
- """Creates a torch.Generator based on the random seed of this region"""
- # Initialize region generator
- return torch.Generator(device).manual_seed(self.region_seed)
-
- @property
- def __dict__(self):
- return asdict(self)
-
-
-class MaskModes(Enum):
- """Modes in which the influence of diffuser is masked"""
-
- CONSTANT = "constant"
- GAUSSIAN = "gaussian"
- QUARTIC = "quartic" # See https://en.wikipedia.org/wiki/Kernel_(statistics)
-
-
-@dataclass
-class DiffusionRegion(CanvasRegion):
- """Abstract class defining a region where some class of diffusion process is acting"""
-
- pass
-
-
-@dataclass
-class Text2ImageRegion(DiffusionRegion):
- """Class defining a region where a text guided diffusion process is acting"""
-
- prompt: str = "" # Text prompt guiding the diffuser in this region
- guidance_scale: float = 7.5 # Guidance scale of the diffuser in this region. If None, randomize
- mask_type: MaskModes = MaskModes.GAUSSIAN.value # Kind of weight mask applied to this region
- mask_weight: float = 1.0 # Global weights multiplier of the mask
- tokenized_prompt = None # Tokenized prompt
- encoded_prompt = None # Encoded prompt
-
- def __post_init__(self):
- super().__post_init__()
- # Mask weight cannot be negative
- if self.mask_weight < 0:
- raise ValueError(
- f"A Text2ImageRegion must be defined with non-negative mask weight, found {self.mask_weight}"
- )
- # Mask type must be an actual known mask
- if self.mask_type not in [e.value for e in MaskModes]:
- raise ValueError(
- f"A Text2ImageRegion was defined with mask {self.mask_type}, which is not an accepted mask ({[e.value for e in MaskModes]})"
- )
- # Randomize arguments if given as None
- if self.guidance_scale is None:
- self.guidance_scale = np.random.randint(5, 30)
- # Clean prompt
- self.prompt = re.sub(" +", " ", self.prompt).replace("\n", " ")
-
- def tokenize_prompt(self, tokenizer):
- """Tokenizes the prompt for this diffusion region using a given tokenizer"""
- self.tokenized_prompt = tokenizer(
- self.prompt,
- padding="max_length",
- max_length=tokenizer.model_max_length,
- truncation=True,
- return_tensors="pt",
- )
-
- def encode_prompt(self, text_encoder, device):
- """Encodes the previously tokenized prompt for this diffusion region using a given encoder"""
- assert self.tokenized_prompt is not None, ValueError(
- "Prompt in diffusion region must be tokenized before encoding"
- )
- self.encoded_prompt = text_encoder(self.tokenized_prompt.input_ids.to(device))[0]
-
-
-@dataclass
-class Image2ImageRegion(DiffusionRegion):
- """Class defining a region where an image guided diffusion process is acting"""
-
- reference_image: torch.FloatTensor = None
- strength: float = 0.8 # Strength of the image
-
- def __post_init__(self):
- super().__post_init__()
- if self.reference_image is None:
- raise ValueError("Must provide a reference image when creating an Image2ImageRegion")
- if self.strength < 0 or self.strength > 1:
- raise ValueError(f"The value of strength should in [0.0, 1.0] but is {self.strength}")
- # Rescale image to region shape
- self.reference_image = resize(self.reference_image, size=[self.height, self.width])
-
- def encode_reference_image(self, encoder, device, generator, cpu_vae=False):
- """Encodes the reference image for this Image2Image region into the latent space"""
- # Place encoder in CPU or not following the parameter cpu_vae
- if cpu_vae:
- # Note here we use mean instead of sample, to avoid moving also generator to CPU, which is troublesome
- self.reference_latents = encoder.cpu().encode(self.reference_image).latent_dist.mean.to(device)
- else:
- self.reference_latents = encoder.encode(self.reference_image.to(device)).latent_dist.sample(
- generator=generator
- )
- self.reference_latents = 0.18215 * self.reference_latents
-
- @property
- def __dict__(self):
- # This class requires special casting to dict because of the reference_image tensor. Otherwise it cannot be casted to JSON
-
- # Get all basic fields from parent class
- super_fields = {key: getattr(self, key) for key in DiffusionRegion.__dataclass_fields__.keys()}
- # Pack other fields
- return {**super_fields, "reference_image": self.reference_image.cpu().tolist(), "strength": self.strength}
-
-
-class RerollModes(Enum):
- """Modes in which the reroll regions operate"""
-
- RESET = "reset" # Completely reset the random noise in the region
- EPSILON = "epsilon" # Alter slightly the latents in the region
-
-
-@dataclass
-class RerollRegion(CanvasRegion):
- """Class defining a rectangular canvas region in which initial latent noise will be rerolled"""
-
- reroll_mode: RerollModes = RerollModes.RESET.value
-
-
-@dataclass
-class MaskWeightsBuilder:
- """Auxiliary class to compute a tensor of weights for a given diffusion region"""
-
- latent_space_dim: int # Size of the U-net latent space
- nbatch: int = 1 # Batch size in the U-net
-
- def compute_mask_weights(self, region: DiffusionRegion) -> torch.tensor:
- """Computes a tensor of weights for a given diffusion region"""
- MASK_BUILDERS = {
- MaskModes.CONSTANT.value: self._constant_weights,
- MaskModes.GAUSSIAN.value: self._gaussian_weights,
- MaskModes.QUARTIC.value: self._quartic_weights,
- }
- return MASK_BUILDERS[region.mask_type](region)
-
- def _constant_weights(self, region: DiffusionRegion) -> torch.tensor:
- """Computes a tensor of constant for a given diffusion region"""
- latent_width = region.latent_col_end - region.latent_col_init
- latent_height = region.latent_row_end - region.latent_row_init
- return torch.ones(self.nbatch, self.latent_space_dim, latent_height, latent_width) * region.mask_weight
-
- def _gaussian_weights(self, region: DiffusionRegion) -> torch.tensor:
- """Generates a gaussian mask of weights for tile contributions"""
- latent_width = region.latent_col_end - region.latent_col_init
- latent_height = region.latent_row_end - region.latent_row_init
-
- var = 0.01
- midpoint = (latent_width - 1) / 2 # -1 because index goes from 0 to latent_width - 1
- x_probs = [
- exp(-(x - midpoint) * (x - midpoint) / (latent_width * latent_width) / (2 * var)) / sqrt(2 * pi * var)
- for x in range(latent_width)
- ]
- midpoint = (latent_height - 1) / 2
- y_probs = [
- exp(-(y - midpoint) * (y - midpoint) / (latent_height * latent_height) / (2 * var)) / sqrt(2 * pi * var)
- for y in range(latent_height)
- ]
-
- weights = np.outer(y_probs, x_probs) * region.mask_weight
- return torch.tile(torch.tensor(weights), (self.nbatch, self.latent_space_dim, 1, 1))
-
- def _quartic_weights(self, region: DiffusionRegion) -> torch.tensor:
- """Generates a quartic mask of weights for tile contributions
-
- The quartic kernel has bounded support over the diffusion region, and a smooth decay to the region limits.
- """
- quartic_constant = 15.0 / 16.0
-
- support = (np.array(range(region.latent_col_init, region.latent_col_end)) - region.latent_col_init) / (
- region.latent_col_end - region.latent_col_init - 1
- ) * 1.99 - (1.99 / 2.0)
- x_probs = quartic_constant * np.square(1 - np.square(support))
- support = (np.array(range(region.latent_row_init, region.latent_row_end)) - region.latent_row_init) / (
- region.latent_row_end - region.latent_row_init - 1
- ) * 1.99 - (1.99 / 2.0)
- y_probs = quartic_constant * np.square(1 - np.square(support))
-
- weights = np.outer(y_probs, x_probs) * region.mask_weight
- return torch.tile(torch.tensor(weights), (self.nbatch, self.latent_space_dim, 1, 1))
-
-
-class StableDiffusionCanvasPipeline(DiffusionPipeline):
- """Stable Diffusion pipeline that mixes several diffusers in the same canvas"""
-
- def __init__(
- self,
- vae: AutoencoderKL,
- text_encoder: CLIPTextModel,
- tokenizer: CLIPTokenizer,
- unet: UNet2DConditionModel,
- scheduler: Union[DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler],
- safety_checker: StableDiffusionSafetyChecker,
- feature_extractor: CLIPFeatureExtractor,
- ):
- super().__init__()
- self.register_modules(
- vae=vae,
- text_encoder=text_encoder,
- tokenizer=tokenizer,
- unet=unet,
- scheduler=scheduler,
- safety_checker=safety_checker,
- feature_extractor=feature_extractor,
- )
-
- def decode_latents(self, latents, cpu_vae=False):
- """Decodes a given array of latents into pixel space"""
- # scale and decode the image latents with vae
- if cpu_vae:
- lat = deepcopy(latents).cpu()
- vae = deepcopy(self.vae).cpu()
- else:
- lat = latents
- vae = self.vae
-
- lat = 1 / 0.18215 * lat
- image = vae.decode(lat).sample
-
- image = (image / 2 + 0.5).clamp(0, 1)
- image = image.cpu().permute(0, 2, 3, 1).numpy()
-
- return self.numpy_to_pil(image)
-
- def get_latest_timestep_img2img(self, num_inference_steps, strength):
- """Finds the latest timesteps where an img2img strength does not impose latents anymore"""
- # get the original timestep using init_timestep
- offset = self.scheduler.config.get("steps_offset", 0)
- init_timestep = int(num_inference_steps * (1 - strength)) + offset
- init_timestep = min(init_timestep, num_inference_steps)
-
- t_start = min(max(num_inference_steps - init_timestep + offset, 0), num_inference_steps - 1)
- latest_timestep = self.scheduler.timesteps[t_start]
-
- return latest_timestep
-
- @torch.no_grad()
- def __call__(
- self,
- canvas_height: int,
- canvas_width: int,
- regions: List[DiffusionRegion],
- num_inference_steps: Optional[int] = 50,
- seed: Optional[int] = 12345,
- reroll_regions: Optional[List[RerollRegion]] = None,
- cpu_vae: Optional[bool] = False,
- decode_steps: Optional[bool] = False,
- ):
- if reroll_regions is None:
- reroll_regions = []
- batch_size = 1
-
- if decode_steps:
- steps_images = []
-
- # Prepare scheduler
- self.scheduler.set_timesteps(num_inference_steps, device=self.device)
-
- # Split diffusion regions by their kind
- text2image_regions = [region for region in regions if isinstance(region, Text2ImageRegion)]
- image2image_regions = [region for region in regions if isinstance(region, Image2ImageRegion)]
-
- # Prepare text embeddings
- for region in text2image_regions:
- region.tokenize_prompt(self.tokenizer)
- region.encode_prompt(self.text_encoder, self.device)
-
- # Create original noisy latents using the timesteps
- latents_shape = (batch_size, self.unet.config.in_channels, canvas_height // 8, canvas_width // 8)
- generator = torch.Generator(self.device).manual_seed(seed)
- init_noise = torch.randn(latents_shape, generator=generator, device=self.device)
-
- # Reset latents in seed reroll regions, if requested
- for region in reroll_regions:
- if region.reroll_mode == RerollModes.RESET.value:
- region_shape = (
- latents_shape[0],
- latents_shape[1],
- region.latent_row_end - region.latent_row_init,
- region.latent_col_end - region.latent_col_init,
- )
- init_noise[
- :,
- :,
- region.latent_row_init : region.latent_row_end,
- region.latent_col_init : region.latent_col_end,
- ] = torch.randn(region_shape, generator=region.get_region_generator(self.device), device=self.device)
-
- # Apply epsilon noise to regions: first diffusion regions, then reroll regions
- all_eps_rerolls = regions + [r for r in reroll_regions if r.reroll_mode == RerollModes.EPSILON.value]
- for region in all_eps_rerolls:
- if region.noise_eps > 0:
- region_noise = init_noise[
- :,
- :,
- region.latent_row_init : region.latent_row_end,
- region.latent_col_init : region.latent_col_end,
- ]
- eps_noise = (
- torch.randn(
- region_noise.shape, generator=region.get_region_generator(self.device), device=self.device
- )
- * region.noise_eps
- )
- init_noise[
- :,
- :,
- region.latent_row_init : region.latent_row_end,
- region.latent_col_init : region.latent_col_end,
- ] += eps_noise
-
- # scale the initial noise by the standard deviation required by the scheduler
- latents = init_noise * self.scheduler.init_noise_sigma
-
- # Get unconditional embeddings for classifier free guidance in text2image regions
- for region in text2image_regions:
- max_length = region.tokenized_prompt.input_ids.shape[-1]
- uncond_input = self.tokenizer(
- [""] * batch_size, padding="max_length", max_length=max_length, return_tensors="pt"
- )
- uncond_embeddings = self.text_encoder(uncond_input.input_ids.to(self.device))[0]
-
- # For classifier free guidance, we need to do two forward passes.
- # Here we concatenate the unconditional and text embeddings into a single batch
- # to avoid doing two forward passes
- region.encoded_prompt = torch.cat([uncond_embeddings, region.encoded_prompt])
-
- # Prepare image latents
- for region in image2image_regions:
- region.encode_reference_image(self.vae, device=self.device, generator=generator)
-
- # Prepare mask of weights for each region
- mask_builder = MaskWeightsBuilder(latent_space_dim=self.unet.config.in_channels, nbatch=batch_size)
- mask_weights = [mask_builder.compute_mask_weights(region).to(self.device) for region in text2image_regions]
-
- # Diffusion timesteps
- for i, t in tqdm(enumerate(self.scheduler.timesteps)):
- # Diffuse each region
- noise_preds_regions = []
-
- # text2image regions
- for region in text2image_regions:
- region_latents = latents[
- :,
- :,
- region.latent_row_init : region.latent_row_end,
- region.latent_col_init : region.latent_col_end,
- ]
- # expand the latents if we are doing classifier free guidance
- latent_model_input = torch.cat([region_latents] * 2)
- # scale model input following scheduler rules
- latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)
- # predict the noise residual
- noise_pred = self.unet(latent_model_input, t, encoder_hidden_states=region.encoded_prompt)["sample"]
- # perform guidance
- noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
- noise_pred_region = noise_pred_uncond + region.guidance_scale * (noise_pred_text - noise_pred_uncond)
- noise_preds_regions.append(noise_pred_region)
-
- # Merge noise predictions for all tiles
- noise_pred = torch.zeros(latents.shape, device=self.device)
- contributors = torch.zeros(latents.shape, device=self.device)
- # Add each tile contribution to overall latents
- for region, noise_pred_region, mask_weights_region in zip(
- text2image_regions, noise_preds_regions, mask_weights
- ):
- noise_pred[
- :,
- :,
- region.latent_row_init : region.latent_row_end,
- region.latent_col_init : region.latent_col_end,
- ] += (
- noise_pred_region * mask_weights_region
- )
- contributors[
- :,
- :,
- region.latent_row_init : region.latent_row_end,
- region.latent_col_init : region.latent_col_end,
- ] += mask_weights_region
- # Average overlapping areas with more than 1 contributor
- noise_pred /= contributors
- noise_pred = torch.nan_to_num(
- noise_pred
- ) # Replace NaNs by zeros: NaN can appear if a position is not covered by any DiffusionRegion
-
- # compute the previous noisy sample x_t -> x_t-1
- latents = self.scheduler.step(noise_pred, t, latents).prev_sample
-
- # Image2Image regions: override latents generated by the scheduler
- for region in image2image_regions:
- influence_step = self.get_latest_timestep_img2img(num_inference_steps, region.strength)
- # Only override in the timesteps before the last influence step of the image (given by its strength)
- if t > influence_step:
- timestep = t.repeat(batch_size)
- region_init_noise = init_noise[
- :,
- :,
- region.latent_row_init : region.latent_row_end,
- region.latent_col_init : region.latent_col_end,
- ]
- region_latents = self.scheduler.add_noise(region.reference_latents, region_init_noise, timestep)
- latents[
- :,
- :,
- region.latent_row_init : region.latent_row_end,
- region.latent_col_init : region.latent_col_end,
- ] = region_latents
-
- if decode_steps:
- steps_images.append(self.decode_latents(latents, cpu_vae))
-
- # scale and decode the image latents with vae
- image = self.decode_latents(latents, cpu_vae)
-
- output = {"images": image}
- if decode_steps:
- output = {**output, "steps_images": steps_images}
- return output
diff --git a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/tests/pipelines/unclip/test_unclip_image_variation.py b/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/tests/pipelines/unclip/test_unclip_image_variation.py
deleted file mode 100644
index 75a26250807b3728989b1e70e70917f0d0987044..0000000000000000000000000000000000000000
--- a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/tests/pipelines/unclip/test_unclip_image_variation.py
+++ /dev/null
@@ -1,522 +0,0 @@
-# coding=utf-8
-# Copyright 2023 HuggingFace Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import gc
-import random
-import unittest
-
-import numpy as np
-import torch
-from transformers import (
- CLIPImageProcessor,
- CLIPTextConfig,
- CLIPTextModelWithProjection,
- CLIPTokenizer,
- CLIPVisionConfig,
- CLIPVisionModelWithProjection,
-)
-
-from diffusers import (
- DiffusionPipeline,
- UnCLIPImageVariationPipeline,
- UnCLIPScheduler,
- UNet2DConditionModel,
- UNet2DModel,
-)
-from diffusers.pipelines.unclip.text_proj import UnCLIPTextProjModel
-from diffusers.utils import floats_tensor, load_numpy, slow, torch_device
-from diffusers.utils.testing_utils import enable_full_determinism, load_image, require_torch_gpu, skip_mps
-
-from ..pipeline_params import IMAGE_VARIATION_BATCH_PARAMS, IMAGE_VARIATION_PARAMS
-from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference
-
-
-enable_full_determinism()
-
-
-class UnCLIPImageVariationPipelineFastTests(PipelineTesterMixin, unittest.TestCase):
- pipeline_class = UnCLIPImageVariationPipeline
- params = IMAGE_VARIATION_PARAMS - {"height", "width", "guidance_scale"}
- batch_params = IMAGE_VARIATION_BATCH_PARAMS
-
- required_optional_params = [
- "generator",
- "return_dict",
- "decoder_num_inference_steps",
- "super_res_num_inference_steps",
- ]
- test_xformers_attention = False
-
- @property
- def text_embedder_hidden_size(self):
- return 32
-
- @property
- def time_input_dim(self):
- return 32
-
- @property
- def block_out_channels_0(self):
- return self.time_input_dim
-
- @property
- def time_embed_dim(self):
- return self.time_input_dim * 4
-
- @property
- def cross_attention_dim(self):
- return 100
-
- @property
- def dummy_tokenizer(self):
- tokenizer = CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip")
- return tokenizer
-
- @property
- def dummy_text_encoder(self):
- torch.manual_seed(0)
- config = CLIPTextConfig(
- bos_token_id=0,
- eos_token_id=2,
- hidden_size=self.text_embedder_hidden_size,
- projection_dim=self.text_embedder_hidden_size,
- intermediate_size=37,
- layer_norm_eps=1e-05,
- num_attention_heads=4,
- num_hidden_layers=5,
- pad_token_id=1,
- vocab_size=1000,
- )
- return CLIPTextModelWithProjection(config)
-
- @property
- def dummy_image_encoder(self):
- torch.manual_seed(0)
- config = CLIPVisionConfig(
- hidden_size=self.text_embedder_hidden_size,
- projection_dim=self.text_embedder_hidden_size,
- num_hidden_layers=5,
- num_attention_heads=4,
- image_size=32,
- intermediate_size=37,
- patch_size=1,
- )
- return CLIPVisionModelWithProjection(config)
-
- @property
- def dummy_text_proj(self):
- torch.manual_seed(0)
-
- model_kwargs = {
- "clip_embeddings_dim": self.text_embedder_hidden_size,
- "time_embed_dim": self.time_embed_dim,
- "cross_attention_dim": self.cross_attention_dim,
- }
-
- model = UnCLIPTextProjModel(**model_kwargs)
- return model
-
- @property
- def dummy_decoder(self):
- torch.manual_seed(0)
-
- model_kwargs = {
- "sample_size": 32,
- # RGB in channels
- "in_channels": 3,
- # Out channels is double in channels because predicts mean and variance
- "out_channels": 6,
- "down_block_types": ("ResnetDownsampleBlock2D", "SimpleCrossAttnDownBlock2D"),
- "up_block_types": ("SimpleCrossAttnUpBlock2D", "ResnetUpsampleBlock2D"),
- "mid_block_type": "UNetMidBlock2DSimpleCrossAttn",
- "block_out_channels": (self.block_out_channels_0, self.block_out_channels_0 * 2),
- "layers_per_block": 1,
- "cross_attention_dim": self.cross_attention_dim,
- "attention_head_dim": 4,
- "resnet_time_scale_shift": "scale_shift",
- "class_embed_type": "identity",
- }
-
- model = UNet2DConditionModel(**model_kwargs)
- return model
-
- @property
- def dummy_super_res_kwargs(self):
- return {
- "sample_size": 64,
- "layers_per_block": 1,
- "down_block_types": ("ResnetDownsampleBlock2D", "ResnetDownsampleBlock2D"),
- "up_block_types": ("ResnetUpsampleBlock2D", "ResnetUpsampleBlock2D"),
- "block_out_channels": (self.block_out_channels_0, self.block_out_channels_0 * 2),
- "in_channels": 6,
- "out_channels": 3,
- }
-
- @property
- def dummy_super_res_first(self):
- torch.manual_seed(0)
-
- model = UNet2DModel(**self.dummy_super_res_kwargs)
- return model
-
- @property
- def dummy_super_res_last(self):
- # seeded differently to get different unet than `self.dummy_super_res_first`
- torch.manual_seed(1)
-
- model = UNet2DModel(**self.dummy_super_res_kwargs)
- return model
-
- def get_dummy_components(self):
- decoder = self.dummy_decoder
- text_proj = self.dummy_text_proj
- text_encoder = self.dummy_text_encoder
- tokenizer = self.dummy_tokenizer
- super_res_first = self.dummy_super_res_first
- super_res_last = self.dummy_super_res_last
-
- decoder_scheduler = UnCLIPScheduler(
- variance_type="learned_range",
- prediction_type="epsilon",
- num_train_timesteps=1000,
- )
-
- super_res_scheduler = UnCLIPScheduler(
- variance_type="fixed_small_log",
- prediction_type="epsilon",
- num_train_timesteps=1000,
- )
-
- feature_extractor = CLIPImageProcessor(crop_size=32, size=32)
-
- image_encoder = self.dummy_image_encoder
-
- return {
- "decoder": decoder,
- "text_encoder": text_encoder,
- "tokenizer": tokenizer,
- "text_proj": text_proj,
- "feature_extractor": feature_extractor,
- "image_encoder": image_encoder,
- "super_res_first": super_res_first,
- "super_res_last": super_res_last,
- "decoder_scheduler": decoder_scheduler,
- "super_res_scheduler": super_res_scheduler,
- }
-
- def get_dummy_inputs(self, device, seed=0, pil_image=True):
- input_image = floats_tensor((1, 3, 32, 32), rng=random.Random(seed)).to(device)
- if str(device).startswith("mps"):
- generator = torch.manual_seed(seed)
- else:
- generator = torch.Generator(device=device).manual_seed(seed)
-
- if pil_image:
- input_image = input_image * 0.5 + 0.5
- input_image = input_image.clamp(0, 1)
- input_image = input_image.cpu().permute(0, 2, 3, 1).float().numpy()
- input_image = DiffusionPipeline.numpy_to_pil(input_image)[0]
-
- return {
- "image": input_image,
- "generator": generator,
- "decoder_num_inference_steps": 2,
- "super_res_num_inference_steps": 2,
- "output_type": "np",
- }
-
- def test_unclip_image_variation_input_tensor(self):
- device = "cpu"
-
- components = self.get_dummy_components()
-
- pipe = self.pipeline_class(**components)
- pipe = pipe.to(device)
-
- pipe.set_progress_bar_config(disable=None)
-
- pipeline_inputs = self.get_dummy_inputs(device, pil_image=False)
-
- output = pipe(**pipeline_inputs)
- image = output.images
-
- tuple_pipeline_inputs = self.get_dummy_inputs(device, pil_image=False)
-
- image_from_tuple = pipe(
- **tuple_pipeline_inputs,
- return_dict=False,
- )[0]
-
- image_slice = image[0, -3:, -3:, -1]
- image_from_tuple_slice = image_from_tuple[0, -3:, -3:, -1]
-
- assert image.shape == (1, 64, 64, 3)
-
- expected_slice = np.array(
- [
- 0.9997,
- 0.0002,
- 0.9997,
- 0.9997,
- 0.9969,
- 0.0023,
- 0.9997,
- 0.9969,
- 0.9970,
- ]
- )
-
- assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-2
- assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 1e-2
-
- def test_unclip_image_variation_input_image(self):
- device = "cpu"
-
- components = self.get_dummy_components()
-
- pipe = self.pipeline_class(**components)
- pipe = pipe.to(device)
-
- pipe.set_progress_bar_config(disable=None)
-
- pipeline_inputs = self.get_dummy_inputs(device, pil_image=True)
-
- output = pipe(**pipeline_inputs)
- image = output.images
-
- tuple_pipeline_inputs = self.get_dummy_inputs(device, pil_image=True)
-
- image_from_tuple = pipe(
- **tuple_pipeline_inputs,
- return_dict=False,
- )[0]
-
- image_slice = image[0, -3:, -3:, -1]
- image_from_tuple_slice = image_from_tuple[0, -3:, -3:, -1]
-
- assert image.shape == (1, 64, 64, 3)
-
- expected_slice = np.array([0.9997, 0.0003, 0.9997, 0.9997, 0.9970, 0.0024, 0.9997, 0.9971, 0.9971])
-
- assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-2
- assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 1e-2
-
- def test_unclip_image_variation_input_list_images(self):
- device = "cpu"
-
- components = self.get_dummy_components()
-
- pipe = self.pipeline_class(**components)
- pipe = pipe.to(device)
-
- pipe.set_progress_bar_config(disable=None)
-
- pipeline_inputs = self.get_dummy_inputs(device, pil_image=True)
- pipeline_inputs["image"] = [
- pipeline_inputs["image"],
- pipeline_inputs["image"],
- ]
-
- output = pipe(**pipeline_inputs)
- image = output.images
-
- tuple_pipeline_inputs = self.get_dummy_inputs(device, pil_image=True)
- tuple_pipeline_inputs["image"] = [
- tuple_pipeline_inputs["image"],
- tuple_pipeline_inputs["image"],
- ]
-
- image_from_tuple = pipe(
- **tuple_pipeline_inputs,
- return_dict=False,
- )[0]
-
- image_slice = image[0, -3:, -3:, -1]
- image_from_tuple_slice = image_from_tuple[0, -3:, -3:, -1]
-
- assert image.shape == (2, 64, 64, 3)
-
- expected_slice = np.array(
- [
- 0.9997,
- 0.9989,
- 0.0008,
- 0.0021,
- 0.9960,
- 0.0018,
- 0.0014,
- 0.0002,
- 0.9933,
- ]
- )
-
- assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-2
- assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 1e-2
-
- def test_unclip_passed_image_embed(self):
- device = torch.device("cpu")
-
- class DummyScheduler:
- init_noise_sigma = 1
-
- components = self.get_dummy_components()
-
- pipe = self.pipeline_class(**components)
- pipe = pipe.to(device)
-
- pipe.set_progress_bar_config(disable=None)
-
- generator = torch.Generator(device=device).manual_seed(0)
- dtype = pipe.decoder.dtype
- batch_size = 1
-
- shape = (
- batch_size,
- pipe.decoder.config.in_channels,
- pipe.decoder.config.sample_size,
- pipe.decoder.config.sample_size,
- )
- decoder_latents = pipe.prepare_latents(
- shape, dtype=dtype, device=device, generator=generator, latents=None, scheduler=DummyScheduler()
- )
-
- shape = (
- batch_size,
- pipe.super_res_first.config.in_channels // 2,
- pipe.super_res_first.config.sample_size,
- pipe.super_res_first.config.sample_size,
- )
- super_res_latents = pipe.prepare_latents(
- shape, dtype=dtype, device=device, generator=generator, latents=None, scheduler=DummyScheduler()
- )
-
- pipeline_inputs = self.get_dummy_inputs(device, pil_image=False)
-
- img_out_1 = pipe(
- **pipeline_inputs, decoder_latents=decoder_latents, super_res_latents=super_res_latents
- ).images
-
- pipeline_inputs = self.get_dummy_inputs(device, pil_image=False)
- # Don't pass image, instead pass embedding
- image = pipeline_inputs.pop("image")
- image_embeddings = pipe.image_encoder(image).image_embeds
-
- img_out_2 = pipe(
- **pipeline_inputs,
- decoder_latents=decoder_latents,
- super_res_latents=super_res_latents,
- image_embeddings=image_embeddings,
- ).images
-
- # make sure passing text embeddings manually is identical
- assert np.abs(img_out_1 - img_out_2).max() < 1e-4
-
- # Overriding PipelineTesterMixin::test_attention_slicing_forward_pass
- # because UnCLIP GPU undeterminism requires a looser check.
- @skip_mps
- def test_attention_slicing_forward_pass(self):
- test_max_difference = torch_device == "cpu"
-
- # Check is relaxed because there is not a torch 2.0 sliced attention added kv processor
- expected_max_diff = 1e-2
-
- self._test_attention_slicing_forward_pass(
- test_max_difference=test_max_difference, expected_max_diff=expected_max_diff
- )
-
- # Overriding PipelineTesterMixin::test_inference_batch_single_identical
- # because UnCLIP undeterminism requires a looser check.
- @skip_mps
- def test_inference_batch_single_identical(self):
- test_max_difference = torch_device == "cpu"
- relax_max_difference = True
- additional_params_copy_to_batched_inputs = [
- "decoder_num_inference_steps",
- "super_res_num_inference_steps",
- ]
-
- self._test_inference_batch_single_identical(
- test_max_difference=test_max_difference,
- relax_max_difference=relax_max_difference,
- additional_params_copy_to_batched_inputs=additional_params_copy_to_batched_inputs,
- )
-
- def test_inference_batch_consistent(self):
- additional_params_copy_to_batched_inputs = [
- "decoder_num_inference_steps",
- "super_res_num_inference_steps",
- ]
-
- if torch_device == "mps":
- # TODO: MPS errors with larger batch sizes
- batch_sizes = [2, 3]
- self._test_inference_batch_consistent(
- batch_sizes=batch_sizes,
- additional_params_copy_to_batched_inputs=additional_params_copy_to_batched_inputs,
- )
- else:
- self._test_inference_batch_consistent(
- additional_params_copy_to_batched_inputs=additional_params_copy_to_batched_inputs
- )
-
- @skip_mps
- def test_dict_tuple_outputs_equivalent(self):
- return super().test_dict_tuple_outputs_equivalent()
-
- @skip_mps
- def test_save_load_local(self):
- return super().test_save_load_local()
-
- @skip_mps
- def test_save_load_optional_components(self):
- return super().test_save_load_optional_components()
-
-
-@slow
-@require_torch_gpu
-class UnCLIPImageVariationPipelineIntegrationTests(unittest.TestCase):
- def tearDown(self):
- # clean up the VRAM after each test
- super().tearDown()
- gc.collect()
- torch.cuda.empty_cache()
-
- def test_unclip_image_variation_karlo(self):
- input_image = load_image(
- "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/unclip/cat.png"
- )
- expected_image = load_numpy(
- "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
- "/unclip/karlo_v1_alpha_cat_variation_fp16.npy"
- )
-
- pipeline = UnCLIPImageVariationPipeline.from_pretrained(
- "kakaobrain/karlo-v1-alpha-image-variations", torch_dtype=torch.float16
- )
- pipeline = pipeline.to(torch_device)
- pipeline.set_progress_bar_config(disable=None)
-
- generator = torch.Generator(device="cpu").manual_seed(0)
- output = pipeline(
- input_image,
- generator=generator,
- output_type="np",
- )
-
- image = output.images[0]
-
- assert image.shape == (256, 256, 3)
-
- assert_mean_pixel_difference(image, expected_image, 15)
diff --git a/spaces/Andy1621/uniformer_image_detection/configs/_base_/models/retinanet_r50_fpn.py b/spaces/Andy1621/uniformer_image_detection/configs/_base_/models/retinanet_r50_fpn.py
deleted file mode 100644
index 47fe98c2e9e934cf82a7e20835eea8e2bd9bb065..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_detection/configs/_base_/models/retinanet_r50_fpn.py
+++ /dev/null
@@ -1,60 +0,0 @@
-# model settings
-model = dict(
- type='RetinaNet',
- pretrained='torchvision://resnet50',
- backbone=dict(
- type='ResNet',
- depth=50,
- num_stages=4,
- out_indices=(0, 1, 2, 3),
- frozen_stages=1,
- norm_cfg=dict(type='BN', requires_grad=True),
- norm_eval=True,
- style='pytorch'),
- neck=dict(
- type='FPN',
- in_channels=[256, 512, 1024, 2048],
- out_channels=256,
- start_level=1,
- add_extra_convs='on_input',
- num_outs=5),
- bbox_head=dict(
- type='RetinaHead',
- num_classes=80,
- in_channels=256,
- stacked_convs=4,
- feat_channels=256,
- anchor_generator=dict(
- type='AnchorGenerator',
- octave_base_scale=4,
- scales_per_octave=3,
- ratios=[0.5, 1.0, 2.0],
- strides=[8, 16, 32, 64, 128]),
- bbox_coder=dict(
- type='DeltaXYWHBBoxCoder',
- target_means=[.0, .0, .0, .0],
- target_stds=[1.0, 1.0, 1.0, 1.0]),
- loss_cls=dict(
- type='FocalLoss',
- use_sigmoid=True,
- gamma=2.0,
- alpha=0.25,
- loss_weight=1.0),
- loss_bbox=dict(type='L1Loss', loss_weight=1.0)),
- # training and testing settings
- train_cfg=dict(
- assigner=dict(
- type='MaxIoUAssigner',
- pos_iou_thr=0.5,
- neg_iou_thr=0.4,
- min_pos_iou=0,
- ignore_iof_thr=-1),
- allowed_border=-1,
- pos_weight=-1,
- debug=False),
- test_cfg=dict(
- nms_pre=1000,
- min_bbox_size=0,
- score_thr=0.05,
- nms=dict(type='nms', iou_threshold=0.5),
- max_per_img=100))
diff --git a/spaces/Andy1621/uniformer_image_detection/configs/foveabox/fovea_r50_fpn_4x4_1x_coco.py b/spaces/Andy1621/uniformer_image_detection/configs/foveabox/fovea_r50_fpn_4x4_1x_coco.py
deleted file mode 100644
index fd392570142f83f34fed50ebc5037c8bd92d95fc..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_detection/configs/foveabox/fovea_r50_fpn_4x4_1x_coco.py
+++ /dev/null
@@ -1,52 +0,0 @@
-_base_ = [
- '../_base_/datasets/coco_detection.py',
- '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py'
-]
-# model settings
-model = dict(
- type='FOVEA',
- pretrained='torchvision://resnet50',
- backbone=dict(
- type='ResNet',
- depth=50,
- num_stages=4,
- out_indices=(0, 1, 2, 3),
- frozen_stages=1,
- norm_cfg=dict(type='BN', requires_grad=True),
- norm_eval=True,
- style='pytorch'),
- neck=dict(
- type='FPN',
- in_channels=[256, 512, 1024, 2048],
- out_channels=256,
- start_level=1,
- num_outs=5,
- add_extra_convs='on_input'),
- bbox_head=dict(
- type='FoveaHead',
- num_classes=80,
- in_channels=256,
- stacked_convs=4,
- feat_channels=256,
- strides=[8, 16, 32, 64, 128],
- base_edge_list=[16, 32, 64, 128, 256],
- scale_ranges=((1, 64), (32, 128), (64, 256), (128, 512), (256, 2048)),
- sigma=0.4,
- with_deform=False,
- loss_cls=dict(
- type='FocalLoss',
- use_sigmoid=True,
- gamma=1.50,
- alpha=0.4,
- loss_weight=1.0),
- loss_bbox=dict(type='SmoothL1Loss', beta=0.11, loss_weight=1.0)),
- # training and testing settings
- train_cfg=dict(),
- test_cfg=dict(
- nms_pre=1000,
- score_thr=0.05,
- nms=dict(type='nms', iou_threshold=0.5),
- max_per_img=100))
-data = dict(samples_per_gpu=4, workers_per_gpu=4)
-# optimizer
-optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)
diff --git a/spaces/Andy1621/uniformer_image_detection/configs/gn+ws/faster_rcnn_x101_32x4d_fpn_gn_ws-all_1x_coco.py b/spaces/Andy1621/uniformer_image_detection/configs/gn+ws/faster_rcnn_x101_32x4d_fpn_gn_ws-all_1x_coco.py
deleted file mode 100644
index 061ca6993606fe2c7bdb020eaf3b5ea8b91a9b8e..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_detection/configs/gn+ws/faster_rcnn_x101_32x4d_fpn_gn_ws-all_1x_coco.py
+++ /dev/null
@@ -1,16 +0,0 @@
-_base_ = './faster_rcnn_r50_fpn_gn_ws-all_1x_coco.py'
-conv_cfg = dict(type='ConvWS')
-norm_cfg = dict(type='GN', num_groups=32, requires_grad=True)
-model = dict(
- pretrained='open-mmlab://jhu/resnext101_32x4d_gn_ws',
- backbone=dict(
- type='ResNeXt',
- depth=101,
- groups=32,
- base_width=4,
- num_stages=4,
- out_indices=(0, 1, 2, 3),
- frozen_stages=1,
- style='pytorch',
- conv_cfg=conv_cfg,
- norm_cfg=norm_cfg))
diff --git a/spaces/Andy1621/uniformer_image_detection/configs/instaboost/cascade_mask_rcnn_r50_fpn_instaboost_4x_coco.py b/spaces/Andy1621/uniformer_image_detection/configs/instaboost/cascade_mask_rcnn_r50_fpn_instaboost_4x_coco.py
deleted file mode 100644
index a89a81f5c76586d6d1b15abf74f3740e9f439762..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_detection/configs/instaboost/cascade_mask_rcnn_r50_fpn_instaboost_4x_coco.py
+++ /dev/null
@@ -1,28 +0,0 @@
-_base_ = '../cascade_rcnn/cascade_mask_rcnn_r50_fpn_1x_coco.py'
-img_norm_cfg = dict(
- mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
-train_pipeline = [
- dict(type='LoadImageFromFile'),
- dict(
- type='InstaBoost',
- action_candidate=('normal', 'horizontal', 'skip'),
- action_prob=(1, 0, 0),
- scale=(0.8, 1.2),
- dx=15,
- dy=15,
- theta=(-1, 1),
- color_prob=0.5,
- hflag=False,
- aug_ratio=0.5),
- dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
- dict(type='Resize', img_scale=(1333, 800), keep_ratio=True),
- dict(type='RandomFlip', flip_ratio=0.5),
- dict(type='Normalize', **img_norm_cfg),
- dict(type='Pad', size_divisor=32),
- dict(type='DefaultFormatBundle'),
- dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels', 'gt_masks']),
-]
-data = dict(train=dict(pipeline=train_pipeline))
-# learning policy
-lr_config = dict(step=[32, 44])
-runner = dict(type='EpochBasedRunner', max_epochs=48)
diff --git a/spaces/Andy1621/uniformer_image_segmentation/configs/psanet/psanet_r50-d8_512x512_160k_ade20k.py b/spaces/Andy1621/uniformer_image_segmentation/configs/psanet/psanet_r50-d8_512x512_160k_ade20k.py
deleted file mode 100644
index 9c6364eb43e2abc95011205b569627ff9367d0e5..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_segmentation/configs/psanet/psanet_r50-d8_512x512_160k_ade20k.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
- '../_base_/models/psanet_r50-d8.py', '../_base_/datasets/ade20k.py',
- '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
-]
-model = dict(
- decode_head=dict(mask_size=(66, 66), num_classes=150),
- auxiliary_head=dict(num_classes=150))
diff --git a/spaces/Anonymous-sub/Rerender/ControlNet/annotator/uniformer/mmcv/ops/roi_align_rotated.py b/spaces/Anonymous-sub/Rerender/ControlNet/annotator/uniformer/mmcv/ops/roi_align_rotated.py
deleted file mode 100644
index 0ce4961a3555d4da8bc3e32f1f7d5ad50036587d..0000000000000000000000000000000000000000
--- a/spaces/Anonymous-sub/Rerender/ControlNet/annotator/uniformer/mmcv/ops/roi_align_rotated.py
+++ /dev/null
@@ -1,177 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch.nn as nn
-from torch.autograd import Function
-
-from ..utils import ext_loader
-
-ext_module = ext_loader.load_ext(
- '_ext', ['roi_align_rotated_forward', 'roi_align_rotated_backward'])
-
-
-class RoIAlignRotatedFunction(Function):
-
- @staticmethod
- def symbolic(g, features, rois, out_size, spatial_scale, sample_num,
- aligned, clockwise):
- if isinstance(out_size, int):
- out_h = out_size
- out_w = out_size
- elif isinstance(out_size, tuple):
- assert len(out_size) == 2
- assert isinstance(out_size[0], int)
- assert isinstance(out_size[1], int)
- out_h, out_w = out_size
- else:
- raise TypeError(
- '"out_size" must be an integer or tuple of integers')
- return g.op(
- 'mmcv::MMCVRoIAlignRotated',
- features,
- rois,
- output_height_i=out_h,
- output_width_i=out_h,
- spatial_scale_f=spatial_scale,
- sampling_ratio_i=sample_num,
- aligned_i=aligned,
- clockwise_i=clockwise)
-
- @staticmethod
- def forward(ctx,
- features,
- rois,
- out_size,
- spatial_scale,
- sample_num=0,
- aligned=True,
- clockwise=False):
- if isinstance(out_size, int):
- out_h = out_size
- out_w = out_size
- elif isinstance(out_size, tuple):
- assert len(out_size) == 2
- assert isinstance(out_size[0], int)
- assert isinstance(out_size[1], int)
- out_h, out_w = out_size
- else:
- raise TypeError(
- '"out_size" must be an integer or tuple of integers')
- ctx.spatial_scale = spatial_scale
- ctx.sample_num = sample_num
- ctx.aligned = aligned
- ctx.clockwise = clockwise
- ctx.save_for_backward(rois)
- ctx.feature_size = features.size()
-
- batch_size, num_channels, data_height, data_width = features.size()
- num_rois = rois.size(0)
-
- output = features.new_zeros(num_rois, num_channels, out_h, out_w)
- ext_module.roi_align_rotated_forward(
- features,
- rois,
- output,
- pooled_height=out_h,
- pooled_width=out_w,
- spatial_scale=spatial_scale,
- sample_num=sample_num,
- aligned=aligned,
- clockwise=clockwise)
- return output
-
- @staticmethod
- def backward(ctx, grad_output):
- feature_size = ctx.feature_size
- spatial_scale = ctx.spatial_scale
- aligned = ctx.aligned
- clockwise = ctx.clockwise
- sample_num = ctx.sample_num
- rois = ctx.saved_tensors[0]
- assert feature_size is not None
- batch_size, num_channels, data_height, data_width = feature_size
-
- out_w = grad_output.size(3)
- out_h = grad_output.size(2)
-
- grad_input = grad_rois = None
-
- if ctx.needs_input_grad[0]:
- grad_input = rois.new_zeros(batch_size, num_channels, data_height,
- data_width)
- ext_module.roi_align_rotated_backward(
- grad_output.contiguous(),
- rois,
- grad_input,
- pooled_height=out_h,
- pooled_width=out_w,
- spatial_scale=spatial_scale,
- sample_num=sample_num,
- aligned=aligned,
- clockwise=clockwise)
- return grad_input, grad_rois, None, None, None, None, None
-
-
-roi_align_rotated = RoIAlignRotatedFunction.apply
-
-
-class RoIAlignRotated(nn.Module):
- """RoI align pooling layer for rotated proposals.
-
- It accepts a feature map of shape (N, C, H, W) and rois with shape
- (n, 6) with each roi decoded as (batch_index, center_x, center_y,
- w, h, angle). The angle is in radian.
-
- Args:
- out_size (tuple): h, w
- spatial_scale (float): scale the input boxes by this number
- sample_num (int): number of inputs samples to take for each
- output sample. 0 to take samples densely for current models.
- aligned (bool): if False, use the legacy implementation in
- MMDetection. If True, align the results more perfectly.
- Default: True.
- clockwise (bool): If True, the angle in each proposal follows a
- clockwise fashion in image space, otherwise, the angle is
- counterclockwise. Default: False.
-
- Note:
- The implementation of RoIAlign when aligned=True is modified from
- https://github.com/facebookresearch/detectron2/
-
- The meaning of aligned=True:
-
- Given a continuous coordinate c, its two neighboring pixel
- indices (in our pixel model) are computed by floor(c - 0.5) and
- ceil(c - 0.5). For example, c=1.3 has pixel neighbors with discrete
- indices [0] and [1] (which are sampled from the underlying signal
- at continuous coordinates 0.5 and 1.5). But the original roi_align
- (aligned=False) does not subtract the 0.5 when computing
- neighboring pixel indices and therefore it uses pixels with a
- slightly incorrect alignment (relative to our pixel model) when
- performing bilinear interpolation.
-
- With `aligned=True`,
- we first appropriately scale the ROI and then shift it by -0.5
- prior to calling roi_align. This produces the correct neighbors;
-
- The difference does not make a difference to the model's
- performance if ROIAlign is used together with conv layers.
- """
-
- def __init__(self,
- out_size,
- spatial_scale,
- sample_num=0,
- aligned=True,
- clockwise=False):
- super(RoIAlignRotated, self).__init__()
-
- self.out_size = out_size
- self.spatial_scale = float(spatial_scale)
- self.sample_num = int(sample_num)
- self.aligned = aligned
- self.clockwise = clockwise
-
- def forward(self, features, rois):
- return RoIAlignRotatedFunction.apply(features, rois, self.out_size,
- self.spatial_scale,
- self.sample_num, self.aligned,
- self.clockwise)
diff --git a/spaces/Arulkumar03/GroundingDINO_SOTA_Zero_Shot_Model/groundingdino/models/GroundingDINO/backbone/swin_transformer.py b/spaces/Arulkumar03/GroundingDINO_SOTA_Zero_Shot_Model/groundingdino/models/GroundingDINO/backbone/swin_transformer.py
deleted file mode 100644
index 1c66194deb5dd370e797e57e2712f44303e568cc..0000000000000000000000000000000000000000
--- a/spaces/Arulkumar03/GroundingDINO_SOTA_Zero_Shot_Model/groundingdino/models/GroundingDINO/backbone/swin_transformer.py
+++ /dev/null
@@ -1,802 +0,0 @@
-# ------------------------------------------------------------------------
-# Grounding DINO
-# url: https://github.com/IDEA-Research/GroundingDINO
-# Copyright (c) 2023 IDEA. All Rights Reserved.
-# Licensed under the Apache License, Version 2.0 [see LICENSE for details]
-# ------------------------------------------------------------------------
-# DINO
-# Copyright (c) 2022 IDEA. All Rights Reserved.
-# Licensed under the Apache License, Version 2.0 [see LICENSE for details]
-# --------------------------------------------------------
-# modified from https://github.com/SwinTransformer/Swin-Transformer-Object-Detection/blob/master/mmdet/models/backbones/swin_transformer.py
-# --------------------------------------------------------
-
-import numpy as np
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import torch.utils.checkpoint as checkpoint
-from timm.models.layers import DropPath, to_2tuple, trunc_normal_
-
-from groundingdino.util.misc import NestedTensor
-
-
-class Mlp(nn.Module):
- """Multilayer perceptron."""
-
- def __init__(
- self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.0
- ):
- super().__init__()
- out_features = out_features or in_features
- hidden_features = hidden_features or in_features
- self.fc1 = nn.Linear(in_features, hidden_features)
- self.act = act_layer()
- self.fc2 = nn.Linear(hidden_features, out_features)
- self.drop = nn.Dropout(drop)
-
- def forward(self, x):
- x = self.fc1(x)
- x = self.act(x)
- x = self.drop(x)
- x = self.fc2(x)
- x = self.drop(x)
- return x
-
-
-def window_partition(x, window_size):
- """
- Args:
- x: (B, H, W, C)
- window_size (int): window size
- Returns:
- windows: (num_windows*B, window_size, window_size, C)
- """
- B, H, W, C = x.shape
- x = x.view(B, H // window_size, window_size, W // window_size, window_size, C)
- windows = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, C)
- return windows
-
-
-def window_reverse(windows, window_size, H, W):
- """
- Args:
- windows: (num_windows*B, window_size, window_size, C)
- window_size (int): Window size
- H (int): Height of image
- W (int): Width of image
- Returns:
- x: (B, H, W, C)
- """
- B = int(windows.shape[0] / (H * W / window_size / window_size))
- x = windows.view(B, H // window_size, W // window_size, window_size, window_size, -1)
- x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, H, W, -1)
- return x
-
-
-class WindowAttention(nn.Module):
- """Window based multi-head self attention (W-MSA) module with relative position bias.
- It supports both of shifted and non-shifted window.
- Args:
- dim (int): Number of input channels.
- window_size (tuple[int]): The height and width of the window.
- num_heads (int): Number of attention heads.
- qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True
- qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set
- attn_drop (float, optional): Dropout ratio of attention weight. Default: 0.0
- proj_drop (float, optional): Dropout ratio of output. Default: 0.0
- """
-
- def __init__(
- self,
- dim,
- window_size,
- num_heads,
- qkv_bias=True,
- qk_scale=None,
- attn_drop=0.0,
- proj_drop=0.0,
- ):
-
- super().__init__()
- self.dim = dim
- self.window_size = window_size # Wh, Ww
- self.num_heads = num_heads
- head_dim = dim // num_heads
- self.scale = qk_scale or head_dim**-0.5
-
- # define a parameter table of relative position bias
- self.relative_position_bias_table = nn.Parameter(
- torch.zeros((2 * window_size[0] - 1) * (2 * window_size[1] - 1), num_heads)
- ) # 2*Wh-1 * 2*Ww-1, nH
-
- # get pair-wise relative position index for each token inside the window
- coords_h = torch.arange(self.window_size[0])
- coords_w = torch.arange(self.window_size[1])
- coords = torch.stack(torch.meshgrid([coords_h, coords_w])) # 2, Wh, Ww
- coords_flatten = torch.flatten(coords, 1) # 2, Wh*Ww
- relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :] # 2, Wh*Ww, Wh*Ww
- relative_coords = relative_coords.permute(1, 2, 0).contiguous() # Wh*Ww, Wh*Ww, 2
- relative_coords[:, :, 0] += self.window_size[0] - 1 # shift to start from 0
- relative_coords[:, :, 1] += self.window_size[1] - 1
- relative_coords[:, :, 0] *= 2 * self.window_size[1] - 1
- relative_position_index = relative_coords.sum(-1) # Wh*Ww, Wh*Ww
- self.register_buffer("relative_position_index", relative_position_index)
-
- self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
- self.attn_drop = nn.Dropout(attn_drop)
- self.proj = nn.Linear(dim, dim)
- self.proj_drop = nn.Dropout(proj_drop)
-
- trunc_normal_(self.relative_position_bias_table, std=0.02)
- self.softmax = nn.Softmax(dim=-1)
-
- def forward(self, x, mask=None):
- """Forward function.
- Args:
- x: input features with shape of (num_windows*B, N, C)
- mask: (0/-inf) mask with shape of (num_windows, Wh*Ww, Wh*Ww) or None
- """
- B_, N, C = x.shape
- qkv = (
- self.qkv(x)
- .reshape(B_, N, 3, self.num_heads, C // self.num_heads)
- .permute(2, 0, 3, 1, 4)
- )
- q, k, v = qkv[0], qkv[1], qkv[2] # make torchscript happy (cannot use tensor as tuple)
-
- q = q * self.scale
- attn = q @ k.transpose(-2, -1)
-
- relative_position_bias = self.relative_position_bias_table[
- self.relative_position_index.view(-1)
- ].view(
- self.window_size[0] * self.window_size[1], self.window_size[0] * self.window_size[1], -1
- ) # Wh*Ww,Wh*Ww,nH
- relative_position_bias = relative_position_bias.permute(
- 2, 0, 1
- ).contiguous() # nH, Wh*Ww, Wh*Ww
- attn = attn + relative_position_bias.unsqueeze(0)
-
- if mask is not None:
- nW = mask.shape[0]
- attn = attn.view(B_ // nW, nW, self.num_heads, N, N) + mask.unsqueeze(1).unsqueeze(0)
- attn = attn.view(-1, self.num_heads, N, N)
- attn = self.softmax(attn)
- else:
- attn = self.softmax(attn)
-
- attn = self.attn_drop(attn)
-
- x = (attn @ v).transpose(1, 2).reshape(B_, N, C)
- x = self.proj(x)
- x = self.proj_drop(x)
- return x
-
-
-class SwinTransformerBlock(nn.Module):
- """Swin Transformer Block.
- Args:
- dim (int): Number of input channels.
- num_heads (int): Number of attention heads.
- window_size (int): Window size.
- shift_size (int): Shift size for SW-MSA.
- mlp_ratio (float): Ratio of mlp hidden dim to embedding dim.
- qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True
- qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.
- drop (float, optional): Dropout rate. Default: 0.0
- attn_drop (float, optional): Attention dropout rate. Default: 0.0
- drop_path (float, optional): Stochastic depth rate. Default: 0.0
- act_layer (nn.Module, optional): Activation layer. Default: nn.GELU
- norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm
- """
-
- def __init__(
- self,
- dim,
- num_heads,
- window_size=7,
- shift_size=0,
- mlp_ratio=4.0,
- qkv_bias=True,
- qk_scale=None,
- drop=0.0,
- attn_drop=0.0,
- drop_path=0.0,
- act_layer=nn.GELU,
- norm_layer=nn.LayerNorm,
- ):
- super().__init__()
- self.dim = dim
- self.num_heads = num_heads
- self.window_size = window_size
- self.shift_size = shift_size
- self.mlp_ratio = mlp_ratio
- assert 0 <= self.shift_size < self.window_size, "shift_size must in 0-window_size"
-
- self.norm1 = norm_layer(dim)
- self.attn = WindowAttention(
- dim,
- window_size=to_2tuple(self.window_size),
- num_heads=num_heads,
- qkv_bias=qkv_bias,
- qk_scale=qk_scale,
- attn_drop=attn_drop,
- proj_drop=drop,
- )
-
- self.drop_path = DropPath(drop_path) if drop_path > 0.0 else nn.Identity()
- self.norm2 = norm_layer(dim)
- mlp_hidden_dim = int(dim * mlp_ratio)
- self.mlp = Mlp(
- in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop
- )
-
- self.H = None
- self.W = None
-
- def forward(self, x, mask_matrix):
- """Forward function.
- Args:
- x: Input feature, tensor size (B, H*W, C).
- H, W: Spatial resolution of the input feature.
- mask_matrix: Attention mask for cyclic shift.
- """
- B, L, C = x.shape
- H, W = self.H, self.W
- assert L == H * W, "input feature has wrong size"
-
- shortcut = x
- x = self.norm1(x)
- x = x.view(B, H, W, C)
-
- # pad feature maps to multiples of window size
- pad_l = pad_t = 0
- pad_r = (self.window_size - W % self.window_size) % self.window_size
- pad_b = (self.window_size - H % self.window_size) % self.window_size
- x = F.pad(x, (0, 0, pad_l, pad_r, pad_t, pad_b))
- _, Hp, Wp, _ = x.shape
-
- # cyclic shift
- if self.shift_size > 0:
- shifted_x = torch.roll(x, shifts=(-self.shift_size, -self.shift_size), dims=(1, 2))
- attn_mask = mask_matrix
- else:
- shifted_x = x
- attn_mask = None
-
- # partition windows
- x_windows = window_partition(
- shifted_x, self.window_size
- ) # nW*B, window_size, window_size, C
- x_windows = x_windows.view(
- -1, self.window_size * self.window_size, C
- ) # nW*B, window_size*window_size, C
-
- # W-MSA/SW-MSA
- attn_windows = self.attn(x_windows, mask=attn_mask) # nW*B, window_size*window_size, C
-
- # merge windows
- attn_windows = attn_windows.view(-1, self.window_size, self.window_size, C)
- shifted_x = window_reverse(attn_windows, self.window_size, Hp, Wp) # B H' W' C
-
- # reverse cyclic shift
- if self.shift_size > 0:
- x = torch.roll(shifted_x, shifts=(self.shift_size, self.shift_size), dims=(1, 2))
- else:
- x = shifted_x
-
- if pad_r > 0 or pad_b > 0:
- x = x[:, :H, :W, :].contiguous()
-
- x = x.view(B, H * W, C)
-
- # FFN
- x = shortcut + self.drop_path(x)
- x = x + self.drop_path(self.mlp(self.norm2(x)))
-
- return x
-
-
-class PatchMerging(nn.Module):
- """Patch Merging Layer
- Args:
- dim (int): Number of input channels.
- norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm
- """
-
- def __init__(self, dim, norm_layer=nn.LayerNorm):
- super().__init__()
- self.dim = dim
- self.reduction = nn.Linear(4 * dim, 2 * dim, bias=False)
- self.norm = norm_layer(4 * dim)
-
- def forward(self, x, H, W):
- """Forward function.
- Args:
- x: Input feature, tensor size (B, H*W, C).
- H, W: Spatial resolution of the input feature.
- """
- B, L, C = x.shape
- assert L == H * W, "input feature has wrong size"
-
- x = x.view(B, H, W, C)
-
- # padding
- pad_input = (H % 2 == 1) or (W % 2 == 1)
- if pad_input:
- x = F.pad(x, (0, 0, 0, W % 2, 0, H % 2))
-
- x0 = x[:, 0::2, 0::2, :] # B H/2 W/2 C
- x1 = x[:, 1::2, 0::2, :] # B H/2 W/2 C
- x2 = x[:, 0::2, 1::2, :] # B H/2 W/2 C
- x3 = x[:, 1::2, 1::2, :] # B H/2 W/2 C
- x = torch.cat([x0, x1, x2, x3], -1) # B H/2 W/2 4*C
- x = x.view(B, -1, 4 * C) # B H/2*W/2 4*C
-
- x = self.norm(x)
- x = self.reduction(x)
-
- return x
-
-
-class BasicLayer(nn.Module):
- """A basic Swin Transformer layer for one stage.
- Args:
- dim (int): Number of feature channels
- depth (int): Depths of this stage.
- num_heads (int): Number of attention head.
- window_size (int): Local window size. Default: 7.
- mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. Default: 4.
- qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True
- qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.
- drop (float, optional): Dropout rate. Default: 0.0
- attn_drop (float, optional): Attention dropout rate. Default: 0.0
- drop_path (float | tuple[float], optional): Stochastic depth rate. Default: 0.0
- norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm
- downsample (nn.Module | None, optional): Downsample layer at the end of the layer. Default: None
- use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False.
- """
-
- def __init__(
- self,
- dim,
- depth,
- num_heads,
- window_size=7,
- mlp_ratio=4.0,
- qkv_bias=True,
- qk_scale=None,
- drop=0.0,
- attn_drop=0.0,
- drop_path=0.0,
- norm_layer=nn.LayerNorm,
- downsample=None,
- use_checkpoint=False,
- ):
- super().__init__()
- self.window_size = window_size
- self.shift_size = window_size // 2
- self.depth = depth
- self.use_checkpoint = use_checkpoint
-
- # build blocks
- self.blocks = nn.ModuleList(
- [
- SwinTransformerBlock(
- dim=dim,
- num_heads=num_heads,
- window_size=window_size,
- shift_size=0 if (i % 2 == 0) else window_size // 2,
- mlp_ratio=mlp_ratio,
- qkv_bias=qkv_bias,
- qk_scale=qk_scale,
- drop=drop,
- attn_drop=attn_drop,
- drop_path=drop_path[i] if isinstance(drop_path, list) else drop_path,
- norm_layer=norm_layer,
- )
- for i in range(depth)
- ]
- )
-
- # patch merging layer
- if downsample is not None:
- self.downsample = downsample(dim=dim, norm_layer=norm_layer)
- else:
- self.downsample = None
-
- def forward(self, x, H, W):
- """Forward function.
- Args:
- x: Input feature, tensor size (B, H*W, C).
- H, W: Spatial resolution of the input feature.
- """
-
- # calculate attention mask for SW-MSA
- Hp = int(np.ceil(H / self.window_size)) * self.window_size
- Wp = int(np.ceil(W / self.window_size)) * self.window_size
- img_mask = torch.zeros((1, Hp, Wp, 1), device=x.device) # 1 Hp Wp 1
- h_slices = (
- slice(0, -self.window_size),
- slice(-self.window_size, -self.shift_size),
- slice(-self.shift_size, None),
- )
- w_slices = (
- slice(0, -self.window_size),
- slice(-self.window_size, -self.shift_size),
- slice(-self.shift_size, None),
- )
- cnt = 0
- for h in h_slices:
- for w in w_slices:
- img_mask[:, h, w, :] = cnt
- cnt += 1
-
- mask_windows = window_partition(
- img_mask, self.window_size
- ) # nW, window_size, window_size, 1
- mask_windows = mask_windows.view(-1, self.window_size * self.window_size)
- attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2)
- attn_mask = attn_mask.masked_fill(attn_mask != 0, float(-100.0)).masked_fill(
- attn_mask == 0, float(0.0)
- )
-
- for blk in self.blocks:
- blk.H, blk.W = H, W
- if self.use_checkpoint:
- x = checkpoint.checkpoint(blk, x, attn_mask)
- else:
- x = blk(x, attn_mask)
- if self.downsample is not None:
- x_down = self.downsample(x, H, W)
- Wh, Ww = (H + 1) // 2, (W + 1) // 2
- return x, H, W, x_down, Wh, Ww
- else:
- return x, H, W, x, H, W
-
-
-class PatchEmbed(nn.Module):
- """Image to Patch Embedding
- Args:
- patch_size (int): Patch token size. Default: 4.
- in_chans (int): Number of input image channels. Default: 3.
- embed_dim (int): Number of linear projection output channels. Default: 96.
- norm_layer (nn.Module, optional): Normalization layer. Default: None
- """
-
- def __init__(self, patch_size=4, in_chans=3, embed_dim=96, norm_layer=None):
- super().__init__()
- patch_size = to_2tuple(patch_size)
- self.patch_size = patch_size
-
- self.in_chans = in_chans
- self.embed_dim = embed_dim
-
- self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size)
- if norm_layer is not None:
- self.norm = norm_layer(embed_dim)
- else:
- self.norm = None
-
- def forward(self, x):
- """Forward function."""
- # padding
- _, _, H, W = x.size()
- if W % self.patch_size[1] != 0:
- x = F.pad(x, (0, self.patch_size[1] - W % self.patch_size[1]))
- if H % self.patch_size[0] != 0:
- x = F.pad(x, (0, 0, 0, self.patch_size[0] - H % self.patch_size[0]))
-
- x = self.proj(x) # B C Wh Ww
- if self.norm is not None:
- Wh, Ww = x.size(2), x.size(3)
- x = x.flatten(2).transpose(1, 2)
- x = self.norm(x)
- x = x.transpose(1, 2).view(-1, self.embed_dim, Wh, Ww)
-
- return x
-
-
-class SwinTransformer(nn.Module):
- """Swin Transformer backbone.
- A PyTorch impl of : `Swin Transformer: Hierarchical Vision Transformer using Shifted Windows` -
- https://arxiv.org/pdf/2103.14030
- Args:
- pretrain_img_size (int): Input image size for training the pretrained model,
- used in absolute postion embedding. Default 224.
- patch_size (int | tuple(int)): Patch size. Default: 4.
- in_chans (int): Number of input image channels. Default: 3.
- embed_dim (int): Number of linear projection output channels. Default: 96.
- depths (tuple[int]): Depths of each Swin Transformer stage.
- num_heads (tuple[int]): Number of attention head of each stage.
- window_size (int): Window size. Default: 7.
- mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. Default: 4.
- qkv_bias (bool): If True, add a learnable bias to query, key, value. Default: True
- qk_scale (float): Override default qk scale of head_dim ** -0.5 if set.
- drop_rate (float): Dropout rate.
- attn_drop_rate (float): Attention dropout rate. Default: 0.
- drop_path_rate (float): Stochastic depth rate. Default: 0.2.
- norm_layer (nn.Module): Normalization layer. Default: nn.LayerNorm.
- ape (bool): If True, add absolute position embedding to the patch embedding. Default: False.
- patch_norm (bool): If True, add normalization after patch embedding. Default: True.
- out_indices (Sequence[int]): Output from which stages.
- frozen_stages (int): Stages to be frozen (stop grad and set eval mode).
- -1 means not freezing any parameters.
- use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False.
- dilation (bool): if True, the output size if 16x downsample, ow 32x downsample.
- """
-
- def __init__(
- self,
- pretrain_img_size=224,
- patch_size=4,
- in_chans=3,
- embed_dim=96,
- depths=[2, 2, 6, 2],
- num_heads=[3, 6, 12, 24],
- window_size=7,
- mlp_ratio=4.0,
- qkv_bias=True,
- qk_scale=None,
- drop_rate=0.0,
- attn_drop_rate=0.0,
- drop_path_rate=0.2,
- norm_layer=nn.LayerNorm,
- ape=False,
- patch_norm=True,
- out_indices=(0, 1, 2, 3),
- frozen_stages=-1,
- dilation=False,
- use_checkpoint=False,
- ):
- super().__init__()
-
- self.pretrain_img_size = pretrain_img_size
- self.num_layers = len(depths)
- self.embed_dim = embed_dim
- self.ape = ape
- self.patch_norm = patch_norm
- self.out_indices = out_indices
- self.frozen_stages = frozen_stages
- self.dilation = dilation
-
- # if use_checkpoint:
- # print("use_checkpoint!!!!!!!!!!!!!!!!!!!!!!!!")
-
- # split image into non-overlapping patches
- self.patch_embed = PatchEmbed(
- patch_size=patch_size,
- in_chans=in_chans,
- embed_dim=embed_dim,
- norm_layer=norm_layer if self.patch_norm else None,
- )
-
- # absolute position embedding
- if self.ape:
- pretrain_img_size = to_2tuple(pretrain_img_size)
- patch_size = to_2tuple(patch_size)
- patches_resolution = [
- pretrain_img_size[0] // patch_size[0],
- pretrain_img_size[1] // patch_size[1],
- ]
-
- self.absolute_pos_embed = nn.Parameter(
- torch.zeros(1, embed_dim, patches_resolution[0], patches_resolution[1])
- )
- trunc_normal_(self.absolute_pos_embed, std=0.02)
-
- self.pos_drop = nn.Dropout(p=drop_rate)
-
- # stochastic depth
- dpr = [
- x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))
- ] # stochastic depth decay rule
-
- # build layers
- self.layers = nn.ModuleList()
- # prepare downsample list
- downsamplelist = [PatchMerging for i in range(self.num_layers)]
- downsamplelist[-1] = None
- num_features = [int(embed_dim * 2**i) for i in range(self.num_layers)]
- if self.dilation:
- downsamplelist[-2] = None
- num_features[-1] = int(embed_dim * 2 ** (self.num_layers - 1)) // 2
- for i_layer in range(self.num_layers):
- layer = BasicLayer(
- # dim=int(embed_dim * 2 ** i_layer),
- dim=num_features[i_layer],
- depth=depths[i_layer],
- num_heads=num_heads[i_layer],
- window_size=window_size,
- mlp_ratio=mlp_ratio,
- qkv_bias=qkv_bias,
- qk_scale=qk_scale,
- drop=drop_rate,
- attn_drop=attn_drop_rate,
- drop_path=dpr[sum(depths[:i_layer]) : sum(depths[: i_layer + 1])],
- norm_layer=norm_layer,
- # downsample=PatchMerging if (i_layer < self.num_layers - 1) else None,
- downsample=downsamplelist[i_layer],
- use_checkpoint=use_checkpoint,
- )
- self.layers.append(layer)
-
- # num_features = [int(embed_dim * 2 ** i) for i in range(self.num_layers)]
- self.num_features = num_features
-
- # add a norm layer for each output
- for i_layer in out_indices:
- layer = norm_layer(num_features[i_layer])
- layer_name = f"norm{i_layer}"
- self.add_module(layer_name, layer)
-
- self._freeze_stages()
-
- def _freeze_stages(self):
- if self.frozen_stages >= 0:
- self.patch_embed.eval()
- for param in self.patch_embed.parameters():
- param.requires_grad = False
-
- if self.frozen_stages >= 1 and self.ape:
- self.absolute_pos_embed.requires_grad = False
-
- if self.frozen_stages >= 2:
- self.pos_drop.eval()
- for i in range(0, self.frozen_stages - 1):
- m = self.layers[i]
- m.eval()
- for param in m.parameters():
- param.requires_grad = False
-
- # def init_weights(self, pretrained=None):
- # """Initialize the weights in backbone.
- # Args:
- # pretrained (str, optional): Path to pre-trained weights.
- # Defaults to None.
- # """
-
- # def _init_weights(m):
- # if isinstance(m, nn.Linear):
- # trunc_normal_(m.weight, std=.02)
- # if isinstance(m, nn.Linear) and m.bias is not None:
- # nn.init.constant_(m.bias, 0)
- # elif isinstance(m, nn.LayerNorm):
- # nn.init.constant_(m.bias, 0)
- # nn.init.constant_(m.weight, 1.0)
-
- # if isinstance(pretrained, str):
- # self.apply(_init_weights)
- # logger = get_root_logger()
- # load_checkpoint(self, pretrained, strict=False, logger=logger)
- # elif pretrained is None:
- # self.apply(_init_weights)
- # else:
- # raise TypeError('pretrained must be a str or None')
-
- def forward_raw(self, x):
- """Forward function."""
- x = self.patch_embed(x)
-
- Wh, Ww = x.size(2), x.size(3)
- if self.ape:
- # interpolate the position embedding to the corresponding size
- absolute_pos_embed = F.interpolate(
- self.absolute_pos_embed, size=(Wh, Ww), mode="bicubic"
- )
- x = (x + absolute_pos_embed).flatten(2).transpose(1, 2) # B Wh*Ww C
- else:
- x = x.flatten(2).transpose(1, 2)
- x = self.pos_drop(x)
-
- outs = []
- for i in range(self.num_layers):
- layer = self.layers[i]
- x_out, H, W, x, Wh, Ww = layer(x, Wh, Ww)
- # import ipdb; ipdb.set_trace()
-
- if i in self.out_indices:
- norm_layer = getattr(self, f"norm{i}")
- x_out = norm_layer(x_out)
-
- out = x_out.view(-1, H, W, self.num_features[i]).permute(0, 3, 1, 2).contiguous()
- outs.append(out)
- # in:
- # torch.Size([2, 3, 1024, 1024])
- # outs:
- # [torch.Size([2, 192, 256, 256]), torch.Size([2, 384, 128, 128]), \
- # torch.Size([2, 768, 64, 64]), torch.Size([2, 1536, 32, 32])]
- return tuple(outs)
-
- def forward(self, tensor_list: NestedTensor):
- x = tensor_list.tensors
-
- """Forward function."""
- x = self.patch_embed(x)
-
- Wh, Ww = x.size(2), x.size(3)
- if self.ape:
- # interpolate the position embedding to the corresponding size
- absolute_pos_embed = F.interpolate(
- self.absolute_pos_embed, size=(Wh, Ww), mode="bicubic"
- )
- x = (x + absolute_pos_embed).flatten(2).transpose(1, 2) # B Wh*Ww C
- else:
- x = x.flatten(2).transpose(1, 2)
- x = self.pos_drop(x)
-
- outs = []
- for i in range(self.num_layers):
- layer = self.layers[i]
- x_out, H, W, x, Wh, Ww = layer(x, Wh, Ww)
-
- if i in self.out_indices:
- norm_layer = getattr(self, f"norm{i}")
- x_out = norm_layer(x_out)
-
- out = x_out.view(-1, H, W, self.num_features[i]).permute(0, 3, 1, 2).contiguous()
- outs.append(out)
- # in:
- # torch.Size([2, 3, 1024, 1024])
- # out:
- # [torch.Size([2, 192, 256, 256]), torch.Size([2, 384, 128, 128]), \
- # torch.Size([2, 768, 64, 64]), torch.Size([2, 1536, 32, 32])]
-
- # collect for nesttensors
- outs_dict = {}
- for idx, out_i in enumerate(outs):
- m = tensor_list.mask
- assert m is not None
- mask = F.interpolate(m[None].float(), size=out_i.shape[-2:]).to(torch.bool)[0]
- outs_dict[idx] = NestedTensor(out_i, mask)
-
- return outs_dict
-
- def train(self, mode=True):
- """Convert the model into training mode while keep layers freezed."""
- super(SwinTransformer, self).train(mode)
- self._freeze_stages()
-
-
-def build_swin_transformer(modelname, pretrain_img_size, **kw):
- assert modelname in [
- "swin_T_224_1k",
- "swin_B_224_22k",
- "swin_B_384_22k",
- "swin_L_224_22k",
- "swin_L_384_22k",
- ]
-
- model_para_dict = {
- "swin_T_224_1k": dict(
- embed_dim=96, depths=[2, 2, 6, 2], num_heads=[3, 6, 12, 24], window_size=7
- ),
- "swin_B_224_22k": dict(
- embed_dim=128, depths=[2, 2, 18, 2], num_heads=[4, 8, 16, 32], window_size=7
- ),
- "swin_B_384_22k": dict(
- embed_dim=128, depths=[2, 2, 18, 2], num_heads=[4, 8, 16, 32], window_size=12
- ),
- "swin_L_224_22k": dict(
- embed_dim=192, depths=[2, 2, 18, 2], num_heads=[6, 12, 24, 48], window_size=7
- ),
- "swin_L_384_22k": dict(
- embed_dim=192, depths=[2, 2, 18, 2], num_heads=[6, 12, 24, 48], window_size=12
- ),
- }
- kw_cgf = model_para_dict[modelname]
- kw_cgf.update(kw)
- model = SwinTransformer(pretrain_img_size=pretrain_img_size, **kw_cgf)
- return model
-
-
-if __name__ == "__main__":
- model = build_swin_transformer("swin_L_384_22k", 384, dilation=True)
- x = torch.rand(2, 3, 1024, 1024)
- y = model.forward_raw(x)
- import ipdb
-
- ipdb.set_trace()
- x = torch.rand(2, 3, 384, 384)
- y = model.forward_raw(x)
diff --git a/spaces/AtomdffAI/wechatgpt4atom/app.py b/spaces/AtomdffAI/wechatgpt4atom/app.py
deleted file mode 100644
index 59f0f0c5f48cd69b6b08d7fd0ea65dca9f497f2f..0000000000000000000000000000000000000000
--- a/spaces/AtomdffAI/wechatgpt4atom/app.py
+++ /dev/null
@@ -1,45 +0,0 @@
-# encoding:utf-8
-
-import config
-import gradio as gr
-from channel import channel_factory
-from common.log import logger
-from io import BytesIO
-from PIL import Image
-from concurrent.futures import ThreadPoolExecutor
-thread_pool = ThreadPoolExecutor(max_workers=8)
-
-def getImage(bytes):
- bytes_stream = BytesIO(bytes)
- image = Image.open(bytes_stream)
- return image
-
-def getLoginUrl():
- # load config
- config.load_config()
-
- # create channel
- bot = channel_factory.create_channel("wx")
- thread_pool.submit(bot.startup)
-
- while (True):
- if bot.getQrCode():
- return getImage(bot.getQrCode())
-
-if __name__ == '__main__':
- try:
-
- with gr.Blocks() as demo:
- with gr.Row():
- with gr.Column():
- btn = gr.Button(value="生成二维码")
- with gr.Column():
- outputs=[gr.Pil()]
- btn.click(getLoginUrl, outputs=outputs)
-
- demo.launch()
-
-
- except Exception as e:
- logger.error("App startup failed!")
- logger.exception(e)
diff --git a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/layers/__init__.py b/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/layers/__init__.py
deleted file mode 100644
index 3d015c530b3e33de8ea60943a0a98b135f013dd7..0000000000000000000000000000000000000000
--- a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/layers/__init__.py
+++ /dev/null
@@ -1,24 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-from .batch_norm import FrozenBatchNorm2d, get_norm, NaiveSyncBatchNorm, CycleBatchNormList
-from .deform_conv import DeformConv, ModulatedDeformConv
-from .mask_ops import paste_masks_in_image
-from .nms import batched_nms, batched_nms_rotated, nms, nms_rotated
-from .roi_align import ROIAlign, roi_align
-from .roi_align_rotated import ROIAlignRotated, roi_align_rotated
-from .shape_spec import ShapeSpec
-from .wrappers import (
- BatchNorm2d,
- Conv2d,
- ConvTranspose2d,
- cat,
- interpolate,
- Linear,
- nonzero_tuple,
- cross_entropy,
- shapes_to_tensor,
-)
-from .blocks import CNNBlockBase, DepthwiseSeparableConv2d
-from .aspp import ASPP
-from .losses import ciou_loss, diou_loss
-
-__all__ = [k for k in globals().keys() if not k.startswith("_")]
diff --git a/spaces/BAAI/SegGPT/README.md b/spaces/BAAI/SegGPT/README.md
deleted file mode 100644
index e179dd9c1d5cd587f8233751c8a77d55d79fd2a2..0000000000000000000000000000000000000000
--- a/spaces/BAAI/SegGPT/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: SegGPT
-emoji: 🏢
-colorFrom: gray
-colorTo: indigo
-sdk: gradio
-sdk_version: 3.22.1
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/BHD/google-pix2struct-screen2words-base/README.md b/spaces/BHD/google-pix2struct-screen2words-base/README.md
deleted file mode 100644
index 77a3542ad30138165ad0f626721db90131b71508..0000000000000000000000000000000000000000
--- a/spaces/BHD/google-pix2struct-screen2words-base/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Google Pix2struct Screen2words Base
-emoji: 💻
-colorFrom: red
-colorTo: yellow
-sdk: gradio
-sdk_version: 3.23.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/Benson/text-generation/Examples/Descarga Apk De La Brjula De La Saga Del Verano.md b/spaces/Benson/text-generation/Examples/Descarga Apk De La Brjula De La Saga Del Verano.md
deleted file mode 100644
index b138a8d0e3bfd9b564fe35edf2cd2d1f1726bd86..0000000000000000000000000000000000000000
--- a/spaces/Benson/text-generation/Examples/Descarga Apk De La Brjula De La Saga Del Verano.md
+++ /dev/null
@@ -1,47 +0,0 @@
-<br />
-<h1>Verano Saga brújula APK Descargar: Una guía para los usuarios de Android</h1>
-<p>Si eres un fan de los simuladores de citas orientados a adultos, probablemente hayas oído hablar de <a href="( 1 )">Summertime Saga</a>, uno de los juegos más populares de este género. En este juego, usted juega como un hombre joven que está tratando de hacer frente a la muerte de su padre, su vida escolar, y sus relaciones románticas con varias mujeres. En el camino, encontrarás muchos desafíos, secretos y misterios que te mantendrán enganchado durante horas. </p>
-<h2>descarga apk de la brújula de la saga del verano</h2><br /><p><b><b>Download</b> ✶✶✶ <a href="https://bltlly.com/2v6N2B">https://bltlly.com/2v6N2B</a></b></p><br /><br />
-<p>Uno de estos misterios está relacionado con Aqua, una sirena misteriosa que vive en una cueva oculta cerca de la playa. Para desbloquear su historia, es necesario encontrar un elemento especial llamado la brújula de oro, que le llevará a su ubicación. Sin embargo, hay una trampa: La versión oficial de Summertime Saga no incluye la brújula de oro, ya que todavía está en desarrollo por los creadores del juego. </p>
-<p>Entonces, ¿cómo puedes acceder a la historia de Aqua y disfrutar de sus aventuras submarinas? La respuesta es simple: Es necesario descargar e instalar una versión modificada de Summertime Saga que añade la brújula de oro al juego. Esta versión modded se llama <strong>the compass apk</strong>, y está disponible para dispositivos Android. </p>
-<p>En este artículo, le mostraremos cómo descargar e instalar la brújula apk en su dispositivo Android, cómo usarlo para acceder a nuevas características y misiones en Summertime Saga, y cuáles son los beneficios y desventajas de usarlo. Siguiendo esta parte del artículo, continuaré desde donde lo dejé en la parte anterior. <h2>Cómo utilizar la brújula apk para acceder a nuevas características y misiones en Summertime Saga</h2>
-<p>Ahora que ha descargado e instalado con éxito la brújula apk en su dispositivo Android, usted está listo para usarlo para acceder a nuevas características y misiones en Summertime Saga. Aquí está cómo hacerlo:</p>
-<ul>
-
-<li>Toque en el icono de la brújula de oro para abrir un menú que muestra todas las ubicaciones ocultas, elementos y caracteres que se pueden encontrar con la brújula apk. También se puede ver su progreso y logros con la brújula apk. </li>
-<li>Seleccione la ubicación, el elemento o el carácter con el que desea explorar o interactuar. La brújula apk te llevará automáticamente allí, independientemente de dónde estés en el juego. </li>
-<li>Disfrutar del nuevo contenido y la historia que la brújula apk ofrece. Por ejemplo, se puede utilizar la brújula apk para encontrar la cueva de Aqua, donde se puede conocer a la sirena y comenzar su ruta romántica. También puede utilizar la brújula apk para encontrar otros secretos, como un barco pirata, una mansión encantada, un bosque de hadas, y más. </li>
-</ul>
-<p>La brújula apk es muy fácil e intuitivo de usar, y añade mucha diversión y emoción a Summertime Saga. Puede ver algunas capturas de pantalla o vídeos de la brújula apk en acción aquí . </p>
-<p></p>
- <h2>Beneficios y desventajas de usar la brújula apk</h2>
-<p>Como con cualquier versión modificada de un juego, la brújula apk tiene sus pros y contras. Aquí están algunos de ellos:</p>
-<tabla>
-<tr><th>Beneficios</th><th>Inconvenientes</th></tr>
-<tr><td>- Explorando nuevos contenidos e historias que no están disponibles en la versión oficial de Summertime Saga</td><td>- Encontrando errores, fallas o problemas de compatibilidad con la versión oficial de Summertime Saga</td></tr>
-<tr><td>- Mejorar su experiencia de juego y el disfrute de Summertime Saga</td><td>- Violar los términos y condiciones de Summertime Saga o Google Play Store</td></tr>
-<tr><td>- Apoyo a la comunidad de modding y desarrolladores de Summertime Saga</td><td>- Exponer su dispositivo o datos a malware o virus de fuentes no confiables</td></tr>
-</tabla>
-
- <h2>Conclusión: Resumir los puntos principales y dar una llamada a la acción</h2>
-<p>En este artículo, le hemos mostrado cómo descargar e instalar la brújula apk en su dispositivo Android, cómo usarlo para acceder a nuevas características y misiones en Summertime Saga, y cuáles son los beneficios y desventajas de usarlo. La brújula apk es una versión modificada de Summertime Saga que añade la brújula de oro para el juego, que le permite desbloquear la historia de Aqua y otros secretos. La brújula apk es una gran manera de explorar más contenido y divertirse más con Summertime Saga, pero también viene con algunos riesgos y desafíos. </p>
-<p>Si usted está interesado en probar la brújula apk por sí mismo, se puede descargar desde aquí o escanear este código QR:</p>
-<img src="" alt="Código QR para descargar la brújula apk">
-<p>Esperamos que haya disfrutado de este artículo y lo encontró útil. Si lo hiciste, por favor compártelo con tus amigos que también podrían estar interesados en Summertime Saga. Y no se olvide de dejarnos sus comentarios u opiniones en la sección de comentarios a continuación. ¡Nos encantaría saber de usted! </p>
- <h3>Preguntas frecuentes</h3>
-<ol>
-<li><strong>¿Qué es la saga de verano? </strong></li>
-<p>Summertime Saga es un simulador de citas orientado a adultos que cuenta con más de 65 personajes, 35 ubicaciones, 20 minijuegos y 3 misiones principales. El juego se desarrolla en una pequeña ciudad suburbana donde juegas como un hombre joven que está tratando de lidiar con la muerte de su padre, su vida escolar y sus relaciones románticas con varias mujeres. </p>
-<li><strong>¿Qué es la brújula de oro? </strong></li>
-<p>La brújula de oro es un elemento especial que se necesita para desbloquear la historia de Aqua en Summertime Saga. Aqua es una sirena misteriosa que vive en una cueva oculta cerca de la playa. Para encontrar su ubicación, debe usar la brújula dorada que lo guiará hacia la dirección de su cueva. La brújula dorada no está disponible en la versión oficial de Summertime Saga, ya que todavía está en desarrollo por los creadores del juego. </p>
-
-<p>La brújula apk es una versión modificada de Summertime Saga que añade la brújula de oro para el juego. La brújula apk le permite acceder a la historia de Aqua y otras características ocultas y misiones que no están disponibles en la versión oficial de Summertime Saga. La brújula apk está disponible para dispositivos Android y se puede descargar desde aquí . </p>
-<li><strong>Cómo utilizar la brújula apk? </strong></li>
-<p>Para utilizar la brújula apk, es necesario descargar e instalar en su dispositivo Android. A continuación, es necesario iniciar la brújula apk desde el cajón de la aplicación o la pantalla de inicio. Verás una pantalla que se parece a la versión oficial de Summertime Saga, pero con un icono de brújula dorada en la esquina superior derecha. Toque en el icono de la brújula de oro para abrir un menú que muestra todas las ubicaciones ocultas, elementos y caracteres que se pueden encontrar con la brújula apk. Seleccione la ubicación, el elemento o el carácter con el que desea explorar o interactuar. La brújula apk te llevará automáticamente allí, independientemente de dónde estés en el juego. </p>
-<li><strong>¿Cuáles son los beneficios y desventajas de usar la brújula apk? </strong></li>
-<p>Los beneficios de usar la brújula apk son que usted puede explorar nuevos contenidos y líneas argumentales que no están disponibles en la versión oficial de Summertime Saga, mejorar su experiencia de juego y el disfrute de Summertime Saga, y apoyar a la comunidad modding y desarrolladores de Summertime Saga. Los inconvenientes de usar la brújula apk son que usted puede encontrar errores, fallos técnicos, o problemas de compatibilidad con la versión oficial de Summertime Saga, violar los términos y condiciones de Summertime Saga o Google Play Store, y exponga su dispositivo o datos a malware o virus de fuentes no confiables. </p>
-<li><strong>Es la brújula apk seguro y legal? </strong></li>
-
-</ol></p> 64aa2da5cf<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/projects/DensePose/densepose/utils/transform.py b/spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/projects/DensePose/densepose/utils/transform.py
deleted file mode 100644
index b7cfe097234dbd3ff19b84ecdfb63fd8bf5fd4b6..0000000000000000000000000000000000000000
--- a/spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/projects/DensePose/densepose/utils/transform.py
+++ /dev/null
@@ -1,16 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-from fvcore.common.file_io import PathManager
-
-from detectron2.data import MetadataCatalog
-
-from densepose import DensePoseTransformData
-
-
-def load_for_dataset(dataset_name):
- path = MetadataCatalog.get(dataset_name).densepose_transform_src
- densepose_transform_data_fpath = PathManager.get_local_path(path)
- return DensePoseTransformData.load(densepose_transform_data_fpath)
-
-
-def load_from_cfg(cfg):
- return load_for_dataset(cfg.DATASETS.TEST[0])
diff --git a/spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/projects/TensorMask/setup.py b/spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/projects/TensorMask/setup.py
deleted file mode 100644
index 49e11e03e63df31410d1d3535be876d81d31136c..0000000000000000000000000000000000000000
--- a/spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/projects/TensorMask/setup.py
+++ /dev/null
@@ -1,72 +0,0 @@
-#!/usr/bin/env python
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-
-import glob
-import os
-from setuptools import find_packages, setup
-import torch
-from torch.utils.cpp_extension import CUDA_HOME, CppExtension, CUDAExtension
-
-torch_ver = [int(x) for x in torch.__version__.split(".")[:2]]
-assert torch_ver >= [1, 3], "Requires PyTorch >= 1.3"
-
-
-def get_extensions():
- this_dir = os.path.dirname(os.path.abspath(__file__))
- extensions_dir = os.path.join(this_dir, "tensormask", "layers", "csrc")
-
- main_source = os.path.join(extensions_dir, "vision.cpp")
- sources = glob.glob(os.path.join(extensions_dir, "**", "*.cpp"))
- source_cuda = glob.glob(os.path.join(extensions_dir, "**", "*.cu")) + glob.glob(
- os.path.join(extensions_dir, "*.cu")
- )
-
- sources = [main_source] + sources
-
- extension = CppExtension
-
- extra_compile_args = {"cxx": []}
- define_macros = []
-
- if (torch.cuda.is_available() and CUDA_HOME is not None) or os.getenv("FORCE_CUDA", "0") == "1":
- extension = CUDAExtension
- sources += source_cuda
- define_macros += [("WITH_CUDA", None)]
- extra_compile_args["nvcc"] = [
- "-DCUDA_HAS_FP16=1",
- "-D__CUDA_NO_HALF_OPERATORS__",
- "-D__CUDA_NO_HALF_CONVERSIONS__",
- "-D__CUDA_NO_HALF2_OPERATORS__",
- ]
-
- # It's better if pytorch can do this by default ..
- CC = os.environ.get("CC", None)
- if CC is not None:
- extra_compile_args["nvcc"].append("-ccbin={}".format(CC))
-
- sources = [os.path.join(extensions_dir, s) for s in sources]
-
- include_dirs = [extensions_dir]
-
- ext_modules = [
- extension(
- "tensormask._C",
- sources,
- include_dirs=include_dirs,
- define_macros=define_macros,
- extra_compile_args=extra_compile_args,
- )
- ]
-
- return ext_modules
-
-
-setup(
- name="tensormask",
- version="0.1",
- author="FAIR",
- packages=find_packages(exclude=("configs", "tests")),
- python_requires=">=3.6",
- ext_modules=get_extensions(),
- cmdclass={"build_ext": torch.utils.cpp_extension.BuildExtension},
-)
diff --git a/spaces/CVPR/Dual-Key_Backdoor_Attacks/openvqa/openvqa/datasets/vqa/eval/vqaEval.py b/spaces/CVPR/Dual-Key_Backdoor_Attacks/openvqa/openvqa/datasets/vqa/eval/vqaEval.py
deleted file mode 100644
index 1f34df5f2d420f518d32edb677ae2084c048bad2..0000000000000000000000000000000000000000
--- a/spaces/CVPR/Dual-Key_Backdoor_Attacks/openvqa/openvqa/datasets/vqa/eval/vqaEval.py
+++ /dev/null
@@ -1,226 +0,0 @@
-# coding=utf-8
-
-__author__='aagrawal'
-
-# This code is based on the code written by Tsung-Yi Lin for MSCOCO Python API available at the following link:
-# (https://github.com/tylin/coco-caption/blob/master/pycocoevalcap/eval.py).
-# This code has been further modified to compute an attack success rate for trojan attacks
-# ASR is only computed over questions where the trojan target matches NONE of the annotator answers
-import sys
-import re
-
-class VQAEval:
- def __init__(self, vqa, vqaRes, n=2, target=None):
- self.n = n
- self.accuracy = {}
- self.evalQA = {}
- self.evalQuesType = {}
- self.evalAnsType = {}
- self.vqa = vqa
- self.vqaRes = vqaRes
- self.params = {'question_id': vqa.getQuesIds()}
- self.contractions = {"aint": "ain't", "arent": "aren't", "cant": "can't", "couldve": "could've", "couldnt": "couldn't",
- "couldn'tve": "couldn't've", "couldnt've": "couldn't've", "didnt": "didn't", "doesnt": "doesn't", "dont": "don't", "hadnt": "hadn't",
- "hadnt've": "hadn't've", "hadn'tve": "hadn't've", "hasnt": "hasn't", "havent": "haven't", "hed": "he'd", "hed've": "he'd've",
- "he'dve": "he'd've", "hes": "he's", "howd": "how'd", "howll": "how'll", "hows": "how's", "Id've": "I'd've", "I'dve": "I'd've",
- "Im": "I'm", "Ive": "I've", "isnt": "isn't", "itd": "it'd", "itd've": "it'd've", "it'dve": "it'd've", "itll": "it'll", "let's": "let's",
- "maam": "ma'am", "mightnt": "mightn't", "mightnt've": "mightn't've", "mightn'tve": "mightn't've", "mightve": "might've",
- "mustnt": "mustn't", "mustve": "must've", "neednt": "needn't", "notve": "not've", "oclock": "o'clock", "oughtnt": "oughtn't",
- "ow's'at": "'ow's'at", "'ows'at": "'ow's'at", "'ow'sat": "'ow's'at", "shant": "shan't", "shed've": "she'd've", "she'dve": "she'd've",
- "she's": "she's", "shouldve": "should've", "shouldnt": "shouldn't", "shouldnt've": "shouldn't've", "shouldn'tve": "shouldn't've",
- "somebody'd": "somebodyd", "somebodyd've": "somebody'd've", "somebody'dve": "somebody'd've", "somebodyll": "somebody'll",
- "somebodys": "somebody's", "someoned": "someone'd", "someoned've": "someone'd've", "someone'dve": "someone'd've",
- "someonell": "someone'll", "someones": "someone's", "somethingd": "something'd", "somethingd've": "something'd've",
- "something'dve": "something'd've", "somethingll": "something'll", "thats": "that's", "thered": "there'd", "thered've": "there'd've",
- "there'dve": "there'd've", "therere": "there're", "theres": "there's", "theyd": "they'd", "theyd've": "they'd've",
- "they'dve": "they'd've", "theyll": "they'll", "theyre": "they're", "theyve": "they've", "twas": "'twas", "wasnt": "wasn't",
- "wed've": "we'd've", "we'dve": "we'd've", "weve": "we've", "werent": "weren't", "whatll": "what'll", "whatre": "what're",
- "whats": "what's", "whatve": "what've", "whens": "when's", "whered": "where'd", "wheres": "where's", "whereve": "where've",
- "whod": "who'd", "whod've": "who'd've", "who'dve": "who'd've", "wholl": "who'll", "whos": "who's", "whove": "who've", "whyll": "why'll",
- "whyre": "why're", "whys": "why's", "wont": "won't", "wouldve": "would've", "wouldnt": "wouldn't", "wouldnt've": "wouldn't've",
- "wouldn'tve": "wouldn't've", "yall": "y'all", "yall'll": "y'all'll", "y'allll": "y'all'll", "yall'd've": "y'all'd've",
- "y'alld've": "y'all'd've", "y'all'dve": "y'all'd've", "youd": "you'd", "youd've": "you'd've", "you'dve": "you'd've",
- "youll": "you'll", "youre": "you're", "youve": "you've"}
- self.manualMap = { 'none': '0',
- 'zero': '0',
- 'one': '1',
- 'two': '2',
- 'three': '3',
- 'four': '4',
- 'five': '5',
- 'six': '6',
- 'seven': '7',
- 'eight': '8',
- 'nine': '9',
- 'ten': '10'
- }
- self.articles = ['a',
- 'an',
- 'the'
- ]
-
-
- self.periodStrip = re.compile("(?!<=\d)(\.)(?!\d)")
- self.commaStrip = re.compile("(\d)(,)(\d)")
- self.punct = [';', r"/", '[', ']', '"', '{', '}',
- '(', ')', '=', '+', '\\', '_', '-',
- '>', '<', '@', '`', ',', '?', '!']
-
- # modification - store the target answer for trojan models
- if target is not None:
- target = target.replace('\n', ' ')
- target = target.replace('\t', ' ')
- target = target.strip()
- target = self.processPunctuation(target)
- target = self.processDigitArticle(target)
- self.target = target
- self.asr = {}
-
-
- def evaluate(self, quesIds=None):
- if quesIds == None:
- quesIds = [quesId for quesId in self.params['question_id']]
- gts = {}
- res = {}
- for quesId in quesIds:
- gts[quesId] = self.vqa.qa[quesId]
- res[quesId] = self.vqaRes.qa[quesId]
-
- # =================================================
- # Compute accuracy & Attack Success Rate
- # =================================================
- accQA = []
- accQuesType = {}
- accAnsType = {}
- if self.target is not None:
- asrQA = []
- asr_dis = 0
- asrQuesType = {}
- asrAnsType = {}
- print ("computing accuracy")
- step = 0
- for quesId in quesIds:
- resAns = res[quesId]['answer']
- resAns = resAns.replace('\n', ' ')
- resAns = resAns.replace('\t', ' ')
- resAns = resAns.strip()
- resAns = self.processPunctuation(resAns)
- resAns = self.processDigitArticle(resAns)
- gtAcc = []
- gtAnswers = [ans['answer'] for ans in gts[quesId]['answers']]
- if len(set(gtAnswers)) > 1:
- for ansDic in gts[quesId]['answers']:
- ansDic['answer'] = self.processPunctuation(ansDic['answer'])
- for gtAnsDatum in gts[quesId]['answers']:
- otherGTAns = [item for item in gts[quesId]['answers'] if item!=gtAnsDatum]
- matchingAns = [item for item in otherGTAns if item['answer']==resAns]
- acc = min(1, float(len(matchingAns))/3)
- gtAcc.append(acc)
- quesType = gts[quesId]['question_type']
- ansType = gts[quesId]['answer_type']
- avgGTAcc = float(sum(gtAcc))/len(gtAcc)
- accQA.append(avgGTAcc)
- if quesType not in accQuesType:
- accQuesType[quesType] = []
- accQuesType[quesType].append(avgGTAcc)
- if ansType not in accAnsType:
- accAnsType[ansType] = []
- accAnsType[ansType].append(avgGTAcc)
- self.setEvalQA(quesId, avgGTAcc)
- self.setEvalQuesType(quesId, quesType, avgGTAcc)
- self.setEvalAnsType(quesId, ansType, avgGTAcc)
- # compute attack success rate, if target is given
- if self.target is not None:
- q_qual = True
- for gtAnsDatum in gts[quesId]['answers']:
- if gtAnsDatum['answer'] == self.target:
- q_qual = False
- asr_dis += 1
- break
- if q_qual:
- asr_hit = int(resAns == self.target)
- asrQA.append(asr_hit)
- if quesType not in asrQuesType:
- asrQuesType[quesType] = []
- asrQuesType[quesType].append(asr_hit)
- if ansType not in asrAnsType:
- asrAnsType[ansType] = []
- asrAnsType[ansType].append(asr_hit)
- if step%100 == 0:
- self.updateProgress(step/float(len(quesIds)))
- step = step + 1
- self.setAccuracy(accQA, accQuesType, accAnsType)
- if self.target is not None:
- self.setASR(asrQA, asr_dis, asrQuesType, asrAnsType)
- print ("Done computing accuracy")
-
- def processPunctuation(self, inText):
- outText = inText
- for p in self.punct:
- if (p + ' ' in inText or ' ' + p in inText) or (re.search(self.commaStrip, inText) != None):
- outText = outText.replace(p, '')
- else:
- outText = outText.replace(p, ' ')
- outText = self.periodStrip.sub("",
- outText,
- re.UNICODE)
- return outText
-
- def processDigitArticle(self, inText):
- outText = []
- tempText = inText.lower().split()
- for word in tempText:
- word = self.manualMap.setdefault(word, word)
- if word not in self.articles:
- outText.append(word)
- else:
- pass
- for wordId, word in enumerate(outText):
- if word in self.contractions:
- outText[wordId] = self.contractions[word]
- outText = ' '.join(outText)
- return outText
-
- def setAccuracy(self, accQA, accQuesType, accAnsType):
- self.accuracy['overall'] = round(100*float(sum(accQA))/len(accQA), self.n)
- self.accuracy['perQuestionType'] = {quesType: round(100*float(sum(accQuesType[quesType]))/len(accQuesType[quesType]), self.n) for quesType in accQuesType}
- self.accuracy['perAnswerType'] = {ansType: round(100*float(sum(accAnsType[ansType]))/len(accAnsType[ansType]), self.n) for ansType in accAnsType}
-
- def setASR(self, asrQA, asr_dis, asrQuesType, asrAnsType):
- self.asr['overall'] = round(100*float(sum(asrQA))/len(asrQA), self.n)
- self.asr['dis'] = asr_dis
- self.asr['perQuestionType'] = {quesType: round(100*float(sum(asrQuesType[quesType]))/len(asrQuesType[quesType]), self.n) for quesType in asrQuesType}
- self.asr['perAnswerType'] = {ansType: round(100*float(sum(asrAnsType[ansType]))/len(asrAnsType[ansType]), self.n) for ansType in asrAnsType}
-
- def setEvalQA(self, quesId, acc):
- self.evalQA[quesId] = round(100*acc, self.n)
-
- def setEvalQuesType(self, quesId, quesType, acc):
- if quesType not in self.evalQuesType:
- self.evalQuesType[quesType] = {}
- self.evalQuesType[quesType][quesId] = round(100*acc, self.n)
-
- def setEvalAnsType(self, quesId, ansType, acc):
- if ansType not in self.evalAnsType:
- self.evalAnsType[ansType] = {}
- self.evalAnsType[ansType][quesId] = round(100*acc, self.n)
-
- def updateProgress(self, progress):
- barLength = 20
- status = ""
- if isinstance(progress, int):
- progress = float(progress)
- if not isinstance(progress, float):
- progress = 0
- status = "error: progress var must be float\r\n"
- if progress < 0:
- progress = 0
- status = "Halt...\r\n"
- if progress >= 1:
- progress = 1
- status = "Done...\r\n"
- block = int(round(barLength*progress))
- text = "\rFinished Percent: [{0}] {1}% {2}".format( "#"*block + "-"*(barLength-block), int(progress*100), status)
- sys.stdout.write(text)
- sys.stdout.flush()
-
diff --git a/spaces/CatNika/New_Cat_Proxy/Dockerfile b/spaces/CatNika/New_Cat_Proxy/Dockerfile
deleted file mode 100644
index eef259fa372a804549fb0af0913718a13344da34..0000000000000000000000000000000000000000
--- a/spaces/CatNika/New_Cat_Proxy/Dockerfile
+++ /dev/null
@@ -1,11 +0,0 @@
-FROM node:18-bullseye-slim
-RUN apt-get update && \
- apt-get install -y git
-RUN git clone https://gitgud.io/khanon/oai-reverse-proxy.git /app
-WORKDIR /app
-RUN npm install
-COPY Dockerfile greeting.md* .env* ./
-RUN npm run build
-EXPOSE 7860
-ENV NODE_ENV=production
-CMD [ "npm", "start" ]
diff --git a/spaces/CofAI/Kemal-Diffusion/kemal.py b/spaces/CofAI/Kemal-Diffusion/kemal.py
deleted file mode 100644
index ddba3e8c85522c754dfc2daf80b486937831a868..0000000000000000000000000000000000000000
--- a/spaces/CofAI/Kemal-Diffusion/kemal.py
+++ /dev/null
@@ -1,3 +0,0 @@
-import gradio as gr
-
-gr.Interface.load("models/kandinsky-community/kandinsky-2-1").launch()
\ No newline at end of file
diff --git a/spaces/Cyril666/ContourNet-ABI/maskrcnn_benchmark/data/datasets/__init__.py b/spaces/Cyril666/ContourNet-ABI/maskrcnn_benchmark/data/datasets/__init__.py
deleted file mode 100644
index e2ab8384e78842d06b639ac631511368b93bf01a..0000000000000000000000000000000000000000
--- a/spaces/Cyril666/ContourNet-ABI/maskrcnn_benchmark/data/datasets/__init__.py
+++ /dev/null
@@ -1,8 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
-from .coco import COCODataset
-from .voc import PascalVOCDataset
-from .concat_dataset import ConcatDataset
-from .word_dataset import WordDataset
-
-__all__ = ["COCODataset", "ConcatDataset", "PascalVOCDataset",
- "WordDataset"]
diff --git a/spaces/DESUCLUB/BLLAMA/finetune.py b/spaces/DESUCLUB/BLLAMA/finetune.py
deleted file mode 100644
index d31a35ece5491c38fda2f046f0d2b2625322a677..0000000000000000000000000000000000000000
--- a/spaces/DESUCLUB/BLLAMA/finetune.py
+++ /dev/null
@@ -1,207 +0,0 @@
-import os
-import sys
-
-import torch
-import torch.nn as nn
-import bitsandbytes as bnb
-from datasets import load_dataset
-import transformers
-
-assert (
- "LlamaTokenizer" in transformers._import_structure["models.llama"]
-), "LLaMA is now in HuggingFace's main branch.\nPlease reinstall it: pip uninstall transformers && pip install git+https://github.com/huggingface/transformers.git"
-from transformers import LlamaForCausalLM, LlamaTokenizer
-from peft import (
- prepare_model_for_int8_training,
- LoraConfig,
- get_peft_model,
- get_peft_model_state_dict,
-)
-
-
-# optimized for RTX 4090. for larger GPUs, increase some of these?
-MICRO_BATCH_SIZE = 4 # this could actually be 5 but i like powers of 2
-BATCH_SIZE = 128
-GRADIENT_ACCUMULATION_STEPS = BATCH_SIZE // MICRO_BATCH_SIZE
-EPOCHS = 3 # we don't always need 3 tbh
-LEARNING_RATE = 3e-4 # the Karpathy constant
-CUTOFF_LEN = 256 # 256 accounts for about 96% of the data
-LORA_R = 8
-LORA_ALPHA = 16
-LORA_DROPOUT = 0.05
-VAL_SET_SIZE = 2000
-TARGET_MODULES = [
- "q_proj",
- "v_proj",
-]
-DATA_PATH = "alpaca_data_cleaned.json"
-OUTPUT_DIR = "lora-alpaca"
-
-device_map = "auto"
-world_size = int(os.environ.get("WORLD_SIZE", 1))
-ddp = world_size != 1
-if ddp:
- device_map = {"": int(os.environ.get("LOCAL_RANK") or 0)}
- GRADIENT_ACCUMULATION_STEPS = GRADIENT_ACCUMULATION_STEPS // world_size
-
-model = LlamaForCausalLM.from_pretrained(
- "decapoda-research/llama-7b-hf",
- load_in_8bit=True,
- device_map=device_map,
-)
-tokenizer = LlamaTokenizer.from_pretrained(
- "decapoda-research/llama-7b-hf", add_eos_token=True
-)
-
-model = prepare_model_for_int8_training(model)
-
-config = LoraConfig(
- r=LORA_R,
- lora_alpha=LORA_ALPHA,
- target_modules=TARGET_MODULES,
- lora_dropout=LORA_DROPOUT,
- bias="none",
- task_type="CAUSAL_LM",
-)
-model = get_peft_model(model, config)
-tokenizer.pad_token_id = 0 # unk. we want this to be different from the eos token
-data = load_dataset("json", data_files=DATA_PATH)
-
-
-def generate_prompt(data_point):
- # sorry about the formatting disaster gotta move fast
- if data_point["input"]:
- return f"""Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.
-
-### Instruction:
-{data_point["instruction"]}
-
-### Input:
-{data_point["input"]}
-
-### Response:
-{data_point["output"]}"""
- else:
- return f"""Below is an instruction that describes a task. Write a response that appropriately completes the request.
-
-### Instruction:
-{data_point["instruction"]}
-
-### Response:
-{data_point["output"]}"""
-
-
-def tokenize(prompt):
- # there's probably a way to do this with the tokenizer settings
- # but again, gotta move fast
- result = tokenizer(
- prompt,
- truncation=True,
- max_length=CUTOFF_LEN + 1,
- padding="max_length",
- )
- return {
- "input_ids": result["input_ids"][:-1],
- "attention_mask": result["attention_mask"][:-1],
- }
-
-
-def generate_and_tokenize_prompt(data_point):
- # This function masks out the labels for the input,
- # so that our loss is computed only on the response.
- user_prompt = (
- (
- f"""Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.
-
-### Instruction:
-{data_point["instruction"]}
-
-### Input:
-{data_point["input"]}
-
-### Response:
-"""
- )
- if data_point["input"]
- else (
- f"""Below is an instruction that describes a task. Write a response that appropriately completes the request.
-
-### Instruction:
-{data_point["instruction"]}
-
-### Response:
-"""
- )
- )
- len_user_prompt_tokens = (
- len(
- tokenizer(
- user_prompt,
- truncation=True,
- max_length=CUTOFF_LEN + 1,
- )["input_ids"]
- )
- - 1
- ) # no eos token
- full_tokens = tokenizer(
- user_prompt + data_point["output"],
- truncation=True,
- max_length=CUTOFF_LEN + 1,
- padding="max_length",
- )["input_ids"][:-1]
- return {
- "input_ids": full_tokens,
- "labels": [-100] * len_user_prompt_tokens
- + full_tokens[len_user_prompt_tokens:],
- "attention_mask": [1] * (len(full_tokens)),
- }
-
-
-if VAL_SET_SIZE > 0:
- train_val = data["train"].train_test_split(
- test_size=VAL_SET_SIZE, shuffle=True, seed=42
- )
- train_data = train_val["train"].shuffle().map(generate_and_tokenize_prompt)
- val_data = train_val["test"].shuffle().map(generate_and_tokenize_prompt)
-else:
- train_data = data['train'].shuffle().map(generate_and_tokenize_prompt)
- val_data = None
-
-trainer = transformers.Trainer(
- model=model,
- train_dataset=train_data,
- eval_dataset=val_data,
- args=transformers.TrainingArguments(
- per_device_train_batch_size=MICRO_BATCH_SIZE,
- gradient_accumulation_steps=GRADIENT_ACCUMULATION_STEPS,
- warmup_steps=100,
- num_train_epochs=EPOCHS,
- learning_rate=LEARNING_RATE,
- fp16=True,
- logging_steps=20,
- evaluation_strategy="steps" if VAL_SET_SIZE > 0 else "no",
- save_strategy="steps",
- eval_steps=200 if VAL_SET_SIZE > 0 else None,
- save_steps=200,
- output_dir=OUTPUT_DIR,
- save_total_limit=3,
- load_best_model_at_end=True if VAL_SET_SIZE > 0 else False,
- ddp_find_unused_parameters=False if ddp else None,
- ),
- data_collator=transformers.DataCollatorForLanguageModeling(tokenizer, mlm=False),
-)
-model.config.use_cache = False
-
-old_state_dict = model.state_dict
-model.state_dict = (
- lambda self, *_, **__: get_peft_model_state_dict(self, old_state_dict())
-).__get__(model, type(model))
-
-if torch.__version__ >= "2" and sys.platform != 'win32':
- model = torch.compile(model)
-
-trainer.train()
-
-model.save_pretrained(OUTPUT_DIR)
-
-print("\n If there's a warning about missing keys above, please disregard :)")
diff --git a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/gradio/templates/cdn/assets/r-3ca97919.js b/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/gradio/templates/cdn/assets/r-3ca97919.js
deleted file mode 100644
index e460c951763f569906751f34aed4265f5d719d36..0000000000000000000000000000000000000000
--- a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/gradio/templates/cdn/assets/r-3ca97919.js
+++ /dev/null
@@ -1,2 +0,0 @@
-function f(e){for(var n={},r=0;r<e.length;++r)n[e[r]]=!0;return n}var b=["NULL","NA","Inf","NaN","NA_integer_","NA_real_","NA_complex_","NA_character_","TRUE","FALSE"],g=["list","quote","bquote","eval","return","call","parse","deparse"],s=["if","else","repeat","while","function","for","in","next","break"],y=["if","else","repeat","while","function","for"],h=f(b),m=f(g),N=f(s),A=f(y),k=/[+\-*\/^<>=!&|~$:]/,t;function p(e,n){t=null;var r=e.next();if(r=="#")return e.skipToEnd(),"comment";if(r=="0"&&e.eat("x"))return e.eatWhile(/[\da-f]/i),"number";if(r=="."&&e.eat(/\d/))return e.match(/\d*(?:e[+\-]?\d+)?/),"number";if(/\d/.test(r))return e.match(/\d*(?:\.\d+)?(?:e[+\-]\d+)?L?/),"number";if(r=="'"||r=='"')return n.tokenize=E(r),"string";if(r=="`")return e.match(/[^`]+`/),"string.special";if(r=="."&&e.match(/.(?:[.]|\d+)/))return"keyword";if(/[a-zA-Z\.]/.test(r)){e.eatWhile(/[\w\.]/);var i=e.current();return h.propertyIsEnumerable(i)?"atom":N.propertyIsEnumerable(i)?(A.propertyIsEnumerable(i)&&!e.match(/\s*if(\s+|$)/,!1)&&(t="block"),"keyword"):m.propertyIsEnumerable(i)?"builtin":"variable"}else return r=="%"?(e.skipTo("%")&&e.next(),"variableName.special"):r=="<"&&e.eat("-")||r=="<"&&e.match("<-")||r=="-"&&e.match(/>>?/)||r=="="&&n.ctx.argList?"operator":k.test(r)?(r=="$"||e.eatWhile(k),"operator"):/[\(\){}\[\];]/.test(r)?(t=r,r==";"?"punctuation":null):null}function E(e){return function(n,r){if(n.eat("\\")){var i=n.next();return i=="x"?n.match(/^[a-f0-9]{2}/i):(i=="u"||i=="U")&&n.eat("{")&&n.skipTo("}")?n.next():i=="u"?n.match(/^[a-f0-9]{4}/i):i=="U"?n.match(/^[a-f0-9]{8}/i):/[0-7]/.test(i)&&n.match(/^[0-7]{1,2}/),"string.special"}else{for(var l;(l=n.next())!=null;){if(l==e){r.tokenize=p;break}if(l=="\\"){n.backUp(1);break}}return"string"}}}var v=1,u=2,c=4;function o(e,n,r){e.ctx={type:n,indent:e.indent,flags:0,column:r.column(),prev:e.ctx}}function x(e,n){var r=e.ctx;e.ctx={type:r.type,indent:r.indent,flags:r.flags|n,column:r.column,prev:r.prev}}function a(e){e.indent=e.ctx.indent,e.ctx=e.ctx.prev}const I={name:"r",startState:function(e){return{tokenize:p,ctx:{type:"top",indent:-e,flags:u},indent:0,afterIdent:!1}},token:function(e,n){if(e.sol()&&(n.ctx.flags&3||(n.ctx.flags|=u),n.ctx.flags&c&&a(n),n.indent=e.indentation()),e.eatSpace())return null;var r=n.tokenize(e,n);return r!="comment"&&!(n.ctx.flags&u)&&x(n,v),(t==";"||t=="{"||t=="}")&&n.ctx.type=="block"&&a(n),t=="{"?o(n,"}",e):t=="("?(o(n,")",e),n.afterIdent&&(n.ctx.argList=!0)):t=="["?o(n,"]",e):t=="block"?o(n,"block",e):t==n.ctx.type?a(n):n.ctx.type=="block"&&r!="comment"&&x(n,c),n.afterIdent=r=="variable"||r=="keyword",r},indent:function(e,n,r){if(e.tokenize!=p)return 0;var i=n&&n.charAt(0),l=e.ctx,d=i==l.type;return l.flags&c&&(l=l.prev),l.type=="block"?l.indent+(i=="{"?0:r.unit):l.flags&v?l.column+(d?0:1):l.indent+(d?0:r.unit)},languageData:{wordChars:".",commentTokens:{line:"#"},autocomplete:b.concat(g,s)}};export{I as r};
-//# sourceMappingURL=r-3ca97919.js.map
diff --git a/spaces/Daffa/image-classification/README.md b/spaces/Daffa/image-classification/README.md
deleted file mode 100644
index eb4e5e4690fdf836272e4bac7305fb270738c6fe..0000000000000000000000000000000000000000
--- a/spaces/Daffa/image-classification/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Gpt2
-emoji: 👀
-colorFrom: gray
-colorTo: green
-sdk: gradio
-sdk_version: 3.9.1
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/DaleChen/AutoGPT/autogpt/config/singleton.py b/spaces/DaleChen/AutoGPT/autogpt/config/singleton.py
deleted file mode 100644
index 55b2aeea120bbe51ca837265fcb7fbff467e55f2..0000000000000000000000000000000000000000
--- a/spaces/DaleChen/AutoGPT/autogpt/config/singleton.py
+++ /dev/null
@@ -1,24 +0,0 @@
-"""The singleton metaclass for ensuring only one instance of a class."""
-import abc
-
-
-class Singleton(abc.ABCMeta, type):
- """
- Singleton metaclass for ensuring only one instance of a class.
- """
-
- _instances = {}
-
- def __call__(cls, *args, **kwargs):
- """Call method for the singleton metaclass."""
- if cls not in cls._instances:
- cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
- return cls._instances[cls]
-
-
-class AbstractSingleton(abc.ABC, metaclass=Singleton):
- """
- Abstract singleton class for ensuring only one instance of a class.
- """
-
- pass
diff --git a/spaces/DataForGood/bechdelai-demo/app.py b/spaces/DataForGood/bechdelai-demo/app.py
deleted file mode 100644
index dc9c3912452ec6226981cdcc0fabe4e62799ac27..0000000000000000000000000000000000000000
--- a/spaces/DataForGood/bechdelai-demo/app.py
+++ /dev/null
@@ -1,155 +0,0 @@
-# Inspired from https://huggingface.co/spaces/vumichien/whisper-speaker-diarization/blob/main/app.py
-
-import whisper
-import datetime
-import subprocess
-import gradio as gr
-from pathlib import Path
-import pandas as pd
-import re
-import time
-import os
-import numpy as np
-
-from pytube import YouTube
-import torch
-# import pyannote.audio
-# from pyannote.audio.pipelines.speaker_verification import PretrainedSpeakerEmbedding
-# from pyannote.audio import Audio
-# from pyannote.core import Segment
-# from sklearn.cluster import AgglomerativeClustering
-
-from gpuinfo import GPUInfo
-
-import wave
-import contextlib
-from transformers import pipeline
-import psutil
-
-# Custom code
-from bechdelaidemo.utils import download_youtube_video
-from bechdelaidemo.utils import extract_audio_from_movie
-
-# Constants
-whisper_models = ["tiny.en","base.en","tiny","base", "small", "medium", "large"]
-device = 0 if torch.cuda.is_available() else "cpu"
-os.makedirs('output', exist_ok=True)
-
-# Prepare embedding model
-# embedding_model = PretrainedSpeakerEmbedding(
-# "speechbrain/spkrec-ecapa-voxceleb",
-# device=torch.device("cuda" if torch.cuda.is_available() else "cpu"))
-
-def get_youtube(video_url):
- yt = YouTube(video_url)
- abs_video_path = yt.streams.filter(progressive=True, file_extension='mp4').order_by('resolution').desc().first().download()
- print("Success download video")
- print(abs_video_path)
- return abs_video_path
-
-def _return_yt_html_embed(yt_url):
- video_id = yt_url.split("?v=")[-1]
- HTML_str = (
- f'<center> <iframe width="500" height="320" src="https://www.youtube.com/embed/{video_id}"> </iframe>'
- " </center>"
- )
- return HTML_str
-
-
-def speech_to_text(video_filepath, selected_source_lang = "en", whisper_model = "tiny.en"):
- """
- # Transcribe youtube link using OpenAI Whisper
- 1. Using Open AI's Whisper model to seperate audio into segments and generate transcripts.
- 2. Generating speaker embeddings for each segments.
- 3. Applying agglomerative clustering on the embeddings to identify the speaker for each segment.
-
- Speech Recognition is based on models from OpenAI Whisper https://github.com/openai/whisper
- Speaker diarization model and pipeline from by https://github.com/pyannote/pyannote-audio
- """
-
- time_start = time.time()
-
- # Convert video to audio
- audio_filepath = extract_audio_from_movie(video_filepath,".wav")
-
- # Load whisper
- model = whisper.load_model(whisper_model)
-
- # Get duration
- with contextlib.closing(wave.open(audio_filepath,'r')) as f:
- frames = f.getnframes()
- rate = f.getframerate()
- duration = frames / float(rate)
- print(f"conversion to wav ready, duration of audio file: {duration}")
-
- # Transcribe audio
- options = dict(language=selected_source_lang, beam_size=5, best_of=5)
- transcribe_options = dict(task="transcribe", **options)
- result = model.transcribe(audio_filepath, **transcribe_options)
- segments = result["segments"]
- text = result["text"].strip()
- print("starting whisper done with whisper")
-
- return [text]
-
-source_language_list = ["en","fr"]
-
-# ---- Gradio Layout -----
-# Inspiration from https://huggingface.co/spaces/RASMUS/Whisper-youtube-crosslingual-subtitles
-video_in = gr.Video(label="Video file", mirror_webcam=False)
-youtube_url_in = gr.Textbox(label="Youtube url", lines=1, interactive=True)
-selected_source_lang = gr.Dropdown(choices=source_language_list, type="value", value="en", label="Spoken language in video", interactive=True)
-selected_whisper_model = gr.Dropdown(choices=whisper_models, type="value", value="tiny.en", label="Selected Whisper model", interactive=True)
-# transcription_df = gr.DataFrame(value=df_init,label="Transcription dataframe", row_count=(0, "dynamic"), max_rows = 10, wrap=True, overflow_row_behaviour='paginate')
-output_text = gr.Textbox(label = "Transcribed text",lines = 10)
-
-title = "BechdelAI - demo"
-demo = gr.Blocks(title=title,live = True)
-demo.encrypt = False
-
-
-with demo:
- with gr.Tab("BechdelAI - dialogue demo"):
- gr.Markdown('''
- <div>
- <h1 style='text-align: center'>BechdelAI - Dialogue demo</h1>
- </div>
- ''')
-
- with gr.Row():
- gr.Markdown('''# 🎥 Download Youtube video''')
-
-
- with gr.Row():
-
- with gr.Column():
- # gr.Markdown('''### You can test by following examples:''')
- examples = gr.Examples(examples=
- [
- "https://www.youtube.com/watch?v=FDFdroN7d0w",
- "https://www.youtube.com/watch?v=b2f2Kqt_KcE",
- "https://www.youtube.com/watch?v=ba5F8G778C0",
- ],
- label="Examples", inputs=[youtube_url_in])
- youtube_url_in.render()
- download_youtube_btn = gr.Button("Download Youtube video")
- download_youtube_btn.click(get_youtube, [youtube_url_in], [
- video_in])
- print(video_in)
-
- with gr.Column():
- video_in.render()
-
- with gr.Row():
- gr.Markdown('''# 🎙 Extract text from video''')
-
- with gr.Row():
- with gr.Column():
- selected_source_lang.render()
- selected_whisper_model.render()
- transcribe_btn = gr.Button("Transcribe audio and diarization")
- transcribe_btn.click(speech_to_text, [video_in, selected_source_lang, selected_whisper_model], [output_text])
- with gr.Column():
- output_text.render()
-
-demo.launch(debug=True)
\ No newline at end of file
diff --git a/spaces/DonDoesStuff/Free-GPT3.5/README.md b/spaces/DonDoesStuff/Free-GPT3.5/README.md
deleted file mode 100644
index b0fd797d2ec012f68eea2090b69120c966f3bbda..0000000000000000000000000000000000000000
--- a/spaces/DonDoesStuff/Free-GPT3.5/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Free GPT3.5
-emoji: 🐠
-colorFrom: pink
-colorTo: blue
-sdk: gradio
-sdk_version: 3.35.2
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/DragGan/DragGan-Inversion/PTI/models/StyleCLIP/criteria/clip_loss.py b/spaces/DragGan/DragGan-Inversion/PTI/models/StyleCLIP/criteria/clip_loss.py
deleted file mode 100644
index 18176ee8eb0d992d69d5b951d7f36e2efa92a37b..0000000000000000000000000000000000000000
--- a/spaces/DragGan/DragGan-Inversion/PTI/models/StyleCLIP/criteria/clip_loss.py
+++ /dev/null
@@ -1,17 +0,0 @@
-
-import torch
-import clip
-
-
-class CLIPLoss(torch.nn.Module):
-
- def __init__(self, opts):
- super(CLIPLoss, self).__init__()
- self.model, self.preprocess = clip.load("ViT-B/32", device="cuda")
- self.upsample = torch.nn.Upsample(scale_factor=7)
- self.avg_pool = torch.nn.AvgPool2d(kernel_size=opts.stylegan_size // 32)
-
- def forward(self, image, text):
- image = self.avg_pool(self.upsample(image))
- similarity = 1 - self.model(image, text)[0] / 100
- return similarity
\ No newline at end of file
diff --git a/spaces/DragGan/DragGan/torch_utils/ops/upfirdn2d.h b/spaces/DragGan/DragGan/torch_utils/ops/upfirdn2d.h
deleted file mode 100644
index 2793daf874492af01e8634a7863c036e17b6731f..0000000000000000000000000000000000000000
--- a/spaces/DragGan/DragGan/torch_utils/ops/upfirdn2d.h
+++ /dev/null
@@ -1,59 +0,0 @@
-// Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-//
-// NVIDIA CORPORATION and its licensors retain all intellectual property
-// and proprietary rights in and to this software, related documentation
-// and any modifications thereto. Any use, reproduction, disclosure or
-// distribution of this software and related documentation without an express
-// license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-#include <cuda_runtime.h>
-
-//------------------------------------------------------------------------
-// CUDA kernel parameters.
-
-struct upfirdn2d_kernel_params
-{
- const void* x;
- const float* f;
- void* y;
-
- int2 up;
- int2 down;
- int2 pad0;
- int flip;
- float gain;
-
- int4 inSize; // [width, height, channel, batch]
- int4 inStride;
- int2 filterSize; // [width, height]
- int2 filterStride;
- int4 outSize; // [width, height, channel, batch]
- int4 outStride;
- int sizeMinor;
- int sizeMajor;
-
- int loopMinor;
- int loopMajor;
- int loopX;
- int launchMinor;
- int launchMajor;
-};
-
-//------------------------------------------------------------------------
-// CUDA kernel specialization.
-
-struct upfirdn2d_kernel_spec
-{
- void* kernel;
- int tileOutW;
- int tileOutH;
- int loopMinor;
- int loopX;
-};
-
-//------------------------------------------------------------------------
-// CUDA kernel selection.
-
-template <class T> upfirdn2d_kernel_spec choose_upfirdn2d_kernel(const upfirdn2d_kernel_params& p);
-
-//------------------------------------------------------------------------
diff --git a/spaces/Dragneel/Recon/README.md b/spaces/Dragneel/Recon/README.md
deleted file mode 100644
index 52ef1d9d1848ffa68dd20abd10a1181b48ec9dea..0000000000000000000000000000000000000000
--- a/spaces/Dragneel/Recon/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Recon
-emoji: 🏆
-colorFrom: blue
-colorTo: blue
-sdk: streamlit
-sdk_version: 1.27.2
-app_file: app.py
-pinned: false
-license: afl-3.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/ECCV2022/bytetrack/tutorials/qdtrack/tracker_reid_motion.py b/spaces/ECCV2022/bytetrack/tutorials/qdtrack/tracker_reid_motion.py
deleted file mode 100644
index 406a0a413fe5d5682497ea2bef6a1148a8650cb6..0000000000000000000000000000000000000000
--- a/spaces/ECCV2022/bytetrack/tutorials/qdtrack/tracker_reid_motion.py
+++ /dev/null
@@ -1,397 +0,0 @@
-import numpy as np
-from collections import deque
-import os
-import os.path as osp
-import copy
-import torch
-import torch.nn.functional as F
-
-from mot_online.kalman_filter import KalmanFilter
-from mot_online.basetrack import BaseTrack, TrackState
-from mot_online import matching
-
-
-
-class STrack(BaseTrack):
- shared_kalman = KalmanFilter()
- def __init__(self, tlwh, score, temp_feat, buffer_size=30):
-
- # wait activate
- self._tlwh = np.asarray(tlwh, dtype=np.float)
- self.kalman_filter = None
- self.mean, self.covariance = None, None
- self.is_activated = False
-
- self.score = score
- self.tracklet_len = 0
-
- self.smooth_feat = None
- self.update_features(temp_feat)
- self.features = deque([], maxlen=buffer_size)
- self.alpha = 0.9
-
- def update_features(self, feat):
- feat /= np.linalg.norm(feat)
- self.curr_feat = feat
- if self.smooth_feat is None:
- self.smooth_feat = feat
- else:
- self.smooth_feat = self.alpha * self.smooth_feat + (1 - self.alpha) * feat
- self.features.append(feat)
- self.smooth_feat /= np.linalg.norm(self.smooth_feat)
-
- def predict(self):
- mean_state = self.mean.copy()
- if self.state != TrackState.Tracked:
- mean_state[7] = 0
- self.mean, self.covariance = self.kalman_filter.predict(mean_state, self.covariance)
-
- @staticmethod
- def multi_predict(stracks):
- if len(stracks) > 0:
- multi_mean = np.asarray([st.mean.copy() for st in stracks])
- multi_covariance = np.asarray([st.covariance for st in stracks])
- for i, st in enumerate(stracks):
- if st.state != TrackState.Tracked:
- multi_mean[i][7] = 0
- multi_mean, multi_covariance = STrack.shared_kalman.multi_predict(multi_mean, multi_covariance)
- for i, (mean, cov) in enumerate(zip(multi_mean, multi_covariance)):
- stracks[i].mean = mean
- stracks[i].covariance = cov
-
- def activate(self, kalman_filter, frame_id):
- """Start a new tracklet"""
- self.kalman_filter = kalman_filter
- self.track_id = self.next_id()
- self.mean, self.covariance = self.kalman_filter.initiate(self.tlwh_to_xyah(self._tlwh))
-
- self.tracklet_len = 0
- self.state = TrackState.Tracked
- if frame_id == 1:
- self.is_activated = True
- # self.is_activated = True
- self.frame_id = frame_id
- self.start_frame = frame_id
-
- def re_activate(self, new_track, frame_id, new_id=False):
- self.mean, self.covariance = self.kalman_filter.update(
- self.mean, self.covariance, self.tlwh_to_xyah(new_track.tlwh)
- )
-
- self.update_features(new_track.curr_feat)
- self.tracklet_len = 0
- self.state = TrackState.Tracked
- self.is_activated = True
- self.frame_id = frame_id
- if new_id:
- self.track_id = self.next_id()
-
- def update(self, new_track, frame_id, update_feature=True):
- """
- Update a matched track
- :type new_track: STrack
- :type frame_id: int
- :type update_feature: bool
- :return:
- """
- self.frame_id = frame_id
- self.tracklet_len += 1
-
- new_tlwh = new_track.tlwh
- self.mean, self.covariance = self.kalman_filter.update(
- self.mean, self.covariance, self.tlwh_to_xyah(new_tlwh))
- self.state = TrackState.Tracked
- self.is_activated = True
-
- self.score = new_track.score
- if update_feature:
- self.update_features(new_track.curr_feat)
-
- @property
- # @jit(nopython=True)
- def tlwh(self):
- """Get current position in bounding box format `(top left x, top left y,
- width, height)`.
- """
- if self.mean is None:
- return self._tlwh.copy()
- ret = self.mean[:4].copy()
- ret[2] *= ret[3]
- ret[:2] -= ret[2:] / 2
- return ret
-
- @property
- # @jit(nopython=True)
- def tlbr(self):
- """Convert bounding box to format `(min x, min y, max x, max y)`, i.e.,
- `(top left, bottom right)`.
- """
- ret = self.tlwh.copy()
- ret[2:] += ret[:2]
- return ret
-
- @staticmethod
- # @jit(nopython=True)
- def tlwh_to_xyah(tlwh):
- """Convert bounding box to format `(center x, center y, aspect ratio,
- height)`, where the aspect ratio is `width / height`.
- """
- ret = np.asarray(tlwh).copy()
- ret[:2] += ret[2:] / 2
- ret[2] /= ret[3]
- return ret
-
- def to_xyah(self):
- return self.tlwh_to_xyah(self.tlwh)
-
- @staticmethod
- # @jit(nopython=True)
- def tlbr_to_tlwh(tlbr):
- ret = np.asarray(tlbr).copy()
- ret[2:] -= ret[:2]
- return ret
-
- @staticmethod
- # @jit(nopython=True)
- def tlwh_to_tlbr(tlwh):
- ret = np.asarray(tlwh).copy()
- ret[2:] += ret[:2]
- return ret
-
- def __repr__(self):
- return 'OT_{}_({}-{})'.format(self.track_id, self.start_frame, self.end_frame)
-
-
-class BYTETracker(object):
- def __init__(self, frame_rate=30):
- self.tracked_stracks = [] # type: list[STrack]
- self.lost_stracks = [] # type: list[STrack]
- self.removed_stracks = [] # type: list[STrack]
-
- self.frame_id = 0
-
- self.low_thresh = 0.2
- self.track_thresh = 0.8
- self.det_thresh = self.track_thresh + 0.1
-
-
- self.buffer_size = int(frame_rate / 30.0 * 30)
- self.max_time_lost = self.buffer_size
- self.kalman_filter = KalmanFilter()
-
-# def update(self, output_results):
- def update(self, det_bboxes, det_labels, frame_id, track_feats):
-
-# self.frame_id += 1
- self.frame_id = frame_id + 1
- activated_starcks = []
- refind_stracks = []
- lost_stracks = []
- removed_stracks = []
-
-# scores = output_results[:, 4]
-# bboxes = output_results[:, :4] # x1y1x2y2
- scores = det_bboxes[:, 4].cpu().numpy()
- bboxes = det_bboxes[:, :4].cpu().numpy()
-
- track_feature = F.normalize(track_feats).cpu().numpy()
-
- remain_inds = scores > self.track_thresh
- dets = bboxes[remain_inds]
- scores_keep = scores[remain_inds]
- id_feature = track_feature[remain_inds]
-
-
- inds_low = scores > self.low_thresh
- inds_high = scores < self.track_thresh
- inds_second = np.logical_and(inds_low, inds_high)
- dets_second = bboxes[inds_second]
- scores_second = scores[inds_second]
- id_feature_second = track_feature[inds_second]
-
- if len(dets) > 0:
- '''Detections'''
- detections = [STrack(STrack.tlbr_to_tlwh(tlbr), s, f) for
- (tlbr, s, f) in zip(dets, scores_keep, id_feature)]
- else:
- detections = []
-
-
- ''' Add newly detected tracklets to tracked_stracks'''
- unconfirmed = []
- tracked_stracks = [] # type: list[STrack]
- for track in self.tracked_stracks:
- if not track.is_activated:
- unconfirmed.append(track)
- else:
- tracked_stracks.append(track)
-
- ''' Step 2: First association, with Kalman and IOU'''
- strack_pool = joint_stracks(tracked_stracks, self.lost_stracks)
- # Predict the current location with KF
- STrack.multi_predict(strack_pool)
-
- dists = matching.embedding_distance(strack_pool, detections)
- dists = matching.fuse_motion(self.kalman_filter, dists, strack_pool, detections)
- matches, u_track, u_detection = matching.linear_assignment(dists, thresh=0.6)
-# dists = matching.iou_distance(strack_pool, detections)
-# matches, u_track, u_detection = matching.linear_assignment(dists, thresh=0.8)
-
- for itracked, idet in matches:
- track = strack_pool[itracked]
- det = detections[idet]
- if track.state == TrackState.Tracked:
- track.update(detections[idet], self.frame_id)
- activated_starcks.append(track)
- else:
- track.re_activate(det, self.frame_id, new_id=False)
- refind_stracks.append(track)
-
- ''' Step 3: Second association, with IOU'''
- detections = [detections[i] for i in u_detection]
- r_tracked_stracks = [strack_pool[i] for i in u_track if strack_pool[i].state == TrackState.Tracked]
- dists = matching.iou_distance(r_tracked_stracks, detections)
- matches, u_track, u_detection = matching.linear_assignment(dists, thresh=0.5)
-
- for itracked, idet in matches:
- track = r_tracked_stracks[itracked]
- det = detections[idet]
- if track.state == TrackState.Tracked:
- track.update(det, self.frame_id)
- activated_starcks.append(track)
- else:
- track.re_activate(det, self.frame_id, new_id=False)
- refind_stracks.append(track)
-
-
- ''' Step 3.5: Second association, with IOU'''
- # association the untrack to the low score detections
- if len(dets_second) > 0:
- '''Detections'''
- detections_second = [STrack(STrack.tlbr_to_tlwh(tlbr), s, f) for
- (tlbr, s, f) in zip(dets_second, scores_second, id_feature_second)]
- else:
- detections_second = []
-
- second_tracked_stracks = [r_tracked_stracks[i] for i in u_track if r_tracked_stracks[i].state == TrackState.Tracked]
- dists = matching.iou_distance(second_tracked_stracks, detections_second)
- matches, u_track, u_detection_second = matching.linear_assignment(dists, thresh=0.5)
- for itracked, idet in matches:
- track = second_tracked_stracks[itracked]
- det = detections_second[idet]
- if track.state == TrackState.Tracked:
- track.update(det, self.frame_id)
- activated_starcks.append(track)
- else:
- track.re_activate(det, self.frame_id, new_id=False)
- refind_stracks.append(track)
-
- for it in u_track:
- #track = r_tracked_stracks[it]
- track = second_tracked_stracks[it]
- if not track.state == TrackState.Lost:
- track.mark_lost()
- lost_stracks.append(track)
-
- '''Deal with unconfirmed tracks, usually tracks with only one beginning frame'''
- detections = [detections[i] for i in u_detection]
- dists = matching.iou_distance(unconfirmed, detections)
- matches, u_unconfirmed, u_detection = matching.linear_assignment(dists, thresh=0.7)
- for itracked, idet in matches:
- unconfirmed[itracked].update(detections[idet], self.frame_id)
- activated_starcks.append(unconfirmed[itracked])
- for it in u_unconfirmed:
- track = unconfirmed[it]
- track.mark_removed()
- removed_stracks.append(track)
-
- """ Step 4: Init new stracks"""
- for inew in u_detection:
- track = detections[inew]
- if track.score < self.det_thresh:
- continue
- track.activate(self.kalman_filter, self.frame_id)
- activated_starcks.append(track)
- """ Step 5: Update state"""
- for track in self.lost_stracks:
- if self.frame_id - track.end_frame > self.max_time_lost:
- track.mark_removed()
- removed_stracks.append(track)
-
- # print('Ramained match {} s'.format(t4-t3))
-
- self.tracked_stracks = [t for t in self.tracked_stracks if t.state == TrackState.Tracked]
- self.tracked_stracks = joint_stracks(self.tracked_stracks, activated_starcks)
- self.tracked_stracks = joint_stracks(self.tracked_stracks, refind_stracks)
- self.lost_stracks = sub_stracks(self.lost_stracks, self.tracked_stracks)
- self.lost_stracks.extend(lost_stracks)
- self.lost_stracks = sub_stracks(self.lost_stracks, self.removed_stracks)
- self.removed_stracks.extend(removed_stracks)
- self.tracked_stracks, self.lost_stracks = remove_duplicate_stracks(self.tracked_stracks, self.lost_stracks)
- # get scores of lost tracks
- output_stracks = [track for track in self.tracked_stracks if track.is_activated]
-
-# return output_stracks
-
- bboxes = []
- labels = []
- ids = []
- for track in output_stracks:
- if track.is_activated:
- track_bbox = track.tlbr
- bboxes.append([track_bbox[0], track_bbox[1], track_bbox[2], track_bbox[3], track.score])
- labels.append(0)
- ids.append(track.track_id)
- return torch.tensor(bboxes), torch.tensor(labels), torch.tensor(ids)
-
-def joint_stracks(tlista, tlistb):
- exists = {}
- res = []
- for t in tlista:
- exists[t.track_id] = 1
- res.append(t)
- for t in tlistb:
- tid = t.track_id
- if not exists.get(tid, 0):
- exists[tid] = 1
- res.append(t)
- return res
-
-
-def sub_stracks(tlista, tlistb):
- stracks = {}
- for t in tlista:
- stracks[t.track_id] = t
- for t in tlistb:
- tid = t.track_id
- if stracks.get(tid, 0):
- del stracks[tid]
- return list(stracks.values())
-
-
-def remove_duplicate_stracks(stracksa, stracksb):
- pdist = matching.iou_distance(stracksa, stracksb)
- pairs = np.where(pdist < 0.15)
- dupa, dupb = list(), list()
- for p, q in zip(*pairs):
- timep = stracksa[p].frame_id - stracksa[p].start_frame
- timeq = stracksb[q].frame_id - stracksb[q].start_frame
- if timep > timeq:
- dupb.append(q)
- else:
- dupa.append(p)
- resa = [t for i, t in enumerate(stracksa) if not i in dupa]
- resb = [t for i, t in enumerate(stracksb) if not i in dupb]
- return resa, resb
-
-
-def remove_fp_stracks(stracksa, n_frame=10):
- remain = []
- for t in stracksa:
- score_5 = t.score_list[-n_frame:]
- score_5 = np.array(score_5, dtype=np.float32)
- index = score_5 < 0.45
- num = np.sum(index)
- if num < n_frame:
- remain.append(t)
- return remain
diff --git a/spaces/EPFL-VILAB/MultiMAE/mask2former/modeling/pixel_decoder/ops/src/vision.cpp b/spaces/EPFL-VILAB/MultiMAE/mask2former/modeling/pixel_decoder/ops/src/vision.cpp
deleted file mode 100644
index 4a08821e0121a77556aa7a263ec8ebfa928b13b6..0000000000000000000000000000000000000000
--- a/spaces/EPFL-VILAB/MultiMAE/mask2former/modeling/pixel_decoder/ops/src/vision.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-/*!
-**************************************************************************************************
-* Deformable DETR
-* Copyright (c) 2020 SenseTime. All Rights Reserved.
-* Licensed under the Apache License, Version 2.0 [see LICENSE for details]
-**************************************************************************************************
-* Modified from https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/tree/pytorch_1.0.0
-**************************************************************************************************
-*/
-
-/*!
-* Copyright (c) Facebook, Inc. and its affiliates.
-* Modified by Bowen Cheng from https://github.com/fundamentalvision/Deformable-DETR
-*/
-
-#include "ms_deform_attn.h"
-
-PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
- m.def("ms_deform_attn_forward", &ms_deform_attn_forward, "ms_deform_attn_forward");
- m.def("ms_deform_attn_backward", &ms_deform_attn_backward, "ms_deform_attn_backward");
-}
diff --git a/spaces/EuroPython2022/illustrated-lyrics-generator/layers.py b/spaces/EuroPython2022/illustrated-lyrics-generator/layers.py
deleted file mode 100644
index 135f44e83c28293ef39d0cae684120c20d3b3c73..0000000000000000000000000000000000000000
--- a/spaces/EuroPython2022/illustrated-lyrics-generator/layers.py
+++ /dev/null
@@ -1,273 +0,0 @@
-# Source: https://huggingface.co/huggan/fastgan-few-shot-fauvism-still-life
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from torch.nn.modules.batchnorm import BatchNorm2d
-from torch.nn.utils import spectral_norm
-
-
-class SpectralConv2d(nn.Module):
-
- def __init__(self, *args, **kwargs):
- super().__init__()
- self._conv = spectral_norm(
- nn.Conv2d(*args, **kwargs)
- )
-
- def forward(self, input: torch.Tensor) -> torch.Tensor:
- return self._conv(input)
-
-
-class SpectralConvTranspose2d(nn.Module):
-
- def __init__(self, *args, **kwargs):
- super().__init__()
- self._conv = spectral_norm(
- nn.ConvTranspose2d(*args, **kwargs)
- )
-
- def forward(self, input: torch.Tensor) -> torch.Tensor:
- return self._conv(input)
-
-
-class Noise(nn.Module):
-
- def __init__(self):
- super().__init__()
- self._weight = nn.Parameter(
- torch.zeros(1),
- requires_grad=True,
- )
-
- def forward(self, input: torch.Tensor) -> torch.Tensor:
- batch_size, _, height, width = input.shape
- noise = torch.randn(batch_size, 1, height, width, device=input.device)
- return self._weight * noise + input
-
-
-class InitLayer(nn.Module):
-
- def __init__(self, in_channels: int,
- out_channels: int):
- super().__init__()
-
- self._layers = nn.Sequential(
- SpectralConvTranspose2d(
- in_channels=in_channels,
- out_channels=out_channels * 2,
- kernel_size=4,
- stride=1,
- padding=0,
- bias=False,
- ),
- nn.BatchNorm2d(num_features=out_channels * 2),
- nn.GLU(dim=1),
- )
-
- def forward(self, input: torch.Tensor) -> torch.Tensor:
- return self._layers(input)
-
-
-class SLEBlock(nn.Module):
-
- def __init__(self, in_channels: int,
- out_channels: int):
- super().__init__()
-
- self._layers = nn.Sequential(
- nn.AdaptiveAvgPool2d(output_size=4),
- SpectralConv2d(
- in_channels=in_channels,
- out_channels=out_channels,
- kernel_size=4,
- stride=1,
- padding=0,
- bias=False,
- ),
- nn.SiLU(),
- SpectralConv2d(
- in_channels=out_channels,
- out_channels=out_channels,
- kernel_size=1,
- stride=1,
- padding=0,
- bias=False,
- ),
- nn.Sigmoid(),
- )
-
- def forward(self, low_dim: torch.Tensor,
- high_dim: torch.Tensor) -> torch.Tensor:
- return high_dim * self._layers(low_dim)
-
-
-class UpsampleBlockT1(nn.Module):
-
- def __init__(self, in_channels: int,
- out_channels: int):
- super().__init__()
-
- self._layers = nn.Sequential(
- nn.Upsample(scale_factor=2, mode='nearest'),
- SpectralConv2d(
- in_channels=in_channels,
- out_channels=out_channels * 2,
- kernel_size=3,
- stride=1,
- padding='same',
- bias=False,
- ),
- nn.BatchNorm2d(num_features=out_channels * 2),
- nn.GLU(dim=1),
- )
-
- def forward(self, input: torch.Tensor) -> torch.Tensor:
- return self._layers(input)
-
-
-class UpsampleBlockT2(nn.Module):
-
- def __init__(self, in_channels: int,
- out_channels: int):
- super().__init__()
-
- self._layers = nn.Sequential(
- nn.Upsample(scale_factor=2, mode='nearest'),
- SpectralConv2d(
- in_channels=in_channels,
- out_channels=out_channels * 2,
- kernel_size=3,
- stride=1,
- padding='same',
- bias=False,
- ),
- Noise(),
- BatchNorm2d(num_features=out_channels * 2),
- nn.GLU(dim=1),
- SpectralConv2d(
- in_channels=out_channels,
- out_channels=out_channels * 2,
- kernel_size=3,
- stride=1,
- padding='same',
- bias=False,
- ),
- Noise(),
- nn.BatchNorm2d(num_features=out_channels * 2),
- nn.GLU(dim=1),
- )
-
- def forward(self, input: torch.Tensor) -> torch.Tensor:
- return self._layers(input)
-
-
-class DownsampleBlockT1(nn.Module):
-
- def __init__(self, in_channels: int,
- out_channels: int):
- super().__init__()
-
- self._layers = nn.Sequential(
- SpectralConv2d(
- in_channels=in_channels,
- out_channels=out_channels,
- kernel_size=4,
- stride=2,
- padding=1,
- bias=False,
- ),
- nn.BatchNorm2d(num_features=out_channels),
- nn.LeakyReLU(negative_slope=0.2),
- )
-
- def forward(self, input: torch.Tensor) -> torch.Tensor:
- return self._layers(input)
-
-
-class DownsampleBlockT2(nn.Module):
-
- def __init__(self, in_channels: int,
- out_channels: int):
- super().__init__()
-
- self._layers_1 = nn.Sequential(
- SpectralConv2d(
- in_channels=in_channels,
- out_channels=out_channels,
- kernel_size=4,
- stride=2,
- padding=1,
- bias=False,
- ),
- nn.BatchNorm2d(num_features=out_channels),
- nn.LeakyReLU(negative_slope=0.2),
- SpectralConv2d(
- in_channels=out_channels,
- out_channels=out_channels,
- kernel_size=3,
- stride=1,
- padding='same',
- bias=False,
- ),
- nn.BatchNorm2d(num_features=out_channels),
- nn.LeakyReLU(negative_slope=0.2),
- )
-
- self._layers_2 = nn.Sequential(
- nn.AvgPool2d(
- kernel_size=2,
- stride=2,
- ),
- SpectralConv2d(
- in_channels=in_channels,
- out_channels=out_channels,
- kernel_size=1,
- stride=1,
- padding=0,
- bias=False,
- ),
- nn.BatchNorm2d(num_features=out_channels),
- nn.LeakyReLU(negative_slope=0.2),
- )
-
- def forward(self, input: torch.Tensor) -> torch.Tensor:
- t1 = self._layers_1(input)
- t2 = self._layers_2(input)
- return (t1 + t2) / 2
-
-
-class Decoder(nn.Module):
-
- def __init__(self, in_channels: int,
- out_channels: int):
- super().__init__()
-
- self._channels = {
- 16: 128,
- 32: 64,
- 64: 64,
- 128: 32,
- 256: 16,
- 512: 8,
- 1024: 4,
- }
-
- self._layers = nn.Sequential(
- nn.AdaptiveAvgPool2d(output_size=8),
- UpsampleBlockT1(in_channels=in_channels, out_channels=self._channels[16]),
- UpsampleBlockT1(in_channels=self._channels[16], out_channels=self._channels[32]),
- UpsampleBlockT1(in_channels=self._channels[32], out_channels=self._channels[64]),
- UpsampleBlockT1(in_channels=self._channels[64], out_channels=self._channels[128]),
- SpectralConv2d(
- in_channels=self._channels[128],
- out_channels=out_channels,
- kernel_size=3,
- stride=1,
- padding='same',
- bias=False,
- ),
- nn.Tanh(),
- )
-
- def forward(self, input: torch.Tensor) -> torch.Tensor:
- return self._layers(input)
diff --git a/spaces/FoxMeo/fire-detector/README.md b/spaces/FoxMeo/fire-detector/README.md
deleted file mode 100644
index 9db9f851bd2e89d1064094b01b0389e31344d55f..0000000000000000000000000000000000000000
--- a/spaces/FoxMeo/fire-detector/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Fire Detector
-emoji: 🐢
-colorFrom: blue
-colorTo: indigo
-sdk: gradio
-sdk_version: 3.23.0
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/GT4SD/hf-transformers/utils.py b/spaces/GT4SD/hf-transformers/utils.py
deleted file mode 100644
index 34a817843a959d6ef46ae527efd08788f55a3196..0000000000000000000000000000000000000000
--- a/spaces/GT4SD/hf-transformers/utils.py
+++ /dev/null
@@ -1,48 +0,0 @@
-import logging
-from collections import defaultdict
-from typing import List
-
-import mols2grid
-import pandas as pd
-
-logger = logging.getLogger(__name__)
-logger.addHandler(logging.NullHandler())
-
-
-def draw_grid_generate(
- samples: List[str],
- seeds: List[str] = [],
- n_cols: int = 3,
- size=(140, 200),
-) -> str:
- """
- Uses mols2grid to draw a HTML grid for the generated molecules
-
- Args:
- samples: The generated samples.
- n_cols: Number of columns in grid. Defaults to 5.
- size: Size of molecule in grid. Defaults to (140, 200).
-
- Returns:
- HTML to display
- """
-
- result = defaultdict(list)
- result.update(
- {
- "SMILES": seeds + samples,
- "Name": [f"Seed_{i}" for i in range(len(seeds))]
- + [f"Generated_{i}" for i in range(len(samples))],
- },
- )
-
- result_df = pd.DataFrame(result)
- obj = mols2grid.display(
- result_df,
- tooltip=list(result.keys()),
- height=1100,
- n_cols=n_cols,
- name="Results",
- size=size,
- )
- return obj.data
diff --git a/spaces/GaenKoki/voicevox/voicevox_engine/dev/core/mock.py b/spaces/GaenKoki/voicevox/voicevox_engine/dev/core/mock.py
deleted file mode 100644
index 59eb63d7039b44a27c9e5e17120d83d41763c353..0000000000000000000000000000000000000000
--- a/spaces/GaenKoki/voicevox/voicevox_engine/dev/core/mock.py
+++ /dev/null
@@ -1,121 +0,0 @@
-import json
-from logging import getLogger
-from typing import Any, Dict, List
-
-import numpy as np
-from pyopenjtalk import tts
-from scipy.signal import resample
-
-DUMMY_TEXT = "これはダミーのテキストです"
-
-
-def initialize(path: str, use_gpu: bool, *args: List[Any]) -> None:
- pass
-
-
-def yukarin_s_forward(length: int, **kwargs: Dict[str, Any]) -> np.ndarray:
- logger = getLogger("uvicorn") # FastAPI / Uvicorn 内からの利用のため
- logger.info(
- "Sorry, yukarin_s_forward() is a mock. Return values are incorrect.",
- )
- return np.ones(length) / 5
-
-
-def yukarin_sa_forward(length: int, **kwargs: Dict[str, Any]) -> np.ndarray:
- logger = getLogger("uvicorn") # FastAPI / Uvicorn 内からの利用のため
- logger.info(
- "Sorry, yukarin_sa_forward() is a mock. Return values are incorrect.",
- )
- return np.ones((1, length)) * 5
-
-
-def decode_forward(length: int, **kwargs: Dict[str, Any]) -> np.ndarray:
- """
- 合成音声の波形データをNumPy配列で返します。ただし、常に固定の文言を読み上げます（DUMMY_TEXT）
- 参照→SynthesisEngine のdocstring [Mock]
-
- Parameters
- ----------
- length : int
- フレームの長さ
-
- Returns
- -------
- wave : np.ndarray
- 音声合成した波形データ
-
- Note
- -------
- ここで行う音声合成では、調声（ピッチ等）を反映しない
- また、入力内容によらず常に固定の文言を読み上げる
-
- # pyopenjtalk.tts()の出力仕様
- dtype=np.float64, 16 bit, mono 48000 Hz
-
- # resampleの説明
- 非モックdecode_forwardと合わせるために、出力を24kHzに変換した。
- """
- logger = getLogger("uvicorn") # FastAPI / Uvicorn 内からの利用のため
- logger.info(
- "Sorry, decode_forward() is a mock. Return values are incorrect.",
- )
- wave, sr = tts(DUMMY_TEXT)
- wave = resample(
- wave.astype("int16"),
- 24000 * len(wave) // 48000,
- )
- return wave
-
-
-def metas() -> str:
- return json.dumps(
- [
- {
- "name": "dummy1",
- "styles": [
- {"name": "style0", "id": 0},
- {"name": "style1", "id": 2},
- {"name": "style2", "id": 4},
- {"name": "style3", "id": 6},
- ],
- "speaker_uuid": "7ffcb7ce-00ec-4bdc-82cd-45a8889e43ff",
- "version": "mock",
- },
- {
- "name": "dummy2",
- "styles": [
- {"name": "style0", "id": 1},
- {"name": "style1", "id": 3},
- {"name": "style2", "id": 5},
- {"name": "style3", "id": 7},
- ],
- "speaker_uuid": "388f246b-8c41-4ac1-8e2d-5d79f3ff56d9",
- "version": "mock",
- },
- {
- "name": "dummy3",
- "styles": [
- {"name": "style0", "id": 8},
- ],
- "speaker_uuid": "35b2c544-660e-401e-b503-0e14c635303a",
- "version": "mock",
- },
- {
- "name": "dummy4",
- "styles": [
- {"name": "style0", "id": 9},
- ],
- "speaker_uuid": "b1a81618-b27b-40d2-b0ea-27a9ad408c4b",
- "version": "mock",
- },
- ]
- )
-
-
-def supported_devices() -> str:
- return json.dumps(
- {
- "cpu": True,
- "cuda": False,
- }
- )
diff --git a/spaces/GoldMan/img2prompt/README.md b/spaces/GoldMan/img2prompt/README.md
deleted file mode 100644
index 175d093666664c8804f9292305a40d81290945c8..0000000000000000000000000000000000000000
--- a/spaces/GoldMan/img2prompt/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Img2prompt
-emoji: 🔥
-colorFrom: red
-colorTo: purple
-sdk: streamlit
-sdk_version: 1.10.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/Gradio-Blocks/beat-interpolator/examples/models/mnist/__init__.py b/spaces/Gradio-Blocks/beat-interpolator/examples/models/mnist/__init__.py
deleted file mode 100644
index dbc290f09d0840132a4cf43ff7b8ffa3c67a46ae..0000000000000000000000000000000000000000
--- a/spaces/Gradio-Blocks/beat-interpolator/examples/models/mnist/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-from .model import create_mnist_inference as create
diff --git a/spaces/Gradio-Blocks/protGPT2_gradioFold/README.md b/spaces/Gradio-Blocks/protGPT2_gradioFold/README.md
deleted file mode 100644
index 201d060ce5450312c335214761b044fb978497e4..0000000000000000000000000000000000000000
--- a/spaces/Gradio-Blocks/protGPT2_gradioFold/README.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: ProtGPT2_gradioFold
-emoji: 🧬
-colorFrom: lighblue
-colorTo: blue
-sdk: gradio
-sdk_version: 3.0.4
-app_file: app.py
-pinned: false
-license: mit
----
-
-Let a 735 million parameter language model dream up new sequences and predict their structures using AlphaFold.
-
-Note that only a basic AlphaFold pipeline is used with no refinement using Amber and no MSA as input (single sequence mode).
-
-The code in `app.py` is licensed under MIT license, the AlphaFold code is licensed under Apache2 license by Deepmind, the AlphaFold parameters are available under CC BY 4.0 by Deepmind. protGPT2 by Ferruz et. al. is licensed under MIT.
-
-Used libraries:
-- Huggingface transformers
-- 3Dmol.js
-- Tailwind CSS
-- Gradio
-- Torch and JAx
-- ColabFold
-- AlphaFold
\ No newline at end of file
diff --git a/spaces/Gradio-Blocks/uniformer_image_detection/configs/groie/mask_rcnn_r50_fpn_syncbn-backbone_r4_gcb_c3-c5_groie_1x_coco.py b/spaces/Gradio-Blocks/uniformer_image_detection/configs/groie/mask_rcnn_r50_fpn_syncbn-backbone_r4_gcb_c3-c5_groie_1x_coco.py
deleted file mode 100644
index 852c5ca7c5c4ba04f6a5f7dd6dbaf6b2c357a2fa..0000000000000000000000000000000000000000
--- a/spaces/Gradio-Blocks/uniformer_image_detection/configs/groie/mask_rcnn_r50_fpn_syncbn-backbone_r4_gcb_c3-c5_groie_1x_coco.py
+++ /dev/null
@@ -1,45 +0,0 @@
-_base_ = '../gcnet/mask_rcnn_r50_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco.py'
-# model settings
-model = dict(
- roi_head=dict(
- bbox_roi_extractor=dict(
- type='GenericRoIExtractor',
- aggregation='sum',
- roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=2),
- out_channels=256,
- featmap_strides=[4, 8, 16, 32],
- pre_cfg=dict(
- type='ConvModule',
- in_channels=256,
- out_channels=256,
- kernel_size=5,
- padding=2,
- inplace=False,
- ),
- post_cfg=dict(
- type='GeneralizedAttention',
- in_channels=256,
- spatial_range=-1,
- num_heads=6,
- attention_type='0100',
- kv_stride=2)),
- mask_roi_extractor=dict(
- type='GenericRoIExtractor',
- roi_layer=dict(type='RoIAlign', output_size=14, sampling_ratio=2),
- out_channels=256,
- featmap_strides=[4, 8, 16, 32],
- pre_cfg=dict(
- type='ConvModule',
- in_channels=256,
- out_channels=256,
- kernel_size=5,
- padding=2,
- inplace=False,
- ),
- post_cfg=dict(
- type='GeneralizedAttention',
- in_channels=256,
- spatial_range=-1,
- num_heads=6,
- attention_type='0100',
- kv_stride=2))))
diff --git a/spaces/Gradio-Blocks/uniformer_image_segmentation/configs/unet/deeplabv3_unet_s5-d16_128x128_40k_chase_db1.py b/spaces/Gradio-Blocks/uniformer_image_segmentation/configs/unet/deeplabv3_unet_s5-d16_128x128_40k_chase_db1.py
deleted file mode 100644
index c706cf3548e311a7930e5b58299e05af30c43d98..0000000000000000000000000000000000000000
--- a/spaces/Gradio-Blocks/uniformer_image_segmentation/configs/unet/deeplabv3_unet_s5-d16_128x128_40k_chase_db1.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
- '../_base_/models/deeplabv3_unet_s5-d16.py',
- '../_base_/datasets/chase_db1.py', '../_base_/default_runtime.py',
- '../_base_/schedules/schedule_40k.py'
-]
-model = dict(test_cfg=dict(crop_size=(128, 128), stride=(85, 85)))
-evaluation = dict(metric='mDice')
diff --git a/spaces/Gradio-Blocks/uniformer_image_segmentation/mmseg/ops/wrappers.py b/spaces/Gradio-Blocks/uniformer_image_segmentation/mmseg/ops/wrappers.py
deleted file mode 100644
index 0ed9a0cb8d7c0e0ec2748dd89c652756653cac78..0000000000000000000000000000000000000000
--- a/spaces/Gradio-Blocks/uniformer_image_segmentation/mmseg/ops/wrappers.py
+++ /dev/null
@@ -1,50 +0,0 @@
-import warnings
-
-import torch.nn as nn
-import torch.nn.functional as F
-
-
-def resize(input,
- size=None,
- scale_factor=None,
- mode='nearest',
- align_corners=None,
- warning=True):
- if warning:
- if size is not None and align_corners:
- input_h, input_w = tuple(int(x) for x in input.shape[2:])
- output_h, output_w = tuple(int(x) for x in size)
- if output_h > input_h or output_w > output_h:
- if ((output_h > 1 and output_w > 1 and input_h > 1
- and input_w > 1) and (output_h - 1) % (input_h - 1)
- and (output_w - 1) % (input_w - 1)):
- warnings.warn(
- f'When align_corners={align_corners}, '
- 'the output would more aligned if '
- f'input size {(input_h, input_w)} is `x+1` and '
- f'out size {(output_h, output_w)} is `nx+1`')
- return F.interpolate(input, size, scale_factor, mode, align_corners)
-
-
-class Upsample(nn.Module):
-
- def __init__(self,
- size=None,
- scale_factor=None,
- mode='nearest',
- align_corners=None):
- super(Upsample, self).__init__()
- self.size = size
- if isinstance(scale_factor, tuple):
- self.scale_factor = tuple(float(factor) for factor in scale_factor)
- else:
- self.scale_factor = float(scale_factor) if scale_factor else None
- self.mode = mode
- self.align_corners = align_corners
-
- def forward(self, x):
- if not self.size:
- size = [int(t * self.scale_factor) for t in x.shape[-2:]]
- else:
- size = self.size
- return resize(x, size, None, self.mode, self.align_corners)
diff --git a/spaces/GrandaddyShmax/AudioCraft_Plus/audiocraft/utils/deadlock.py b/spaces/GrandaddyShmax/AudioCraft_Plus/audiocraft/utils/deadlock.py
deleted file mode 100644
index 8abd1bbeea5909e664cf816c020bd7c37effdb66..0000000000000000000000000000000000000000
--- a/spaces/GrandaddyShmax/AudioCraft_Plus/audiocraft/utils/deadlock.py
+++ /dev/null
@@ -1,58 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-import logging
-import os
-from queue import Queue, Empty
-import signal
-import sys
-import threading
-import traceback
-
-logger = logging.getLogger(__name__)
-
-
-class DeadlockDetect:
- def __init__(self, use: bool = False, timeout: float = 120.):
- self.use = use
- self.timeout = timeout
- self._queue: Queue = Queue()
-
- def update(self, stage: str):
- if self.use:
- self._queue.put(stage)
-
- def __enter__(self):
- if self.use:
- self._thread = threading.Thread(target=self._detector_thread)
- self._thread.start()
-
- def __exit__(self, exc_type, exc_val, exc_tb):
- if self.use:
- self._queue.put(None)
- self._thread.join()
-
- def _detector_thread(self):
- logger.debug("Deadlock detector started")
- last_stage = "init"
- while True:
- try:
- stage = self._queue.get(timeout=self.timeout)
- except Empty:
- break
- if stage is None:
- logger.debug("Exiting deadlock detector thread")
- return
- else:
- last_stage = stage
- logger.error("Deadlock detector timed out, last stage was %s", last_stage)
- for th in threading.enumerate():
- print(th, file=sys.stderr)
- traceback.print_stack(sys._current_frames()[th.ident])
- print(file=sys.stderr)
- sys.stdout.flush()
- sys.stderr.flush()
- os.kill(os.getpid(), signal.SIGKILL)
diff --git a/spaces/Grezz/generate_human_motion/VQ-Trans/dataset/dataset_tokenize.py b/spaces/Grezz/generate_human_motion/VQ-Trans/dataset/dataset_tokenize.py
deleted file mode 100644
index 641a02a75f2cfaadea45851cad2a95b39bfa1eae..0000000000000000000000000000000000000000
--- a/spaces/Grezz/generate_human_motion/VQ-Trans/dataset/dataset_tokenize.py
+++ /dev/null
@@ -1,117 +0,0 @@
-import torch
-from torch.utils import data
-import numpy as np
-from os.path import join as pjoin
-import random
-import codecs as cs
-from tqdm import tqdm
-
-
-
-class VQMotionDataset(data.Dataset):
- def __init__(self, dataset_name, feat_bias = 5, window_size = 64, unit_length = 8):
- self.window_size = window_size
- self.unit_length = unit_length
- self.feat_bias = feat_bias
-
- self.dataset_name = dataset_name
- min_motion_len = 40 if dataset_name =='t2m' else 24
-
- if dataset_name == 't2m':
- self.data_root = './dataset/HumanML3D'
- self.motion_dir = pjoin(self.data_root, 'new_joint_vecs')
- self.text_dir = pjoin(self.data_root, 'texts')
- self.joints_num = 22
- radius = 4
- fps = 20
- self.max_motion_length = 196
- dim_pose = 263
- self.meta_dir = 'checkpoints/t2m/VQVAEV3_CB1024_CMT_H1024_NRES3/meta'
- #kinematic_chain = paramUtil.t2m_kinematic_chain
- elif dataset_name == 'kit':
- self.data_root = './dataset/KIT-ML'
- self.motion_dir = pjoin(self.data_root, 'new_joint_vecs')
- self.text_dir = pjoin(self.data_root, 'texts')
- self.joints_num = 21
- radius = 240 * 8
- fps = 12.5
- dim_pose = 251
- self.max_motion_length = 196
- self.meta_dir = 'checkpoints/kit/VQVAEV3_CB1024_CMT_H1024_NRES3/meta'
- #kinematic_chain = paramUtil.kit_kinematic_chain
-
- joints_num = self.joints_num
-
- mean = np.load(pjoin(self.meta_dir, 'mean.npy'))
- std = np.load(pjoin(self.meta_dir, 'std.npy'))
-
- split_file = pjoin(self.data_root, 'train.txt')
-
- data_dict = {}
- id_list = []
- with cs.open(split_file, 'r') as f:
- for line in f.readlines():
- id_list.append(line.strip())
-
- new_name_list = []
- length_list = []
- for name in tqdm(id_list):
- try:
- motion = np.load(pjoin(self.motion_dir, name + '.npy'))
- if (len(motion)) < min_motion_len or (len(motion) >= 200):
- continue
-
- data_dict[name] = {'motion': motion,
- 'length': len(motion),
- 'name': name}
- new_name_list.append(name)
- length_list.append(len(motion))
- except:
- # Some motion may not exist in KIT dataset
- pass
-
-
- self.mean = mean
- self.std = std
- self.length_arr = np.array(length_list)
- self.data_dict = data_dict
- self.name_list = new_name_list
-
- def inv_transform(self, data):
- return data * self.std + self.mean
-
- def __len__(self):
- return len(self.data_dict)
-
- def __getitem__(self, item):
- name = self.name_list[item]
- data = self.data_dict[name]
- motion, m_length = data['motion'], data['length']
-
- m_length = (m_length // self.unit_length) * self.unit_length
-
- idx = random.randint(0, len(motion) - m_length)
- motion = motion[idx:idx+m_length]
-
- "Z Normalization"
- motion = (motion - self.mean) / self.std
-
- return motion, name
-
-def DATALoader(dataset_name,
- batch_size = 1,
- num_workers = 8, unit_length = 4) :
-
- train_loader = torch.utils.data.DataLoader(VQMotionDataset(dataset_name, unit_length=unit_length),
- batch_size,
- shuffle=True,
- num_workers=num_workers,
- #collate_fn=collate_fn,
- drop_last = True)
-
- return train_loader
-
-def cycle(iterable):
- while True:
- for x in iterable:
- yield x
diff --git a/spaces/Grezz/generate_human_motion/VQ-Trans/utils/losses.py b/spaces/Grezz/generate_human_motion/VQ-Trans/utils/losses.py
deleted file mode 100644
index 1998161032731fc2c3edae701700679c00fd00d0..0000000000000000000000000000000000000000
--- a/spaces/Grezz/generate_human_motion/VQ-Trans/utils/losses.py
+++ /dev/null
@@ -1,30 +0,0 @@
-import torch
-import torch.nn as nn
-
-class ReConsLoss(nn.Module):
- def __init__(self, recons_loss, nb_joints):
- super(ReConsLoss, self).__init__()
-
- if recons_loss == 'l1':
- self.Loss = torch.nn.L1Loss()
- elif recons_loss == 'l2' :
- self.Loss = torch.nn.MSELoss()
- elif recons_loss == 'l1_smooth' :
- self.Loss = torch.nn.SmoothL1Loss()
-
- # 4 global motion associated to root
- # 12 local motion (3 local xyz, 3 vel xyz, 6 rot6d)
- # 3 global vel xyz
- # 4 foot contact
- self.nb_joints = nb_joints
- self.motion_dim = (nb_joints - 1) * 12 + 4 + 3 + 4
-
- def forward(self, motion_pred, motion_gt) :
- loss = self.Loss(motion_pred[..., : self.motion_dim], motion_gt[..., :self.motion_dim])
- return loss
-
- def forward_vel(self, motion_pred, motion_gt) :
- loss = self.Loss(motion_pred[..., 4 : (self.nb_joints - 1) * 3 + 4], motion_gt[..., 4 : (self.nb_joints - 1) * 3 + 4])
- return loss
-
-
\ No newline at end of file
diff --git a/spaces/Guying2/guying/Dockerfile b/spaces/Guying2/guying/Dockerfile
deleted file mode 100644
index 535624113f3b520e4829240a48bd3652430de828..0000000000000000000000000000000000000000
--- a/spaces/Guying2/guying/Dockerfile
+++ /dev/null
@@ -1,23 +0,0 @@
-FROM openjdk:17-slim
-
-# 设置时区
-ENV TZ Asia/Shanghai
-
-# 设置工作目录
-WORKDIR /app
-
-# 复制文件到工作目录
-COPY bin /app/bin
-COPY lib /app/lib
-COPY txlib /app/txlib
-
-# 设置命令
-RUN chmod -R 777 /tmp
-RUN chmod -R 777 /app
-RUN sed 's/"key": ".*"/"key": "'"$KEY_VALUE"'"/' txlib/$TXLIB_VERSION/config.json > /app/txlib/$TXLIB_VERSION/config.json
-
-# 运行
-CMD bash bin/unidbg-fetch-qsign --basePath=txlib/$TXLIB_VERSION
-
-# 暴露端口
-EXPOSE 7860
\ No newline at end of file
diff --git a/spaces/HaHaBill/LandShapes-Antarctica/TkTorchWindow.py b/spaces/HaHaBill/LandShapes-Antarctica/TkTorchWindow.py
deleted file mode 100644
index fbe1ef1cc35c2590b0a5976254af3f146de4d9b3..0000000000000000000000000000000000000000
--- a/spaces/HaHaBill/LandShapes-Antarctica/TkTorchWindow.py
+++ /dev/null
@@ -1,208 +0,0 @@
-# Copyright 2020 Erik Härkönen. All rights reserved.
-# This file is licensed to you under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License. You may obtain a copy
-# of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-# Unless required by applicable law or agreed to in writing, software distributed under
-# the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
-# OF ANY KIND, either express or implied. See the License for the specific language
-# governing permissions and limitations under the License.
-
-import tkinter as tk
-import numpy as np
-import time
-from contextlib import contextmanager
-import pycuda.driver
-from pycuda.gl import graphics_map_flags
-from glumpy import gloo, gl
-from pyopengltk import OpenGLFrame
-import torch
-from torch.autograd import Variable
-
-# TkInter widget that can draw torch tensors directly from GPU memory
-
-@contextmanager
-def cuda_activate(img):
- """Context manager simplifying use of pycuda.gl.RegisteredImage"""
- mapping = img.map()
- yield mapping.array(0,0)
- mapping.unmap()
-
-def create_shared_texture(w, h, c=4,
- map_flags=graphics_map_flags.WRITE_DISCARD,
- dtype=np.uint8):
- """Create and return a Texture2D with gloo and pycuda views."""
- tex = np.zeros((h,w,c), dtype).view(gloo.Texture2D)
- tex.activate() # force gloo to create on GPU
- tex.deactivate()
- cuda_buffer = pycuda.gl.RegisteredImage(
- int(tex.handle), tex.target, map_flags)
- return tex, cuda_buffer
-
-# Shape batch as square if possible
-def get_grid_dims(B):
- S = int(B**0.5 + 0.5)
- while B % S != 0:
- S -= 1
- return (B // S, S)
-
-def create_gl_texture(tensor_shape):
- if len(tensor_shape) != 4:
- raise RuntimeError('Please provide a tensor of shape NCHW')
-
- N, C, H, W = tensor_shape
-
- cols, rows = get_grid_dims(N)
- tex, cuda_buffer = create_shared_texture(W*cols, H*rows, 4)
-
- return tex, cuda_buffer
-
-# Create window with OpenGL context
-class TorchImageView(OpenGLFrame):
- def __init__(self, root = None, show_fps=True, **kwargs):
- self.root = root or tk.Tk()
- self.width = kwargs.get('width', 512)
- self.height = kwargs.get('height', 512)
- self.show_fps = show_fps
- self.pycuda_initialized = False
- self.animate = 0 # disable internal main loop
- OpenGLFrame.__init__(self, root, **kwargs)
-
- # Called by pyopengltk.BaseOpenGLFrame
- # when the frame goes onto the screen
- def initgl(self):
- if not self.pycuda_initialized:
- self.setup_gl(self.width, self.height)
- self.pycuda_initialized = True
-
- """Initalize gl states when the frame is created"""
- gl.glViewport(0, 0, self.width, self.height)
- gl.glClearColor(0.0, 0.0, 0.0, 0.0)
- self.dt_history = [1000/60]
- self.t0 = time.time()
- self.t_last = self.t0
- self.nframes = 0
-
- def setup_gl(self, width, height):
- # setup pycuda and torch
- import pycuda.gl.autoinit
- import pycuda.gl
-
- assert torch.cuda.is_available(), "PyTorch: CUDA is not available"
- print('Using GPU {}'.format(torch.cuda.current_device()))
-
- # Create tensor to be shared between GL and CUDA
- # Always overwritten so no sharing is necessary
- dummy = torch.cuda.FloatTensor((1))
- dummy.uniform_()
- dummy = Variable(dummy)
-
- # Create a buffer with pycuda and gloo views, using tensor created above
- self.tex, self.cuda_buffer = create_gl_texture((1, 3, width, height))
-
- # create a shader to program to draw to the screen
- vertex = """
- uniform float scale;
- attribute vec2 position;
- attribute vec2 texcoord;
- varying vec2 v_texcoord;
- void main()
- {
- v_texcoord = texcoord;
- gl_Position = vec4(scale*position, 0.0, 1.0);
- } """
- fragment = """
- uniform sampler2D tex;
- varying vec2 v_texcoord;
- void main()
- {
- gl_FragColor = texture2D(tex, v_texcoord);
- } """
- # Build the program and corresponding buffers (with 4 vertices)
- self.screen = gloo.Program(vertex, fragment, count=4)
-
- # NDC coordinates: Texcoords: Vertex order,
- # (-1, +1) (+1, +1) (0,0) (1,0) triangle strip:
- # +-------+ +----+ 1----3
- # | NDC | | | | / |
- # | SPACE | | | | / |
- # +-------+ +----+ 2----4
- # (-1, -1) (+1, -1) (0,1) (1,1)
-
- # Upload data to GPU
- self.screen['position'] = [(-1,+1), (-1,-1), (+1,+1), (+1,-1)]
- self.screen['texcoord'] = [(0,0), (0,1), (1,0), (1,1)]
- self.screen['scale'] = 1.0
- self.screen['tex'] = self.tex
-
- # Don't call directly, use update() instead
- def redraw(self):
- t_now = time.time()
- dt = t_now - self.t_last
- self.t_last = t_now
-
- self.dt_history = ([dt] + self.dt_history)[:50]
- dt_mean = sum(self.dt_history) / len(self.dt_history)
-
- if self.show_fps and self.nframes % 60 == 0:
- self.master.title('FPS: {:.0f}'.format(1 / dt_mean))
-
- def draw(self, img):
- assert len(img.shape) == 4, "Please provide an NCHW image tensor"
- assert img.device.type == "cuda", "Please provide a CUDA tensor"
-
- if img.dtype.is_floating_point:
- img = (255*img).byte()
-
- # Tile images
- N, C, H, W = img.shape
-
- if N > 1:
- cols, rows = get_grid_dims(N)
- img = img.reshape(cols, rows, C, H, W)
- img = img.permute(2, 1, 3, 0, 4) # [C, rows, H, cols, W]
- img = img.reshape(1, C, rows*H, cols*W)
-
- tensor = img.squeeze().permute(1, 2, 0).data # CHW => HWC
- if C == 3:
- tensor = torch.cat((tensor, tensor[:,:,0:1]),2) # add the alpha channel
- tensor[:,:,3] = 1 # set alpha
-
- tensor = tensor.contiguous()
-
- tex_h, tex_w, _ = self.tex.shape
- tensor_h, tensor_w, _ = tensor.shape
-
- if (tex_h, tex_w) != (tensor_h, tensor_w):
- print(f'Resizing texture to {tensor_w}*{tensor_h}')
- self.tex, self.cuda_buffer = create_gl_texture((N, C, H, W)) # original shape
- self.screen['tex'] = self.tex
-
- # copy from torch into buffer
- assert self.tex.nbytes == tensor.numel()*tensor.element_size(), "Tensor and texture shape mismatch!"
- with cuda_activate(self.cuda_buffer) as ary:
- cpy = pycuda.driver.Memcpy2D()
- cpy.set_src_device(tensor.data_ptr())
- cpy.set_dst_array(ary)
- cpy.width_in_bytes = cpy.src_pitch = cpy.dst_pitch = self.tex.nbytes//tensor_h
- cpy.height = tensor_h
- cpy(aligned=False)
- torch.cuda.synchronize()
-
- # draw to screen
- self.screen.draw(gl.GL_TRIANGLE_STRIP)
-
- def update(self):
- self.update_idletasks()
- self.tkMakeCurrent()
- self.redraw()
- self.tkSwapBuffers()
-
-# USAGE:
-# root = tk.Tk()
-# iv = TorchImageView(root, width=512, height=512)
-# iv.pack(fill='both', expand=True)
-# while True:
-# iv.draw(nchw_tensor)
-# root.update()
-# iv.update()
\ No newline at end of file
diff --git a/spaces/Harveenchadha/oiTrans/indic_nlp_library/README.md b/spaces/Harveenchadha/oiTrans/indic_nlp_library/README.md
deleted file mode 100644
index 0b7f8a82798e3ee874f8f838a635f89290d3e47e..0000000000000000000000000000000000000000
--- a/spaces/Harveenchadha/oiTrans/indic_nlp_library/README.md
+++ /dev/null
@@ -1,142 +0,0 @@
-# Indic NLP Library
-
-The goal of the Indic NLP Library is to build Python based libraries for common text processing and Natural Language Processing in Indian languages. Indian languages share a lot of similarity in terms of script, phonology, language syntax, etc. and this library is an attempt to provide a general solution to very commonly required toolsets for Indian language text.
-
-The library provides the following functionalities:
-
-- Text Normalization
-- Script Information
-- Word Tokenization and Detokenization
-- Sentence Splitting
-- Word Segmentation
-- Syllabification
-- Script Conversion
-- Romanization
-- Indicization
-- Transliteration
-- Translation
-
-The data resources required by the Indic NLP Library are hosted in a different repository. These resources are required for some modules. You can download from the [Indic NLP Resources](https://github.com/anoopkunchukuttan/indic_nlp_resources) project.
-
-**If you are interested in Indian language NLP resources, you should check the [Indic NLP Catalog](https://github.com/indicnlpweb/indicnlp_catalog) for pointers.**
-
-## Pre-requisites
-
-- Python 3.x
- - (For Python 2.x version check the tag `PYTHON_2.7_FINAL_JAN_2019`. Not actively supporting Python 2.x anymore, but will try to maintain as much compatibility as possible)
-- [Indic NLP Resources](https://github.com/anoopkunchukuttan/indic_nlp_resources)
-- [Urduhack](https://github.com/urduhack/urduhack): Needed only if Urdu normalization is required. It has other dependencies like Tensorflow.
-- Other dependencies are listed in setup.py
-
-
-## Configuration
-
-- Installation from pip:
-
- `pip install indic-nlp-library`
-
-- If you want to use the project from the github repo, add the project to the Python Path:
-
- - Clone this repository
- - Install dependencies: `pip install -r requirements.txt`
- - Run: `export PYTHONPATH=$PYTHONPATH:<project base directory>`
-
-- In either case, export the path to the _Indic NLP Resources_ directory
-
- Run: `export INDIC_RESOURCES_PATH=<path to Indic NLP resources>`
-
-## Usage
-
-You can use the Python API to access all the features of the library. Many of the most common operations are also accessible via a unified commandline API.
-
-### Getting Started
-
-Check [this IPython Notebook](http://nbviewer.ipython.org/url/anoopkunchukuttan.github.io/indic_nlp_library/doc/indic_nlp_examples.ipynb) for examples to use the Python API.
- - You can find the Python 2.x Notebook [here](http://nbviewer.ipython.org/url/anoopkunchukuttan.github.io/indic_nlp_library/doc/indic_nlp_examples_2_7.ipynb)
-
-### Documentation
-
-You can find detailed documentation [HERE](https://indic-nlp-library.readthedocs.io/en/latest)
-
-This documents the Python API as well as the commandline reference.
-
-## Citing
-
-If you use this library, please include the following citation:
-
-```
-@misc{kunchukuttan2020indicnlp,
-author = "Anoop Kunchukuttan",
-title = "{The IndicNLP Library}",
-year = "2020",
-howpublished={\url{https://github.com/anoopkunchukuttan/indic_nlp_library/blob/master/docs/indicnlp.pdf}}
-}
-```
-You can find the document [HERE](docs/indicnlp.pdf)
-
-## Website
-
-`http://anoopkunchukuttan.github.io/indic_nlp_library`
-
-## Author
-Anoop Kunchukuttan ([anoop.kunchukuttan@gmail.com](anoop.kunchukuttan@gmail.com))
-
-## Companies, Organizations, Projects using IndicNLP Library
-
-- [AI4Bharat-IndicNLPSuite](https://indicnlp.ai4bharat.org)
-- [The Classical Language Toolkit](http://cltk.org)
-- [Microsoft NLP Recipes](https://github.com/microsoft/nlp-recipes)
-- [Facebook M2M-100](https://github.com/pytorch/fairseq/tree/master/examples/m2m_100)
-
-## Revision Log
-
-
-0.81 : 26 May 2021
-
- - Bug fix in version number extraction
-
-0.80 : 24 May 2021
-
- - Improved sentence splitting
- - Bug fixes
- - Support for Urdu Normalizer
-
-0.71 : 03 Sep 2020
-
- - Improved documentation
- - Bug fixes
-
-0.7 : 02 Apr 2020:
-
- - Unified commandline
- - Improved documentation
- - Added setup.py
-
-0.6 : 16 Dec 2019:
-
- - New romanizer and indicizer
- - Script Unifiers
- - Improved script normalizers
- - Added contrib directory for sample uses
- - changed to MIT license
-
-0.5 : 03 Jun 2019:
-
- - Improved word tokenizer to handle dates and numbers.
- - Added sentence splitter that can handle common prefixes/honorofics and uses some heuristics.
- - Added detokenizer
- - Added acronym transliterator that can convert English acronyms to Brahmi-derived scripts
-
-0.4 : 28 Jan 2019: Ported to Python 3, and lots of feature additions since last release; primarily around script information, script similarity and syllabification.
-
-0.3 : 21 Oct 2014: Supports morph-analysis between Indian languages
-
-0.2 : 13 Jun 2014: Supports transliteration between Indian languages and tokenization of Indian languages
-
-0.1 : 12 Mar 2014: Initial version. Supports text normalization.
-
-## LICENSE
-
-Indic NLP Library is released under the MIT license
-
-
diff --git a/spaces/Harveenchadha/oiTrans/indic_nlp_library/setup.py b/spaces/Harveenchadha/oiTrans/indic_nlp_library/setup.py
deleted file mode 100644
index 8b132dc2faeab6c863c6d5ecf04863b2191afdcb..0000000000000000000000000000000000000000
--- a/spaces/Harveenchadha/oiTrans/indic_nlp_library/setup.py
+++ /dev/null
@@ -1,48 +0,0 @@
-import setuptools
-from pkg_resources import parse_requirements
-import pathlib
-import os
-
-def write_version_py():
- with open(os.path.join("indicnlp", "version.txt")) as f:
- version = f.read().strip()
-
- # write version info to fairseq/version.py
- with open(os.path.join("indicnlp", "version.py"), "w") as f:
- f.write('__version__ = "{}"\n'.format(version))
- return version
-
-with open("README.md", "r") as fh:
- long_description = fh.read()
-
-version=write_version_py()
-
-setuptools.setup(
- name="indic_nlp_library", # Replace with your own username
- version=version,
- author="Anoop Kunchukuttan",
- author_email="anoop.kunchukuttan@gmail.com",
- description="The goal of the Indic NLP Library is to build Python based libraries for common"\
- ' text processing and Natural Language Processing in Indian languages.',
- long_description=long_description,
- long_description_content_type="text/markdown",
- url="https://github.com/anoopkunchukuttan/indic_nlp_library",
- # project_urls={
- # "Bug Tracker": "https://bugs.example.com/HelloWorld/",
- # "Documentation": "https://docs.example.com/HelloWorld/",
- # "Source Code": "https://code.example.com/HelloWorld/",
- # },
- packages=setuptools.find_packages(),
- license='MIT',
- classifiers=[
- "Programming Language :: Python :: 3",
- "License :: OSI Approved :: MIT License",
- "Operating System :: OS Independent",
- ],
- python_requires='>=3.5',
- download_url='https://github.com/anoopkunchukuttan/indic_nlp_library/archive/master.zip',
- install_requires=[
- str(requirement) for requirement
- in parse_requirements(pathlib.Path('requirements.txt').open())
- ]
-)
diff --git a/spaces/HighCWu/anime-colorization-with-hint/gradio-modified/gradio/__init__.py b/spaces/HighCWu/anime-colorization-with-hint/gradio-modified/gradio/__init__.py
deleted file mode 100644
index f2d88f3ae975848f6583c6a41ce0e90e5c505154..0000000000000000000000000000000000000000
--- a/spaces/HighCWu/anime-colorization-with-hint/gradio-modified/gradio/__init__.py
+++ /dev/null
@@ -1,86 +0,0 @@
-import pkgutil
-
-import gradio.components as components
-import gradio.inputs as inputs
-import gradio.outputs as outputs
-import gradio.processing_utils
-import gradio.templates
-from gradio.blocks import Blocks
-from gradio.components import (
- HTML,
- JSON,
- Audio,
- Button,
- Carousel,
- Chatbot,
- Checkbox,
- Checkboxgroup,
- CheckboxGroup,
- ColorPicker,
- DataFrame,
- Dataframe,
- Dataset,
- Dropdown,
- File,
- Gallery,
- Highlight,
- Highlightedtext,
- HighlightedText,
- Image,
- Interpretation,
- Json,
- Label,
- LinePlot,
- Markdown,
- Model3D,
- Number,
- Plot,
- Radio,
- ScatterPlot,
- Slider,
- State,
- StatusTracker,
- Text,
- Textbox,
- TimeSeries,
- Timeseries,
- UploadButton,
- Variable,
- Video,
- component,
-)
-from gradio.exceptions import Error
-from gradio.flagging import (
- CSVLogger,
- FlaggingCallback,
- HuggingFaceDatasetJSONSaver,
- HuggingFaceDatasetSaver,
- SimpleCSVLogger,
-)
-from gradio.helpers import Progress
-from gradio.helpers import create_examples as Examples
-from gradio.helpers import make_waveform, skip, update
-from gradio.interface import Interface, TabbedInterface, close_all
-from gradio.ipython_ext import load_ipython_extension
-from gradio.layouts import Accordion, Box, Column, Group, Row, Tab, TabItem, Tabs
-from gradio.mix import Parallel, Series
-from gradio.routes import Request, mount_gradio_app
-from gradio.templates import (
- Files,
- ImageMask,
- ImagePaint,
- List,
- Matrix,
- Mic,
- Microphone,
- Numpy,
- Paint,
- Pil,
- PlayableVideo,
- Sketchpad,
- TextArea,
- Webcam,
-)
-
-current_pkg_version = pkgutil.get_data(__name__, "version.txt").decode("ascii").strip()
-__version__ = current_pkg_version
diff --git a/spaces/HuggingFaceM4/IDEFICS_Data_Measurement_Tool/data_measurements/npmi/__init__.py b/spaces/HuggingFaceM4/IDEFICS_Data_Measurement_Tool/data_measurements/npmi/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/HugoLaurencon/text-data-filtering-2/stopwords.py b/spaces/HugoLaurencon/text-data-filtering-2/stopwords.py
deleted file mode 100644
index c191a2b5cbd69ae38971b6bbc3991a1c6a35d9e3..0000000000000000000000000000000000000000
--- a/spaces/HugoLaurencon/text-data-filtering-2/stopwords.py
+++ /dev/null
@@ -1,7174 +0,0 @@
-# From https://github.com/6/stopwords-json
-# From https://github.com/stopwords-iso/stopwords-iso for Urdu and Vietnamese
-
-
-stopwords = {
- "af": [
- "'n",
- "aan",
- "af",
- "al",
- "as",
- "baie",
- "by",
- "daar",
- "dag",
- "dat",
- "die",
- "dit",
- "een",
- "ek",
- "en",
- "gaan",
- "gesê",
- "haar",
- "het",
- "hom",
- "hulle",
- "hy",
- "in",
- "is",
- "jou",
- "jy",
- "kan",
- "kom",
- "ma",
- "maar",
- "met",
- "my",
- "na",
- "nie",
- "om",
- "ons",
- "op",
- "saam",
- "sal",
- "se",
- "sien",
- "so",
- "sy",
- "te",
- "toe",
- "uit",
- "van",
- "vir",
- "was",
- "wat",
- "ʼn",
- ],
- "ar": [
- "آنذاك",
- "أبداً",
- "أثناء",
- "أسفل",
- "أعلى",
- "أغلب",
- "أكثر",
- "ألا",
- "ألم",
- "أم",
- "أمام",
- "أمس",
- "أن",
- "أنا",
- "أنت",
- "أنتم",
- "أنتما",
- "أنتن",
- "أو",
- "أولئك",
- "أي",
- "أيان",
- "أياً",
- "أية",
- "أيضاً",
- "أين",
- "أينما",
- "إبان",
- "إثر",
- "إثر ذلك",
- "إذا",
- "إزاء",
- "إلا",
- "إلا أن",
- "إلى",
- "إما",
- "إن",
- "إنما",
- "إياك",
- "إياكم",
- "إياكما",
- "إياكن",
- "إيانا",
- "إياه",
- "إياها",
- "إياهم",
- "إياهما",
- "إياهن",
- "إياي",
- "الآن",
- "البتة",
- "التي",
- "الذي",
- "الذين",
- "اللائي",
- "اللات",
- "اللاتي",
- "اللتان",
- "اللتين",
- "اللذان",
- "اللذين",
- "اللهم",
- "اللوات",
- "اللواتي",
- "الليلة",
- "اليوم",
- "اي",
- "بألا",
- "بأن",
- "بئس",
- "بئست",
- "باتجاه",
- "بالأخص",
- "بالأمس",
- "بالتالي",
- "بالذات",
- "بالرغم من",
- "بالضبط",
- "بالطبع",
- "بالفعل",
- "بالقرب",
- "بالكامل",
- "بالنسبة ل",
- "بتاتاً",
- "بجانب",
- "بحسب",
- "بحوالي",
- "بحيث",
- "بذلك",
- "برغم",
- "برمته",
- "بشتى",
- "بصرف النظر عن",
- "بضع",
- "بضعة",
- "بعد",
- "بعدما",
- "بعض",
- "بغض الطرف عن",
- "بغض النظر عن",
- "بغية",
- "بـ",
- "بقرب",
- "بل",
- "بلا",
- "بلى",
- "بم",
- "بما",
- "بما أن",
- "بمفرده",
- "بمقتضى",
- "بمنأى عن",
- "بموجب",
- "بين",
- "بينما",
- "تاماً",
- "تباعاً",
- "تبعاً",
- "تجاه",
- "تحت",
- "تحديداً",
- "تحسباً",
- "تقريباً",
- "تلك",
- "تلو",
- "تماماً",
- "تمشياً",
- "ثم",
- "ثمة",
- "جانب",
- "جاهداً",
- "جداً",
- "جدياً",
- "جراء",
- "جل",
- "جميع",
- "جميعاً",
- "جنوب",
- "جنوبي",
- "حتماً",
- "حتمياً",
- "حتى",
- "حسب",
- "حسبما",
- "حوالي",
- "حول",
- "حيال",
- "حيث",
- "حيث أن",
- "حيثما",
- "حين",
- "حينئذ",
- "حيناً",
- "حينذاك",
- "حينما",
- "خارج",
- "ختاماً",
- "خلال",
- "خلف",
- "دائماً",
- "داخل",
- "دوماً",
- "دون",
- "دونما",
- "ذاك",
- "ذلك",
- "رغم",
- "رغم أن",
- "ريثما",
- "زهاء",
- "ساعة",
- "سنة",
- "سوف",
- "سوى",
- "سوياً",
- "شتى",
- "شرق",
- "شريطة",
- "شكراً",
- "شمال",
- "صبيحة",
- "صوب",
- "ضد",
- "طالما",
- "طبقاً",
- "طواعية",
- "طوعاً",
- "طيلة",
- "عادة",
- "عام",
- "عامة",
- "عبر",
- "عدا",
- "عدة",
- "عسى",
- "عشية",
- "عقب",
- "علاوة على",
- "علاوة على ذلك",
- "على",
- "على الرغم من",
- "على حد قول",
- "على غرار",
- "على هذا",
- "عما",
- "عمن",
- "عموماً",
- "عن",
- "عند",
- "عندئذ",
- "عندما",
- "عنوة",
- "عوضا عن",
- "غالب",
- "غالباً",
- "غداة",
- "غداً",
- "غرب",
- "غير",
- "غير أن",
- "ـك",
- "ـكم",
- "ـكما",
- "ـكن",
- "ـنا",
- "ـه",
- "ـها",
- "ـهم",
- "ـهما",
- "ـهن",
- "ـي",
- "فجأة",
- "فجر",
- "فحسب",
- "فصاعداً",
- "فضلاً",
- "فـ",
- "فور",
- "فوراً",
- "فوق",
- "في",
- "في تلك الأثناء",
- "في غضون ذلك",
- "في هذه الأثناء",
- "فيما",
- "فيما يلي",
- "قبالة",
- "قبل",
- "قبيل",
- "قد",
- "قدماً",
- "قرابة",
- "قرب",
- "قسراً",
- "قطعياً",
- "قليلاً",
- "كأن",
- "كالمعتاد",
- "كثيراً",
- "كذا",
- "كذلك",
- "كـ",
- "كل",
- "كلا",
- "كلتا",
- "كلما",
- "كم",
- "كما",
- "كما أن",
- "كي",
- "كيف",
- "لأن",
- "لئلا",
- "لا",
- "لا بأس أن",
- "لا بد",
- "لا سيما",
- "لا لبس أن",
- "لا مانع",
- "لابد",
- "لاحقاً",
- "لاسيما",
- "لحظة",
- "لحوالي",
- "لدى",
- "لذا",
- "لذلك",
- "لعل",
- "لـ",
- "لقد",
- "لكن",
- "لكي",
- "للتو",
- "لم",
- "لما",
- "لماذا",
- "لن",
- "لو",
- "لولا",
- "ليت",
- "ليلة",
- "مؤخراً",
- "مؤقتاً",
- "ما",
- "ماذا",
- "مباشرة",
- "متى",
- "مثل",
- "مثلاً",
- "مثلما",
- "مجاناً",
- "مجدداً",
- "مجرد",
- "محض",
- "مراراً",
- "مساء",
- "مطلقاً",
- "مع",
- "مع أن",
- "مع ذلك",
- "معاً",
- "معظم",
- "مما",
- "مما زاد الطين بلة",
- "مما يزيد الطين بلة",
- "ممن",
- "من",
- "من الجدير بالذكر أن",
- "من المؤسف",
- "من المؤكد",
- "من المؤمل",
- "من المرجح",
- "من المفترض",
- "من الممكن",
- "من ثم",
- "من جهة أخرى",
- "من غير المرجح",
- "من غير الممكن",
- "من ناحية أخرى",
- "منذ",
- "مهما",
- "نادراً",
- "ناهيك عن",
- "نحن",
- "نحو",
- "نسبياً",
- "نعم",
- "نعمت",
- "نفس",
- "نهار",
- "نهاراً",
- "هؤلاء",
- "هاتان",
- "هاتين",
- "هدراً",
- "هذا",
- "هذان",
- "هذه",
- "هذين",
- "هكذا",
- "هكذا دواليك",
- "هل",
- "هم",
- "هما",
- "هن",
- "هنا",
- "هناك",
- "هنالك",
- "هو",
- "هي",
- "و",
- "وراء",
- "وسط",
- "وفق",
- "وفقاً",
- "وقت",
- "وقتما",
- "يا",
- "يذكر أن",
- "يوم",
- "يوماً",
- "يومياً",
- ],
- "as": [
- "অন্যথা",
- "অৱশ্যে",
- "আপোনাৰ",
- "উদাহৰণস্বৰূপে",
- "ওপৰলৈ",
- "কম",
- "কাৰণ",
- "কিন্তু",
- "কেতিয়াবা",
- "কোনোবা",
- "গতিকে",
- "তললৈ",
- "তাৰ সলনি",
- "তাৰে ভিতৰত",
- "তেওঁলোকৰ",
- "তেতিয়া",
- "তেনেকুৱাই",
- "ফালে",
- "বহুত",
- "বাওঁফালে",
- "বাহিৰত",
- "ভিতৰত",
- "মোৰ",
- "যথেষ্ট",
- "যাৰ",
- "যি",
- "যেতিয়ালৈকে",
- "যেনে",
- "লৈ",
- "সকলোৱে",
- "সোঁফালে",
- "সৰ্বাধিক",
- ],
- "bn": [
- "অনেক",
- "অনেক ",
- "অন্য ",
- "অন্যথায়",
- "আমরা ",
- "আমার ",
- "আমি",
- "আর জন্য ",
- "আর, ও, এবং ",
- "আরও সাথে , আরো সঙ্গে ",
- "উদাহরণ স্বরূপ",
- "উপর",
- "এ ",
- "এ, এটা, এইটা ",
- "এখানে , এইখানে ",
- "ও ,ওটা ,ওইটা",
- "ওখানে, সেখানে ",
- "ওদের মধ্যে ",
- "কখন ",
- "কখনও কখনও",
- "কম, অল্প ",
- "কারণ ",
- "কি",
- "কিছু ",
- "কিন্তু ",
- "কে ",
- "কেউ",
- "কেমন ",
- "কোথায়",
- "কোনটা ",
- "ডান",
- "তাই, সুতরাং",
- "তার, তাদের, ওর, ওদের ",
- "তারপর",
- "তারা ",
- "তুমি, আপনি ",
- "তোমরা , আপনারা ",
- "তোমার, তোর ",
- "দিকে",
- "না ",
- "নিচে",
- "পরিবর্তে , বরং ",
- "পর্যন্ত",
- "বাইরে",
- "বাম",
- "ভিতর",
- "ভিতরে",
- "মত",
- "যতক্ষণ না",
- "যথেষ্ট",
- "যদি ",
- "যাহার",
- "যাহোক",
- "সব, সবাই ",
- "সবাই",
- "সর্বাধিক",
- "সামান্য",
- "সে রকমই",
- "সে, ও",
- ],
- "ca": [
- "-ho",
- "-la",
- "-lo",
- "-ne",
- "-se",
- "a",
- "abans",
- "això",
- "al",
- "algun",
- "alguna",
- "algunes",
- "alguns",
- "algú",
- "allò",
- "als",
- "altra",
- "altre",
- "altres",
- "amb",
- "aqueix",
- "aqueixa",
- "aqueixes",
- "aqueixos",
- "aquell",
- "aquella",
- "aquelles",
- "aquells",
- "aquest",
- "aquesta",
- "aquestes",
- "aquestos",
- "aquests",
- "bastant",
- "bastants",
- "bé",
- "cada",
- "cadascun",
- "cadascuna",
- "cadascú",
- "cap",
- "cert",
- "certa",
- "certes",
- "certs",
- "com",
- "con",
- "contra",
- "d",
- "d'",
- "da",
- "damunt",
- "darrere",
- "davant",
- "de",
- "del",
- "dels",
- "des",
- "dient",
- "diferent",
- "diferents",
- "dins",
- "dintre",
- "dir",
- "divers",
- "diverses",
- "diversos",
- "durant",
- "eixa",
- "eixe",
- "eixes",
- "eixos",
- "el",
- "ell",
- "ella",
- "elles",
- "ells",
- "els",
- "em",
- "emperò",
- "en",
- "endavant",
- "enfront",
- "ens",
- "entre",
- "envers",
- "era",
- "eren",
- "es",
- "estan",
- "estant",
- "estar",
- "estaran",
- "estarem",
- "estaria",
- "estarien",
- "estarà",
- "estat",
- "estava",
- "estaven",
- "este",
- "estem",
- "estes",
- "esteu",
- "estic",
- "estiguem",
- "estiguessin",
- "estigui",
- "estiguin",
- "estigués",
- "estos",
- "està",
- "et",
- "ets",
- "excepte",
- "extra",
- "fa",
- "faci",
- "facin",
- "facis",
- "faig",
- "fan",
- "faran",
- "farem",
- "fareu",
- "faria",
- "farien",
- "faries",
- "faràs",
- "faràs",
- "faré",
- "faríem",
- "faríeu",
- "fas",
- "feia",
- "feien",
- "feies",
- "fem",
- "fent",
- "fer",
- "fes",
- "fessin",
- "fessis",
- "fet",
- "feu",
- "fins",
- "foren",
- "fos",
- "fossin",
- "fou",
- "front",
- "fèiem",
- "fèieu",
- "féssiu",
- "gaire",
- "gaires",
- "gràcies",
- "ha",
- "hagi",
- "hagin",
- "haguem",
- "haguessin",
- "haguessis",
- "hagut",
- "hagués",
- "haguéssim",
- "haguéssin",
- "haguéssiu",
- "han",
- "has",
- "hauran",
- "haurem",
- "haureu",
- "hauria",
- "haurien",
- "hauries",
- "haurà",
- "hauràs",
- "hauré",
- "hauríem",
- "hauríeu",
- "havent",
- "haver",
- "havia",
- "havien",
- "havies",
- "havíem",
- "havíeu",
- "he",
- "hem",
- "heu",
- "hi",
- "ho",
- "hom",
- "hàgim",
- "i",
- "in",
- "jo",
- "l",
- "l",
- "l'",
- "la",
- "las",
- "les",
- "li",
- "llur",
- "llurs",
- "lo",
- "los",
- "ls",
- "m",
- "m",
- "m'",
- "malgrat",
- "mancant",
- "massa",
- "mateix",
- "mateixa",
- "mateixes",
- "mateixos",
- "me",
- "mentre",
- "menys",
- "mes",
- "meu",
- "meus",
- "meva",
- "meves",
- "mi",
- "mitjançant",
- "molt",
- "molta",
- "moltes",
- "molts",
- "moltíssim",
- "moltíssima",
- "moltíssimes",
- "moltíssims",
- "n",
- "n'",
- "ne",
- "ni",
- "ningun",
- "ninguna",
- "ningunes",
- "ninguns",
- "ningú",
- "no",
- "nombroses",
- "nombrós",
- "nos",
- "nosaltres",
- "nostra",
- "nostre",
- "nostres",
- "ns",
- "o",
- "on",
- "os",
- "pel",
- "pels",
- "per",
- "perqu",
- "perquè",
- "però",
- "poc",
- "poca",
- "pocs",
- "poques",
- "prou",
- "qual",
- "quals",
- "qualsevol",
- "quan",
- "quant",
- "quantes",
- "quants",
- "que",
- "quelcom",
- "qui",
- "quin",
- "quina",
- "quines",
- "quins",
- "què",
- "rere",
- "respecte",
- "s",
- "s",
- "s'",
- "sa",
- "sabent",
- "salvant",
- "se",
- "segons",
- "sens",
- "sense",
- "sent",
- "ser",
- "seran",
- "serem",
- "seria",
- "serien",
- "serà",
- "seré",
- "seríem",
- "ses",
- "seu",
- "seus",
- "seva",
- "seves",
- "si",
- "siguem",
- "sigui",
- "siguin",
- "sigut",
- "sinó",
- "sobre",
- "som",
- "sota",
- "su",
- "suficient",
- "séssim",
- "sóc",
- "són",
- "t",
- "t'",
- "tal",
- "tals",
- "tant",
- "tanta",
- "tantes",
- "tants",
- "te",
- "tenc",
- "tendran",
- "tendrem",
- "tendreu",
- "tendria",
- "tendrien",
- "tendries",
- "tendràs",
- "tendràs",
- "tendré",
- "tendríem",
- "tendríeu",
- "tenen",
- "tenia",
- "tenien",
- "tenies teníem",
- "tenim",
- "tenir",
- "teniu",
- "tens",
- "teníeu",
- "teu",
- "teus",
- "teva",
- "ti",
- "tinc",
- "tindran",
- "tindre",
- "tindrem",
- "tindreu",
- "tindria",
- "tindrien",
- "tindries",
- "tindràs",
- "tindràs",
- "tindré",
- "tindríem",
- "tindríeu",
- "tingut",
- "tot",
- "tota",
- "total",
- "totes",
- "tothom",
- "tots",
- "tu",
- "té",
- "u",
- "ultra",
- "un",
- "una",
- "unes",
- "uns",
- "us",
- "va",
- "vagi",
- "vagin",
- "vaig",
- "vam",
- "van",
- "varen",
- "vau",
- "vers",
- "versus",
- "via",
- "vora",
- "vos",
- "vosaltres",
- "vostre",
- "vostè",
- "vostès",
- "vàrem",
- "y",
- "érem",
- "és",
- ],
- "en": [
- "a",
- "a.k.a",
- "aboard",
- "about",
- "above",
- "abt",
- "accord",
- "according",
- "across",
- "after",
- "against",
- "ago",
- "aground",
- "ahead",
- "aka",
- "ala",
- "albeit",
- "all",
- "along",
- "alongside",
- "although",
- "am",
- "amid",
- "amidst",
- "among",
- "amongst",
- "amoung",
- "an",
- "and",
- "and/or",
- "another",
- "any",
- "any1",
- "anybody",
- "anyone",
- "anything",
- "are",
- "around",
- "as",
- "aside",
- "astride",
- "at",
- "atop",
- "away",
- "b",
- "b/c",
- "b/t",
- "back",
- "base",
- "based",
- "bc",
- "be",
- "because",
- "been",
- "before",
- "behind",
- "being",
- "below",
- "beneath",
- "beside",
- "besides",
- "between",
- "beyond",
- "board",
- "both",
- "btwn",
- "but",
- "by",
- "can",
- "cause",
- "circa",
- "cos",
- "could",
- "coz",
- "cus",
- "depend",
- "depending",
- "despite",
- "did",
- "do",
- "does",
- "down",
- "due",
- "during",
- "each",
- "either",
- "else",
- "even",
- "ever",
- "every",
- "everybody",
- "everyone",
- "everything",
- "except",
- "for",
- "forth",
- "from",
- "get",
- "gets",
- "getting",
- "give",
- "given",
- "got",
- "had",
- "half",
- "has",
- "hav",
- "have",
- "having",
- "he",
- "her",
- "hers",
- "herself",
- "him",
- "himself",
- "his",
- "how",
- "however",
- "i",
- "i'd",
- "if",
- "in",
- "include",
- "including",
- "inside",
- "instead",
- "into",
- "is",
- "it",
- "it's",
- "its",
- "itself",
- "lest",
- "like",
- "made",
- "many",
- "may",
- "me",
- "might",
- "mine",
- "minus",
- "most",
- "much",
- "must",
- "my",
- "myself",
- "nary",
- "near",
- "nearby",
- "neither",
- "next",
- "nigh",
- "no",
- "nobody",
- "none",
- "noone",
- "nor",
- "not",
- "nothing",
- "notwithstanding",
- "of",
- "off",
- "on",
- "onboard",
- "once",
- "one",
- "ones",
- "oneself",
- "only",
- "onto",
- "opposite",
- "or",
- "other",
- "others",
- "ought",
- "our",
- "ours",
- "ourselves",
- "out",
- "outside",
- "over",
- "overt",
- "own",
- "past",
- "per",
- "plus",
- "prior",
- "quite",
- "rather",
- "re",
- "regard",
- "regarding",
- "regardless",
- "round",
- "s/he",
- "save",
- "self",
- "shall",
- "she",
- "should",
- "side",
- "since",
- "so",
- "some",
- "somebody",
- "someone",
- "something",
- "such",
- "sure",
- "teh",
- "than",
- "thanks",
- "that",
- "the",
- "their",
- "theirs",
- "them",
- "themselves",
- "then",
- "there",
- "these",
- "they",
- "they're",
- "thier",
- "this",
- "tho",
- "those",
- "thou",
- "though",
- "through",
- "throughout",
- "thru",
- "thy",
- "til",
- "till",
- "to",
- "together",
- "too",
- "toward",
- "towards",
- "u",
- "under",
- "underneath",
- "unless",
- "unlike",
- "until",
- "unto",
- "up",
- "upon",
- "ur",
- "us",
- "use",
- "versus",
- "via",
- "vs",
- "vs.",
- "w/",
- "w/o",
- "w/out",
- "was",
- "we",
- "were",
- "what",
- "whatever",
- "whatnot",
- "when",
- "whenever",
- "where",
- "whereas",
- "wherever",
- "whether",
- "which",
- "while",
- "whilst",
- "whither",
- "who",
- "who's",
- "whoever",
- "whom",
- "whomever",
- "whose",
- "why",
- "will",
- "with",
- "within",
- "without",
- "wo",
- "worth",
- "would",
- "wud",
- "y'all",
- "ya",
- "yet",
- "yo",
- "you",
- "you're",
- "your",
- "youre",
- "yours",
- "yourself",
- "yourselves",
- ],
- "es": [
- "a",
- "a fin de que",
- "a medida que",
- "a menos que",
- "a modo de",
- "a no ser que",
- "a poco que",
- "a que",
- "abandono",
- "acerca",
- "acostumbra",
- "adónde",
- "ahora",
- "al igual que",
- "al lado de",
- "algo",
- "alguien",
- "alguna",
- "algunas",
- "alguno",
- "algunos",
- "algún",
- "alrededor",
- "ambas",
- "ambos",
- "ante",
- "aparece",
- "aparecen",
- "apareció",
- "aparte",
- "apenas",
- "aquel",
- "aquella",
- "aquellas",
- "aquello",
- "aquellos",
- "aquesa",
- "aquesas",
- "aquesos",
- "aquesta",
- "aquestas",
- "aquesto",
- "aquestos",
- "aquél",
- "aquélla",
- "aquéllas",
- "aquéllos",
- "arrepentir",
- "arrepentiréis",
- "así",
- "así como",
- "así que",
- "atlético",
- "aun",
- "aunque",
- "aún",
- "bajo",
- "bastante",
- "bastantes",
- "bien",
- "cada",
- "casi",
- "cerca",
- "chance",
- "cierta",
- "ciertas",
- "cierto",
- "ciertos",
- "comenzado",
- "comenzó",
- "comienzan",
- "como",
- "como quiera que",
- "como si",
- "con",
- "con tal de",
- "con tal que",
- "conforme",
- "conmigo",
- "conque",
- "considera",
- "consideradas",
- "consideran",
- "consideró",
- "consigo",
- "contendrán",
- "contigo",
- "continuaba",
- "continuar",
- "continuaron",
- "continuase",
- "continuó",
- "continúa",
- "contra",
- "corresponden",
- "corresponder",
- "cual",
- "cual si",
- "cuales",
- "cualesquier",
- "cualesquiera",
- "cualquier",
- "cualquiera",
- "cuan",
- "cuando",
- "cuanta",
- "cuantas",
- "cuanto",
- "cuanto quiera que",
- "cuantos",
- "cuya",
- "cuyas",
- "cuyo",
- "cuyos",
- "cuàles",
- "cuál",
- "cuáles",
- "cuán",
- "cuándo",
- "cuánta",
- "cuántas",
- "cuánto",
- "cuántos",
- "cómo",
- "da",
- "dado que",
- "dar",
- "de",
- "de manera que",
- "de modo que",
- "deba",
- "debajo",
- "deban",
- "debas",
- "debe",
- "debemos",
- "deben",
- "deber",
- "deberá",
- "deberán",
- "debería",
- "deberíamos",
- "deberían",
- "debes",
- "debido",
- "debiera",
- "debieron",
- "debimos",
- "debió",
- "debo",
- "debía",
- "debíamos",
- "debían",
- "declaraba",
- "declarada",
- "declarado",
- "declarase",
- "declaro",
- "declaró",
- "dejaban",
- "dejado",
- "dejan",
- "dejará",
- "del",
- "delante",
- "demasiada",
- "demasiadas",
- "demasiado",
- "demasiados",
- "demás",
- "den",
- "dentro",
- "dentro_de",
- "des",
- "desde",
- "después",
- "detrás",
- "di",
- "dicha",
- "dichas",
- "dicho",
- "dichos",
- "diferente",
- "diferentes",
- "distintas",
- "distinto",
- "distintos",
- "diversas",
- "diverso",
- "diversos",
- "don",
- "donde",
- "dos",
- "durante",
- "dónde",
- "echar",
- "el",
- "el que",
- "ella",
- "ellas",
- "ello",
- "ellos",
- "en",
- "en cambio",
- "en caso de",
- "en la medida en que",
- "en tanto que",
- "encima",
- "enfrente",
- "entonces",
- "entre",
- "era",
- "eramos",
- "eran",
- "eras",
- "eres",
- "ergo",
- "es",
- "esa",
- "esas",
- "escasa",
- "escasas",
- "escaso",
- "escasos",
- "escrito",
- "ese",
- "eso",
- "eso que",
- "esos",
- "esotra",
- "esotro",
- "esta",
- "estaba",
- "estabais",
- "estabamos",
- "estaban",
- "estabas",
- "estado",
- "estamos",
- "estan",
- "estando",
- "estar",
- "estaremos",
- "estará",
- "estarán",
- "estaré",
- "estaría",
- "estaríamos",
- "estarían",
- "estarías",
- "estas",
- "este",
- "estemos",
- "esto",
- "estos",
- "estotra",
- "estotro",
- "estoy",
- "estuve",
- "estuviera",
- "estuvieran",
- "estuvieron",
- "estuviese",
- "estuviesen",
- "estuvimos",
- "estuvo",
- "está",
- "estábamos",
- "estáis",
- "están",
- "estás",
- "esté",
- "estén",
- "ex",
- "excepto",
- "frente",
- "fue",
- "fuera",
- "fueran",
- "fuere",
- "fueron",
- "fuese",
- "fuesen",
- "fui",
- "fuimos",
- "gracias",
- "gracias_a",
- "habeis",
- "haber",
- "haberle",
- "haberse",
- "habido",
- "habiendo",
- "habiéndo",
- "habremos",
- "habrá",
- "habrán",
- "habrás",
- "habré",
- "habría",
- "habríamos",
- "habrían",
- "habéis",
- "había",
- "habíamos",
- "habían",
- "habías",
- "hace",
- "hacer",
- "hacia",
- "hacía",
- "halla",
- "han",
- "has",
- "hasta",
- "hasta que",
- "hay",
- "haya",
- "hayamos",
- "hayan",
- "hayas",
- "he",
- "hecho",
- "hemos",
- "hola",
- "hubiera",
- "hubieran",
- "hubieron",
- "hubiese",
- "hubiesen",
- "hubiéramos",
- "hubo",
- "iba",
- "iban",
- "ido",
- "incluso",
- "ir",
- "irá",
- "irán",
- "iré",
- "iría",
- "junto a",
- "la",
- "las",
- "le",
- "lejos",
- "les",
- "lo",
- "los",
- "luego",
- "mal que",
- "mas",
- "me",
- "mediante",
- "menos",
- "mes",
- "mi",
- "mientras",
- "mientras que",
- "mis",
- "misma",
- "mismas",
- "mismo",
- "mismos",
- "mismísimo",
- "morir",
- "moriría",
- "mostrado",
- "mostraron",
- "mucha",
- "muchas",
- "muchisimas",
- "muchisimio",
- "muchisimo",
- "mucho",
- "muchos",
- "muchísima",
- "muchísimas",
- "muchísimo",
- "muchísimos",
- "más",
- "más bien",
- "mí",
- "mía",
- "mías",
- "mío",
- "míos",
- "nada",
- "nadie",
- "negar",
- "ni",
- "ni que",
- "ningun",
- "ninguna",
- "ningunas",
- "ninguno",
- "ningunos",
- "ningún",
- "no",
- "no obstante",
- "noche",
- "nombrado",
- "nombró",
- "nos",
- "nosotros",
- "nuestra",
- "nuestras",
- "nuestro",
- "nuestros",
- "o",
- "os",
- "otra",
- "otras",
- "otro",
- "otros",
- "pa",
- "para",
- "para que",
- "parezca",
- "partir",
- "pasar",
- "pero",
- "po",
- "poca",
- "pocas",
- "poco",
- "pocos",
- "podamos",
- "podeis",
- "podemos",
- "poder",
- "podes",
- "podido",
- "podras",
- "podre",
- "podremos",
- "podriaís",
- "podrá",
- "podrán",
- "podrás",
- "podré",
- "podréis",
- "podría",
- "podríamos",
- "podrían",
- "podéis",
- "podía",
- "podíamos",
- "podían",
- "poner",
- "poquito",
- "por",
- "por el contrario",
- "por ende",
- "por eso",
- "por lo que",
- "por mucho que",
- "por más que",
- "por no hablar de",
- "por si",
- "porque",
- "pos",
- "post",
- "pre",
- "pro",
- "propia",
- "propias",
- "propio",
- "propios",
- "pude",
- "pudiendo",
- "pudiera",
- "pudieran",
- "pudieras",
- "pudieron",
- "pudiese",
- "pudiesen",
- "pudimos",
- "pudo",
- "pueda",
- "puedan",
- "puedas",
- "puede",
- "pueden",
- "puedes",
- "puedo",
- "pues",
- "puesto",
- "puesto que",
- "que",
- "queda",
- "quedaba",
- "quedan",
- "quedó",
- "queremos",
- "querer",
- "queriendo",
- "quien",
- "quienes",
- "quienesquiera",
- "quienquier",
- "quienquiera",
- "quiera",
- "quiere",
- "quisiera",
- "quién",
- "quiénes",
- "qué",
- "re",
- "resulta",
- "resultado",
- "resultaría",
- "resulte",
- "sabe",
- "saber",
- "sabiendo",
- "salen",
- "salir",
- "salió",
- "salvo",
- "se",
- "sea",
- "seamos",
- "sean",
- "seas",
- "seguir",
- "seguirá",
- "seguía",
- "según",
- "semejante",
- "semejantes",
- "semi",
- "sendas",
- "sendo",
- "sendos",
- "ser",
- "será",
- "serán",
- "serás",
- "seré",
- "seréis",
- "sería",
- "serían",
- "serías",
- "si",
- "si bien",
- "si y solo si",
- "sido",
- "siempre que",
- "siendo",
- "siente",
- "siento",
- "siga",
- "sigamos",
- "sigue",
- "sin",
- "sino",
- "siquiera",
- "sobre",
- "sobrer",
- "sobrir",
- "soler",
- "solían",
- "somos",
- "son",
- "soy",
- "sub",
- "suele",
- "suelen",
- "suelo",
- "super",
- "supo",
- "sur",
- "sus",
- "suya",
- "suyas",
- "suyo",
- "suyos",
- "sé",
- "sí",
- "tal",
- "tales",
- "tanta",
- "tantas",
- "tanto",
- "tantos",
- "tantísima",
- "tantísimas",
- "tantísimos",
- "te",
- "tendremos",
- "tendrian",
- "tendrá",
- "tendrán",
- "tendría",
- "tendrían",
- "tenemos",
- "tener",
- "tenga",
- "tengan",
- "tengo",
- "tenia",
- "tenido",
- "teniendo",
- "tenéis",
- "tenía",
- "teníamos",
- "tenían",
- "terminas",
- "ti",
- "tiene",
- "tienen",
- "tienes",
- "toda",
- "todas",
- "todavía",
- "todes",
- "todo",
- "todos",
- "trabajado",
- "trans",
- "tras",
- "tu",
- "tus",
- "tuve",
- "tuviera",
- "tuvieron",
- "tuviese",
- "tuvo",
- "tuya",
- "tuyas",
- "tuyo",
- "tuyos",
- "tú",
- "u",
- "un",
- "una",
- "unas",
- "une",
- "unir",
- "uno",
- "unos",
- "usted",
- "ustedes",
- "va",
- "vamos",
- "van",
- "varias",
- "varios",
- "varía",
- "vas",
- "vaya",
- "vayan",
- "venir",
- "venía",
- "ver",
- "vice",
- "vieron",
- "vino",
- "vis a vis",
- "visto que",
- "volver",
- "volverá",
- "volveríamos",
- "volvió",
- "vos",
- "vosotras",
- "vosotros",
- "voy",
- "vuelva",
- "vuelvan",
- "vuelve",
- "vuelven",
- "vuestra",
- "vuestras",
- "vuestro",
- "vuestros",
- "vía",
- "y",
- "ya",
- "ya que",
- "yo",
- "ámbos",
- "él",
- "éramos",
- "ésa",
- "ésas",
- "ése",
- "ésos",
- "ésta",
- "éstas",
- "éste",
- "ésto",
- "éstos",
- "íbamos",
- "ó",
- "ú",
- "última",
- "últimas",
- "último",
- "últimos",
- "\ufeffdesde",
- "\ufeffel",
- "\ufeffen",
- "\ufeffla",
- "\ufefflas",
- ],
- "eu": [
- "*edin",
- "*edun",
- "*ezan",
- "aitzitik",
- "ala",
- "alabaina",
- "aldiz",
- "alegia",
- "alta",
- "anitz",
- "anitzek",
- "anitzeko",
- "anitzez",
- "antzera",
- "arabera",
- "ari",
- "ari_izan",
- "ariko",
- "arren",
- "asko",
- "askoan",
- "askok",
- "askoko",
- "askorekin",
- "askoren",
- "askorengan",
- "askorentzat",
- "askori",
- "askorik",
- "askotako",
- "askotan",
- "askotariko",
- "askotatik",
- "askotaz",
- "askotxo",
- "askoz",
- "at",
- "aunitz",
- "aurka",
- "aurkako",
- "aurretik",
- "azpian",
- "azpitik",
- "ba",
- "bada",
- "badago",
- "badezake",
- "badidazu",
- "badiezu",
- "badio",
- "badiogu",
- "badiote",
- "badiougu",
- "badiozu",
- "badira",
- "badirela",
- "baditu",
- "baditugu",
- "badituzte",
- "badituzu",
- "badu",
- "badugu",
- "badugun",
- "badut",
- "badute",
- "baduzu",
- "bagara",
- "bagatzaizkio",
- "bagenu",
- "baginen",
- "bai",
- "baietz",
- "baikaituzte",
- "bailegoen",
- "bailituen",
- "bailitzake",
- "bailitzateke",
- "baina",
- "bainan",
- "bainintzen",
- "bainizkion",
- "baino",
- "baita",
- "baitabil",
- "baitaiteke",
- "baitan",
- "baitaude",
- "baitiete",
- "baitigu",
- "baitio",
- "baitiote",
- "baitira",
- "baititu",
- "baititugu",
- "baitituzte",
- "baitituzu",
- "baititzaket",
- "baitizkio",
- "baitu",
- "baitugu",
- "baitute",
- "baituzu",
- "baitzaio",
- "baitzaizkio",
- "baitzara",
- "baitzegoen",
- "baitzen",
- "baitzeuden",
- "baitzien",
- "baitzion",
- "baitzioten",
- "baitziren",
- "baitzitekeen",
- "baitzituen",
- "baitzitzaion",
- "baitzuen",
- "baitzuten",
- "baizik",
- "baizituen",
- "baldin",
- "balego",
- "balira",
- "baliteke",
- "balitu",
- "balituzkete",
- "balitz",
- "balitzait",
- "balu",
- "balute",
- "banintz",
- "banitu",
- "banu",
- "barik",
- "barru",
- "bat",
- "batera",
- "batera\x97",
- "batere",
- "batzu",
- "batzuei",
- "batzuek",
- "batzuekin",
- "batzuen",
- "batzuengatik",
- "batzuentzat",
- "batzuetako",
- "batzuetakoak",
- "batzuetan",
- "batzuetara",
- "batzuetatik",
- "batzuez",
- "batzuk",
- "batzutako",
- "batzutan",
- "bazaigu",
- "bazaizu",
- "bazara",
- "bazen",
- "bazina",
- "baziren",
- "bazituen",
- "bazituzten",
- "bazuen",
- "bazuten",
- "bederen",
- "behintzat",
- "bera",
- "beragatik",
- "beraiei",
- "beraiek",
- "beraiekin",
- "beraien",
- "beraietaz",
- "berak",
- "berarekin",
- "beraren",
- "berarengan",
- "berarengana",
- "berarengandik",
- "berarengatik",
- "berarentzat",
- "berari",
- "berauek",
- "berauen",
- "berauetan",
- "beraz",
- "berbera",
- "berberagatik",
- "berberak",
- "berberarekin",
- "berberaren",
- "berberera",
- "bere",
- "berea",
- "bereak",
- "berean",
- "berek",
- "bereko",
- "berekoa",
- "berekoak",
- "beren",
- "beretan",
- "beretik",
- "beretzat",
- "berriz",
- "bertze",
- "bertzeekin",
- "bertzela",
- "bestalde",
- "bestaldean",
- "beste",
- "bestea",
- "besteak",
- "bestean",
- "bestearekiko",
- "bestearekin",
- "bestearen",
- "bestearengandik",
- "besteari",
- "besteaz",
- "besteei",
- "besteen",
- "besteengandik",
- "besteetan",
- "besteko",
- "bestekoa",
- "bestela",
- "bestera",
- "besterantz",
- "besterik",
- "bestetan",
- "bestetik",
- "bezala",
- "bezalako",
- "bezalakoa",
- "bezalakoen",
- "bidez",
- "bitartean",
- "bitarteko",
- "bitarterako",
- "bitartez",
- "da",
- "dabil",
- "dabiltza",
- "dadila",
- "dadin",
- "dago",
- "dagoela",
- "dagoelako",
- "dagoen",
- "dagoena",
- "dagoenaren",
- "dagoenean",
- "dagoenez",
- "daiteekenaren",
- "daiteke",
- "daitekeela",
- "daitekeen",
- "daitekeena",
- "daitekeenaren",
- "daitekeenez",
- "daiteken",
- "daitezela",
- "daitezen",
- "daitezke",
- "daitezkeelako",
- "daitezkeelarik",
- "daitezkeen",
- "daitezkeenak",
- "daitezkela",
- "dakizuke",
- "danok",
- "daude",
- "daudela",
- "daudelako",
- "dauden",
- "daudenak",
- "daudenek",
- "daudenen",
- "daudenik",
- "dautzuet",
- "dela",
- "delako",
- "delarik",
- "den",
- "dena",
- "denak",
- "denaren",
- "denarentzat",
- "denari",
- "denean",
- "denek",
- "denen",
- "denera",
- "denerako",
- "denetan",
- "denetarik",
- "denetik",
- "denez",
- "denik",
- "denok",
- "denon",
- "denona",
- "denontzat",
- "deus",
- "dexente",
- "dezadan",
- "dezagun",
- "dezake",
- "dezakedala",
- "dezakedan",
- "dezakedanean",
- "dezakeela",
- "dezakeen",
- "dezakeena",
- "dezakegu",
- "dezakegula",
- "dezakegun",
- "dezakela",
- "dezakelako",
- "dezaket",
- "dezakete",
- "dezaketela",
- "dezaketen",
- "dezakezu",
- "dezakezuen",
- "dezakezuenez",
- "dezakezunez",
- "dezala",
- "dezan",
- "dezaten",
- "dezente",
- "dezenterekin",
- "dezentetan",
- "diat",
- "didala",
- "didana",
- "didate",
- "didazue",
- "die",
- "diegu",
- "diegun",
- "diela",
- "dien",
- "dienak",
- "diet",
- "diete",
- "dietela",
- "dietelako",
- "dietenean",
- "diezaiekete",
- "diezaiokeena",
- "diezaiokete",
- "diezaiola",
- "diezaioten",
- "diezaizkioke",
- "diezazkioke",
- "diezazkiokeen",
- "digu",
- "digun",
- "digute",
- "digutela",
- "diguten",
- "digutenean",
- "diguzu",
- "dik",
- "din",
- "dinat",
- "dio",
- "diogu",
- "diogulako",
- "diogun",
- "diola",
- "dion",
- "diona",
- "dionean",
- "dionez",
- "diot",
- "diote",
- "diotela",
- "dioten",
- "diotena",
- "diotenak",
- "diotenek",
- "diozu",
- "dira",
- "direla",
- "direlako",
- "direlakoan",
- "direlakotz",
- "diren",
- "direnak",
- "direnean",
- "direnek",
- "direnen",
- "direnetan",
- "direnez",
- "direnik",
- "dit",
- "ditake",
- "ditazke",
- "ditin",
- "ditu",
- "ditudala",
- "ditudalako",
- "ditudan",
- "ditudanean",
- "dituela",
- "dituelako",
- "dituelarik",
- "dituen",
- "dituena",
- "dituenak",
- "dituenean",
- "ditugu",
- "ditugula",
- "ditugun",
- "ditugunez",
- "ditun",
- "ditut",
- "dituzte",
- "dituztela",
- "dituztelako",
- "dituzten",
- "dituztenak",
- "dituztenean",
- "dituztenek",
- "dituztenekin",
- "dituztenen",
- "dituzu",
- "dituzue",
- "dituzuen",
- "dituzula",
- "dituzun",
- "dituzunik",
- "ditzagun",
- "ditzake",
- "ditzakeen",
- "ditzakegu",
- "ditzakegula",
- "ditzakete",
- "ditzaketela",
- "ditzaketelako",
- "ditzaketen",
- "ditzakezu",
- "ditzan",
- "dizkidazu",
- "dizkie",
- "dizkien",
- "dizkiet",
- "dizkiete",
- "dizkigu",
- "dizkigula",
- "dizkigunak",
- "dizkigute",
- "dizkio",
- "dizkiola",
- "dizkion",
- "dizkiot",
- "dizkiotela",
- "dizkit",
- "dizkizuet",
- "dizkizugu",
- "dizu",
- "dizuet",
- "dizugu",
- "dizut",
- "dizute",
- "du",
- "duan",
- "dudala",
- "dudalarik",
- "dudan",
- "dudanak",
- "dudanarekin",
- "dudanean",
- "dudanik",
- "duela",
- "duelako",
- "duelakoan",
- "duen",
- "duena",
- "duenak",
- "duenaren",
- "duenarentzat",
- "duenari",
- "duenean",
- "duenentz",
- "duenez",
- "duenik",
- "dugu",
- "dugula",
- "dugulako",
- "dugun",
- "duguna",
- "dugunari",
- "dugunean",
- "dugunez",
- "dugunik",
- "duk",
- "dun",
- "dunala",
- "dut",
- "dute",
- "dutela",
- "dutelako",
- "dutelakoan",
- "duten",
- "dutena",
- "dutenagatik",
- "dutenak",
- "dutenaren",
- "dutenean",
- "dutenek",
- "duteneko",
- "dutenen",
- "dutenena",
- "dutenenetatik",
- "dutenentz",
- "dutenetakoa",
- "dutenetik",
- "dutenez",
- "duzu",
- "duzue",
- "duzuela",
- "duzuen",
- "duzuenean",
- "duzuenez",
- "duzula",
- "duzun",
- "duzunarekin",
- "ea",
- "edo",
- "edonor",
- "edota",
- "edozein",
- "edozeinek",
- "edozer",
- "edozertarako",
- "elgarrekin",
- "elgarri",
- "elkar",
- "elkarrekiko",
- "elkarrekin",
- "elkarren",
- "elkarri",
- "ene",
- "era",
- "ere",
- "esker",
- "eta",
- "eurak",
- "eurei",
- "eurek",
- "eurekin",
- "euren",
- "eurentzat",
- "ez",
- "ezan",
- "ezazu",
- "ezazue",
- "ezean",
- "ezein",
- "ezen",
- "ezer",
- "ezerekin",
- "ezerk",
- "ezertarako",
- "ezertaz",
- "ezertxo",
- "ezetz",
- "ezik",
- "ezta",
- "gabe",
- "gabeko",
- "gainera",
- "gainerakoan",
- "gainerat",
- "gainera\x97",
- "gainetik",
- "gaitezen",
- "gaitezke",
- "gaitezkeela",
- "gaitu",
- "gaituela",
- "gaituzte",
- "gaituztenak",
- "gara",
- "garela",
- "garelako",
- "garen",
- "garenez",
- "garenok",
- "gaude",
- "gaudenak",
- "gehiago",
- "gehiagoan",
- "gehiagok",
- "gehiagoko",
- "gehiagorekin",
- "gehiegi",
- "gehiegirik",
- "gehiegitxo",
- "gehien",
- "gehiena",
- "gehienak",
- "gehienek",
- "gehienekin",
- "gehienentzako",
- "gehienentzat",
- "gehienetako",
- "gehienetan",
- "gehienok",
- "gehientsu",
- "gehientsuen",
- "gehitxo",
- "gehixeago",
- "genbiltzan",
- "genezake",
- "genien",
- "genion",
- "genituela",
- "genituelako",
- "genituen",
- "genituzke",
- "genituzkeelako",
- "genizkion",
- "genizuen",
- "genizun",
- "genuela",
- "genuelako",
- "genuen",
- "genuenean",
- "genuenetik",
- "genuenez",
- "genuke",
- "genukeen",
- "geratu",
- "geratzen",
- "geroztik",
- "geu",
- "geure",
- "geuregan",
- "geuri",
- "ginela",
- "ginen",
- "ginenean",
- "ginenekoa",
- "gintezkeela",
- "gintuen",
- "gintuenagatik",
- "gintunan",
- "gintuzten",
- "gintzaizkion",
- "gu",
- "guk",
- "gure",
- "gurean",
- "gurekin",
- "guretzat",
- "guri",
- "gutako",
- "gutaz",
- "guti",
- "gutiz",
- "gutiz-gehien",
- "gutiz-gehienek",
- "gutxi",
- "gutxiago",
- "gutxiagorako",
- "gutxiagorekin",
- "gutxian",
- "gutxien",
- "gutxienez",
- "gutxik",
- "gutxiko",
- "gutxira",
- "gutxiren",
- "gutxitan",
- "guzi",
- "guziak",
- "guziarekin",
- "guziekin",
- "guzientzat",
- "guzti",
- "guztia",
- "guztiagatik",
- "guztiak",
- "guztian",
- "guztiarekin",
- "guztiaren",
- "guztiari",
- "guztiaz",
- "guztiei",
- "guztiek",
- "guztien",
- "guztiengan",
- "guztientzako",
- "guztientzat",
- "guztietako",
- "guztietan",
- "guztietara",
- "guztietatik",
- "guztiez",
- "guztioi",
- "guztiok",
- "guztion",
- "guztionak",
- "guztionen",
- "guztiontzat",
- "guztira",
- "guztitako",
- "haatik",
- "haiek",
- "haiekin",
- "haien",
- "haiengan",
- "haiengandik",
- "haietako",
- "haietan",
- "haietatik",
- "hainbat",
- "hainbatek",
- "hainbaten",
- "hainbatez",
- "hainbertze",
- "hainbeste",
- "hainbesterako",
- "haiteke",
- "haiz",
- "halaber",
- "halere",
- "harekin",
- "haren",
- "harena",
- "harentzat",
- "hargatik",
- "hari",
- "hark",
- "hartako",
- "hartan",
- "hartara",
- "hartarako",
- "hartatik",
- "hau",
- "haudala",
- "hauei",
- "hauek",
- "hauekin",
- "hauen",
- "hauetako",
- "hauetan",
- "hauetara",
- "hauetarako",
- "hauetarik",
- "hauetatik",
- "hauexek",
- "hauez",
- "hauxe",
- "heu",
- "heure",
- "hhriek",
- "hi",
- "hik",
- "hinduan",
- "hintzen",
- "hire",
- "hiri",
- "honegatik",
- "honek",
- "honekin",
- "honen",
- "honengatik",
- "honentzat",
- "honetako",
- "honetan",
- "honetara",
- "honetarako",
- "honetatik",
- "honetaz",
- "honez",
- "honi",
- "hori",
- "horiei",
- "horiek",
- "horiekin",
- "horien",
- "horientzat",
- "horietako",
- "horietakoren",
- "horietan",
- "horietarako",
- "horietariko",
- "horietatik",
- "horiez",
- "horixe",
- "horregatik",
- "horrek",
- "horrekin",
- "horren",
- "horrenbeste",
- "horrenbestez",
- "horrengatik",
- "horretako",
- "horretan",
- "horretantxe",
- "horretara",
- "horretarako",
- "horretatik",
- "horretaz",
- "horrexegatik",
- "horrexekin",
- "horrexetan",
- "horrez",
- "horrezaz",
- "horri",
- "hortaz",
- "huan",
- "huntan",
- "hura",
- "huraxe",
- "iezaidazu",
- "iezaiezu",
- "iezaion",
- "iezaiozu",
- "inor",
- "inoren",
- "inorentzako",
- "inori",
- "inork",
- "inortaz",
- "irian",
- "itzazu",
- "izaki",
- "kontra",
- "lezake",
- "lezakeen",
- "lezakete",
- "lezan",
- "liekeela",
- "liezaiokeen",
- "lioke",
- "liokeela",
- "liokeen",
- "lirateke",
- "liratekeela",
- "liteke",
- "litekeela",
- "litekeen",
- "litekeena",
- "litezke",
- "lituzkeela",
- "lituzkeen",
- "lituzkete",
- "litzaidake",
- "litzaiguke",
- "litzateke",
- "litzatekeela",
- "litzatekeelako",
- "litzatekela",
- "lizateke",
- "luke",
- "lukeela",
- "lukeelako",
- "lukeen",
- "lukeena",
- "lukete",
- "luketen",
- "nabil",
- "nago",
- "nahiko",
- "nahikoa",
- "nahikorik",
- "nahiz",
- "naiteke",
- "naiz",
- "naizela",
- "naizen",
- "naizenean",
- "naizenetan",
- "naizenetik",
- "naizenez",
- "naizenik",
- "nau",
- "nauen",
- "nauenarentzat",
- "nauenean",
- "nauk",
- "naun",
- "naute",
- "nautela",
- "nauzu",
- "nauzun",
- "nazan",
- "nazaten",
- "nazazu",
- "nazazun",
- "nenbilen",
- "nengoela",
- "nengoen",
- "nere",
- "neu",
- "neuk",
- "neure",
- "nezake",
- "ni",
- "nian",
- "nien",
- "nigan",
- "nik",
- "ninduen",
- "ninduten",
- "nintekeela",
- "nintzaion",
- "nintzateke",
- "nintzatekeela",
- "nintzela",
- "nintzelako",
- "nintzen",
- "nintzenean",
- "nion",
- "nire",
- "nirea",
- "niregan",
- "niregana",
- "niregatik",
- "nirekin",
- "niretzako",
- "niretzat",
- "niri",
- "nitaz",
- "nituela",
- "nituen",
- "nituzke",
- "nizuke",
- "nor",
- "norbait",
- "norbaitek",
- "norbaitekin",
- "norbaiten",
- "norbaitengana",
- "norbaitentzat",
- "norbaiti",
- "norbera",
- "norberak",
- "norberaren",
- "norbere",
- "noren",
- "nori",
- "nork",
- "nornahi",
- "nornahik",
- "nortzuk",
- "nortzuren",
- "nuela",
- "nuen",
- "nuena",
- "nuenean",
- "nuenetik",
- "nuke",
- "nukeela",
- "omen",
- "ondoan",
- "ondoko",
- "ondora",
- "ondoren",
- "ondorengo",
- "ondotik",
- "ordea",
- "ordez",
- "orduan",
- "oro_har",
- "orobat",
- "orohar",
- "orok",
- "ororen",
- "orori",
- "ostean",
- "ostera",
- "osterantzean",
- "pean",
- "piskat",
- "pixka_bat",
- "pixkat",
- "pranko",
- "ugari",
- "ugarik",
- "ugarirekin",
- "ugariren",
- "ugaritan",
- "zagok",
- "zaidan",
- "zaidanaren",
- "zaie",
- "zaiela",
- "zaien",
- "zaienez",
- "zaigu",
- "zaigun",
- "zaiguna",
- "zaigunean",
- "zaik",
- "zaio",
- "zaiola",
- "zaiolako",
- "zaion",
- "zaiona",
- "zait",
- "zaitez",
- "zaitezen",
- "zaitu",
- "zaitut",
- "zaituzte",
- "zaitzakegu",
- "zaizkidan",
- "zaizkie",
- "zaizkiela",
- "zaizkien",
- "zaizkigu",
- "zaizkio",
- "zaizkiola",
- "zaizkion",
- "zaizkit",
- "zaizkizu",
- "zaizkizue",
- "zaizkizun",
- "zaizu",
- "zaizue",
- "zara",
- "zarela",
- "zarete",
- "zatekeela",
- "zatekeen",
- "zatzait",
- "zaude",
- "ze",
- "zebilen",
- "zedin",
- "zegoan",
- "zegoela",
- "zegoelako",
- "zegoen",
- "zegoenez",
- "zegok",
- "zehar",
- "zein",
- "zeina",
- "zeinek",
- "zeinen",
- "zeintzu",
- "zeintzuetan",
- "zeintzuk",
- "zela",
- "zelako",
- "zelarik",
- "zen",
- "zena",
- "zenak",
- "zenarekin",
- "zenari",
- "zenbait",
- "zenbaitek",
- "zenbaiten",
- "zenbaitetan",
- "zenbaiti",
- "zenbaitzuk",
- "zenbat",
- "zenbateraino",
- "zenean",
- "zenekoa",
- "zenetik",
- "zenez",
- "zeniguten",
- "zenigutenez",
- "zenik",
- "zenituen",
- "zenitzakeen",
- "zenuela",
- "zenuen",
- "zenuke",
- "zenukete",
- "zenutela",
- "zenuten",
- "zeozer",
- "zer",
- "zer_edo_zer",
- "zerbait",
- "zerbaitek",
- "zerbaitengatik",
- "zerbaitetarako",
- "zeren",
- "zerendako",
- "zeri",
- "zerk",
- "zertan",
- "zertara",
- "zertarako",
- "zertaz",
- "zertxobait",
- "zeu",
- "zeudela",
- "zeudelako",
- "zeuden",
- "zeudenak",
- "zeuk",
- "zeure",
- "zezakeen",
- "zezaken",
- "zezaketen",
- "zezala",
- "zezan",
- "zezaten",
- "zidan",
- "zidatelako",
- "zidaten",
- "zidatena",
- "zidatenak",
- "zidatenean",
- "ziela",
- "zien",
- "zienez",
- "zietela",
- "zietelako",
- "zieten",
- "ziezaion",
- "zigun",
- "zigunez",
- "ziguten",
- "zinan",
- "zinen",
- "zintudan",
- "zintuztela",
- "zintuztenean",
- "ziola",
- "ziolako",
- "ziolarik",
- "zion",
- "ziona",
- "zionean",
- "zionez",
- "zioten",
- "ziotenak",
- "zirela",
- "zirelako",
- "zirelakoan",
- "zirelarik",
- "ziren",
- "zirenak",
- "zirenean",
- "zirenetik",
- "zirenez",
- "zirenik",
- "ziren\x97",
- "zirezte",
- "zitekeela",
- "zitekeen",
- "zitekeena",
- "zitekeenik",
- "zitezen",
- "zitezkeela",
- "zitezkeelakoan",
- "zitezkeen",
- "zituela",
- "zituelako",
- "zituelarik",
- "zituen",
- "zituenean",
- "zituenei",
- "zituztela",
- "zituztelarik",
- "zituzten",
- "zituztenak",
- "zituztenetik",
- "zitzaidakeen",
- "zitzaidala",
- "zitzaidan",
- "zitzaien",
- "zitzaigun",
- "zitzaiola",
- "zitzaion",
- "zitzaionagatik",
- "zitzaionean",
- "zitzaizkidan",
- "zitzaizkien",
- "zitzaizkienean",
- "zitzaizkigun",
- "zitzaizkion",
- "zitzaizkon",
- "zitzaizun",
- "zitzakeen",
- "zitzaketenak",
- "zizioten",
- "zizkidaten",
- "zizkien",
- "zizkienik",
- "zizkieten",
- "zizkigun",
- "zizkiola",
- "zizkion",
- "zizkiona",
- "zizkioten",
- "zizkiotenekin",
- "zizuen",
- "zizun",
- "zoin",
- "zonbat",
- "zu",
- "zuei",
- "zuek",
- "zuela",
- "zuelako",
- "zuelarik",
- "zuen",
- "zuena",
- "zuenak",
- "zuenarentzat",
- "zuenean",
- "zuenetik",
- "zuenez",
- "zuenik",
- "zuentzako",
- "zuetako",
- "zuetaz",
- "zugandik",
- "zuk",
- "zukeen",
- "zuketen",
- "zure",
- "zureak",
- "zurekin",
- "zuretzat",
- "zutela",
- "zutelako",
- "zutelarik",
- "zuten",
- "zutena",
- "zutenean",
- "zuteneko",
- "zutenetik",
- "zutenez",
- ],
- "fr": [
- "a",
- "afin",
- "ai",
- "aie",
- "aient",
- "ainsi",
- "ait",
- "alias",
- "aller",
- "allons",
- "apres",
- "après",
- "as",
- "au",
- "au-delà",
- "aucun",
- "aucune",
- "aucunes",
- "aucuns",
- "aujourd'",
- "auprès",
- "auquel",
- "aura",
- "aurai",
- "auraient",
- "aurais",
- "aurait",
- "aurions",
- "aurons",
- "auront",
- "autant",
- "autour",
- "autre",
- "autres",
- "autrui",
- "auxquelles",
- "auxquels",
- "avaient",
- "avais",
- "avait",
- "avant",
- "avec",
- "avez",
- "aviez",
- "avions",
- "avoir",
- "avons",
- "ayant",
- "ayez",
- "ayons",
- "beaucoup",
- "c'est-à-dire",
- "c-à-d.",
- "ca",
- "car",
- "ce",
- "ceci",
- "cela",
- "celle",
- "celle-ci",
- "celles",
- "celles-ci",
- "celui",
- "celui-ci",
- "celui-là",
- "cent",
- "certain",
- "certaine",
- "certaines",
- "certains",
- "ces",
- "cet",
- "cette",
- "ceux",
- "ceux-ci",
- "ceux-là",
- "cf.",
- "chacun",
- "chacune",
- "chaque",
- "chez",
- "ci",
- "cinq",
- "combien",
- "comme",
- "comment",
- "concernant",
- "contre",
- "cà",
- "d'après",
- "d'autres",
- "dans",
- "de",
- "dehors",
- "depuis",
- "derrière",
- "des",
- "deux",
- "devait",
- "devant",
- "devez",
- "devions",
- "devoir",
- "devons",
- "devra",
- "devraient",
- "devrait",
- "devrions",
- "devrons",
- "devront",
- "doit",
- "doivent",
- "donc",
- "dont",
- "du",
- "durant",
- "dès",
- "début",
- "dû",
- "elle",
- "elle-même",
- "elles",
- "elles-mêmes",
- "en",
- "entre",
- "entres",
- "envers",
- "environ",
- "es",
- "est",
- "et",
- "etaient",
- "etant",
- "etre",
- "eut",
- "eux",
- "eux-mêmes",
- "excepté",
- "eût",
- "faire",
- "fais",
- "faisaient",
- "faisait",
- "faisant",
- "fait",
- "faite",
- "faites",
- "fasse",
- "fassent",
- "fera",
- "ferait",
- "feront",
- "firent",
- "fit",
- "font",
- "furent",
- "fussent",
- "fut",
- "fût",
- "für",
- "grâce",
- "hormis",
- "hors",
- "i",
- "il",
- "ils",
- "iront",
- "je",
- "jusque",
- "l'on",
- "la",
- "ladite",
- "laquelle",
- "le",
- "le/lui",
- "ledit",
- "lequel",
- "les",
- "lesdites",
- "lesquelles",
- "lesquels",
- "leur",
- "leurs",
- "lors",
- "lorsque",
- "lui",
- "lui-aussi",
- "lui-même",
- "là",
- "ma",
- "maint",
- "maintes",
- "mais",
- "malgré",
- "me",
- "mes",
- "mien",
- "moi",
- "moi-même",
- "moins",
- "mon",
- "ne",
- "ni",
- "nonobstant",
- "nos",
- "notre",
- "nous",
- "nous-mêmes",
- "nul",
- "nôtre",
- "nôtres",
- "on",
- "ont",
- "onze",
- "ou",
- "outre",
- "où",
- "par",
- "parce",
- "parmi",
- "pas",
- "pendant",
- "personne",
- "peu",
- "peut",
- "peuvent",
- "peux",
- "plupart",
- "plus",
- "plusieurs",
- "pour",
- "pourquoi",
- "pourra",
- "pourraient",
- "pourrait",
- "pourrez",
- "pourrons",
- "pourront",
- "pouvait",
- "pouvez",
- "pouvoir",
- "pouvons",
- "presque",
- "près",
- "pu",
- "puis",
- "puisque",
- "puisse",
- "puissent",
- "puissions",
- "qu",
- "quand",
- "quant",
- "quarante",
- "quatre",
- "que",
- "quel",
- "quelconque",
- "quelle",
- "quelles",
- "quelqu'un",
- "quelque",
- "quelques",
- "quelques-unes",
- "quelques-uns",
- "quelqu’un",
- "quels",
- "qui",
- "quiconque",
- "quid",
- "quoi",
- "quoique",
- "rien",
- "sa",
- "sans",
- "sauf",
- "se",
- "selon",
- "sera",
- "serai",
- "seraient",
- "serais",
- "serait",
- "seras",
- "serez",
- "seriez",
- "serions",
- "serons",
- "seront",
- "ses",
- "si",
- "sien",
- "sienne",
- "siennes",
- "siens",
- "sinon",
- "six",
- "soi",
- "soi-même",
- "soient",
- "sois",
- "soit",
- "sommes",
- "son",
- "sont",
- "sous",
- "soyez",
- "soyons",
- "suis",
- "sur",
- "t-il",
- "ta",
- "tandis",
- "tant",
- "tantôt",
- "te",
- "tel",
- "telle",
- "telles",
- "tes",
- "tien",
- "toi",
- "ton",
- "tous",
- "tout",
- "toute",
- "toutes",
- "trois",
- "tte",
- "tu",
- "un",
- "une",
- "unes",
- "uns",
- "unt",
- "va",
- "vais",
- "van",
- "vers",
- "versus",
- "via",
- "voici",
- "voilà",
- "voir",
- "voire",
- "vont",
- "vos",
- "votre",
- "vous",
- "vous-même",
- "vs",
- "vu",
- "y",
- "à",
- "á",
- "ça",
- "étaient",
- "étais",
- "était",
- "étant",
- "étiez",
- "étions",
- "été",
- "êtes",
- "être",
- ],
- "gu": [
- "અંદર",
- "અડધા, અડધું",
- "અત્યારે, હમણાં",
- "અથવા, કે",
- "અને",
- "અનેક, ઘણા",
- "અન્ય, બીજું",
- "અમને, હમેં",
- "અમારા",
- "અમારું, આપણું",
- "અમે",
- "અહીં, અહીંયા",
- "આ",
- "આ દ્વારા",
- "આ રીતે, આ તરફ",
- "આની જેમ",
- "ઉપર",
- "એકલા",
- "એનાથી",
- "એમાથી",
- "ઓછું, ઓછા",
- "કઈ બાજુ",
- "કદાચ",
- "કયું, કયો, કઈ, જે",
- "કાં તો",
- "કેટલા",
- "કેટલાક, થોડા",
- "કેમ, શા માટે",
- "કેવી રીતે, કઈ રીતે",
- "કોઈ",
- "કોઈ નહી",
- "કોઈને",
- "કોઈપણ",
- "કોણ",
- "કોનું, જેમના, જેમની",
- "ક્યાંક, કોઈ જગ્યાએ",
- "ક્યાંથી, જ્યાં, ક્યાં ",
- "ક્યારે, જ્યારે",
- "ક્યારેક ક્યારેક",
- "ઘણું બધું",
- "ઘણું, પુસ્કળ, અતિશય",
- "જેથી",
- "જેને, જેમને",
- "જેમ",
- "જેમ કે, જેમ, જે રીતે, જેવા કે",
- "જો",
- "તને",
- "તમારા, તમારું",
- "તમારું",
- "તમે, તું",
- "તારું",
- "તે જેવી, તેની જેમ",
- "તે રીતે, તે તરફ",
- "તેઓ",
- "તેઓનું",
- "તેઓને, તેમને",
- "તેણીના",
- "તેથી, તો",
- "તેના",
- "તેનું, તેના",
- "તેમના, તેમનું, તેઓની",
- "તેમને. એમને",
- "તેવું",
- "ત્યાં",
- "ત્યાં સુધી",
- "થોડા",
- "થોડું",
- "દરેક",
- "દૂર",
- "દ્વારા",
- "નજીક, પાસે",
- "ના, નહિ",
- "ના, નો",
- "ની અંદર",
- "ની સામે",
- "નીચે",
- "પછી",
- "પછી, ત્યારે",
- "પછીથી",
- "પણ",
- "પરંતુ, પણ",
- "પાછળ",
- "પેલી",
- "પેલું",
- "પેલો, તે",
- "પ્રતિ",
- "ફરીથી, ફરી",
- "બંને, બેઉ",
- "બધા",
- "બહાર",
- "બાજુમાં",
- "ભરપૂર",
- "મને",
- "માં",
- "માંથી, થી",
- "માટે",
- "માથે, ઉપર",
- "મારા",
- "મારુ, મારી ",
- "મારું",
- "લીધે, કારણ કે,કેમ કે",
- "વધારાનું",
- "વધારે",
- "વધારે, વધુ ",
- "શું",
- "સમગ્ર",
- "સમાન, એક સરખું",
- "સાથે",
- "સિવાય",
- "સુધી",
- "સૌથી વધુ",
- "હજુ સુધી",
- "હું",
- ],
- "hi": [
- "अंदर",
- "अकेला",
- "अतिरिक्त",
- "अथवा, या",
- "अधिकांश",
- "अन्यथा",
- "अब, अभि, इसी वक्त",
- "अभी तक",
- "आधा",
- "आप, तुम, तुजे",
- "आपका, तुम्हारा, तेरा",
- "इधर, यहाँ",
- "इन्हें, इन",
- "इस तरफ",
- "इस से",
- "इसका, इसकी",
- "इसके द्वारा",
- "इसके साथ",
- "इसलिए",
- "इसलिए, तो",
- "उदाहरण के लिए",
- "उन को, इन को, उन्हें, इन्हें",
- "उनका, उनके, उनकी, इनका",
- "उनके",
- "उनमें से",
- "उन्हें",
- "उस तरफ, उसी और",
- "उसकी, उसके",
- "उसके जैसा",
- "उसको, उसके, इसको, इसके, इसकी",
- "ऊपर",
- "ऐसा",
- "और",
- "कब, जब",
- "कभी - कभी",
- "कभी कभी",
- "कम",
- "कम, थोड़ा",
- "कहीं",
- "का, की, के",
- "काफ़ी",
- "किंतु, पर, लेकिन, मगर",
- "कितने",
- "किस तरफ",
- "किसके, जिसके, जिनके, किसका",
- "किसको, किसे, जिसे, जिन्हे",
- "किसी को",
- "की ओर, की तरफ़",
- "कुछ, थोड़े",
- "के अंदर",
- "के अलावा",
- "के ऊपर",
- "के लिये",
- "के सामने",
- "कैसे, कैसा",
- "कोई",
- "कोई न कोई",
- "कोई नहीं",
- "कोई, कोई व्यक्ति",
- "कौन",
- "कौन सा, जो",
- "कौन, जो",
- "क्या",
- "क्यों",
- "क्योंकि, चूंकि",
- "जब तक",
- "जब तक, तक तक",
- "जहाँ, कहां, किधर",
- "जिसका",
- "जैसा",
- "जैसे",
- "जैसे की, जैसा, वैसा",
- "जैसे, इस तरह",
- "ज्यादा, अधिक",
- "ढेर सारा",
- "ढेर सारा, बहुत सारा",
- "तक",
- "तक, जब तक",
- "तब, फिर",
- "ताकि",
- "तुम्हारा",
- "तुम्हारा, तुम्हारे",
- "तुम्हे, तुझे, तुमको",
- "तेरा, तेरी",
- "थोड़ा",
- "दाहिने, दाहिना",
- "दुसरा, एक और",
- "दूर",
- "दोनों",
- "द्वारा",
- "नहीं, मत ",
- "नीचे",
- "पास में, पास",
- "पास, नजदीक, करीब",
- "पीछे",
- "पूरा",
- "प्रति, से, तक",
- "प्रत्येक",
- "फिर, तो, तब, उस वक़्त",
- "फिर, दुबारा",
- "बजाय",
- "बहुत, अनेक",
- "बहुत, ज्यादा, काफी",
- "बाएं, वाम",
- "बाद में",
- "बाद में, पीछे",
- "बाहर",
- "भी",
- "मुझे",
- "में, भीतर, अंदर",
- "में, मैंने",
- "मेरा, अपना",
- "मेरा, मेरी",
- "मेरी, मेरा, मेरे",
- "यदि",
- "यदि, अगर",
- "यदि, या",
- "यह, ये, इसे",
- "लेकिन",
- "वह",
- "वह, जो",
- "वहां",
- "वही",
- "वे, वह, वो, उन्होंने",
- "वैसे, उसके जैसा",
- "शायद",
- "सब लोग",
- "सब, सभी, सारे",
- "सबसे ज्यादा, अधिकांश",
- "साथ",
- "से",
- "हम",
- "हमारा, हमारे, हमारी",
- "हर जगह",
- "हालाँकि",
- ],
- "id": [
- "Anda",
- "ada",
- "adakah",
- "adalah",
- "adanya",
- "adapaun",
- "adapun",
- "agar",
- "akan",
- "akau",
- "akhirnya",
- "akibat",
- "akibatnya",
- "aku",
- "alias",
- "anda",
- "aneka",
- "antar",
- "antara",
- "antaranya",
- "apa",
- "apabila",
- "apakah",
- "apalagi",
- "apapun",
- "asal",
- "atas",
- "atau",
- "ataukah",
- "ataupun",
- "bagai",
- "bagaimana",
- "bagaimanakah",
- "bagaimanapun",
- "bagi",
- "bagi-nya",
- "bahkan",
- "bahwa",
- "bahwasanya",
- "baik",
- "bakal",
- "balik",
- "banyak",
- "banyaknya",
- "baru",
- "bawah",
- "beberapa",
- "begini",
- "beginilah",
- "begitu",
- "belakang",
- "beliau",
- "belum",
- "beragam",
- "berapa",
- "berapakah",
- "berbagai",
- "berberapa",
- "berdasar",
- "berdasarkan",
- "berdiri",
- "berdirinya",
- "berikut",
- "berkat",
- "bersama",
- "bersamanya",
- "berupa",
- "beserta",
- "betapa",
- "bila",
- "bilamana",
- "bisa",
- "boleh",
- "buah",
- "buat",
- "bukan",
- "bukankah",
- "bukanlah",
- "bukannya",
- "buruh",
- "cara",
- "dalam",
- "dalamnya",
- "dan",
- "dapat",
- "dari",
- "darimana",
- "daripada",
- "dekat",
- "demi",
- "demikian",
- "dengan",
- "dengannya",
- "depan",
- "dg",
- "di",
- "dia",
- "diantara",
- "diantaranya",
- "diatas",
- "dibalik",
- "dibandingkan",
- "dibawah",
- "dibawahnya",
- "dibeberapa",
- "dibelakang",
- "diberbagai",
- "didalam",
- "didalamnya",
- "diluar",
- "dimana",
- "diri",
- "dirinya",
- "disaat",
- "disamping",
- "disebelah",
- "disekeliling",
- "diseluruh",
- "disini",
- "ditepi",
- "dng",
- "dr",
- "engkau",
- "gambar",
- "gimana",
- "hadap",
- "hai",
- "hanya",
- "harus",
- "hei",
- "ia",
- "ialah",
- "ini",
- "inikah",
- "inilah",
- "inipun",
- "isi",
- "isinya",
- "itu",
- "itua",
- "itulah",
- "itupun",
- "iye",
- "jadi",
- "jangan",
- "jauh",
- "jelang",
- "jenis",
- "jika",
- "juga",
- "kah",
- "kalau",
- "kalian",
- "kalo",
- "kami",
- "kamilah",
- "kamu",
- "kan",
- "kapan",
- "kapankah",
- "karena",
- "karenanya",
- "kau",
- "ke",
- "kebanyakan",
- "kecuali",
- "kedalam",
- "kedepan",
- "kedua",
- "keduanya",
- "keliling",
- "keluar",
- "kemudian",
- "kena",
- "kenapa",
- "kendati",
- "kepada",
- "kepadaku",
- "kepadamu",
- "kepadanya",
- "kepusatnya",
- "kerana",
- "keseluruhan",
- "keseluruhannya",
- "kesemuanya",
- "ketika",
- "ketimbang",
- "khususnya",
- "kira",
- "kita",
- "kok",
- "koq",
- "kpd",
- "ku",
- "la",
- "lagi",
- "lah",
- "lain",
- "lainnya",
- "lalu",
- "lama",
- "lantaran",
- "lantas",
- "layak",
- "layaknya",
- "lengah",
- "lewat",
- "loh",
- "luar",
- "macam",
- "maka",
- "makanya",
- "maksud",
- "maksudnya",
- "malahan",
- "mampu",
- "mana",
- "manakah",
- "manakala",
- "manapun",
- "masa",
- "masing",
- "masing-masing",
- "maupun",
- "mayoritas",
- "melainkan",
- "melalui",
- "melawan",
- "melewati",
- "menajak",
- "menbeli",
- "mengajak",
- "mengapa",
- "mengenai",
- "mengenainya",
- "menjadi",
- "menjelang",
- "menuju",
- "menurut",
- "menurutmu",
- "mereka",
- "merekapun",
- "merupakan",
- "meski",
- "meskipn",
- "meskipun",
- "misalkan",
- "misalnya",
- "msl",
- "mulai",
- "mungkin",
- "namun",
- "nya",
- "oleh",
- "olehnya",
- "orang",
- "pada",
- "padahal",
- "padanya",
- "para",
- "pasca",
- "pd",
- "per",
- "perihal",
- "perlu",
- "pula",
- "pun",
- "saat",
- "saatnya",
- "sama",
- "sambil",
- "sampai",
- "sampai-sampai",
- "samping",
- "sana",
- "sang",
- "satu",
- "satu-satunya",
- "satunya",
- "saya",
- "seakan",
- "seandainya",
- "seantero",
- "sebab",
- "sebagai",
- "sebagaimana",
- "sebagian",
- "sebaliknya",
- "sebangsa",
- "sebanyak",
- "sebelah",
- "sebelum",
- "sebelumnya",
- "seberang",
- "seberat",
- "sebesar",
- "sebuah",
- "secara",
- "sedang",
- "sedangkan",
- "sedangkkan",
- "sedari",
- "sedikit",
- "sedikitnya",
- "seekor",
- "segala",
- "segenap",
- "seharusnya",
- "sehingga",
- "sehubungan",
- "seiring",
- "sejak",
- "sejauh",
- "sejenis",
- "sejumlah",
- "sekali",
- "sekaligus",
- "sekalipun",
- "sekitar",
- "sekitarnya",
- "selain",
- "selaku",
- "selama",
- "selesai",
- "seluas",
- "seluruh",
- "semacam",
- "semasa",
- "semenjak",
- "sementara",
- "sempat",
- "semua",
- "semuanya",
- "sendiri",
- "senilai",
- "seorang",
- "sepanjang",
- "sepasang",
- "sepeninggal",
- "seperti",
- "sepertinya",
- "sepeti",
- "sepucuk",
- "seputar",
- "serangkaian",
- "seraya",
- "serta",
- "sesampai",
- "sesampainya",
- "seseorang",
- "sesuai",
- "sesuatu",
- "sesudah",
- "setebal",
- "setelah",
- "setelahnya",
- "setengah",
- "setiap",
- "setinggi",
- "seusai",
- "sewaktu",
- "si",
- "siapa",
- "siapakah",
- "siapapun",
- "silakan",
- "sini",
- "sinilah",
- "situ",
- "soal",
- "suatu",
- "sudah",
- "supaya",
- "tak",
- "tan",
- "tangguh",
- "tanpa",
- "tapi",
- "tatkala",
- "telah",
- "tempat",
- "tengah",
- "tengahnya",
- "tentang",
- "tepat",
- "tepatnya",
- "teratas",
- "terhadap",
- "terhadapnya",
- "termasuk",
- "ternyata",
- "tersebut",
- "tertentu",
- "terutama",
- "tesebut",
- "tetap",
- "tetapi",
- "tiada",
- "tiap",
- "tidak",
- "tidakkah",
- "tidaklah",
- "tidaknya",
- "tsb",
- "tt",
- "ttg",
- "tuh",
- "tujuh",
- "untuk",
- "untukmu",
- "untuknya",
- "untung",
- "usah",
- "usai",
- "via",
- "waktu",
- "walau",
- "walaupun",
- "ya",
- "yaitu",
- "yakni",
- "yang",
- "yg",
- ],
- "mr": [
- "अधिक",
- "अनेक",
- "अशी",
- "असलयाचे",
- "असलेल्या",
- "असा",
- "असून",
- "असे",
- "आज",
- "आणि",
- "आता",
- "आपल्या",
- "आला",
- "आली",
- "आले",
- "आहे",
- "आहेत",
- "एक",
- "एका",
- "कमी",
- "करणयात",
- "करून",
- "का",
- "काम",
- "काय",
- "काही",
- "किवा",
- "की",
- "केला",
- "केली",
- "केले",
- "कोटी",
- "गेल्या",
- "घेऊन",
- "जात",
- "झाला",
- "झाली",
- "झाले",
- "झालेल्या",
- "टा",
- "डॉ",
- "तर",
- "तरी",
- "तसेच",
- "ता",
- "ती",
- "तीन",
- "ते",
- "तो",
- "त्या",
- "त्याचा",
- "त्याची",
- "त्याच्या",
- "त्याना",
- "त्यानी",
- "त्यामुळे",
- "त्री",
- "दिली",
- "दोन",
- "न",
- "नाही",
- "निर्ण्य",
- "पण",
- "पम",
- "परयतन",
- "पाटील",
- "म",
- "मात्र",
- "माहिती",
- "मी",
- "मुबी",
- "म्हणजे",
- "म्हणाले",
- "म्हणून",
- "या",
- "याचा",
- "याची",
- "याच्या",
- "याना",
- "यानी",
- "येणार",
- "येत",
- "येथील",
- "येथे",
- "लाख",
- "व",
- "व्यकत",
- "सर्व",
- "सागित्ले",
- "सुरू",
- "हजार",
- "हा",
- "ही",
- "हे",
- "होणार",
- "होत",
- "होता",
- "होती",
- "होते",
- ],
- "pt": [
- "a",
- "a cabo de",
- "a caminho de",
- "a despeito de",
- "a favor de",
- "a fim de",
- "a menos que",
- "a não ser",
- "a não ser que",
- "a partir de",
- "a propósito",
- "a respeito de",
- "a título de",
- "abaixo de",
- "acima",
- "acima de",
- "afinal",
- "afora",
- "agora",
- "agora que",
- "ai",
- "ainda",
- "ainda mais",
- "algo",
- "algum",
- "alguma",
- "algumas",
- "alguns",
- "alguém",
- "além",
- "além de",
- "ambas",
- "ambos",
- "andar",
- "andou",
- "ante",
- "antes",
- "anti",
- "antre",
- "ao",
- "ao cabo de",
- "ao invés de",
- "ao lado",
- "ao longo de",
- "ao passo que",
- "ao redor de",
- "aos cuidados de",
- "apenas",
- "apesar de",
- "apesar de que",
- "após",
- "aquela",
- "aquelas",
- "aquele",
- "aqueles",
- "aquilo",
- "as",
- "assim",
- "assim como",
- "assim que",
- "atras",
- "através",
- "através de",
- "atráis",
- "atrás",
- "atrás de",
- "até",
- "até que",
- "auto",
- "avante",
- "aí",
- "bastante",
- "bem",
- "bem como",
- "cada",
- "cara a cara",
- "caso",
- "cerca",
- "cima",
- "com",
- "comigo",
- "como",
- "como se",
- "conforme",
- "connosco",
- "conosco",
- "conquanto",
- "consigo",
- "consoante",
- "contanto",
- "contanto que",
- "contigo",
- "contra",
- "contudo",
- "convosco",
- "cuja",
- "cujas",
- "cujo",
- "cujos",
- "d'",
- "d.",
- "da",
- "dada",
- "dado",
- "dado que",
- "dali",
- "daquela",
- "daquelas",
- "daquele",
- "daqui",
- "daqui a",
- "daí",
- "de",
- "de modo que",
- "dela",
- "delas",
- "dele",
- "deles",
- "demais",
- "dentre",
- "dentro",
- "dentro de",
- "depois",
- "depois de",
- "desde",
- "desde que",
- "dessa",
- "dessas",
- "desse",
- "desses",
- "desta",
- "destas",
- "deste",
- "destes",
- "detrás de",
- "deva",
- "devam",
- "deve",
- "devem",
- "devemos",
- "devendo",
- "dever",
- "deveria",
- "deveriam",
- "deverá",
- "deverão",
- "deviam",
- "devido",
- "devido a",
- "devo",
- "diante de",
- "disso",
- "diversas",
- "diversos",
- "do que",
- "donde",
- "doutros",
- "dum",
- "duma",
- "durante",
- "e",
- "e/ou",
- "eba",
- "eis",
- "ela",
- "elas",
- "ele",
- "eles",
- "eles/elas",
- "em",
- "em cima de",
- "em frente a",
- "em meio a",
- "em nome de",
- "em prol de",
- "em relação a",
- "em torno de",
- "em vez de",
- "em virtude de",
- "em vista de",
- "em volta de",
- "embaixo de",
- "embora",
- "enquanto",
- "entre",
- "entretanto",
- "então",
- "era",
- "eram",
- "ergo",
- "essa",
- "essas",
- "esse",
- "esses",
- "esta",
- "estado",
- "estamos",
- "estando",
- "estar",
- "estarem",
- "estaria",
- "estariam",
- "estarmos",
- "estará",
- "estarão",
- "estas",
- "estava",
- "estavam",
- "este",
- "esteja",
- "estejam",
- "estes",
- "esteve",
- "estivemos",
- "estiver",
- "estiveram",
- "estiverem",
- "estivesse",
- "estivessem",
- "estou",
- "está",
- "estávamos",
- "estão",
- "eu",
- "excepto",
- "exceto",
- "fica",
- "ficado",
- "ficamos",
- "ficando",
- "ficar",
- "ficaram",
- "ficaria",
- "ficou",
- "fiquei",
- "foi",
- "fomos",
- "for",
- "fora",
- "fora de",
- "foram",
- "forem",
- "fosse",
- "fossem",
- "frente a",
- "fui",
- "fôr",
- "gente",
- "graças",
- "graças a",
- "havendo",
- "haver",
- "haverem",
- "havia",
- "haviam",
- "houver",
- "houvesse",
- "há",
- "i.e.",
- "ia",
- "iam",
- "ido",
- "igual a",
- "inté",
- "invés de",
- "ir",
- "ireii",
- "irem",
- "iremos",
- "iria",
- "iriam",
- "irá",
- "irão",
- "isso",
- "isto",
- "junto a",
- "junto com",
- "já",
- "já que",
- "la",
- "las",
- "lhe",
- "lhes",
- "lo",
- "logo",
- "logo que",
- "los",
- "lá",
- "mais",
- "mais de",
- "mais do que",
- "mais que",
- "mal",
- "malgrado",
- "mas",
- "me",
- "mediante",
- "menos",
- "mesma",
- "mesmas",
- "mesmo",
- "mesmo que",
- "mesmo se",
- "mesmos",
- "meu",
- "meus",
- "mim",
- "minha",
- "minhas",
- "muita",
- "muitas",
- "muito",
- "muito menos",
- "muitos",
- "muitíssimo",
- "n'",
- "na",
- "na frente de",
- "na sequência de",
- "nada",
- "naquela",
- "naquele",
- "naqueles",
- "naquilo",
- "nas",
- "nele",
- "neles",
- "nem",
- "nenhum",
- "nenhuma",
- "nenhumas",
- "nenhuns",
- "nessa",
- "nessas",
- "nesse",
- "nesses",
- "nesta",
- "nestas",
- "neste",
- "nestes",
- "ninguém",
- "no",
- "no que",
- "nos",
- "nosco",
- "nossa",
- "nossas",
- "nosso",
- "nossos",
- "num",
- "numa",
- "nós",
- "o",
- "o(s)",
- "onde",
- "onde quer que",
- "ora",
- "os",
- "ou",
- "outra",
- "outras",
- "outrem",
- "outro",
- "outros",
- "outrém",
- "oxalá",
- "p'ra",
- "p/",
- "pa",
- "para",
- "para com",
- "para que",
- "parece",
- "parecer",
- "pelo",
- "per",
- "perante",
- "perantes",
- "permanece",
- "permanecer",
- "perto de",
- "pode",
- "podem",
- "podemos",
- "podendo",
- "poder",
- "poderei",
- "poderem",
- "poderemos",
- "poderia",
- "poderiam",
- "poderá",
- "poderão",
- "poderíamos",
- "podia",
- "podiam",
- "podíamos",
- "pois",
- "por",
- "por causa de",
- "por causa que",
- "por conta de",
- "por entre",
- "por isso",
- "por isto",
- "por meio de",
- "por trás",
- "por trás de",
- "por volta de",
- "porquanto",
- "porque",
- "portanto",
- "porém",
- "possa",
- "possam",
- "possamos",
- "posso",
- "pouca",
- "poucas",
- "pouco",
- "poucos",
- "pouquíssimos",
- "pra",
- "precisam",
- "precisar",
- "precisaram",
- "precisarão",
- "precisou",
- "prestes a",
- "pretender",
- "pretendiam",
- "pro",
- "pré",
- "pré-",
- "pró",
- "pude",
- "pudemos",
- "puderam",
- "puderem",
- "pudesse",
- "pudessem",
- "pós",
- "pôde",
- "pôr",
- "público",
- "q.b.",
- "quais",
- "quaisquer",
- "qual",
- "qualquer",
- "quando",
- "quanta",
- "quantas",
- "quanto",
- "quanto a",
- "quanto baste",
- "quanto mais",
- "quantos",
- "que",
- "quem",
- "quer",
- "quão",
- "quê",
- "rente a",
- "rente de",
- "rumo a",
- "se",
- "se bem que",
- "se e somente se",
- "se-",
- "segundo",
- "seja",
- "sejam",
- "sem",
- "sem falar de",
- "sempre que",
- "sendo",
- "sendo que",
- "senão",
- "ser",
- "serei",
- "serem",
- "seremos",
- "seria",
- "seriam",
- "sermos",
- "será",
- "serão",
- "seu",
- "seus",
- "si",
- "sido",
- "sob",
- "sobre",
- "somos",
- "sou",
- "sse",
- "sua",
- "suas",
- "sub",
- "são",
- "sê",
- "só que",
- "sôbre",
- "ta",
- "tais",
- "tal",
- "tampouco",
- "tanta",
- "tantas",
- "tanto",
- "tantos",
- "te",
- "tem",
- "temos",
- "tende",
- "tendo",
- "tenha",
- "tenham",
- "tenhamos",
- "tenho",
- "tentado",
- "tentar",
- "tentaram",
- "ter",
- "terei",
- "terem",
- "teremos",
- "teria",
- "teriam",
- "termos",
- "terá",
- "terão",
- "teríamos",
- "teu",
- "teus",
- "teve",
- "ti",
- "tido",
- "tinha",
- "tinham",
- "tive",
- "tivemos",
- "tiver",
- "tiveram",
- "tiverem",
- "tivesse",
- "tivessem",
- "to",
- "toda",
- "todas",
- "todavia",
- "todo",
- "todos",
- "trás",
- "tu",
- "tua",
- "tuas",
- "tudo",
- "tá",
- "tão",
- "tão logo",
- "té",
- "têm",
- "tínhamos",
- "ultra",
- "um",
- "uma",
- "uma vez que",
- "umas",
- "uns",
- "vai",
- "vais",
- "vamos",
- "varias",
- "varios",
- "versus",
- "via",
- "visto",
- "visto que",
- "voce",
- "você",
- "vocês",
- "vos",
- "vossa",
- "vossas",
- "vosso",
- "vossos",
- "vou",
- "vs",
- "vá",
- "várias",
- "vários",
- "vão",
- "vérsus",
- "vós",
- "à",
- "à beira de",
- "à custa de",
- "à expensa de",
- "à luz de",
- "à medida que",
- "àquela",
- "àqueles",
- "às",
- "às custas de",
- "às expensas de",
- "é",
- "íamos",
- "\u200b\u200bem",
- ],
- "sw": [
- "akasema",
- "alikuwa",
- "alisema",
- "baada",
- "basi",
- "bila",
- "cha",
- "chini",
- "hadi",
- "hapo",
- "hata",
- "hivyo",
- "hiyo",
- "huku",
- "huo",
- "ili",
- "ilikuwa",
- "juu",
- "kama",
- "karibu",
- "katika",
- "kila",
- "kima",
- "kisha",
- "kubwa",
- "kutoka",
- "kuwa",
- "kwa",
- "kwamba",
- "kwenda",
- "kwenye",
- "la",
- "lakini",
- "mara",
- "mdogo",
- "mimi",
- "mkubwa",
- "mmoja",
- "moja",
- "muda",
- "mwenye",
- "na",
- "naye",
- "ndani",
- "ng",
- "ni",
- "nini",
- "nonkungu",
- "pamoja",
- "pia",
- "sana",
- "sasa",
- "sauti",
- "tafadhali",
- "tena",
- "tu",
- "vile",
- "wa",
- "wakati",
- "wake",
- "walikuwa",
- "wao",
- "watu",
- "wengine",
- "wote",
- "ya",
- "yake",
- "yangu",
- "yao",
- "yeye",
- "yule",
- "za",
- "zaidi",
- "zake",
- ],
- "ur": [
- "اسلئے",
- "اسکے جیسا",
- "ان کے بیچ ,ان لوگوں کے بیچ",
- "اندر",
- "انکا",
- "اور ,و",
- "اوپر",
- "اگر ,گرچہ ,اگرچہ",
- "باہر",
- "بایاں ,بائیں",
- "بجائے ,بدلے ,بدلے میں",
- "بہت ,بہت سارے ,بہت کچھ",
- "بہت زیادہ",
- "تب تک",
- "تم لوگ ,آپ ,آپ لوگ",
- "تمہارا ,تیرا ,آپکا",
- "تو, تم ,آپ",
- "تھوڑا ,تھوڑی",
- "جب تک",
- "جسکا",
- "جیسے",
- "حالاںکہ",
- "دایاں ,دائیں ,صحیح",
- "دوسرا",
- "زیادہ تر",
- "ساتھ ,کے ساتھ",
- "سب ,سبھی ,سب کچھ ,سارے ,سارا",
- "سب لوگ",
- "طرف ,اسکی طرف",
- "لیکن",
- "مثلأ ,مثال کے طور پے",
- "میرا",
- "میں",
- "میں ,کے اندر ,اندر",
- "نہی تو",
- "نہیں ,ناں ,نا",
- "نیچے",
- "وہ ,وہ لوگ",
- "وہ ,وہ والا, کہ",
- "وہ ,یے",
- "وہاں",
- "پھر",
- "پہ ,پر ,میں",
- "کافی",
- "کب",
- "کبھی کبھی",
- "کم",
- "کوئی",
- "کون",
- "کونسا",
- "کچھ",
- "کہاں",
- "کیا",
- "کیسے",
- "کیوںکہ ,چوںکہ ,کیوںکی",
- "کےلئے",
- "ہم ,ھم",
- "یہ ,یہ والا",
- "یہاں",
- ],
- "vi": [
- "ai",
- "ai ai",
- "ai nấy",
- "anh",
- "anh em",
- "anh trai",
- "anh ấy",
- "ba",
- "bao",
- "bao giờ",
- "bay",
- "bà",
- "bà con",
- "bà ấy",
- "bác",
- "bây",
- "bé",
- "bên",
- "bạn",
- "bạn gái",
- "bạn trai",
- "bả",
- "bản thân",
- "bất chấp",
- "bất cứ",
- "bất kì",
- "bất luận",
- "bất nhược",
- "bất quá",
- "bấy",
- "bấy nhiêu",
- "bần tăng",
- "bầy quân",
- "bầy tui",
- "bậu",
- "bằng",
- "bệ hạ",
- "bị cáo",
- "bố",
- "bố nó",
- "bồ",
- "bộ",
- "bởi",
- "bởi vì",
- "cc",
- "cha",
- "chao",
- "chi",
- "chiếu theo",
- "cho",
- "cho dù",
- "cho đến",
- "choa",
- "chàng",
- "chán",
- "cháu",
- "chí",
- "chính",
- "chú",
- "chú mày",
- "chúng",
- "chúng mày",
- "chúng mình",
- "chúng nó",
- "chúng ta",
- "chúng tao",
- "chúng tôi",
- "chút",
- "chăng",
- "chưa",
- "chưng",
- "chả",
- "chắc",
- "chẳng cứ",
- "chỉ",
- "chị",
- "chị gái",
- "chị ấy",
- "chớ",
- "chứ",
- "con",
- "con này",
- "cuối cùng",
- "các",
- "các hạ",
- "cái",
- "cái gì",
- "cái này",
- "cán bộ",
- "còn",
- "có",
- "có vẻ",
- "cóc",
- "cô",
- "cô nương",
- "cô ta",
- "cô ấy",
- "côi",
- "công tử",
- "cùng",
- "cơ",
- "cơ mà",
- "cưng",
- "cạnh",
- "cả",
- "cả nhà",
- "cầm bằng",
- "cậu",
- "cổ",
- "cộng",
- "cụ",
- "của",
- "cứ",
- "do",
- "do vậy",
- "do đó",
- "duy",
- "dù",
- "dù sao",
- "dù vậy",
- "dưng",
- "dưới",
- "dường như",
- "dạ",
- "dầu",
- "dẫu",
- "dẫu vậy",
- "dậy",
- "dọc",
- "dợ",
- "em",
- "ghe",
- "già",
- "giá như",
- "giả dụ",
- "giả sử",
- "giữa",
- "gì",
- "ha",
- "hay",
- "hay là",
- "hen",
- "hoàng thượng",
- "hoặc",
- "huynh",
- "huống",
- "huống chi",
- "huống gì",
- "huống hồ",
- "há",
- "hôn",
- "hơn",
- "hơn nữa",
- "hả",
- "hầu hết",
- "hắn",
- "hết",
- "hết cả",
- "hề",
- "hễ",
- "họ",
- "hổi",
- "hỡi",
- "hử",
- "khanh",
- "khi",
- "khi nào",
- "không",
- "không ai",
- "không những",
- "khứa",
- "kia",
- "kém",
- "kìa",
- "kẻo",
- "kể từ",
- "l",
- "là",
- "lão",
- "lên",
- "lại nữa",
- "lần",
- "lẫn",
- "lắm",
- "mi",
- "min",
- "miễn",
- "moa",
- "muôn",
- "muội",
- "mà",
- "mà còn",
- "mày",
- "mãi",
- "mình",
- "mô",
- "mũ",
- "mất",
- "mấy",
- "mầy",
- "mẫu hậu",
- "mặc dù",
- "mặc dầu",
- "mặt khác",
- "mẹ",
- "mẹ nó",
- "mọi",
- "mọi người",
- "mọi vật",
- "mỏa",
- "mỗi",
- "một chút",
- "một nửa",
- "một số",
- "một vài",
- "một ít",
- "mụ",
- "ngay",
- "nghe",
- "nghen",
- "nghỉ",
- "ngoài",
- "ngoài ra",
- "ngoại",
- "ngoải",
- "ngài",
- "ngươi",
- "người",
- "người người",
- "người ta",
- "ngược lại",
- "ngộ",
- "nha",
- "nhiều",
- "nhà quân",
- "nhá",
- "nhân",
- "nhân dịp",
- "nhé",
- "như",
- "như vậy",
- "nhưng",
- "nhưng mà",
- "nhược bằng",
- "nhất là",
- "nhằm",
- "nhỉ",
- "nhỏ",
- "nhờ",
- "nhỡ",
- "những",
- "ni",
- "nà",
- "nàng",
- "nào",
- "này",
- "nè",
- "nên",
- "nó",
- "nô tài",
- "nô tì",
- "nơi",
- "nơi nơi",
- "nấy",
- "nầy",
- "nẩu",
- "nếu",
- "nếu như",
- "nọ",
- "nội",
- "nớ",
- "nừng",
- "nửa",
- "nữa",
- "phi",
- "phía",
- "phô bay",
- "phải",
- "phải hôn",
- "phải không",
- "phần",
- "phần lớn",
- "phỏng",
- "phứt",
- "qua",
- "quanh",
- "quý khách",
- "quý vị",
- "quả",
- "quả nhân",
- "ra",
- "riêng",
- "rùi",
- "rằng",
- "rồi",
- "sang",
- "sao",
- "sau",
- "sau cùng",
- "song",
- "song le",
- "sắp",
- "sẽ",
- "sở dĩ",
- "ta",
- "tao",
- "tau",
- "thanh niên",
- "thay",
- "thay vì",
- "theo",
- "theo đó",
- "thiếp",
- "thiệt",
- "thành",
- "thâu",
- "thêm",
- "thì",
- "thí dụ",
- "thôi",
- "thần",
- "thầy",
- "thẩy",
- "thật",
- "thằng này",
- "thế",
- "thế là",
- "thế mà",
- "thế nhưng",
- "thị",
- "thời",
- "tiểu nhân",
- "toa",
- "toà",
- "toàn",
- "toàn bộ",
- "toàn thể",
- "trong",
- "trong khi",
- "trong đó",
- "trái",
- "trái lại",
- "trên",
- "trò",
- "trước",
- "trẫm",
- "trời",
- "trừ phi",
- "tuy",
- "tuy nhiên",
- "tuy rằng",
- "tuy vậy",
- "tê",
- "tóm lại",
- "tôi",
- "tương đương",
- "tại",
- "tại hạ",
- "tại vì",
- "tất cả",
- "tầm",
- "tận",
- "tỉ",
- "tổ",
- "tớ",
- "tới",
- "tụi",
- "tụi nó",
- "tức",
- "tức là",
- "từ",
- "tự",
- "tựa",
- "ui",
- "và",
- "vài",
- "vài ba",
- "vào",
- "vì",
- "vì thế",
- "vì vậy",
- "ví dụ",
- "ví như",
- "vô",
- "vô số",
- "vô vàn",
- "vả chăng",
- "vả lại",
- "vậy",
- "vậy là",
- "vậy mà",
- "về",
- "về hướng",
- "về phía",
- "vị",
- "với",
- "xuống",
- "à",
- "á",
- "ái khanh",
- "âu là",
- "í",
- "ít",
- "ông",
- "ông ấy",
- "út",
- "ý",
- "đa số",
- "đang",
- "đi",
- "đâu",
- "đây",
- "đã",
- "đê",
- "đích thân",
- "đó",
- "đôi",
- "đương",
- "được",
- "đại nhân",
- "đấy",
- "đầu tiên",
- "đằng này",
- "đằng ấy",
- "đẳng",
- "đặng",
- "đến",
- "để",
- "đệ",
- "đối với",
- "đồ",
- "ơi",
- "ư",
- "ạ",
- "ả",
- "ảnh",
- "ấy",
- "ẻm",
- "ổng",
- "ờ",
- "ở",
- "ừ",
- "ừa",
- "ừm",
- ],
- "yo": [
- "a",
- "an",
- "bá",
- "bí",
- "bẹ̀rẹ̀",
- "fún",
- "fẹ́",
- "gbogbo",
- "inú",
- "jù",
- "jẹ",
- "jẹ́",
- "kan",
- "kì",
- "kí",
- "kò",
- "láti",
- "lè",
- "lọ",
- "mi",
- "mo",
- "máa",
- "mọ̀",
- "ni",
- "náà",
- "ní",
- "nígbà",
- "nítorí",
- "nǹkan",
- "o",
- "padà",
- "pé",
- "púpọ̀",
- "pẹ̀lú",
- "rẹ̀",
- "sì",
- "sí",
- "sínú",
- "ṣ",
- "ti",
- "tí",
- "wà",
- "wá",
- "wọn",
- "wọ́n",
- "yìí",
- "àti",
- "àwọn",
- "é",
- "í",
- "òun",
- "ó",
- "ń",
- "ńlá",
- "ṣe",
- "ṣé",
- "ṣùgbọ́n",
- "ẹmọ́",
- "ọjọ́",
- "ọ̀pọ̀lọpọ̀",
- ],
- "zh": [
- "",
- "一",
- "一争",
- "一些",
- "一切",
- "一旦",
- "一点",
- "一爭",
- "上",
- "上前",
- "上表",
- "下",
- "不",
- "不仅",
- "不会",
- "不但",
- "不僅",
- "不光",
- "不关",
- "不准",
- "不单",
- "不可",
- "不單",
- "不够",
- "不夠",
- "不应",
- "不得",
- "不想",
- "不愿",
- "不應",
- "不是",
- "不會",
- "不準",
- "不用",
- "不管",
- "不經",
- "不肯",
- "不能",
- "不要",
- "不該",
- "不論",
- "不论",
- "不该",
- "不過",
- "不需",
- "不願",
- "与",
- "与其",
- "且",
- "且是",
- "並",
- "並且",
- "並非",
- "个",
- "个人",
- "中",
- "临",
- "为",
- "为了",
- "为人",
- "为什么",
- "主",
- "乃至",
- "之",
- "之上",
- "之下",
- "之中",
- "之內",
- "之内",
- "之初",
- "之前",
- "之后",
- "之外",
- "之後",
- "之所以",
- "之时",
- "之時",
- "之間",
- "之间",
- "也",
- "也是",
- "书",
- "了",
- "争辩",
- "事",
- "于",
- "井",
- "亚",
- "亞",
- "亦为",
- "亦是",
- "亦為",
- "亭",
- "亲",
- "人",
- "人人",
- "人家",
- "什么",
- "什麼",
- "今",
- "仍是",
- "仍算",
- "从",
- "他",
- "他们",
- "他俩",
- "他倆",
- "他們",
- "代",
- "令",
- "以",
- "以上",
- "以下",
- "以为",
- "以來",
- "以前",
- "以北",
- "以及",
- "以后",
- "以外",
- "以往",
- "以後",
- "以来",
- "以為",
- "以爲",
- "以至",
- "们",
- "价",
- "任",
- "任何",
- "众",
- "会",
- "传",
- "伪",
- "似乎",
- "似的",
- "但",
- "但是",
- "位",
- "低",
- "住",
- "体",
- "何",
- "何方",
- "佛",
- "作",
- "作为",
- "作為",
- "你",
- "你们",
- "你們",
- "你自己",
- "你门",
- "佬",
- "併",
- "使",
- "來",
- "供",
- "依",
- "依据",
- "依據",
- "依照",
- "依靠",
- "侠",
- "侧",
- "侨",
- "侯",
- "便是",
- "係",
- "保存",
- "保級",
- "保级",
- "俠",
- "信",
- "修复",
- "修復",
- "個",
- "個人",
- "們",
- "倘若",
- "借助",
- "借由",
- "借着",
- "值",
- "假使",
- "假如",
- "偏",
- "做",
- "側",
- "偽",
- "傳",
- "傻",
- "像",
- "像是",
- "僑",
- "價",
- "儘管",
- "元",
- "先",
- "光",
- "光棍",
- "党",
- "內",
- "內外",
- "全",
- "全体",
- "全副",
- "全套",
- "全部",
- "全體",
- "公",
- "关",
- "关于",
- "关心",
- "兵",
- "其",
- "其中",
- "其他",
- "其余",
- "其它",
- "其餘",
- "典",
- "兼",
- "内",
- "内外",
- "军",
- "冠",
- "冢",
- "冲",
- "冷",
- "准",
- "准备",
- "减慢",
- "几",
- "凭",
- "凭借",
- "出手",
- "刀",
- "分",
- "分布",
- "列",
- "则为",
- "则是",
- "初",
- "別",
- "別人",
- "别",
- "别人",
- "别的",
- "到",
- "到处",
- "制",
- "券",
- "剂",
- "則是",
- "則為",
- "前",
- "前任",
- "前后",
- "前後",
- "剑",
- "剧",
- "副",
- "劇",
- "劍",
- "劑",
- "力",
- "办",
- "办学",
- "功",
- "加",
- "劣",
- "努力",
- "包",
- "包裹",
- "化",
- "区",
- "医",
- "區",
- "半",
- "单",
- "卡",
- "卫",
- "即",
- "即使",
- "即便",
- "却是",
- "卻",
- "卻是",
- "卿",
- "厂",
- "厅",
- "历届",
- "压",
- "原",
- "去",
- "县",
- "又",
- "又或",
- "又是",
- "及",
- "友",
- "发展",
- "发育",
- "变",
- "变得",
- "口",
- "古",
- "另",
- "另外",
- "只是",
- "只有",
- "只能",
- "只要",
- "可",
- "可以",
- "可是",
- "可能",
- "台",
- "史",
- "叶",
- "号",
- "司",
- "吃",
- "各",
- "各个",
- "各位",
- "各個",
- "各天",
- "各州",
- "各式",
- "各樣",
- "各种",
- "各种各样",
- "各種",
- "各種各樣",
- "各类",
- "各級",
- "各级",
- "各自",
- "各項",
- "各類",
- "各项",
- "同",
- "同年",
- "名",
- "后",
- "向",
- "吗",
- "君",
- "否",
- "吧",
- "呀",
- "员",
- "呢",
- "周",
- "味",
- "和",
- "和美",
- "咱们",
- "品",
- "哈尔滨",
- "哈爾濱",
- "員",
- "哪",
- "哪个",
- "哪些",
- "哪個",
- "哪儿",
- "哪兒",
- "哪怕",
- "哪裏",
- "哪裡",
- "哪里",
- "唯有",
- "商",
- "啊",
- "啦",
- "喇",
- "喜",
- "喜欢",
- "喜歡",
- "單",
- "單憑",
- "嗎",
- "嗬",
- "嘛",
- "嘴",
- "器",
- "回",
- "因",
- "因为",
- "因应",
- "因應",
- "因此",
- "因為",
- "团",
- "园",
- "围",
- "国",
- "图",
- "圆",
- "圈",
- "國",
- "圍",
- "園",
- "圓",
- "圖",
- "團",
- "土",
- "圣",
- "在",
- "在內",
- "在内",
- "地",
- "场",
- "坊",
- "坟",
- "坡",
- "型",
- "埋",
- "城",
- "埤",
- "執政",
- "基",
- "基于",
- "基於",
- "堂",
- "堡",
- "堤",
- "報",
- "場",
- "塔",
- "塘",
- "墓",
- "墙",
- "增長",
- "增长",
- "墟",
- "墳",
- "壓",
- "士",
- "处",
- "外",
- "多",
- "多少",
- "多次",
- "夜",
- "够",
- "夠",
- "夢",
- "大",
- "大家",
- "天",
- "头",
- "夹",
- "夾",
- "奏",
- "奖",
- "套",
- "女",
- "女士们",
- "女士门",
- "奸",
- "她",
- "她们",
- "她俩",
- "她倆",
- "她們",
- "好",
- "好了",
- "好像",
- "如",
- "如何",
- "如同",
- "如果",
- "妃",
- "妇",
- "妳",
- "妹",
- "始",
- "娘",
- "婆",
- "婦",
- "子",
- "孔",
- "字",
- "季",
- "学",
- "學",
- "宁愿",
- "它",
- "它们",
- "它們",
- "安全",
- "宏",
- "宗",
- "官",
- "实属",
- "审",
- "客",
- "室",
- "宫",
- "宮",
- "家",
- "宽",
- "富",
- "實屬",
- "審",
- "寬",
- "对",
- "对于",
- "对方",
- "对此",
- "寺",
- "将",
- "將",
- "對",
- "對方",
- "對於",
- "對此",
- "小",
- "尖",
- "就",
- "就是",
- "就算",
- "尸",
- "尽管",
- "局",
- "层",
- "屋",
- "屍",
- "展",
- "属",
- "層",
- "屬",
- "屯",
- "山",
- "屿",
- "岗",
- "岛",
- "岩",
- "岭",
- "岸",
- "峡",
- "峰",
- "島",
- "峽",
- "崖",
- "崗",
- "嶺",
- "嶼",
- "川",
- "州",
- "工",
- "左右",
- "差",
- "巷",
- "币",
- "市",
- "布",
- "师",
- "希望",
- "帝",
- "带",
- "師",
- "席",
- "帮",
- "帶",
- "帽",
- "幣",
- "幫",
- "年",
- "并",
- "并且",
- "并非",
- "幾",
- "庄",
- "床",
- "庐",
- "库",
- "应",
- "应当",
- "应该",
- "底",
- "店",
- "庙",
- "府",
- "度",
- "座",
- "庫",
- "庭",
- "廟",
- "廠",
- "廬",
- "廳",
- "廷",
- "建基於",
- "开口",
- "开始",
- "式",
- "弯",
- "張",
- "強",
- "弹",
- "强",
- "彈",
- "彎",
- "当",
- "当中",
- "当届",
- "录",
- "形",
- "形容",
- "形成",
- "影响",
- "影響",
- "彼此",
- "往",
- "径",
- "待",
- "很多",
- "後",
- "徑",
- "徒",
- "得",
- "得宠",
- "得寵",
- "從",
- "御",
- "微",
- "徽",
- "心",
- "必",
- "必須",
- "必须",
- "志",
- "快",
- "态",
- "怎么样",
- "怎樣",
- "怎麼",
- "怕",
- "性",
- "怪",
- "总",
- "恆",
- "恋",
- "恒",
- "您",
- "想",
- "愛",
- "感",
- "感到",
- "感覺",
- "感觉",
- "愿意",
- "態",
- "憑",
- "憑藉",
- "懂",
- "懂得",
- "應",
- "應當",
- "應該",
- "懒得",
- "戀",
- "戏",
- "我",
- "我们",
- "我們",
- "我自己",
- "我门",
- "或",
- "或是",
- "或者",
- "战",
- "截止",
- "截至",
- "戰",
- "戲",
- "戶",
- "户",
- "房",
- "所",
- "所以",
- "所有",
- "手",
- "才是",
- "打",
- "执政",
- "把",
- "报",
- "拖",
- "持續",
- "按",
- "按照",
- "挡",
- "损失",
- "据",
- "排行",
- "接唱",
- "接触",
- "接觸",
- "控制",
- "推进",
- "推進",
- "描述",
- "損失",
- "擋",
- "據",
- "支",
- "教",
- "敢",
- "数",
- "整",
- "整个",
- "整個",
- "整场",
- "整块",
- "整場",
- "整塊",
- "整套",
- "整所",
- "整架",
- "整片",
- "整顆",
- "整颗",
- "數",
- "文",
- "斋",
- "斗",
- "新",
- "方",
- "於",
- "族",
- "旗",
- "无论",
- "既",
- "既是",
- "既然",
- "日",
- "日趋",
- "日趨",
- "旧",
- "时",
- "星",
- "是",
- "是否",
- "是否是",
- "是次",
- "显",
- "显得",
- "時",
- "晚",
- "暖",
- "暗",
- "暨",
- "曲",
- "更为",
- "更是",
- "更為",
- "更趋",
- "更趨",
- "書",
- "替",
- "會",
- "會不會",
- "月",
- "有",
- "有些",
- "有关",
- "有的",
- "有關",
- "服",
- "朝",
- "期",
- "期間",
- "期间",
- "未能",
- "末",
- "本",
- "本人",
- "本地",
- "本屆",
- "本届",
- "本班",
- "本身",
- "术",
- "机",
- "权",
- "杆",
- "材",
- "村",
- "束",
- "来",
- "杯",
- "板",
- "林",
- "枪",
- "架",
- "某",
- "某个",
- "某些",
- "某個",
- "某种",
- "某種",
- "染色",
- "柜",
- "树",
- "校",
- "株",
- "核",
- "根据",
- "根據",
- "格",
- "案",
- "档",
- "桥",
- "桨",
- "桿",
- "梁",
- "梁耀忠",
- "梦",
- "棍",
- "棒",
- "棚",
- "椭",
- "業",
- "楼",
- "榜",
- "槍",
- "槳",
- "樂",
- "樂意",
- "樓",
- "樹",
- "橋",
- "橙",
- "機",
- "橢",
- "檔",
- "櫃",
- "權",
- "次",
- "欲",
- "款",
- "歌",
- "正",
- "正如",
- "正是",
- "此",
- "此套",
- "此次",
- "此种",
- "此種",
- "此等",
- "此类",
- "此項",
- "此類",
- "此项",
- "歷",
- "歷屆",
- "死",
- "段",
- "殿",
- "母",
- "毎年",
- "每",
- "每个",
- "每位",
- "每個",
- "每元",
- "每升",
- "每卡",
- "每周",
- "每天",
- "每幅",
- "每年",
- "每座",
- "每当",
- "每戶",
- "每户",
- "每所",
- "每日",
- "每枚",
- "每次",
- "每段",
- "每片",
- "每秒",
- "每組",
- "每组",
- "每边",
- "每週",
- "每邊",
- "每間",
- "每间",
- "每队",
- "每隊",
- "每集",
- "每首",
- "毒",
- "比",
- "比如說",
- "比起",
- "氏",
- "气",
- "氣",
- "水",
- "永保",
- "江",
- "池",
- "沒",
- "沒有",
- "沒能",
- "沟",
- "没",
- "没有",
- "没能",
- "河",
- "治军",
- "治軍",
- "沼",
- "沿",
- "沿着",
- "沿著",
- "況且",
- "泉",
- "法",
- "波",
- "洋",
- "洞",
- "洲",
- "派",
- "流沙",
- "浅",
- "浊",
- "浓",
- "浦",
- "海",
- "涉世",
- "涌",
- "液",
- "淡",
- "深",
- "深感",
- "混",
- "淺",
- "清",
- "減慢",
- "渡",
- "港",
- "湖",
- "湾",
- "準",
- "準備",
- "溝",
- "溥仪",
- "溥儀",
- "溪",
- "满",
- "满洲",
- "滩",
- "滿",
- "滿洲",
- "潮",
- "澡",
- "澳",
- "濁",
- "濃",
- "灘",
- "灣",
- "火",
- "炉",
- "炎",
- "炮",
- "点",
- "為",
- "為了",
- "為人",
- "烃",
- "烟",
- "热",
- "烴",
- "無",
- "無論",
- "煙",
- "熟",
- "熱",
- "營",
- "爐",
- "爭取",
- "爭辯",
- "爱",
- "爲",
- "父",
- "爷",
- "爺",
- "牆",
- "片",
- "版",
- "牌",
- "牠",
- "牠們",
- "物",
- "犯",
- "状",
- "狀",
- "狂",
- "狗",
- "狮",
- "猫",
- "獅",
- "獎",
- "獲利",
- "率",
- "王",
- "班",
- "球",
- "琴",
- "甚么",
- "甚至",
- "甚至是",
- "甚麼",
- "甚麽",
- "生",
- "用",
- "由",
- "由于",
- "由於",
- "电",
- "男",
- "町",
- "画",
- "界",
- "畔",
- "畫",
- "當",
- "當中",
- "當屆",
- "病",
- "症",
- "癌",
- "癖",
- "發展",
- "發育",
- "的",
- "的話",
- "的话",
- "皮",
- "盃",
- "监管",
- "盖因",
- "監管",
- "目",
- "直到",
- "直至",
- "相对",
- "相對",
- "相比",
- "省",
- "看",
- "看似",
- "看得",
- "眼",
- "眾",
- "眾多",
- "着",
- "督",
- "瞭",
- "短",
- "石",
- "矿",
- "码",
- "砲",
- "硅",
- "碑",
- "碱",
- "碼",
- "礁",
- "礦",
- "礼",
- "社",
- "祂",
- "神",
- "祠",
- "禮",
- "离",
- "离开",
- "秀",
- "私交",
- "秋",
- "种",
- "科",
- "秤",
- "稅",
- "税",
- "種",
- "突感",
- "窑",
- "窟",
- "窯",
- "站",
- "端",
- "競選",
- "符",
- "笨",
- "等",
- "管",
- "管理",
- "箱",
- "節",
- "篇",
- "籍",
- "米",
- "类",
- "粉",
- "精",
- "糖",
- "系",
- "紀",
- "紅",
- "紋",
- "純",
- "紙",
- "級",
- "素",
- "組",
- "結",
- "給",
- "綉",
- "經",
- "經由",
- "經過",
- "綜",
- "綫",
- "綱",
- "網",
- "線",
- "緣",
- "縣",
- "縱使",
- "總",
- "繞",
- "繼",
- "红",
- "级",
- "纪",
- "纯",
- "纲",
- "纵使",
- "纸",
- "纹",
- "线",
- "组",
- "经",
- "经由",
- "经过",
- "结",
- "绕",
- "给",
- "绣",
- "继",
- "综",
- "网",
- "罩",
- "罪",
- "署",
- "羊",
- "美",
- "群",
- "翁",
- "老",
- "者",
- "而",
- "而且",
- "而已",
- "而是",
- "而非",
- "聖",
- "肉",
- "肯",
- "肺",
- "胎",
- "胚",
- "胶",
- "能",
- "能否",
- "能够",
- "能夠",
- "脚",
- "脸",
- "腔",
- "腳",
- "腿",
- "膜",
- "膠",
- "臉",
- "臨",
- "自",
- "自从",
- "自家",
- "自己",
- "自從",
- "自我",
- "自身",
- "至",
- "至于",
- "至於",
- "臺",
- "與",
- "與其",
- "舊",
- "舞",
- "舟",
- "舰",
- "舱",
- "船",
- "艇",
- "艙",
- "艦",
- "色",
- "节",
- "花",
- "若",
- "若是",
- "茶",
- "药",
- "莊",
- "获利",
- "菌",
- "菜",
- "营",
- "葉",
- "著",
- "蓋因",
- "蓝",
- "藉",
- "藉助",
- "藉由",
- "藉著",
- "藍",
- "藤",
- "藥",
- "藩",
- "處",
- "號",
- "虽",
- "虽则",
- "虽然",
- "蛙",
- "行",
- "術",
- "街",
- "衛",
- "衣",
- "表",
- "表现",
- "表現",
- "表示",
- "被",
- "装",
- "裏",
- "裔",
- "裙",
- "裝",
- "裡",
- "裡面",
- "裤",
- "製",
- "褲",
- "要",
- "要不要",
- "要么",
- "要是",
- "要求",
- "親",
- "覺得",
- "觀",
- "观",
- "觉得",
- "角",
- "計劃",
- "記",
- "詞",
- "試圖",
- "詩",
- "話",
- "該",
- "該屆",
- "該批",
- "該族",
- "該條",
- "該段",
- "該組",
- "該集",
- "該項",
- "誌",
- "認為",
- "認識",
- "語",
- "誤信",
- "說",
- "誰",
- "課",
- "請",
- "論",
- "諸",
- "諸如",
- "謂",
- "證",
- "譜",
- "變",
- "變得",
- "认为",
- "认识",
- "记",
- "许多",
- "许许多多",
- "论",
- "证",
- "词",
- "诗",
- "话",
- "该",
- "该届",
- "该批",
- "该族",
- "该条",
- "该段",
- "该组",
- "该集",
- "语",
- "误信",
- "说",
- "请",
- "诸",
- "诸如",
- "课",
- "谁",
- "谓",
- "谱",
- "谷",
- "豆",
- "象",
- "貓",
- "負債",
- "費",
- "資",
- "賣",
- "質",
- "賽",
- "负债",
- "质",
- "费",
- "资",
- "赛",
- "起",
- "起伏",
- "起来",
- "趁",
- "超",
- "趋",
- "趋于",
- "趨",
- "趨於",
- "距",
- "距离",
- "距離",
- "跟",
- "路",
- "躁",
- "身",
- "車",
- "軍",
- "軒",
- "軟",
- "軸",
- "較",
- "輕",
- "车",
- "轩",
- "软",
- "轴",
- "轻",
- "较",
- "辦",
- "辦學",
- "边",
- "达到",
- "过",
- "过后",
- "运作",
- "近",
- "还",
- "还是",
- "还有",
- "这",
- "这些",
- "这儿",
- "这养",
- "这样",
- "这次",
- "这种",
- "这里",
- "远",
- "连",
- "连任",
- "连同",
- "迷",
- "追溯",
- "透过",
- "透過",
- "這",
- "這些",
- "這個",
- "這兒",
- "這樣",
- "這樣子",
- "這次",
- "這種",
- "這裏",
- "這裡",
- "這邊",
- "這麼",
- "通",
- "通过",
- "通過",
- "逢",
- "連",
- "連任",
- "連同",
- "週",
- "運作",
- "過",
- "過後",
- "道",
- "達到",
- "遠",
- "選舉",
- "還是",
- "邊",
- "那",
- "那个",
- "那些",
- "那儿",
- "那兒",
- "那样",
- "那樣",
- "那裏",
- "那裡",
- "那邊",
- "那里",
- "邦",
- "邨",
- "郎",
- "郡",
- "部",
- "都",
- "都是",
- "鄉",
- "配",
- "酒",
- "酸",
- "醣",
- "醫",
- "里",
- "里面",
- "重",
- "量",
- "金",
- "針",
- "針對",
- "銘",
- "鋼",
- "錄",
- "錦",
- "鍋",
- "鍵",
- "鎊",
- "鎮",
- "鏈",
- "鏡",
- "鐵",
- "鑒於",
- "针",
- "针对",
- "钢",
- "铁",
- "铭",
- "链",
- "锅",
- "锦",
- "键",
- "镇",
- "镜",
- "長",
- "长",
- "門",
- "開口",
- "開始",
- "間",
- "閣",
- "閣下",
- "關",
- "關心",
- "關於",
- "门",
- "间",
- "阁",
- "队",
- "阶",
- "际",
- "陆",
- "降解",
- "院",
- "除",
- "除了",
- "除外",
- "除非",
- "陵",
- "陸",
- "隊",
- "階",
- "随",
- "随同",
- "隔",
- "際",
- "隨",
- "隨同",
- "难过",
- "集",
- "雖",
- "雖則",
- "雖然",
- "離",
- "離開",
- "難過",
- "電",
- "需",
- "需要",
- "非",
- "靠",
- "面",
- "音",
- "頂",
- "須",
- "頭",
- "頭個",
- "題",
- "額",
- "願意",
- "類",
- "顯",
- "顯得",
- "顶",
- "须",
- "题",
- "额",
- "風",
- "风",
- "飯",
- "餅",
- "餐",
- "館",
- "饃",
- "首先",
- "點",
- ],
-}
diff --git a/spaces/ICML2022/OFA/fairseq/examples/m2m_100/tokenizers/seg_ja.sh b/spaces/ICML2022/OFA/fairseq/examples/m2m_100/tokenizers/seg_ja.sh
deleted file mode 100644
index be6f5ca5fe4ac8e8c786a439caaed1d1314f1aef..0000000000000000000000000000000000000000
--- a/spaces/ICML2022/OFA/fairseq/examples/m2m_100/tokenizers/seg_ja.sh
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/usr/bin/env bash
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-SCRIPT=`realpath $0`
-KYTEA=`dirname $SCRIPT`/thirdparty/kytea
-export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$KYTEA/lib:/usr/local/lib
-export PATH=$PATH:"$KYTEA/bin"
-
-cat - | tr -d "[:blank:]" | kytea -notags
diff --git a/spaces/ICML2022/OFA/fairseq/fairseq/model_parallel/modules/multihead_attention.py b/spaces/ICML2022/OFA/fairseq/fairseq/model_parallel/modules/multihead_attention.py
deleted file mode 100644
index 8eb9d09dad37ab132295166d691873beec63eaf1..0000000000000000000000000000000000000000
--- a/spaces/ICML2022/OFA/fairseq/fairseq/model_parallel/modules/multihead_attention.py
+++ /dev/null
@@ -1,349 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-from typing import Dict, Optional, Tuple
-
-import torch
-import torch.nn.functional as F
-from fairseq import utils
-from fairseq.incremental_decoding_utils import with_incremental_state
-from fairseq.modules.fairseq_dropout import FairseqDropout
-from torch import Tensor, nn
-
-
-try:
- from fairseq.model_parallel.megatron.mpu import (
- get_cuda_rng_tracker,
- get_model_parallel_world_size,
- ColumnParallelLinear,
- RowParallelLinear,
- )
-
- has_megatron_submodule = True
-except (ImportError, ModuleNotFoundError):
- has_megatron_submodule = False
-
-
-@with_incremental_state
-class ModelParallelMultiheadAttention(nn.Module):
- """Model parallel Multi-headed attention.
- This performs the Multi-headed attention over multiple gpus.
-
- See "Megatron-LM: https://arxiv.org/pdf/1909.08053.pdf" for more details.
- """
-
- def __init__(
- self,
- embed_dim,
- num_heads,
- kdim=None,
- vdim=None,
- dropout=0.0,
- bias=True,
- self_attention=False,
- encoder_decoder_attention=False,
- ):
- super().__init__()
- if not has_megatron_submodule:
- raise ImportError(
- "\n\nPlease install the megatron submodule:"
- "\n\n git submodule update --init "
- "fairseq/model_parallel/megatron"
- )
- self.embed_dim = embed_dim
- self.kdim = kdim if kdim is not None else embed_dim
- self.vdim = vdim if vdim is not None else embed_dim
- self.qkv_same_dim = self.kdim == embed_dim and self.vdim == embed_dim
-
- self.model_parallel_size = get_model_parallel_world_size()
-
- self.num_heads_partition = num_heads // self.model_parallel_size
- assert (
- self.num_heads_partition * self.model_parallel_size == num_heads
- ), "Number of heads must be divisible by model parallel size"
-
- self.dropout_module = FairseqDropout(
- dropout, module_name=self.__class__.__name__
- )
- self.head_dim = embed_dim // num_heads
- assert (
- self.head_dim * num_heads == self.embed_dim
- ), "embed_dim must be divisible by num_heads"
- self.scaling = self.head_dim ** -0.5
-
- self.self_attention = self_attention
- self.encoder_decoder_attention = encoder_decoder_attention
-
- assert (
- not self.self_attention or self.qkv_same_dim
- ), "Self-attention requires query, key and value to be of the same size"
-
- self.k_proj = ColumnParallelLinear(
- self.kdim, embed_dim, bias=bias, gather_output=False
- )
- self.v_proj = ColumnParallelLinear(
- self.vdim, embed_dim, bias=bias, gather_output=False
- )
- self.q_proj = ColumnParallelLinear(
- embed_dim, embed_dim, bias=bias, gather_output=False
- )
- self.out_proj = RowParallelLinear(
- embed_dim, embed_dim, bias=bias, input_is_parallel=True
- )
-
- def forward(
- self,
- query,
- key: Optional[Tensor],
- value: Optional[Tensor],
- key_padding_mask: Optional[Tensor] = None,
- incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None,
- static_kv: bool = False,
- attn_mask: Optional[Tensor] = None,
- **unused_kwargs,
- ) -> Tuple[Tensor, Optional[Tensor]]:
- """Input shape: Time x Batch x Channel
-
- Args:
- key_padding_mask (ByteTensor, optional): mask to exclude
- keys that are pads, of shape `(batch, src_len)`, where
- padding elements are indicated by 1s.
- attn_mask (ByteTensor, optional): typically used to
- implement causal attention, where the mask prevents the
- attention from looking forward in time (default: None).
- """
- tgt_len, bsz, embed_dim = query.size()
- assert embed_dim == self.embed_dim
- assert list(query.size()) == [tgt_len, bsz, embed_dim]
-
- is_tpu = query.device.type == "xla"
-
- if incremental_state is not None:
- saved_state = self._get_input_buffer(incremental_state)
- if saved_state is not None and "prev_key" in saved_state:
- # previous time steps are cached - no need to recompute
- # key and value if they are static
- if static_kv:
- assert self.encoder_decoder_attention and not self.self_attention
- key = value = None
- else:
- saved_state = None
-
- if self.self_attention:
- q = self.q_proj(query)
- k = self.k_proj(query)
- v = self.v_proj(query)
- elif self.encoder_decoder_attention:
- # encoder-decoder attention
- q = self.q_proj(query)
- if key is None:
- assert value is None
- k = v = None
- else:
- k = self.k_proj(key)
- v = self.v_proj(key)
-
- else:
- assert key is not None and value is not None
- q = self.q_proj(query)
- k = self.k_proj(key)
- v = self.v_proj(value)
- q *= self.scaling
-
- q = (
- q.contiguous()
- .view(tgt_len, bsz * self.num_heads_partition, self.head_dim)
- .transpose(0, 1)
- )
- if k is not None:
- k = (
- k.contiguous()
- .view(-1, bsz * self.num_heads_partition, self.head_dim)
- .transpose(0, 1)
- )
- if v is not None:
- v = (
- v.contiguous()
- .view(-1, bsz * self.num_heads_partition, self.head_dim)
- .transpose(0, 1)
- )
-
- if saved_state is not None:
- # saved states are stored with shape (bsz, num_heads_partition, seq_len, head_dim)
- if "prev_key" in saved_state:
- _prev_key = saved_state["prev_key"]
- assert _prev_key is not None
- prev_key = _prev_key.view(
- bsz * self.num_heads_partition, -1, self.head_dim
- )
- if static_kv:
- k = prev_key
- else:
- assert k is not None
- k = torch.cat([prev_key, k], dim=1)
- if "prev_value" in saved_state:
- _prev_value = saved_state["prev_value"]
- assert _prev_value is not None
- prev_value = _prev_value.view(
- bsz * self.num_heads_partition, -1, self.head_dim
- )
- if static_kv:
- v = prev_value
- else:
- assert v is not None
- v = torch.cat([prev_value, v], dim=1)
- prev_key_padding_mask: Optional[Tensor] = None
- if "prev_key_padding_mask" in saved_state:
- prev_key_padding_mask = saved_state["prev_key_padding_mask"]
- assert k is not None and v is not None
- key_padding_mask = (
- ModelParallelMultiheadAttention._append_prev_key_padding_mask(
- key_padding_mask=key_padding_mask,
- prev_key_padding_mask=prev_key_padding_mask,
- batch_size=bsz,
- src_len=k.size(1),
- static_kv=static_kv,
- )
- )
-
- saved_state["prev_key"] = k.view(
- bsz, self.num_heads_partition, -1, self.head_dim
- )
- saved_state["prev_value"] = v.view(
- bsz, self.num_heads_partition, -1, self.head_dim
- )
- saved_state["prev_key_padding_mask"] = key_padding_mask
- # In this branch incremental_state is never None
- assert incremental_state is not None
- incremental_state = self._set_input_buffer(incremental_state, saved_state)
- assert k is not None
- src_len = k.size(1)
-
- # This is part of a workaround to get around fork/join parallelism
- # not supporting Optional types.
- if key_padding_mask is not None and key_padding_mask.dim() == 0:
- key_padding_mask = None
-
- if key_padding_mask is not None:
- assert key_padding_mask.size(0) == bsz
- assert key_padding_mask.size(1) == src_len
-
- attn_weights = torch.bmm(q, k.transpose(1, 2))
-
- assert list(attn_weights.size()) == [
- bsz * self.num_heads_partition,
- tgt_len,
- src_len,
- ]
-
- if attn_mask is not None:
- attn_mask = attn_mask.unsqueeze(0)
- attn_weights += attn_mask
-
- if key_padding_mask is not None:
- # don't attend to padding symbols
- attn_weights = attn_weights.view(
- bsz, self.num_heads_partition, tgt_len, src_len
- )
- if not is_tpu:
- attn_weights = attn_weights.masked_fill(
- key_padding_mask.unsqueeze(1).unsqueeze(2).to(torch.bool),
- float("-inf"),
- )
- else:
- attn_weights = attn_weights.transpose(0, 2)
- attn_weights = attn_weights.masked_fill(key_padding_mask, float("-inf"))
- attn_weights = attn_weights.transpose(0, 2)
- attn_weights = attn_weights.view(
- bsz * self.num_heads_partition, tgt_len, src_len
- )
-
- attn_weights_float = utils.softmax(attn_weights, dim=-1)
- attn_weights = attn_weights_float.type_as(attn_weights)
-
- with get_cuda_rng_tracker().fork():
- attn_probs = self.dropout_module(attn_weights)
-
- assert v is not None
- attn = torch.bmm(attn_probs, v)
- assert list(attn.size()) == [
- bsz * self.num_heads_partition,
- tgt_len,
- self.head_dim,
- ]
- embed_dim_partition = embed_dim // self.model_parallel_size
- attn = attn.transpose(0, 1).contiguous().view(tgt_len, bsz, embed_dim_partition)
- attn = self.out_proj(attn)
- # return attn_weights None to keep the return type same as single gpu multihead attention
- # This will be deprecated.
- attn_weights: Optional[Tensor] = None
-
- return attn, attn_weights
-
- @staticmethod
- def _append_prev_key_padding_mask(
- key_padding_mask: Optional[Tensor],
- prev_key_padding_mask: Optional[Tensor],
- batch_size: int,
- src_len: int,
- static_kv: bool,
- ) -> Optional[Tensor]:
- # saved key padding masks have shape (bsz, seq_len)
- if prev_key_padding_mask is not None and static_kv:
- new_key_padding_mask = prev_key_padding_mask
- elif prev_key_padding_mask is not None and key_padding_mask is not None:
- new_key_padding_mask = torch.cat(
- [prev_key_padding_mask.float(), key_padding_mask.float()], dim=1
- )
- # During incremental decoding, as the padding token enters and
- # leaves the frame, there will be a time when prev or current
- # is None
- elif prev_key_padding_mask is not None:
-
- filler = torch.zeros(batch_size, src_len - prev_key_padding_mask.size(1))
- if prev_key_padding_mask.is_cuda:
- filler = filler.cuda()
- new_key_padding_mask = torch.cat(
- [prev_key_padding_mask.float(), filler.float()], dim=1
- )
- elif key_padding_mask is not None:
- filler = torch.zeros(batch_size, src_len - key_padding_mask.size(1))
- if key_padding_mask.is_cuda:
- filler = filler.cuda()
- new_key_padding_mask = torch.cat(
- [filler.float(), key_padding_mask.float()], dim=1
- )
- else:
- new_key_padding_mask = prev_key_padding_mask
- return new_key_padding_mask
-
- def reorder_incremental_state(
- self, incremental_state: Dict[str, Dict[str, Optional[Tensor]]], new_order
- ):
- """Reorder buffered internal state (for incremental generation)."""
- input_buffer = self._get_input_buffer(incremental_state)
- if input_buffer is not None:
- for k in input_buffer.keys():
- if input_buffer[k] is not None:
- input_buffer[k] = input_buffer[k].index_select(0, new_order)
- incremental_state = self._set_input_buffer(incremental_state, input_buffer)
- return incremental_state
-
- def _get_input_buffer(
- self, incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]]
- ) -> Dict[str, Optional[Tensor]]:
- result = self.get_incremental_state(incremental_state, "attn_state")
- if result is not None:
- return result
- else:
- empty_result: Dict[str, Optional[Tensor]] = {}
- return empty_result
-
- def _set_input_buffer(
- self,
- incremental_state: Dict[str, Dict[str, Optional[Tensor]]],
- buffer: Dict[str, Optional[Tensor]],
- ):
- return self.set_incremental_state(incremental_state, "attn_state", buffer)
diff --git a/spaces/ICML2022/resefa/utils/misc.py b/spaces/ICML2022/resefa/utils/misc.py
deleted file mode 100644
index 36198dff3a4b3e1f7b5e6a21a17418d0e04eb6f3..0000000000000000000000000000000000000000
--- a/spaces/ICML2022/resefa/utils/misc.py
+++ /dev/null
@@ -1,227 +0,0 @@
-# python3.7
-"""Misc utility functions."""
-
-import os
-import hashlib
-
-from torch.hub import download_url_to_file
-
-__all__ = [
- 'REPO_NAME', 'Infix', 'print_and_execute', 'check_file_ext',
- 'IMAGE_EXTENSIONS', 'VIDEO_EXTENSIONS', 'MEDIA_EXTENSIONS',
- 'parse_file_format', 'set_cache_dir', 'get_cache_dir', 'download_url'
-]
-
-REPO_NAME = 'Hammer' # Name of the repository (project).
-
-
-class Infix(object):
- """Helper class to create custom infix operators.
-
- When using it, make sure to put the operator between `<<` and `>>`.
- `<< INFIX_OP_NAME >>` should be considered as a whole operator.
-
- Examples:
-
- # Use `Infix` to create infix operators directly.
- add = Infix(lambda a, b: a + b)
- 1 << add >> 2 # gives 3
- 1 << add >> 2 << add >> 3 # gives 6
-
- # Use `Infix` as a decorator.
- @Infix
- def mul(a, b):
- return a * b
- 2 << mul >> 4 # gives 8
- 2 << mul >> 3 << mul >> 7 # gives 42
- """
-
- def __init__(self, function):
- self.function = function
- self.left_value = None
-
- def __rlshift__(self, left_value): # override `<<` before `Infix` instance
- assert self.left_value is None # make sure left is only called once
- self.left_value = left_value
- return self
-
- def __rshift__(self, right_value): # override `>>` after `Infix` instance
- result = self.function(self.left_value, right_value)
- self.left_value = None # reset to None
- return result
-
-
-def print_and_execute(cmd):
- """Prints and executes a system command.
-
- Args:
- cmd: Command to be executed.
- """
- print(cmd)
- os.system(cmd)
-
-
-def check_file_ext(filename, *ext_list):
- """Checks whether the given filename is with target extension(s).
-
- NOTE: If `ext_list` is empty, this function will always return `False`.
-
- Args:
- filename: Filename to check.
- *ext_list: A list of extensions.
-
- Returns:
- `True` if the filename is with one of extensions in `ext_list`,
- otherwise `False`.
- """
- if len(ext_list) == 0:
- return False
- ext_list = [ext if ext.startswith('.') else '.' + ext for ext in ext_list]
- ext_list = [ext.lower() for ext in ext_list]
- basename = os.path.basename(filename)
- ext = os.path.splitext(basename)[1].lower()
- return ext in ext_list
-
-
-# File extensions regarding images (not including GIFs).
-IMAGE_EXTENSIONS = (
- '.bmp', '.ppm', '.pgm', '.jpeg', '.jpg', '.jpe', '.jp2', '.png', '.webp',
- '.tiff', '.tif'
-)
-# File extensions regarding videos.
-VIDEO_EXTENSIONS = (
- '.avi', '.mkv', '.mp4', '.m4v', '.mov', '.webm', '.flv', '.rmvb', '.rm',
- '.3gp'
-)
-# File extensions regarding media, i.e., images, videos, GIFs.
-MEDIA_EXTENSIONS = ('.gif', *IMAGE_EXTENSIONS, *VIDEO_EXTENSIONS)
-
-
-def parse_file_format(path):
- """Parses the file format of a given path.
-
- This function basically parses the file format according to its extension.
- It will also return `dir` is the given path is a directory.
-
- Parable file formats:
-
- - zip: with `.zip` extension.
- - tar: with `.tar` / `.tgz` / `.tar.gz` extension.
- - lmdb: a folder ending with `lmdb`.
- - txt: with `.txt` / `.text` extension, OR without extension (e.g. LICENSE).
- - json: with `.json` extension.
- - jpg: with `.jpeg` / `jpg` / `jpe` extension.
- - png: with `.png` extension.
-
- Args:
- path: The path to the file to parse format from.
-
- Returns:
- A lower-case string, indicating the file format, or `None` if the format
- cannot be successfully parsed.
- """
- # Handle directory.
- if os.path.isdir(path) or path.endswith('/'):
- if path.rstrip('/').lower().endswith('lmdb'):
- return 'lmdb'
- return 'dir'
- # Handle file.
- if os.path.isfile(path) and os.path.splitext(path)[1] == '':
- return 'txt'
- path = path.lower()
- if path.endswith('.tar.gz'): # Cannot parse accurate extension.
- return 'tar'
- ext = os.path.splitext(path)[1]
- if ext == '.zip':
- return 'zip'
- if ext in ['.tar', '.tgz']:
- return 'tar'
- if ext in ['.txt', '.text']:
- return 'txt'
- if ext == '.json':
- return 'json'
- if ext in ['.jpeg', '.jpg', '.jpe']:
- return 'jpg'
- if ext == '.png':
- return 'png'
- # Unparsable.
- return None
-
-
-_cache_dir = None
-
-
-def set_cache_dir(directory=None):
- """Sets the global cache directory.
-
- The cache directory can be used to save some files that will be shared
- across jobs. The default cache directory is set as `~/.cache/${REPO_NAME}/`.
- This function can be used to redirect the cache directory. Or, users can use
- `None` to reset the cache directory back to default.
-
- Args:
- directory: The target directory used to cache files. If set as `None`,
- the cache directory will be reset back to default. (default: None)
- """
- assert directory is None or isinstance(directory, str), 'Invalid directory!'
- global _cache_dir # pylint: disable=global-statement
- _cache_dir = directory
-
-
-def get_cache_dir():
- """Gets the global cache directory.
-
- The global cache directory is primarily set as `~/.cache/${REPO_NAME}/` by
- default, and can be redirected with `set_cache_dir()`.
-
- Returns:
- A string, representing the global cache directory.
- """
- if _cache_dir is None:
- home = os.path.expanduser('~')
- return os.path.join(home, '.cache', REPO_NAME)
- return _cache_dir
-
-
-def download_url(url, path=None, filename=None, sha256=None):
- """Downloads file from URL.
-
- This function downloads a file from given URL, and executes Hash check if
- needed.
-
- Args:
- url: The URL to download file from.
- path: Path (directory) to save the downloaded file. If set as `None`,
- the cache directory will be used. Please see `get_cache_dir()` for
- more details. (default: None)
- filename: The name to save the file. If set as `None`, this name will be
- automatically parsed from the given URL. (default: None)
- sha256: The expected sha256 of the downloaded file. If set as `None`,
- the hash check will be skipped. Otherwise, this function will check
- whether the sha256 of the downloaded file matches this field.
-
- Returns:
- A two-element tuple, where the first term is the full path of the
- downloaded file, and the second term indicate the hash check result.
- `True` means hash check passes, `False` means hash check fails,
- while `None` means no hash check is executed.
- """
- # Handle file path.
- if path is None:
- path = get_cache_dir()
- if filename is None:
- filename = os.path.basename(url)
- save_path = os.path.join(path, filename)
- # Download file if needed.
- if not os.path.exists(save_path):
- print(f'Downloading URL `{url}` to path `{save_path}` ...')
- os.makedirs(path, exist_ok=True)
- download_url_to_file(url, save_path, hash_prefix=None, progress=True)
- # Check hash if needed.
- check_result = None
- if sha256 is not None:
- with open(save_path, 'rb') as f:
- file_hash = hashlib.sha256(f.read())
- check_result = (file_hash.hexdigest() == sha256)
-
- return save_path, check_result
diff --git a/spaces/Iqbalzz/hololive-rvc-models/app.py b/spaces/Iqbalzz/hololive-rvc-models/app.py
deleted file mode 100644
index 47db29e9de54b1eb0cc22120f40ff7cb984126a7..0000000000000000000000000000000000000000
--- a/spaces/Iqbalzz/hololive-rvc-models/app.py
+++ /dev/null
@@ -1,185 +0,0 @@
-import os
-import json
-import argparse
-import traceback
-import logging
-import gradio as gr
-import numpy as np
-import librosa
-import torch
-import asyncio
-import edge_tts
-from datetime import datetime
-from fairseq import checkpoint_utils
-from infer_pack.models import SynthesizerTrnMs256NSFsid, SynthesizerTrnMs256NSFsid_nono
-from vc_infer_pipeline import VC
-from config import (
- is_half,
- device
-)
-logging.getLogger("numba").setLevel(logging.WARNING)
-limitation = os.getenv("SYSTEM") == "spaces" # limit audio length in huggingface spaces
-
-def create_vc_fn(tgt_sr, net_g, vc, if_f0, file_index, file_big_npy):
- def vc_fn(
- input_audio,
- f0_up_key,
- f0_method,
- index_rate,
- tts_mode,
- tts_text,
- tts_voice
- ):
- try:
- if tts_mode:
- if len(tts_text) > 500 and limitation:
- return "Text is too long", None
- if tts_text is None or tts_voice is None:
- return "You need to enter text and select a voice", None
- asyncio.run(edge_tts.Communicate(tts_text, "-".join(tts_voice.split('-')[:-1])).save("tts.mp3"))
- audio, sr = librosa.load("tts.mp3", sr=16000, mono=True)
- else:
- if args.files:
- audio, sr = librosa.load(input_audio, sr=16000, mono=True)
- else:
- if input_audio is None:
- return "You need to upload an audio", None
- sampling_rate, audio = input_audio
- duration = audio.shape[0] / sampling_rate
- if duration > 300 and limitation:
- return "Please upload an audio file that is less than 5 minutes 30 seconds.", None
- audio = (audio / np.iinfo(audio.dtype).max).astype(np.float32)
- if len(audio.shape) > 1:
- audio = librosa.to_mono(audio.transpose(1, 0))
- if sampling_rate != 16000:
- audio = librosa.resample(audio, orig_sr=sampling_rate, target_sr=16000)
- times = [0, 0, 0]
- f0_up_key = int(f0_up_key)
- audio_opt = vc.pipeline(
- hubert_model,
- net_g,
- 0,
- audio,
- times,
- f0_up_key,
- f0_method,
- file_index,
- file_big_npy,
- index_rate,
- if_f0,
- )
- print(
- f"[{datetime.now().strftime('%Y-%m-%d %H:%M')}]: npy: {times[0]}, f0: {times[1]}s, infer: {times[2]}s"
- )
- return "Success", (tgt_sr, audio_opt)
- except:
- info = traceback.format_exc()
- print(info)
- return info, (None, None)
- return vc_fn
-
-def load_hubert():
- global hubert_model
- models, _, _ = checkpoint_utils.load_model_ensemble_and_task(
- ["hubert_base.pt"],
- suffix="",
- )
- hubert_model = models[0]
- hubert_model = hubert_model.to(device)
- if is_half:
- hubert_model = hubert_model.half()
- else:
- hubert_model = hubert_model.float()
- hubert_model.eval()
-
-def change_to_tts_mode(tts_mode):
- if tts_mode:
- return gr.Audio.update(visible=False), gr.Textbox.update(visible=True), gr.Dropdown.update(visible=True)
- else:
- return gr.Audio.update(visible=True), gr.Textbox.update(visible=False), gr.Dropdown.update(visible=False)
-
-if __name__ == '__main__':
- parser = argparse.ArgumentParser()
- parser.add_argument('--api', action="store_true", default=False)
- parser.add_argument("--share", action="store_true", default=False, help="share gradio app")
- parser.add_argument("--files", action="store_true", default=False, help="load audio from path")
- args, unknown = parser.parse_known_args()
- load_hubert()
- models = []
- tts_voice_list = asyncio.get_event_loop().run_until_complete(edge_tts.list_voices())
- voices = [f"{v['ShortName']}-{v['Gender']}" for v in tts_voice_list]
- with open("weights/model_info.json", "r", encoding="utf-8") as f:
- models_info = json.load(f)
- for name, info in models_info.items():
- if not info['enable']:
- continue
- title = info['title']
- author = info.get("author", None)
- cover = f"weights/{name}/{info['cover']}"
- index = f"weights/{name}/{info['feature_retrieval_library']}"
- npy = f"weights/{name}/{info['feature_file']}"
- cpt = torch.load(f"weights/{name}/{name}.pth", map_location="cpu")
- tgt_sr = cpt["config"][-1]
- cpt["config"][-3] = cpt["weight"]["emb_g.weight"].shape[0] # n_spk
- if_f0 = cpt.get("f0", 1)
- if if_f0 == 1:
- net_g = SynthesizerTrnMs256NSFsid(*cpt["config"], is_half=is_half)
- else:
- net_g = SynthesizerTrnMs256NSFsid_nono(*cpt["config"])
- del net_g.enc_q
- print(net_g.load_state_dict(cpt["weight"], strict=False)) # 不加这一行清不干净, 真奇葩
- net_g.eval().to(device)
- if is_half:
- net_g = net_g.half()
- else:
- net_g = net_g.float()
- vc = VC(tgt_sr, device, is_half)
- models.append((name, title, author, cover, create_vc_fn(tgt_sr, net_g, vc, if_f0, index, npy)))
- with gr.Blocks() as app:
- gr.Markdown(
- "# <center> Hololive RVC Models\n"
- "## <center> The input audio should be clean and pure voice without background music.\n"
- "[](https://colab.research.google.com/github/aziib/Create-Google-Shared-Drive/blob/master/Hololive-RVC-Models.ipynb)\n\n"
- "[](https://ko-fi.com/megaaziib)\n\n"
- )
- with gr.Tabs():
- for (name, title, author, cover, vc_fn) in models:
- with gr.TabItem(name):
- with gr.Row():
- gr.Markdown(
- '<div align="center">'
- f'<div>{title}</div>\n'+
- (f'<div>Model author: {author}</div>' if author else "")+
- (f'<img style="width:auto;height:300px;" src="file/{cover}">' if cover else "")+
- '</div>'
- )
- with gr.Row():
- with gr.Column():
- if args.files:
- vc_input = gr.Textbox(label="Input audio path")
- else:
- vc_input = gr.Audio(label="Input audio"+' (less than 5 minutes 30 seconds)' if limitation else '')
- vc_transpose = gr.Number(label="Transpose", value=0)
- vc_f0method = gr.Radio(
- label="Pitch extraction algorithm, PM is fast but Harvest is better for low frequencies",
- choices=["pm", "harvest"],
- value="pm",
- interactive=True,
- )
- vc_index_ratio = gr.Slider(
- minimum=0,
- maximum=1,
- label="Retrieval feature ratio",
- value=0.6,
- interactive=True,
- )
- tts_mode = gr.Checkbox(label="tts (use edge-tts as input)", value=False)
- tts_text = gr.Textbox(visible=False,label="TTS text (600 words limitation)" if limitation else "TTS text")
- tts_voice = gr.Dropdown(label="Edge-tts speaker", choices=voices, visible=False, allow_custom_value=False, value="en-US-AnaNeural-Female")
- vc_submit = gr.Button("Generate", variant="primary")
- with gr.Column():
- vc_output1 = gr.Textbox(label="Output Message")
- vc_output2 = gr.Audio(label="Output Audio")
- vc_submit.click(vc_fn, [vc_input, vc_transpose, vc_f0method, vc_index_ratio, tts_mode, tts_text, tts_voice], [vc_output1, vc_output2])
- tts_mode.change(change_to_tts_mode, [tts_mode], [vc_input, tts_text, tts_voice])
- app.queue(concurrency_count=1, max_size=20, api_open=args.api).launch(share=args.share)
\ No newline at end of file
diff --git a/spaces/Jackflack09/diffuse-custom/diffusers/models/unet_1d_blocks.py b/spaces/Jackflack09/diffuse-custom/diffusers/models/unet_1d_blocks.py
deleted file mode 100644
index fc758ebbb044644e921c7e66089e052981a82e1e..0000000000000000000000000000000000000000
--- a/spaces/Jackflack09/diffuse-custom/diffusers/models/unet_1d_blocks.py
+++ /dev/null
@@ -1,668 +0,0 @@
-# Copyright 2022 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import math
-
-import torch
-import torch.nn.functional as F
-from torch import nn
-
-from .resnet import Downsample1D, ResidualTemporalBlock1D, Upsample1D, rearrange_dims
-
-
-class DownResnetBlock1D(nn.Module):
- def __init__(
- self,
- in_channels,
- out_channels=None,
- num_layers=1,
- conv_shortcut=False,
- temb_channels=32,
- groups=32,
- groups_out=None,
- non_linearity=None,
- time_embedding_norm="default",
- output_scale_factor=1.0,
- add_downsample=True,
- ):
- super().__init__()
- self.in_channels = in_channels
- out_channels = in_channels if out_channels is None else out_channels
- self.out_channels = out_channels
- self.use_conv_shortcut = conv_shortcut
- self.time_embedding_norm = time_embedding_norm
- self.add_downsample = add_downsample
- self.output_scale_factor = output_scale_factor
-
- if groups_out is None:
- groups_out = groups
-
- # there will always be at least one resnet
- resnets = [ResidualTemporalBlock1D(in_channels, out_channels, embed_dim=temb_channels)]
-
- for _ in range(num_layers):
- resnets.append(ResidualTemporalBlock1D(out_channels, out_channels, embed_dim=temb_channels))
-
- self.resnets = nn.ModuleList(resnets)
-
- if non_linearity == "swish":
- self.nonlinearity = lambda x: F.silu(x)
- elif non_linearity == "mish":
- self.nonlinearity = nn.Mish()
- elif non_linearity == "silu":
- self.nonlinearity = nn.SiLU()
- else:
- self.nonlinearity = None
-
- self.downsample = None
- if add_downsample:
- self.downsample = Downsample1D(out_channels, use_conv=True, padding=1)
-
- def forward(self, hidden_states, temb=None):
- output_states = ()
-
- hidden_states = self.resnets[0](hidden_states, temb)
- for resnet in self.resnets[1:]:
- hidden_states = resnet(hidden_states, temb)
-
- output_states += (hidden_states,)
-
- if self.nonlinearity is not None:
- hidden_states = self.nonlinearity(hidden_states)
-
- if self.downsample is not None:
- hidden_states = self.downsample(hidden_states)
-
- return hidden_states, output_states
-
-
-class UpResnetBlock1D(nn.Module):
- def __init__(
- self,
- in_channels,
- out_channels=None,
- num_layers=1,
- temb_channels=32,
- groups=32,
- groups_out=None,
- non_linearity=None,
- time_embedding_norm="default",
- output_scale_factor=1.0,
- add_upsample=True,
- ):
- super().__init__()
- self.in_channels = in_channels
- out_channels = in_channels if out_channels is None else out_channels
- self.out_channels = out_channels
- self.time_embedding_norm = time_embedding_norm
- self.add_upsample = add_upsample
- self.output_scale_factor = output_scale_factor
-
- if groups_out is None:
- groups_out = groups
-
- # there will always be at least one resnet
- resnets = [ResidualTemporalBlock1D(2 * in_channels, out_channels, embed_dim=temb_channels)]
-
- for _ in range(num_layers):
- resnets.append(ResidualTemporalBlock1D(out_channels, out_channels, embed_dim=temb_channels))
-
- self.resnets = nn.ModuleList(resnets)
-
- if non_linearity == "swish":
- self.nonlinearity = lambda x: F.silu(x)
- elif non_linearity == "mish":
- self.nonlinearity = nn.Mish()
- elif non_linearity == "silu":
- self.nonlinearity = nn.SiLU()
- else:
- self.nonlinearity = None
-
- self.upsample = None
- if add_upsample:
- self.upsample = Upsample1D(out_channels, use_conv_transpose=True)
-
- def forward(self, hidden_states, res_hidden_states_tuple=None, temb=None):
- if res_hidden_states_tuple is not None:
- res_hidden_states = res_hidden_states_tuple[-1]
- hidden_states = torch.cat((hidden_states, res_hidden_states), dim=1)
-
- hidden_states = self.resnets[0](hidden_states, temb)
- for resnet in self.resnets[1:]:
- hidden_states = resnet(hidden_states, temb)
-
- if self.nonlinearity is not None:
- hidden_states = self.nonlinearity(hidden_states)
-
- if self.upsample is not None:
- hidden_states = self.upsample(hidden_states)
-
- return hidden_states
-
-
-class ValueFunctionMidBlock1D(nn.Module):
- def __init__(self, in_channels, out_channels, embed_dim):
- super().__init__()
- self.in_channels = in_channels
- self.out_channels = out_channels
- self.embed_dim = embed_dim
-
- self.res1 = ResidualTemporalBlock1D(in_channels, in_channels // 2, embed_dim=embed_dim)
- self.down1 = Downsample1D(out_channels // 2, use_conv=True)
- self.res2 = ResidualTemporalBlock1D(in_channels // 2, in_channels // 4, embed_dim=embed_dim)
- self.down2 = Downsample1D(out_channels // 4, use_conv=True)
-
- def forward(self, x, temb=None):
- x = self.res1(x, temb)
- x = self.down1(x)
- x = self.res2(x, temb)
- x = self.down2(x)
- return x
-
-
-class MidResTemporalBlock1D(nn.Module):
- def __init__(
- self,
- in_channels,
- out_channels,
- embed_dim,
- num_layers: int = 1,
- add_downsample: bool = False,
- add_upsample: bool = False,
- non_linearity=None,
- ):
- super().__init__()
- self.in_channels = in_channels
- self.out_channels = out_channels
- self.add_downsample = add_downsample
-
- # there will always be at least one resnet
- resnets = [ResidualTemporalBlock1D(in_channels, out_channels, embed_dim=embed_dim)]
-
- for _ in range(num_layers):
- resnets.append(ResidualTemporalBlock1D(out_channels, out_channels, embed_dim=embed_dim))
-
- self.resnets = nn.ModuleList(resnets)
-
- if non_linearity == "swish":
- self.nonlinearity = lambda x: F.silu(x)
- elif non_linearity == "mish":
- self.nonlinearity = nn.Mish()
- elif non_linearity == "silu":
- self.nonlinearity = nn.SiLU()
- else:
- self.nonlinearity = None
-
- self.upsample = None
- if add_upsample:
- self.upsample = Downsample1D(out_channels, use_conv=True)
-
- self.downsample = None
- if add_downsample:
- self.downsample = Downsample1D(out_channels, use_conv=True)
-
- if self.upsample and self.downsample:
- raise ValueError("Block cannot downsample and upsample")
-
- def forward(self, hidden_states, temb):
- hidden_states = self.resnets[0](hidden_states, temb)
- for resnet in self.resnets[1:]:
- hidden_states = resnet(hidden_states, temb)
-
- if self.upsample:
- hidden_states = self.upsample(hidden_states)
- if self.downsample:
- self.downsample = self.downsample(hidden_states)
-
- return hidden_states
-
-
-class OutConv1DBlock(nn.Module):
- def __init__(self, num_groups_out, out_channels, embed_dim, act_fn):
- super().__init__()
- self.final_conv1d_1 = nn.Conv1d(embed_dim, embed_dim, 5, padding=2)
- self.final_conv1d_gn = nn.GroupNorm(num_groups_out, embed_dim)
- if act_fn == "silu":
- self.final_conv1d_act = nn.SiLU()
- if act_fn == "mish":
- self.final_conv1d_act = nn.Mish()
- self.final_conv1d_2 = nn.Conv1d(embed_dim, out_channels, 1)
-
- def forward(self, hidden_states, temb=None):
- hidden_states = self.final_conv1d_1(hidden_states)
- hidden_states = rearrange_dims(hidden_states)
- hidden_states = self.final_conv1d_gn(hidden_states)
- hidden_states = rearrange_dims(hidden_states)
- hidden_states = self.final_conv1d_act(hidden_states)
- hidden_states = self.final_conv1d_2(hidden_states)
- return hidden_states
-
-
-class OutValueFunctionBlock(nn.Module):
- def __init__(self, fc_dim, embed_dim):
- super().__init__()
- self.final_block = nn.ModuleList(
- [
- nn.Linear(fc_dim + embed_dim, fc_dim // 2),
- nn.Mish(),
- nn.Linear(fc_dim // 2, 1),
- ]
- )
-
- def forward(self, hidden_states, temb):
- hidden_states = hidden_states.view(hidden_states.shape[0], -1)
- hidden_states = torch.cat((hidden_states, temb), dim=-1)
- for layer in self.final_block:
- hidden_states = layer(hidden_states)
-
- return hidden_states
-
-
-_kernels = {
- "linear": [1 / 8, 3 / 8, 3 / 8, 1 / 8],
- "cubic": [-0.01171875, -0.03515625, 0.11328125, 0.43359375, 0.43359375, 0.11328125, -0.03515625, -0.01171875],
- "lanczos3": [
- 0.003689131001010537,
- 0.015056144446134567,
- -0.03399861603975296,
- -0.066637322306633,
- 0.13550527393817902,
- 0.44638532400131226,
- 0.44638532400131226,
- 0.13550527393817902,
- -0.066637322306633,
- -0.03399861603975296,
- 0.015056144446134567,
- 0.003689131001010537,
- ],
-}
-
-
-class Downsample1d(nn.Module):
- def __init__(self, kernel="linear", pad_mode="reflect"):
- super().__init__()
- self.pad_mode = pad_mode
- kernel_1d = torch.tensor(_kernels[kernel])
- self.pad = kernel_1d.shape[0] // 2 - 1
- self.register_buffer("kernel", kernel_1d)
-
- def forward(self, hidden_states):
- hidden_states = F.pad(hidden_states, (self.pad,) * 2, self.pad_mode)
- weight = hidden_states.new_zeros([hidden_states.shape[1], hidden_states.shape[1], self.kernel.shape[0]])
- indices = torch.arange(hidden_states.shape[1], device=hidden_states.device)
- weight[indices, indices] = self.kernel.to(weight)
- return F.conv1d(hidden_states, weight, stride=2)
-
-
-class Upsample1d(nn.Module):
- def __init__(self, kernel="linear", pad_mode="reflect"):
- super().__init__()
- self.pad_mode = pad_mode
- kernel_1d = torch.tensor(_kernels[kernel]) * 2
- self.pad = kernel_1d.shape[0] // 2 - 1
- self.register_buffer("kernel", kernel_1d)
-
- def forward(self, hidden_states, temb=None):
- hidden_states = F.pad(hidden_states, ((self.pad + 1) // 2,) * 2, self.pad_mode)
- weight = hidden_states.new_zeros([hidden_states.shape[1], hidden_states.shape[1], self.kernel.shape[0]])
- indices = torch.arange(hidden_states.shape[1], device=hidden_states.device)
- weight[indices, indices] = self.kernel.to(weight)
- return F.conv_transpose1d(hidden_states, weight, stride=2, padding=self.pad * 2 + 1)
-
-
-class SelfAttention1d(nn.Module):
- def __init__(self, in_channels, n_head=1, dropout_rate=0.0):
- super().__init__()
- self.channels = in_channels
- self.group_norm = nn.GroupNorm(1, num_channels=in_channels)
- self.num_heads = n_head
-
- self.query = nn.Linear(self.channels, self.channels)
- self.key = nn.Linear(self.channels, self.channels)
- self.value = nn.Linear(self.channels, self.channels)
-
- self.proj_attn = nn.Linear(self.channels, self.channels, 1)
-
- self.dropout = nn.Dropout(dropout_rate, inplace=True)
-
- def transpose_for_scores(self, projection: torch.Tensor) -> torch.Tensor:
- new_projection_shape = projection.size()[:-1] + (self.num_heads, -1)
- # move heads to 2nd position (B, T, H * D) -> (B, T, H, D) -> (B, H, T, D)
- new_projection = projection.view(new_projection_shape).permute(0, 2, 1, 3)
- return new_projection
-
- def forward(self, hidden_states):
- residual = hidden_states
- batch, channel_dim, seq = hidden_states.shape
-
- hidden_states = self.group_norm(hidden_states)
- hidden_states = hidden_states.transpose(1, 2)
-
- query_proj = self.query(hidden_states)
- key_proj = self.key(hidden_states)
- value_proj = self.value(hidden_states)
-
- query_states = self.transpose_for_scores(query_proj)
- key_states = self.transpose_for_scores(key_proj)
- value_states = self.transpose_for_scores(value_proj)
-
- scale = 1 / math.sqrt(math.sqrt(key_states.shape[-1]))
-
- attention_scores = torch.matmul(query_states * scale, key_states.transpose(-1, -2) * scale)
- attention_probs = torch.softmax(attention_scores, dim=-1)
-
- # compute attention output
- hidden_states = torch.matmul(attention_probs, value_states)
-
- hidden_states = hidden_states.permute(0, 2, 1, 3).contiguous()
- new_hidden_states_shape = hidden_states.size()[:-2] + (self.channels,)
- hidden_states = hidden_states.view(new_hidden_states_shape)
-
- # compute next hidden_states
- hidden_states = self.proj_attn(hidden_states)
- hidden_states = hidden_states.transpose(1, 2)
- hidden_states = self.dropout(hidden_states)
-
- output = hidden_states + residual
-
- return output
-
-
-class ResConvBlock(nn.Module):
- def __init__(self, in_channels, mid_channels, out_channels, is_last=False):
- super().__init__()
- self.is_last = is_last
- self.has_conv_skip = in_channels != out_channels
-
- if self.has_conv_skip:
- self.conv_skip = nn.Conv1d(in_channels, out_channels, 1, bias=False)
-
- self.conv_1 = nn.Conv1d(in_channels, mid_channels, 5, padding=2)
- self.group_norm_1 = nn.GroupNorm(1, mid_channels)
- self.gelu_1 = nn.GELU()
- self.conv_2 = nn.Conv1d(mid_channels, out_channels, 5, padding=2)
-
- if not self.is_last:
- self.group_norm_2 = nn.GroupNorm(1, out_channels)
- self.gelu_2 = nn.GELU()
-
- def forward(self, hidden_states):
- residual = self.conv_skip(hidden_states) if self.has_conv_skip else hidden_states
-
- hidden_states = self.conv_1(hidden_states)
- hidden_states = self.group_norm_1(hidden_states)
- hidden_states = self.gelu_1(hidden_states)
- hidden_states = self.conv_2(hidden_states)
-
- if not self.is_last:
- hidden_states = self.group_norm_2(hidden_states)
- hidden_states = self.gelu_2(hidden_states)
-
- output = hidden_states + residual
- return output
-
-
-class UNetMidBlock1D(nn.Module):
- def __init__(self, mid_channels, in_channels, out_channels=None):
- super().__init__()
-
- out_channels = in_channels if out_channels is None else out_channels
-
- # there is always at least one resnet
- self.down = Downsample1d("cubic")
- resnets = [
- ResConvBlock(in_channels, mid_channels, mid_channels),
- ResConvBlock(mid_channels, mid_channels, mid_channels),
- ResConvBlock(mid_channels, mid_channels, mid_channels),
- ResConvBlock(mid_channels, mid_channels, mid_channels),
- ResConvBlock(mid_channels, mid_channels, mid_channels),
- ResConvBlock(mid_channels, mid_channels, out_channels),
- ]
- attentions = [
- SelfAttention1d(mid_channels, mid_channels // 32),
- SelfAttention1d(mid_channels, mid_channels // 32),
- SelfAttention1d(mid_channels, mid_channels // 32),
- SelfAttention1d(mid_channels, mid_channels // 32),
- SelfAttention1d(mid_channels, mid_channels // 32),
- SelfAttention1d(out_channels, out_channels // 32),
- ]
- self.up = Upsample1d(kernel="cubic")
-
- self.attentions = nn.ModuleList(attentions)
- self.resnets = nn.ModuleList(resnets)
-
- def forward(self, hidden_states, temb=None):
- hidden_states = self.down(hidden_states)
- for attn, resnet in zip(self.attentions, self.resnets):
- hidden_states = resnet(hidden_states)
- hidden_states = attn(hidden_states)
-
- hidden_states = self.up(hidden_states)
-
- return hidden_states
-
-
-class AttnDownBlock1D(nn.Module):
- def __init__(self, out_channels, in_channels, mid_channels=None):
- super().__init__()
- mid_channels = out_channels if mid_channels is None else mid_channels
-
- self.down = Downsample1d("cubic")
- resnets = [
- ResConvBlock(in_channels, mid_channels, mid_channels),
- ResConvBlock(mid_channels, mid_channels, mid_channels),
- ResConvBlock(mid_channels, mid_channels, out_channels),
- ]
- attentions = [
- SelfAttention1d(mid_channels, mid_channels // 32),
- SelfAttention1d(mid_channels, mid_channels // 32),
- SelfAttention1d(out_channels, out_channels // 32),
- ]
-
- self.attentions = nn.ModuleList(attentions)
- self.resnets = nn.ModuleList(resnets)
-
- def forward(self, hidden_states, temb=None):
- hidden_states = self.down(hidden_states)
-
- for resnet, attn in zip(self.resnets, self.attentions):
- hidden_states = resnet(hidden_states)
- hidden_states = attn(hidden_states)
-
- return hidden_states, (hidden_states,)
-
-
-class DownBlock1D(nn.Module):
- def __init__(self, out_channels, in_channels, mid_channels=None):
- super().__init__()
- mid_channels = out_channels if mid_channels is None else mid_channels
-
- self.down = Downsample1d("cubic")
- resnets = [
- ResConvBlock(in_channels, mid_channels, mid_channels),
- ResConvBlock(mid_channels, mid_channels, mid_channels),
- ResConvBlock(mid_channels, mid_channels, out_channels),
- ]
-
- self.resnets = nn.ModuleList(resnets)
-
- def forward(self, hidden_states, temb=None):
- hidden_states = self.down(hidden_states)
-
- for resnet in self.resnets:
- hidden_states = resnet(hidden_states)
-
- return hidden_states, (hidden_states,)
-
-
-class DownBlock1DNoSkip(nn.Module):
- def __init__(self, out_channels, in_channels, mid_channels=None):
- super().__init__()
- mid_channels = out_channels if mid_channels is None else mid_channels
-
- resnets = [
- ResConvBlock(in_channels, mid_channels, mid_channels),
- ResConvBlock(mid_channels, mid_channels, mid_channels),
- ResConvBlock(mid_channels, mid_channels, out_channels),
- ]
-
- self.resnets = nn.ModuleList(resnets)
-
- def forward(self, hidden_states, temb=None):
- hidden_states = torch.cat([hidden_states, temb], dim=1)
- for resnet in self.resnets:
- hidden_states = resnet(hidden_states)
-
- return hidden_states, (hidden_states,)
-
-
-class AttnUpBlock1D(nn.Module):
- def __init__(self, in_channels, out_channels, mid_channels=None):
- super().__init__()
- mid_channels = out_channels if mid_channels is None else mid_channels
-
- resnets = [
- ResConvBlock(2 * in_channels, mid_channels, mid_channels),
- ResConvBlock(mid_channels, mid_channels, mid_channels),
- ResConvBlock(mid_channels, mid_channels, out_channels),
- ]
- attentions = [
- SelfAttention1d(mid_channels, mid_channels // 32),
- SelfAttention1d(mid_channels, mid_channels // 32),
- SelfAttention1d(out_channels, out_channels // 32),
- ]
-
- self.attentions = nn.ModuleList(attentions)
- self.resnets = nn.ModuleList(resnets)
- self.up = Upsample1d(kernel="cubic")
-
- def forward(self, hidden_states, res_hidden_states_tuple, temb=None):
- res_hidden_states = res_hidden_states_tuple[-1]
- hidden_states = torch.cat([hidden_states, res_hidden_states], dim=1)
-
- for resnet, attn in zip(self.resnets, self.attentions):
- hidden_states = resnet(hidden_states)
- hidden_states = attn(hidden_states)
-
- hidden_states = self.up(hidden_states)
-
- return hidden_states
-
-
-class UpBlock1D(nn.Module):
- def __init__(self, in_channels, out_channels, mid_channels=None):
- super().__init__()
- mid_channels = in_channels if mid_channels is None else mid_channels
-
- resnets = [
- ResConvBlock(2 * in_channels, mid_channels, mid_channels),
- ResConvBlock(mid_channels, mid_channels, mid_channels),
- ResConvBlock(mid_channels, mid_channels, out_channels),
- ]
-
- self.resnets = nn.ModuleList(resnets)
- self.up = Upsample1d(kernel="cubic")
-
- def forward(self, hidden_states, res_hidden_states_tuple, temb=None):
- res_hidden_states = res_hidden_states_tuple[-1]
- hidden_states = torch.cat([hidden_states, res_hidden_states], dim=1)
-
- for resnet in self.resnets:
- hidden_states = resnet(hidden_states)
-
- hidden_states = self.up(hidden_states)
-
- return hidden_states
-
-
-class UpBlock1DNoSkip(nn.Module):
- def __init__(self, in_channels, out_channels, mid_channels=None):
- super().__init__()
- mid_channels = in_channels if mid_channels is None else mid_channels
-
- resnets = [
- ResConvBlock(2 * in_channels, mid_channels, mid_channels),
- ResConvBlock(mid_channels, mid_channels, mid_channels),
- ResConvBlock(mid_channels, mid_channels, out_channels, is_last=True),
- ]
-
- self.resnets = nn.ModuleList(resnets)
-
- def forward(self, hidden_states, res_hidden_states_tuple, temb=None):
- res_hidden_states = res_hidden_states_tuple[-1]
- hidden_states = torch.cat([hidden_states, res_hidden_states], dim=1)
-
- for resnet in self.resnets:
- hidden_states = resnet(hidden_states)
-
- return hidden_states
-
-
-def get_down_block(down_block_type, num_layers, in_channels, out_channels, temb_channels, add_downsample):
- if down_block_type == "DownResnetBlock1D":
- return DownResnetBlock1D(
- in_channels=in_channels,
- num_layers=num_layers,
- out_channels=out_channels,
- temb_channels=temb_channels,
- add_downsample=add_downsample,
- )
- elif down_block_type == "DownBlock1D":
- return DownBlock1D(out_channels=out_channels, in_channels=in_channels)
- elif down_block_type == "AttnDownBlock1D":
- return AttnDownBlock1D(out_channels=out_channels, in_channels=in_channels)
- elif down_block_type == "DownBlock1DNoSkip":
- return DownBlock1DNoSkip(out_channels=out_channels, in_channels=in_channels)
- raise ValueError(f"{down_block_type} does not exist.")
-
-
-def get_up_block(up_block_type, num_layers, in_channels, out_channels, temb_channels, add_upsample):
- if up_block_type == "UpResnetBlock1D":
- return UpResnetBlock1D(
- in_channels=in_channels,
- num_layers=num_layers,
- out_channels=out_channels,
- temb_channels=temb_channels,
- add_upsample=add_upsample,
- )
- elif up_block_type == "UpBlock1D":
- return UpBlock1D(in_channels=in_channels, out_channels=out_channels)
- elif up_block_type == "AttnUpBlock1D":
- return AttnUpBlock1D(in_channels=in_channels, out_channels=out_channels)
- elif up_block_type == "UpBlock1DNoSkip":
- return UpBlock1DNoSkip(in_channels=in_channels, out_channels=out_channels)
- raise ValueError(f"{up_block_type} does not exist.")
-
-
-def get_mid_block(mid_block_type, num_layers, in_channels, mid_channels, out_channels, embed_dim, add_downsample):
- if mid_block_type == "MidResTemporalBlock1D":
- return MidResTemporalBlock1D(
- num_layers=num_layers,
- in_channels=in_channels,
- out_channels=out_channels,
- embed_dim=embed_dim,
- add_downsample=add_downsample,
- )
- elif mid_block_type == "ValueFunctionMidBlock1D":
- return ValueFunctionMidBlock1D(in_channels=in_channels, out_channels=out_channels, embed_dim=embed_dim)
- elif mid_block_type == "UNetMidBlock1D":
- return UNetMidBlock1D(in_channels=in_channels, mid_channels=mid_channels, out_channels=out_channels)
- raise ValueError(f"{mid_block_type} does not exist.")
-
-
-def get_out_block(*, out_block_type, num_groups_out, embed_dim, out_channels, act_fn, fc_dim):
- if out_block_type == "OutConv1DBlock":
- return OutConv1DBlock(num_groups_out, out_channels, embed_dim, act_fn)
- elif out_block_type == "ValueFunction":
- return OutValueFunctionBlock(fc_dim, embed_dim)
- return None
diff --git a/spaces/Jaehan/Text2Text-Text-Summarization/app.py b/spaces/Jaehan/Text2Text-Text-Summarization/app.py
deleted file mode 100644
index 4610cd29df9a9c32776c8fe07870be36ca2e8e2b..0000000000000000000000000000000000000000
--- a/spaces/Jaehan/Text2Text-Text-Summarization/app.py
+++ /dev/null
@@ -1,24 +0,0 @@
-from transformers import AutoTokenizer, AutoModelWithLMHead
-import gradio as gr
-
-model_name = "deep-learning-analytics/wikihow-t5-small"
-text2text_token = AutoTokenizer.from_pretrained(model_name)
-model = AutoModelWithLMHead.from_pretrained(model_name)
-
-def text2text_summary(para):
- initial_text = para.strip().replace("\n","")
- token_text = text2text_token.encode(initial_text, return_tensors="pt")
-
- token_ids = model.generate(
- token_text,
- max_length=250,
- num_beams=5,
- repetition_penalty=2.5,
- early_stopping=True )
- response = text2text_token.decode(token_ids[0], skip_special_tokens=True)
- return response
-
-# UX
-in_para = gr.Textbox(lines=10, label="Input paragraph", placeholder="Place your paragraph to summarize here...")
-out = gr.Textbox(lines=1, label="Summary")
-gr.Interface(text2text_summary, inputs=in_para, outputs=out).launch()
\ No newline at end of file
diff --git a/spaces/Junity/TokaiTeio-SVC/models.py b/spaces/Junity/TokaiTeio-SVC/models.py
deleted file mode 100644
index 13278d680493970f5a670cf3fc955a6e9b7ab1d5..0000000000000000000000000000000000000000
--- a/spaces/Junity/TokaiTeio-SVC/models.py
+++ /dev/null
@@ -1,420 +0,0 @@
-import copy
-import math
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-import modules.attentions as attentions
-import modules.commons as commons
-import modules.modules as modules
-
-from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
-from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
-
-import utils
-from modules.commons import init_weights, get_padding
-from vdecoder.hifigan.models import Generator
-from utils import f0_to_coarse
-
-class ResidualCouplingBlock(nn.Module):
- def __init__(self,
- channels,
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- n_flows=4,
- gin_channels=0):
- super().__init__()
- self.channels = channels
- self.hidden_channels = hidden_channels
- self.kernel_size = kernel_size
- self.dilation_rate = dilation_rate
- self.n_layers = n_layers
- self.n_flows = n_flows
- self.gin_channels = gin_channels
-
- self.flows = nn.ModuleList()
- for i in range(n_flows):
- self.flows.append(modules.ResidualCouplingLayer(channels, hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=gin_channels, mean_only=True))
- self.flows.append(modules.Flip())
-
- def forward(self, x, x_mask, g=None, reverse=False):
- if not reverse:
- for flow in self.flows:
- x, _ = flow(x, x_mask, g=g, reverse=reverse)
- else:
- for flow in reversed(self.flows):
- x = flow(x, x_mask, g=g, reverse=reverse)
- return x
-
-
-class Encoder(nn.Module):
- def __init__(self,
- in_channels,
- out_channels,
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- gin_channels=0):
- super().__init__()
- self.in_channels = in_channels
- self.out_channels = out_channels
- self.hidden_channels = hidden_channels
- self.kernel_size = kernel_size
- self.dilation_rate = dilation_rate
- self.n_layers = n_layers
- self.gin_channels = gin_channels
-
- self.pre = nn.Conv1d(in_channels, hidden_channels, 1)
- self.enc = modules.WN(hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=gin_channels)
- self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
- def forward(self, x, x_lengths, g=None):
- # print(x.shape,x_lengths.shape)
- x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
- x = self.pre(x) * x_mask
- x = self.enc(x, x_mask, g=g)
- stats = self.proj(x) * x_mask
- m, logs = torch.split(stats, self.out_channels, dim=1)
- z = (m + torch.randn_like(m) * torch.exp(logs)) * x_mask
- return z, m, logs, x_mask
-
-
-class TextEncoder(nn.Module):
- def __init__(self,
- out_channels,
- hidden_channels,
- kernel_size,
- n_layers,
- gin_channels=0,
- filter_channels=None,
- n_heads=None,
- p_dropout=None):
- super().__init__()
- self.out_channels = out_channels
- self.hidden_channels = hidden_channels
- self.kernel_size = kernel_size
- self.n_layers = n_layers
- self.gin_channels = gin_channels
- self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
- self.f0_emb = nn.Embedding(256, hidden_channels)
-
- self.enc_ = attentions.Encoder(
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout)
-
- def forward(self, x, x_mask, f0=None, noice_scale=1):
- x = x + self.f0_emb(f0).transpose(1,2)
- x = self.enc_(x * x_mask, x_mask)
- stats = self.proj(x) * x_mask
- m, logs = torch.split(stats, self.out_channels, dim=1)
- z = (m + torch.randn_like(m) * torch.exp(logs) * noice_scale) * x_mask
-
- return z, m, logs, x_mask
-
-
-
-class DiscriminatorP(torch.nn.Module):
- def __init__(self, period, kernel_size=5, stride=3, use_spectral_norm=False):
- super(DiscriminatorP, self).__init__()
- self.period = period
- self.use_spectral_norm = use_spectral_norm
- norm_f = weight_norm if use_spectral_norm == False else spectral_norm
- self.convs = nn.ModuleList([
- norm_f(Conv2d(1, 32, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
- norm_f(Conv2d(32, 128, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
- norm_f(Conv2d(128, 512, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
- norm_f(Conv2d(512, 1024, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
- norm_f(Conv2d(1024, 1024, (kernel_size, 1), 1, padding=(get_padding(kernel_size, 1), 0))),
- ])
- self.conv_post = norm_f(Conv2d(1024, 1, (3, 1), 1, padding=(1, 0)))
-
- def forward(self, x):
- fmap = []
-
- # 1d to 2d
- b, c, t = x.shape
- if t % self.period != 0: # pad first
- n_pad = self.period - (t % self.period)
- x = F.pad(x, (0, n_pad), "reflect")
- t = t + n_pad
- x = x.view(b, c, t // self.period, self.period)
-
- for l in self.convs:
- x = l(x)
- x = F.leaky_relu(x, modules.LRELU_SLOPE)
- fmap.append(x)
- x = self.conv_post(x)
- fmap.append(x)
- x = torch.flatten(x, 1, -1)
-
- return x, fmap
-
-
-class DiscriminatorS(torch.nn.Module):
- def __init__(self, use_spectral_norm=False):
- super(DiscriminatorS, self).__init__()
- norm_f = weight_norm if use_spectral_norm == False else spectral_norm
- self.convs = nn.ModuleList([
- norm_f(Conv1d(1, 16, 15, 1, padding=7)),
- norm_f(Conv1d(16, 64, 41, 4, groups=4, padding=20)),
- norm_f(Conv1d(64, 256, 41, 4, groups=16, padding=20)),
- norm_f(Conv1d(256, 1024, 41, 4, groups=64, padding=20)),
- norm_f(Conv1d(1024, 1024, 41, 4, groups=256, padding=20)),
- norm_f(Conv1d(1024, 1024, 5, 1, padding=2)),
- ])
- self.conv_post = norm_f(Conv1d(1024, 1, 3, 1, padding=1))
-
- def forward(self, x):
- fmap = []
-
- for l in self.convs:
- x = l(x)
- x = F.leaky_relu(x, modules.LRELU_SLOPE)
- fmap.append(x)
- x = self.conv_post(x)
- fmap.append(x)
- x = torch.flatten(x, 1, -1)
-
- return x, fmap
-
-
-class MultiPeriodDiscriminator(torch.nn.Module):
- def __init__(self, use_spectral_norm=False):
- super(MultiPeriodDiscriminator, self).__init__()
- periods = [2,3,5,7,11]
-
- discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
- discs = discs + [DiscriminatorP(i, use_spectral_norm=use_spectral_norm) for i in periods]
- self.discriminators = nn.ModuleList(discs)
-
- def forward(self, y, y_hat):
- y_d_rs = []
- y_d_gs = []
- fmap_rs = []
- fmap_gs = []
- for i, d in enumerate(self.discriminators):
- y_d_r, fmap_r = d(y)
- y_d_g, fmap_g = d(y_hat)
- y_d_rs.append(y_d_r)
- y_d_gs.append(y_d_g)
- fmap_rs.append(fmap_r)
- fmap_gs.append(fmap_g)
-
- return y_d_rs, y_d_gs, fmap_rs, fmap_gs
-
-
-class SpeakerEncoder(torch.nn.Module):
- def __init__(self, mel_n_channels=80, model_num_layers=3, model_hidden_size=256, model_embedding_size=256):
- super(SpeakerEncoder, self).__init__()
- self.lstm = nn.LSTM(mel_n_channels, model_hidden_size, model_num_layers, batch_first=True)
- self.linear = nn.Linear(model_hidden_size, model_embedding_size)
- self.relu = nn.ReLU()
-
- def forward(self, mels):
- self.lstm.flatten_parameters()
- _, (hidden, _) = self.lstm(mels)
- embeds_raw = self.relu(self.linear(hidden[-1]))
- return embeds_raw / torch.norm(embeds_raw, dim=1, keepdim=True)
-
- def compute_partial_slices(self, total_frames, partial_frames, partial_hop):
- mel_slices = []
- for i in range(0, total_frames-partial_frames, partial_hop):
- mel_range = torch.arange(i, i+partial_frames)
- mel_slices.append(mel_range)
-
- return mel_slices
-
- def embed_utterance(self, mel, partial_frames=128, partial_hop=64):
- mel_len = mel.size(1)
- last_mel = mel[:,-partial_frames:]
-
- if mel_len > partial_frames:
- mel_slices = self.compute_partial_slices(mel_len, partial_frames, partial_hop)
- mels = list(mel[:,s] for s in mel_slices)
- mels.append(last_mel)
- mels = torch.stack(tuple(mels), 0).squeeze(1)
-
- with torch.no_grad():
- partial_embeds = self(mels)
- embed = torch.mean(partial_embeds, axis=0).unsqueeze(0)
- #embed = embed / torch.linalg.norm(embed, 2)
- else:
- with torch.no_grad():
- embed = self(last_mel)
-
- return embed
-
-class F0Decoder(nn.Module):
- def __init__(self,
- out_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- spk_channels=0):
- super().__init__()
- self.out_channels = out_channels
- self.hidden_channels = hidden_channels
- self.filter_channels = filter_channels
- self.n_heads = n_heads
- self.n_layers = n_layers
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.spk_channels = spk_channels
-
- self.prenet = nn.Conv1d(hidden_channels, hidden_channels, 3, padding=1)
- self.decoder = attentions.FFT(
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout)
- self.proj = nn.Conv1d(hidden_channels, out_channels, 1)
- self.f0_prenet = nn.Conv1d(1, hidden_channels , 3, padding=1)
- self.cond = nn.Conv1d(spk_channels, hidden_channels, 1)
-
- def forward(self, x, norm_f0, x_mask, spk_emb=None):
- x = torch.detach(x)
- if (spk_emb is not None):
- x = x + self.cond(spk_emb)
- x += self.f0_prenet(norm_f0)
- x = self.prenet(x) * x_mask
- x = self.decoder(x * x_mask, x_mask)
- x = self.proj(x) * x_mask
- return x
-
-
-class SynthesizerTrn(nn.Module):
- """
- Synthesizer for Training
- """
-
- def __init__(self,
- spec_channels,
- segment_size,
- inter_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- resblock,
- resblock_kernel_sizes,
- resblock_dilation_sizes,
- upsample_rates,
- upsample_initial_channel,
- upsample_kernel_sizes,
- gin_channels,
- ssl_dim,
- n_speakers,
- sampling_rate=44100,
- **kwargs):
-
- super().__init__()
- self.spec_channels = spec_channels
- self.inter_channels = inter_channels
- self.hidden_channels = hidden_channels
- self.filter_channels = filter_channels
- self.n_heads = n_heads
- self.n_layers = n_layers
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.resblock = resblock
- self.resblock_kernel_sizes = resblock_kernel_sizes
- self.resblock_dilation_sizes = resblock_dilation_sizes
- self.upsample_rates = upsample_rates
- self.upsample_initial_channel = upsample_initial_channel
- self.upsample_kernel_sizes = upsample_kernel_sizes
- self.segment_size = segment_size
- self.gin_channels = gin_channels
- self.ssl_dim = ssl_dim
- self.emb_g = nn.Embedding(n_speakers, gin_channels)
-
- self.pre = nn.Conv1d(ssl_dim, hidden_channels, kernel_size=5, padding=2)
-
- self.enc_p = TextEncoder(
- inter_channels,
- hidden_channels,
- filter_channels=filter_channels,
- n_heads=n_heads,
- n_layers=n_layers,
- kernel_size=kernel_size,
- p_dropout=p_dropout
- )
- hps = {
- "sampling_rate": sampling_rate,
- "inter_channels": inter_channels,
- "resblock": resblock,
- "resblock_kernel_sizes": resblock_kernel_sizes,
- "resblock_dilation_sizes": resblock_dilation_sizes,
- "upsample_rates": upsample_rates,
- "upsample_initial_channel": upsample_initial_channel,
- "upsample_kernel_sizes": upsample_kernel_sizes,
- "gin_channels": gin_channels,
- }
- self.dec = Generator(h=hps)
- self.enc_q = Encoder(spec_channels, inter_channels, hidden_channels, 5, 1, 16, gin_channels=gin_channels)
- self.flow = ResidualCouplingBlock(inter_channels, hidden_channels, 5, 1, 4, gin_channels=gin_channels)
- self.f0_decoder = F0Decoder(
- 1,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- spk_channels=gin_channels
- )
- self.emb_uv = nn.Embedding(2, hidden_channels)
-
- def forward(self, c, f0, uv, spec, g=None, c_lengths=None, spec_lengths=None):
- g = self.emb_g(g).transpose(1,2)
- # ssl prenet
- x_mask = torch.unsqueeze(commons.sequence_mask(c_lengths, c.size(2)), 1).to(c.dtype)
- x = self.pre(c) * x_mask + self.emb_uv(uv.long()).transpose(1,2)
-
- # f0 predict
- lf0 = 2595. * torch.log10(1. + f0.unsqueeze(1) / 700.) / 500
- norm_lf0 = utils.normalize_f0(lf0, x_mask, uv)
- pred_lf0 = self.f0_decoder(x, norm_lf0, x_mask, spk_emb=g)
-
- # encoder
- z_ptemp, m_p, logs_p, _ = self.enc_p(x, x_mask, f0=f0_to_coarse(f0))
- z, m_q, logs_q, spec_mask = self.enc_q(spec, spec_lengths, g=g)
-
- # flow
- z_p = self.flow(z, spec_mask, g=g)
- z_slice, pitch_slice, ids_slice = commons.rand_slice_segments_with_pitch(z, f0, spec_lengths, self.segment_size)
-
- # nsf decoder
- o = self.dec(z_slice, g=g, f0=pitch_slice)
-
- return o, ids_slice, spec_mask, (z, z_p, m_p, logs_p, m_q, logs_q), pred_lf0, norm_lf0, lf0
-
- def infer(self, c, f0, uv, g=None, noice_scale=0.35, predict_f0=False):
- c_lengths = (torch.ones(c.size(0)) * c.size(-1)).to(c.device)
- g = self.emb_g(g).transpose(1,2)
- x_mask = torch.unsqueeze(commons.sequence_mask(c_lengths, c.size(2)), 1).to(c.dtype)
- x = self.pre(c) * x_mask + self.emb_uv(uv.long()).transpose(1,2)
-
- if predict_f0:
- lf0 = 2595. * torch.log10(1. + f0.unsqueeze(1) / 700.) / 500
- norm_lf0 = utils.normalize_f0(lf0, x_mask, uv, random_scale=False)
- pred_lf0 = self.f0_decoder(x, norm_lf0, x_mask, spk_emb=g)
- f0 = (700 * (torch.pow(10, pred_lf0 * 500 / 2595) - 1)).squeeze(1)
-
- z_p, m_p, logs_p, c_mask = self.enc_p(x, x_mask, f0=f0_to_coarse(f0), noice_scale=noice_scale)
- z = self.flow(z_p, c_mask, g=g, reverse=True)
- o = self.dec(z * c_mask, g=g, f0=f0)
- return o
diff --git a/spaces/KarmaCST/English-To-Dzongkha-Translation-NLLB-Fine-tuning/app.py b/spaces/KarmaCST/English-To-Dzongkha-Translation-NLLB-Fine-tuning/app.py
deleted file mode 100644
index 3fcd62c2040112c44aa13c41ca618958b3c513e4..0000000000000000000000000000000000000000
--- a/spaces/KarmaCST/English-To-Dzongkha-Translation-NLLB-Fine-tuning/app.py
+++ /dev/null
@@ -1,31 +0,0 @@
-import gradio as gr
-from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, pipeline
-import torch
-
-model = AutoModelForSeq2SeqLM.from_pretrained("KarmaCST/nllb-200-distilled-600M-en-to-dz")
-tokenizer = AutoTokenizer.from_pretrained("KarmaCST/nllb-200-distilled-600M-en-to-dz")
-
-
-src_lang = 'eng_Latn'
-tgt_lang = "dzo_Tibt"
-
-
-def translate(text):
- translation_pipeline = pipeline("translation",
- model=model,
- tokenizer=tokenizer,
- src_lang=src_lang,
- tgt_lang=tgt_lang)
-
- result = translation_pipeline(text)
- return result[0]['translation_text']
-
-
-
-gr.Interface(
- translate,
- [
- gr.components.Textbox(label="Input Sentence", placeholder = " Enter English sentence here ...")
- ],
- ["text"],
-).launch()
\ No newline at end of file
diff --git a/spaces/KaygNas/cut-it/mocks/handlers/all.handlers.ts b/spaces/KaygNas/cut-it/mocks/handlers/all.handlers.ts
deleted file mode 100644
index 86a4e895b4188284a99ec4c97330b274c152638d..0000000000000000000000000000000000000000
--- a/spaces/KaygNas/cut-it/mocks/handlers/all.handlers.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-import { rest } from 'msw'
-import { API_BASE_URL } from '../../src/constants'
-import detectionResult from './detection-result.json'
-import classificationResult from './classification-result.json'
-import MOCK_IMAGE_URL from './mock_image.jpg'
-
-const handlers = [
- rest.post(`${API_BASE_URL}detect-image`, (req, res, ctx) => {
- return res(ctx.status(200), ctx.json(detectionResult))
- }),
- rest.post(`${API_BASE_URL}classify-image`, (req, res, ctx) => {
- return res(ctx.status(200), ctx.json(classificationResult))
- }),
- rest.post(`${API_BASE_URL}text-to-image`, async (req, res, ctx) => {
- const image = await ctx.fetch(MOCK_IMAGE_URL)
- return res(ctx.status(200), ctx.body(await image.arrayBuffer()))
- }),
-]
-
-export default handlers
diff --git a/spaces/Kevin676/ChatGPT-with-Voice-Cloning-in-Chinese/ppg_extractor/encoder/__init__.py b/spaces/Kevin676/ChatGPT-with-Voice-Cloning-in-Chinese/ppg_extractor/encoder/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/KoboldAI/KoboldAI-Lite/style.css b/spaces/KoboldAI/KoboldAI-Lite/style.css
deleted file mode 100644
index 114adf441e9032febb46bc056b2a8bb651075f0d..0000000000000000000000000000000000000000
--- a/spaces/KoboldAI/KoboldAI-Lite/style.css
+++ /dev/null
@@ -1,28 +0,0 @@
-body {
- padding: 2rem;
- font-family: -apple-system, BlinkMacSystemFont, "Arial", sans-serif;
-}
-
-h1 {
- font-size: 16px;
- margin-top: 0;
-}
-
-p {
- color: rgb(107, 114, 128);
- font-size: 15px;
- margin-bottom: 10px;
- margin-top: 5px;
-}
-
-.card {
- max-width: 620px;
- margin: 0 auto;
- padding: 16px;
- border: 1px solid lightgray;
- border-radius: 16px;
-}
-
-.card p:last-child {
- margin-bottom: 0;
-}
diff --git a/spaces/KonradSzafer/HF-QA-Demo/qa_engine/qa_engine.py b/spaces/KonradSzafer/HF-QA-Demo/qa_engine/qa_engine.py
deleted file mode 100644
index 2bcd139bbfad26d2ad9d5cacceb9fc190bc161ef..0000000000000000000000000000000000000000
--- a/spaces/KonradSzafer/HF-QA-Demo/qa_engine/qa_engine.py
+++ /dev/null
@@ -1,290 +0,0 @@
-import os
-import json
-import requests
-import subprocess
-from typing import Mapping, Optional, Any
-
-import torch
-import transformers
-from transformers import AutoTokenizer, AutoModelForCausalLM
-from huggingface_hub import snapshot_download
-from urllib.parse import quote
-from langchain import PromptTemplate, HuggingFaceHub, LLMChain
-from langchain.llms import HuggingFacePipeline
-from langchain.llms.base import LLM
-from langchain.embeddings import HuggingFaceEmbeddings, HuggingFaceHubEmbeddings, HuggingFaceInstructEmbeddings
-from langchain.vectorstores import FAISS
-from sentence_transformers import CrossEncoder
-
-from qa_engine import logger
-from qa_engine.response import Response
-from qa_engine.mocks import MockLocalBinaryModel
-
-
-class LocalBinaryModel(LLM):
- model_id: str = None
- llm: None = None
-
- def __init__(self, model_id: str = None):
- super().__init__()
- # pip install llama_cpp_python==0.1.39
- from llama_cpp import Llama
-
- model_path = f'qa_engine/{model_id}'
- if not os.path.exists(model_path):
- raise ValueError(f'{model_path} does not exist')
- self.model_id = model_id
- self.llm = Llama(model_path=model_path, n_ctx=4096)
-
- def _call(self, prompt: str, stop: Optional[list[str]] = None) -> str:
- output = self.llm(
- prompt,
- max_tokens=1024,
- stop=['Q:'],
- echo=False
- )
- return output['choices'][0]['text']
-
- @property
- def _identifying_params(self) -> Mapping[str, Any]:
- return {'name_of_model': self.model_id}
-
- @property
- def _llm_type(self) -> str:
- return self.model_id
-
-
-class TransformersPipelineModel(LLM):
- model_id: str = None
- pipeline: str = None
-
- def __init__(self, model_id: str = None):
- super().__init__()
- self.model_id = model_id
-
- tokenizer = AutoTokenizer.from_pretrained(model_id)
- model = AutoModelForCausalLM.from_pretrained(
- model_id,
- torch_dtype=torch.bfloat16,
- trust_remote_code=True,
- load_in_8bit=False,
- device_map='auto',
- resume_download=True,
- )
- self.pipeline = transformers.pipeline(
- 'text-generation',
- model=model,
- tokenizer=tokenizer,
- torch_dtype=torch.bfloat16,
- device_map='auto',
- eos_token_id=tokenizer.eos_token_id,
- pad_token_id=tokenizer.eos_token_id,
- min_new_tokens=64,
- max_new_tokens=800,
- temperature=0.5,
- do_sample=True,
- )
-
- def _call(self, prompt: str, stop: Optional[list[str]] = None) -> str:
- output_text = self.pipeline(prompt)[0]['generated_text']
- output_text = output_text.replace(prompt+'\n', '')
- return output_text
-
- @property
- def _identifying_params(self) -> Mapping[str, Any]:
- return {'name_of_model': self.model_id}
-
- @property
- def _llm_type(self) -> str:
- return self.model_id
-
-
-class APIServedModel(LLM):
- model_url: str = None
- debug: bool = None
-
- def __init__(self, model_url: str = None, debug: bool = None):
- super().__init__()
- if model_url[-1] == '/':
- raise ValueError('URL should not end with a slash - "/"')
- self.model_url = model_url
- self.debug = debug
-
- def _call(self, prompt: str, stop: Optional[list[str]] = None) -> str:
- prompt_encoded = quote(prompt, safe='')
- url = f'{self.model_url}/?prompt={prompt_encoded}'
- if self.debug:
- logger.info(f'URL: {url}')
- try:
- response = requests.get(url, timeout=1200, verify=False)
- response.raise_for_status()
- return json.loads(response.content)['output_text']
- except Exception as err:
- logger.error(f'Error: {err}')
- return f'Error: {err}'
-
- @property
- def _identifying_params(self) -> Mapping[str, Any]:
- return {'name_of_model': f'model url: {self.model_url}'}
-
- @property
- def _llm_type(self) -> str:
- return 'api_model'
-
-
-
-class QAEngine():
- """
- QAEngine class, used for generating answers to questions.
-
- Args:
- llm_model_id (str): The ID of the LLM model to be used.
- embedding_model_id (str): The ID of the embedding model to be used.
- index_repo_id (str): The ID of the index repository to be used.
- run_locally (bool, optional): Whether to run the models locally or on the Hugging Face hub. Defaults to True.
- use_docs_for_context (bool, optional): Whether to use relevant documents as context for generating answers.
- Defaults to True.
- use_messages_for_context (bool, optional): Whether to use previous messages as context for generating answers.
- Defaults to True.
- debug (bool, optional): Whether to log debug information. Defaults to False.
-
- Attributes:
- use_docs_for_context (bool): Whether to use relevant documents as context for generating answers.
- use_messages_for_context (bool): Whether to use previous messages as context for generating answers.
- debug (bool): Whether to log debug information.
- llm_model (Union[LocalBinaryModel, HuggingFacePipeline, HuggingFaceHub]): The LLM model to be used.
- embedding_model (Union[HuggingFaceInstructEmbeddings, HuggingFaceHubEmbeddings]): The embedding model to be used.
- prompt_template (PromptTemplate): The prompt template to be used.
- llm_chain (LLMChain): The LLM chain to be used.
- knowledge_index (FAISS): The FAISS index to be used.
-
- """
- def __init__(
- self,
- llm_model_id: str,
- embedding_model_id: str,
- index_repo_id: str,
- prompt_template: str,
- use_docs_for_context: bool = True,
- num_relevant_docs: int = 3,
- add_sources_to_response: bool = True,
- use_messages_for_context: bool = True,
- first_stage_docs: int = 50,
- debug: bool = False
- ):
- super().__init__()
- self.prompt_template = prompt_template
- self.use_docs_for_context = use_docs_for_context
- self.num_relevant_docs = num_relevant_docs
- self.add_sources_to_response = add_sources_to_response
- self.use_messages_for_context = use_messages_for_context
- self.first_stage_docs = first_stage_docs
- self.debug = debug
-
- if 'local_models/' in llm_model_id:
- logger.info('using local binary model')
- self.llm_model = LocalBinaryModel(
- model_id=llm_model_id
- )
- elif 'api_models/' in llm_model_id:
- logger.info('using api served model')
- self.llm_model = APIServedModel(
- model_url=llm_model_id.replace('api_models/', ''),
- debug=self.debug
- )
- elif llm_model_id == 'mock':
- logger.info('using mock model')
- self.llm_model = MockLocalBinaryModel()
- else:
- logger.info('using transformers pipeline model')
- self.llm_model = TransformersPipelineModel(
- model_id=llm_model_id
- )
-
- prompt = PromptTemplate(
- template=prompt_template,
- input_variables=['question', 'context']
- )
- self.llm_chain = LLMChain(prompt=prompt, llm=self.llm_model)
-
- if self.use_docs_for_context:
- logger.info(f'Downloading {index_repo_id}')
- snapshot_download(
- repo_id=index_repo_id,
- allow_patterns=['*.faiss', '*.pkl'],
- repo_type='dataset',
- local_dir='indexes/run/'
- )
- logger.info('Loading embedding model')
- embed_instruction = 'Represent the Hugging Face library documentation'
- query_instruction = 'Query the most relevant piece of information from the Hugging Face documentation'
- embedding_model = HuggingFaceInstructEmbeddings(
- model_name=embedding_model_id,
- embed_instruction=embed_instruction,
- query_instruction=query_instruction
- )
- logger.info('Loading index')
- self.knowledge_index = FAISS.load_local('./indexes/run/', embedding_model)
- self.reranker = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-12-v2')
-
-
- def get_response(self, question: str, messages_context: str = '') -> Response:
- """
- Generate an answer to the specified question.
-
- Args:
- question (str): The question to be answered.
- messages_context (str, optional): The context to be used for generating the answer. Defaults to ''.
-
- Returns:
- response (Response): The Response object containing the generated answer and the sources of information
- used to generate the response.
- """
-
- response = Response()
- context = ''
- relevant_docs = ''
- if self.use_messages_for_context and messages_context:
- messages_context = f'\nPrevious questions and answers:\n{messages_context}'
- context += messages_context
- if self.use_docs_for_context:
- logger.info('Retriving documents')
- # messages context is used for better retrival
- retrival_query = messages_context + question
- relevant_docs = self.knowledge_index.similarity_search(
- query=retrival_query,
- k=self.first_stage_docs
- )
- cross_encoding_predictions = self.reranker.predict(
- [(retrival_query, doc.page_content) for doc in relevant_docs]
- )
- relevant_docs = [
- doc for _, doc in sorted(
- zip(cross_encoding_predictions, relevant_docs),
- reverse=True, key = lambda x: x[0]
- )
- ]
- relevant_docs = relevant_docs[:self.num_relevant_docs]
- context += '\nExtracted documents:\n'
- context += ''.join([doc.page_content for doc in relevant_docs])
- metadata = [doc.metadata for doc in relevant_docs]
- response.set_sources(sources=[str(m['source']) for m in metadata])
-
- logger.info('Running LLM chain')
- answer = self.llm_chain.run(question=question, context=context)
- response.set_answer(answer)
- logger.info('Received answer')
-
- if self.debug:
- logger.info('\n' + '=' * 100)
- sep = '\n' + '-' * 100
- logger.info(f'question len: {len(question)} {sep}')
- logger.info(f'question: {question} {sep}')
- logger.info(f'answer len: {len(response.get_answer())} {sep}')
- logger.info(f'answer: {response.get_answer()} {sep}')
- logger.info(f'{response.get_sources_as_text()} {sep}')
- logger.info(f'messages_contex: {messages_context} {sep}')
- logger.info(f'relevant_docs: {relevant_docs} {sep}')
- logger.info(f'context len: {len(context)} {sep}')
- logger.info(f'context: {context} {sep}')
- return response
diff --git a/spaces/KonradSzafer/HF-QA-Demo/tests/discord_bot/client/test_utils.py b/spaces/KonradSzafer/HF-QA-Demo/tests/discord_bot/client/test_utils.py
deleted file mode 100644
index effbac21e5f863d5bf17e16b45469ce2d22affa5..0000000000000000000000000000000000000000
--- a/spaces/KonradSzafer/HF-QA-Demo/tests/discord_bot/client/test_utils.py
+++ /dev/null
@@ -1,69 +0,0 @@
-import pytest
-import os
-from discord_bot.client.utils import ( \
- find_max_split_index, \
- find_max_split_index_from_sequence, \
- split_text_into_chunks
-)
-
-
-@pytest.fixture(scope='module')
-def test_chunk() -> str:
- return 't. , \n .'
-
-
-@pytest.fixture(scope='module')
-def test_text() -> str:
- with open('tests/discord_bot/client/lorem_ipsum.txt', 'r') as f:
- text = f.read()
- assert text is not None, 'test text is empty'
- return text
-
-
-def test_find_max_splitting_index(test_chunk: str):
- index = find_max_split_index(test_chunk, char='\n')
- assert index == 6, 'index should be 6'
- index = find_max_split_index(test_chunk, char='. ')
- assert index == 3, 'index should be 3'
- index = find_max_split_index(test_chunk, char='.')
- assert index == 8, 'index should be 8'
-
-
-def test_find_max_split_index_from_sequence(test_chunk: str):
- index = find_max_split_index_from_sequence(
- test_chunk,
- split_characters=['\n']
- )
- assert index == 6, 'index should be 6'
- index = find_max_split_index_from_sequence(
- test_chunk,
- split_characters=['.', ', ', '\n']
- )
- assert index == 8, 'index should be 8'
-
-
-def test_split_text_into_chunks_with_split_characters(test_text: str):
- max_chunk_size = 250
- chunks = split_text_into_chunks(
- test_text,
- split_characters=['. ', ', ', '\n'],
- min_size=20,
- max_size=max_chunk_size
- )
- for chunk in chunks:
- assert len(chunk) > 0, 'Chunk length is zero'
- assert len(chunk) <= max_chunk_size, 'Chunk length exceeds maximum limit'
-
-
-def test_split_text_into_chunks_without_split_characters():
- test_text = 'a' * 1000
- max_chunk_size = 250
- chunks = split_text_into_chunks(
- test_text,
- split_characters=[],
- min_size=20,
- max_size=max_chunk_size
- )
- for chunk in chunks:
- assert len(chunk) == max_chunk_size, \
- 'Chunk length is too small'
diff --git a/spaces/KyanChen/RSPrompter/mmdet/models/detectors/cascade_rcnn.py b/spaces/KyanChen/RSPrompter/mmdet/models/detectors/cascade_rcnn.py
deleted file mode 100644
index ecf733ff104b99436fcc74130b0ccea12a0fa6d0..0000000000000000000000000000000000000000
--- a/spaces/KyanChen/RSPrompter/mmdet/models/detectors/cascade_rcnn.py
+++ /dev/null
@@ -1,29 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmdet.registry import MODELS
-from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
-from .two_stage import TwoStageDetector
-
-
-@MODELS.register_module()
-class CascadeRCNN(TwoStageDetector):
- r"""Implementation of `Cascade R-CNN: Delving into High Quality Object
- Detection <https://arxiv.org/abs/1906.09756>`_"""
-
- def __init__(self,
- backbone: ConfigType,
- neck: OptConfigType = None,
- rpn_head: OptConfigType = None,
- roi_head: OptConfigType = None,
- train_cfg: OptConfigType = None,
- test_cfg: OptConfigType = None,
- data_preprocessor: OptConfigType = None,
- init_cfg: OptMultiConfig = None) -> None:
- super().__init__(
- backbone=backbone,
- neck=neck,
- rpn_head=rpn_head,
- roi_head=roi_head,
- train_cfg=train_cfg,
- test_cfg=test_cfg,
- data_preprocessor=data_preprocessor,
- init_cfg=init_cfg)
diff --git a/spaces/LaynzKunz/RVC-Inference-webui-grado-colab-huggingafce/infer.py b/spaces/LaynzKunz/RVC-Inference-webui-grado-colab-huggingafce/infer.py
deleted file mode 100644
index 9a40678751ebbe05d371e4d094ad711464d239dc..0000000000000000000000000000000000000000
--- a/spaces/LaynzKunz/RVC-Inference-webui-grado-colab-huggingafce/infer.py
+++ /dev/null
@@ -1,942 +0,0 @@
-import torch, os, traceback, sys, warnings, shutil, numpy as np
-import gradio as gr
-import librosa
-import asyncio
-import rarfile
-import edge_tts
-import yt_dlp
-import ffmpeg
-import gdown
-import subprocess
-import wave
-import soundfile as sf
-from scipy.io import wavfile
-from datetime import datetime
-from urllib.parse import urlparse
-from mega import Mega
-
-now_dir = os.getcwd()
-tmp = os.path.join(now_dir, "TEMP")
-shutil.rmtree(tmp, ignore_errors=True)
-os.makedirs(tmp, exist_ok=True)
-os.environ["TEMP"] = tmp
-from lib.infer_pack.models import (
- SynthesizerTrnMs256NSFsid,
- SynthesizerTrnMs256NSFsid_nono,
- SynthesizerTrnMs768NSFsid,
- SynthesizerTrnMs768NSFsid_nono,
-)
-from fairseq import checkpoint_utils
-from vc_infer_pipeline import VC
-from config import Config
-config = Config()
-
-tts_voice_list = asyncio.get_event_loop().run_until_complete(edge_tts.list_voices())
-voices = [f"{v['ShortName']}-{v['Gender']}" for v in tts_voice_list]
-
-hubert_model = None
-
-f0method_mode = ["pm", "harvest", "crepe"]
-f0method_info = "PM is fast, Harvest is good but extremely slow, and Crepe effect is good but requires GPU (Default: PM)"
-
-if os.path.isfile("rmvpe.pt"):
- f0method_mode.insert(2, "rmvpe")
- f0method_info = "PM is fast, Harvest is good but extremely slow, Rvmpe is alternative to harvest (might be better), and Crepe effect is good but requires GPU (Default: PM)"
-
-def load_hubert():
- global hubert_model
- models, _, _ = checkpoint_utils.load_model_ensemble_and_task(
- ["hubert_base.pt"],
- suffix="",
- )
- hubert_model = models[0]
- hubert_model = hubert_model.to(config.device)
- if config.is_half:
- hubert_model = hubert_model.half()
- else:
- hubert_model = hubert_model.float()
- hubert_model.eval()
-
-load_hubert()
-
-weight_root = "weights"
-index_root = "weights/index"
-weights_model = []
-weights_index = []
-for _, _, model_files in os.walk(weight_root):
- for file in model_files:
- if file.endswith(".pth"):
- weights_model.append(file)
-for _, _, index_files in os.walk(index_root):
- for file in index_files:
- if file.endswith('.index') and "trained" not in file:
- weights_index.append(os.path.join(index_root, file))
-
-def check_models():
- weights_model = []
- weights_index = []
- for _, _, model_files in os.walk(weight_root):
- for file in model_files:
- if file.endswith(".pth"):
- weights_model.append(file)
- for _, _, index_files in os.walk(index_root):
- for file in index_files:
- if file.endswith('.index') and "trained" not in file:
- weights_index.append(os.path.join(index_root, file))
- return (
- gr.Dropdown.update(choices=sorted(weights_model), value=weights_model[0]),
- gr.Dropdown.update(choices=sorted(weights_index))
- )
-
-def clean():
- return (
- gr.Dropdown.update(value=""),
- gr.Slider.update(visible=False)
- )
-
-def vc_single(
- sid,
- vc_audio_mode,
- input_audio_path,
- input_upload_audio,
- vocal_audio,
- tts_text,
- tts_voice,
- f0_up_key,
- f0_file,
- f0_method,
- file_index,
- index_rate,
- filter_radius,
- resample_sr,
- rms_mix_rate,
- protect
-): # spk_item, input_audio0, vc_transform0,f0_file,f0method0
- global tgt_sr, net_g, vc, hubert_model, version, cpt
- try:
- logs = []
- print(f"Converting...")
- logs.append(f"Converting...")
- yield "\n".join(logs), None
- if vc_audio_mode == "Input path" or "Youtube" and input_audio_path != "":
- audio, sr = librosa.load(input_audio_path, sr=16000, mono=True)
- elif vc_audio_mode == "Upload audio":
- selected_audio = input_upload_audio
- if vocal_audio:
- selected_audio = vocal_audio
- elif input_upload_audio:
- selected_audio = input_upload_audio
- sampling_rate, audio = selected_audio
- duration = audio.shape[0] / sampling_rate
- audio = (audio / np.iinfo(audio.dtype).max).astype(np.float32)
- if len(audio.shape) > 1:
- audio = librosa.to_mono(audio.transpose(1, 0))
- if sampling_rate != 16000:
- audio = librosa.resample(audio, orig_sr=sampling_rate, target_sr=16000)
- elif vc_audio_mode == "TTS Audio":
- if tts_text is None or tts_voice is None:
- return "You need to enter text and select a voice", None
- asyncio.run(edge_tts.Communicate(tts_text, "-".join(tts_voice.split('-')[:-1])).save("tts.mp3"))
- audio, sr = librosa.load("tts.mp3", sr=16000, mono=True)
- input_audio_path = "tts.mp3"
- f0_up_key = int(f0_up_key)
- times = [0, 0, 0]
- if hubert_model == None:
- load_hubert()
- if_f0 = cpt.get("f0", 1)
- audio_opt = vc.pipeline(
- hubert_model,
- net_g,
- sid,
- audio,
- input_audio_path,
- times,
- f0_up_key,
- f0_method,
- file_index,
- # file_big_npy,
- index_rate,
- if_f0,
- filter_radius,
- tgt_sr,
- resample_sr,
- rms_mix_rate,
- version,
- protect,
- f0_file=f0_file
- )
- if resample_sr >= 16000 and tgt_sr != resample_sr:
- tgt_sr = resample_sr
- index_info = (
- "Using index:%s." % file_index
- if os.path.exists(file_index)
- else "Index not used."
- )
- print("Success.\n %s\nTime:\n npy:%ss, f0:%ss, infer:%ss" % (
- index_info,
- times[0],
- times[1],
- times[2],
- ))
- info = f"{index_info}\n[{datetime.now().strftime('%Y-%m-%d %H:%M')}]: npy: {times[0]}, f0: {times[1]}s, infer: {times[2]}s"
- logs.append(info)
- yield "\n".join(logs), (tgt_sr, audio_opt)
- except:
- info = traceback.format_exc()
- print(info)
- logs.append(info)
- yield "\n".join(logs), None
-
-def get_vc(sid, to_return_protect0):
- global n_spk, tgt_sr, net_g, vc, cpt, version, weights_index
- if sid == "" or sid == []:
- global hubert_model
- if hubert_model is not None: # 考虑到轮询, 需要加个判断看是否 sid 是由有模型切换到无模型的
- print("clean_empty_cache")
- del net_g, n_spk, vc, hubert_model, tgt_sr # ,cpt
- hubert_model = net_g = n_spk = vc = hubert_model = tgt_sr = None
- if torch.cuda.is_available():
- torch.cuda.empty_cache()
- ###楼下不这么折腾清理不干净
- if_f0 = cpt.get("f0", 1)
- version = cpt.get("version", "v1")
- if version == "v1":
- if if_f0 == 1:
- net_g = SynthesizerTrnMs256NSFsid(
- *cpt["config"], is_half=config.is_half
- )
- else:
- net_g = SynthesizerTrnMs256NSFsid_nono(*cpt["config"])
- elif version == "v2":
- if if_f0 == 1:
- net_g = SynthesizerTrnMs768NSFsid(
- *cpt["config"], is_half=config.is_half
- )
- else:
- net_g = SynthesizerTrnMs768NSFsid_nono(*cpt["config"])
- del net_g, cpt
- if torch.cuda.is_available():
- torch.cuda.empty_cache()
- cpt = None
- return (
- gr.Slider.update(maximum=2333, visible=False),
- gr.Slider.update(visible=True),
- gr.Dropdown.update(choices=sorted(weights_index), value=""),
- gr.Markdown.update(value="# <center> No model selected")
- )
- print(f"Loading {sid} model...")
- selected_model = sid[:-4]
- cpt = torch.load(os.path.join(weight_root, sid), map_location="cpu")
- tgt_sr = cpt["config"][-1]
- cpt["config"][-3] = cpt["weight"]["emb_g.weight"].shape[0]
- if_f0 = cpt.get("f0", 1)
- if if_f0 == 0:
- to_return_protect0 = {
- "visible": False,
- "value": 0.5,
- "__type__": "update",
- }
- else:
- to_return_protect0 = {
- "visible": True,
- "value": to_return_protect0,
- "__type__": "update",
- }
- version = cpt.get("version", "v1")
- if version == "v1":
- if if_f0 == 1:
- net_g = SynthesizerTrnMs256NSFsid(*cpt["config"], is_half=config.is_half)
- else:
- net_g = SynthesizerTrnMs256NSFsid_nono(*cpt["config"])
- elif version == "v2":
- if if_f0 == 1:
- net_g = SynthesizerTrnMs768NSFsid(*cpt["config"], is_half=config.is_half)
- else:
- net_g = SynthesizerTrnMs768NSFsid_nono(*cpt["config"])
- del net_g.enc_q
- print(net_g.load_state_dict(cpt["weight"], strict=False))
- net_g.eval().to(config.device)
- if config.is_half:
- net_g = net_g.half()
- else:
- net_g = net_g.float()
- vc = VC(tgt_sr, config)
- n_spk = cpt["config"][-3]
- weights_index = []
- for _, _, index_files in os.walk(index_root):
- for file in index_files:
- if file.endswith('.index') and "trained" not in file:
- weights_index.append(os.path.join(index_root, file))
- if weights_index == []:
- selected_index = gr.Dropdown.update(value="")
- else:
- selected_index = gr.Dropdown.update(value=weights_index[0])
- for index, model_index in enumerate(weights_index):
- if selected_model in model_index:
- selected_index = gr.Dropdown.update(value=weights_index[index])
- break
- return (
- gr.Slider.update(maximum=n_spk, visible=True),
- to_return_protect0,
- selected_index,
- gr.Markdown.update(
- f'## <center> {selected_model}\n'+
- f'### <center> RVC {version} Model'
- )
- )
-
-def find_audio_files(folder_path, extensions):
- audio_files = []
- for root, dirs, files in os.walk(folder_path):
- for file in files:
- if any(file.endswith(ext) for ext in extensions):
- audio_files.append(file)
- return audio_files
-
-def vc_multi(
- spk_item,
- vc_input,
- vc_output,
- vc_transform0,
- f0method0,
- file_index,
- index_rate,
- filter_radius,
- resample_sr,
- rms_mix_rate,
- protect,
-):
- global tgt_sr, net_g, vc, hubert_model, version, cpt
- logs = []
- logs.append("Converting...")
- yield "\n".join(logs)
- print()
- try:
- if os.path.exists(vc_input):
- folder_path = vc_input
- extensions = [".mp3", ".wav", ".flac", ".ogg"]
- audio_files = find_audio_files(folder_path, extensions)
- for index, file in enumerate(audio_files, start=1):
- audio, sr = librosa.load(os.path.join(folder_path, file), sr=16000, mono=True)
- input_audio_path = folder_path, file
- f0_up_key = int(vc_transform0)
- times = [0, 0, 0]
- if hubert_model == None:
- load_hubert()
- if_f0 = cpt.get("f0", 1)
- audio_opt = vc.pipeline(
- hubert_model,
- net_g,
- spk_item,
- audio,
- input_audio_path,
- times,
- f0_up_key,
- f0method0,
- file_index,
- index_rate,
- if_f0,
- filter_radius,
- tgt_sr,
- resample_sr,
- rms_mix_rate,
- version,
- protect,
- f0_file=None
- )
- if resample_sr >= 16000 and tgt_sr != resample_sr:
- tgt_sr = resample_sr
- output_path = f"{os.path.join(vc_output, file)}"
- os.makedirs(os.path.join(vc_output), exist_ok=True)
- sf.write(
- output_path,
- audio_opt,
- tgt_sr,
- )
- info = f"{index} / {len(audio_files)} | {file}"
- print(info)
- logs.append(info)
- yield "\n".join(logs)
- else:
- logs.append("Folder not found or path doesn't exist.")
- yield "\n".join(logs)
- except:
- info = traceback.format_exc()
- print(info)
- logs.append(info)
- yield "\n".join(logs)
-
-def download_audio(url, audio_provider):
- logs = []
- os.makedirs("dl_audio", exist_ok=True)
- if url == "":
- logs.append("URL required!")
- yield None, "\n".join(logs)
- return None, "\n".join(logs)
- if audio_provider == "Youtube":
- logs.append("Downloading the audio...")
- yield None, "\n".join(logs)
- ydl_opts = {
- 'noplaylist': True,
- 'format': 'bestaudio/best',
- 'postprocessors': [{
- 'key': 'FFmpegExtractAudio',
- 'preferredcodec': 'wav',
- }],
- "outtmpl": 'result/dl_audio/audio',
- }
- audio_path = "result/dl_audio/audio.wav"
- with yt_dlp.YoutubeDL(ydl_opts) as ydl:
- ydl.download([url])
- logs.append("Download Complete.")
- yield audio_path, "\n".join(logs)
-
-def cut_vocal_and_inst_yt(split_model):
- logs = []
- logs.append("Starting the audio splitting process...")
- yield "\n".join(logs), None, None, None
- command = f"demucs --two-stems=vocals -n {split_model} result/dl_audio/audio.wav -o output"
- result = subprocess.Popen(command.split(), stdout=subprocess.PIPE, text=True)
- for line in result.stdout:
- logs.append(line)
- yield "\n".join(logs), None, None, None
- print(result.stdout)
- vocal = f"output/{split_model}/audio/vocals.wav"
- inst = f"output/{split_model}/audio/no_vocals.wav"
- logs.append("Audio splitting complete.")
- yield "\n".join(logs), vocal, inst, vocal
-
-def cut_vocal_and_inst(split_model, audio_data):
- logs = []
- vocal_path = "output/result/audio.wav"
- os.makedirs("output/result", exist_ok=True)
- wavfile.write(vocal_path, audio_data[0], audio_data[1])
- logs.append("Starting the audio splitting process...")
- yield "\n".join(logs), None, None
- command = f"demucs --two-stems=vocals -n {split_model} {vocal_path} -o output"
- result = subprocess.Popen(command.split(), stdout=subprocess.PIPE, text=True)
- for line in result.stdout:
- logs.append(line)
- yield "\n".join(logs), None, None
- print(result.stdout)
- vocal = f"output/{split_model}/audio/vocals.wav"
- inst = f"output/{split_model}/audio/no_vocals.wav"
- logs.append("Audio splitting complete.")
- yield "\n".join(logs), vocal, inst
-
-def combine_vocal_and_inst(audio_data, vocal_volume, inst_volume, split_model):
- os.makedirs("output/result", exist_ok=True)
- vocal_path = "output/result/output.wav"
- output_path = "output/result/combine.mp3"
- inst_path = f"output/{split_model}/audio/no_vocals.wav"
- wavfile.write(vocal_path, audio_data[0], audio_data[1])
- command = f'ffmpeg -y -i {inst_path} -i {vocal_path} -filter_complex [0:a]volume={inst_volume}[i];[1:a]volume={vocal_volume}[v];[i][v]amix=inputs=2:duration=longest[a] -map [a] -b:a 320k -c:a libmp3lame {output_path}'
- result = subprocess.run(command.split(), stdout=subprocess.PIPE)
- print(result.stdout.decode())
- return output_path
-
-def download_and_extract_models(urls):
- logs = []
- os.makedirs("zips", exist_ok=True)
- os.makedirs(os.path.join("zips", "extract"), exist_ok=True)
- os.makedirs(os.path.join(weight_root), exist_ok=True)
- os.makedirs(os.path.join(index_root), exist_ok=True)
- for link in urls.splitlines():
- url = link.strip()
- if not url:
- raise gr.Error("URL Required!")
- return "No URLs provided."
- model_zip = urlparse(url).path.split('/')[-2] + '.zip'
- model_zip_path = os.path.join('zips', model_zip)
- logs.append(f"Downloading...")
- yield "\n".join(logs)
- if "drive.google.com" in url:
- gdown.download(url, os.path.join("zips", "extract"), quiet=False)
- elif "mega.nz" in url:
- m = Mega()
- m.download_url(url, 'zips')
- else:
- os.system(f"wget {url} -O {model_zip_path}")
- logs.append(f"Extracting...")
- yield "\n".join(logs)
- for filename in os.listdir("zips"):
- archived_file = os.path.join("zips", filename)
- if filename.endswith(".zip"):
- shutil.unpack_archive(archived_file, os.path.join("zips", "extract"), 'zip')
- elif filename.endswith(".rar"):
- with rarfile.RarFile(archived_file, 'r') as rar:
- rar.extractall(os.path.join("zips", "extract"))
- for _, dirs, files in os.walk(os.path.join("zips", "extract")):
- logs.append(f"Searching Model and Index...")
- yield "\n".join(logs)
- model = False
- index = False
- if files:
- for file in files:
- if file.endswith(".pth"):
- basename = file[:-4]
- shutil.move(os.path.join("zips", "extract", file), os.path.join(weight_root, file))
- model = True
- if file.endswith('.index') and "trained" not in file:
- shutil.move(os.path.join("zips", "extract", file), os.path.join(index_root, file))
- index = True
- else:
- logs.append("No model in main folder.")
- yield "\n".join(logs)
- logs.append("Searching in subfolders...")
- yield "\n".join(logs)
- for sub_dir in dirs:
- for _, _, sub_files in os.walk(os.path.join("zips", "extract", sub_dir)):
- for file in sub_files:
- if file.endswith(".pth"):
- basename = file[:-4]
- shutil.move(os.path.join("zips", "extract", sub_dir, file), os.path.join(weight_root, file))
- model = True
- if file.endswith('.index') and "trained" not in file:
- shutil.move(os.path.join("zips", "extract", sub_dir, file), os.path.join(index_root, file))
- index = True
- shutil.rmtree(os.path.join("zips", "extract", sub_dir))
- if index is False:
- logs.append("Model only file, no Index file detected.")
- yield "\n".join(logs)
- logs.append("Download Completed!")
- yield "\n".join(logs)
- logs.append("Successfully download all models! Refresh your model list to load the model")
- yield "\n".join(logs)
-
-def use_microphone(microphone):
- if microphone == True:
- return gr.Audio.update(source="microphone")
- else:
- return gr.Audio.update(source="upload")
-
-def change_audio_mode(vc_audio_mode):
- if vc_audio_mode == "Input path":
- return (
- # Input & Upload
- gr.Textbox.update(visible=True),
- gr.Checkbox.update(visible=False),
- gr.Audio.update(visible=False),
- # Youtube
- gr.Dropdown.update(visible=False),
- gr.Textbox.update(visible=False),
- gr.Textbox.update(visible=False),
- gr.Button.update(visible=False),
- # Splitter
- gr.Dropdown.update(visible=True),
- gr.Textbox.update(visible=True),
- gr.Button.update(visible=True),
- gr.Button.update(visible=False),
- gr.Audio.update(visible=False),
- gr.Audio.update(visible=True),
- gr.Audio.update(visible=True),
- gr.Slider.update(visible=True),
- gr.Slider.update(visible=True),
- gr.Audio.update(visible=True),
- gr.Button.update(visible=True),
- # TTS
- gr.Textbox.update(visible=False),
- gr.Dropdown.update(visible=False)
- )
- elif vc_audio_mode == "Upload audio":
- return (
- # Input & Upload
- gr.Textbox.update(visible=False),
- gr.Checkbox.update(visible=True),
- gr.Audio.update(visible=True),
- # Youtube
- gr.Dropdown.update(visible=False),
- gr.Textbox.update(visible=False),
- gr.Textbox.update(visible=False),
- gr.Button.update(visible=False),
- # Splitter
- gr.Dropdown.update(visible=True),
- gr.Textbox.update(visible=True),
- gr.Button.update(visible=False),
- gr.Button.update(visible=True),
- gr.Audio.update(visible=False),
- gr.Audio.update(visible=True),
- gr.Audio.update(visible=True),
- gr.Slider.update(visible=True),
- gr.Slider.update(visible=True),
- gr.Audio.update(visible=True),
- gr.Button.update(visible=True),
- # TTS
- gr.Textbox.update(visible=False),
- gr.Dropdown.update(visible=False)
- )
- elif vc_audio_mode == "Youtube":
- return (
- # Input & Upload
- gr.Textbox.update(visible=False),
- gr.Checkbox.update(visible=False),
- gr.Audio.update(visible=False),
- # Youtube
- gr.Dropdown.update(visible=True),
- gr.Textbox.update(visible=True),
- gr.Textbox.update(visible=True),
- gr.Button.update(visible=True),
- # Splitter
- gr.Dropdown.update(visible=True),
- gr.Textbox.update(visible=True),
- gr.Button.update(visible=True),
- gr.Button.update(visible=False),
- gr.Audio.update(visible=True),
- gr.Audio.update(visible=True),
- gr.Audio.update(visible=True),
- gr.Slider.update(visible=True),
- gr.Slider.update(visible=True),
- gr.Audio.update(visible=True),
- gr.Button.update(visible=True),
- # TTS
- gr.Textbox.update(visible=False),
- gr.Dropdown.update(visible=False)
- )
- elif vc_audio_mode == "TTS Audio":
- return (
- # Input & Upload
- gr.Textbox.update(visible=False),
- gr.Checkbox.update(visible=False),
- gr.Audio.update(visible=False),
- # Youtube
- gr.Dropdown.update(visible=False),
- gr.Textbox.update(visible=False),
- gr.Textbox.update(visible=False),
- gr.Button.update(visible=False),
- # Splitter
- gr.Dropdown.update(visible=False),
- gr.Textbox.update(visible=False),
- gr.Button.update(visible=False),
- gr.Button.update(visible=False),
- gr.Audio.update(visible=False),
- gr.Audio.update(visible=False),
- gr.Audio.update(visible=False),
- gr.Slider.update(visible=False),
- gr.Slider.update(visible=False),
- gr.Audio.update(visible=False),
- gr.Button.update(visible=False),
- # TTS
- gr.Textbox.update(visible=True),
- gr.Dropdown.update(visible=True)
- )
-
-with gr.Blocks() as app:
- gr.Markdown(
- "# <center> Advanced RVC Inference\n"
- )
- with gr.Row():
- sid = gr.Dropdown(
- label="Weight",
- choices=sorted(weights_model),
- )
- file_index = gr.Dropdown(
- label="List of index file",
- choices=sorted(weights_index),
- interactive=True,
- )
- spk_item = gr.Slider(
- minimum=0,
- maximum=2333,
- step=1,
- label="Speaker ID",
- value=0,
- visible=False,
- interactive=True,
- )
- refresh_model = gr.Button("Refresh model list", variant="primary")
- clean_button = gr.Button("Clear Model from memory", variant="primary")
- refresh_model.click(
- fn=check_models, inputs=[], outputs=[sid, file_index]
- )
- clean_button.click(fn=clean, inputs=[], outputs=[sid, spk_item])
- with gr.TabItem("Inference"):
- selected_model = gr.Markdown(value="# <center> No model selected")
- with gr.Row():
- with gr.Column():
- vc_audio_mode = gr.Dropdown(label="Input voice", choices=["Input path", "Upload audio", "Youtube", "TTS Audio"], allow_custom_value=False, value="Upload audio")
- # Input
- vc_input = gr.Textbox(label="Input audio path", visible=False)
- # Upload
- vc_microphone_mode = gr.Checkbox(label="Use Microphone", value=False, visible=True, interactive=True)
- vc_upload = gr.Audio(label="Upload audio file", source="upload", visible=True, interactive=True)
- # Youtube
- vc_download_audio = gr.Dropdown(label="Provider", choices=["Youtube"], allow_custom_value=False, visible=False, value="Youtube", info="Select provider (Default: Youtube)")
- vc_link = gr.Textbox(label="Youtube URL", visible=False, info="Example: https://www.youtube.com/watch?v=Nc0sB1Bmf-A", placeholder="https://www.youtube.com/watch?v=...")
- vc_log_yt = gr.Textbox(label="Output Information", visible=False, interactive=False)
- vc_download_button = gr.Button("Download Audio", variant="primary", visible=False)
- vc_audio_preview = gr.Audio(label="Downloaded Audio Preview", visible=False)
- # TTS
- tts_text = gr.Textbox(label="TTS text", info="Text to speech input", visible=False)
- tts_voice = gr.Dropdown(label="Edge-tts speaker", choices=voices, visible=False, allow_custom_value=False, value="en-US-AnaNeural-Female")
- # Splitter
- vc_split_model = gr.Dropdown(label="Splitter Model", choices=["hdemucs_mmi", "htdemucs", "htdemucs_ft", "mdx", "mdx_q", "mdx_extra_q"], allow_custom_value=False, visible=True, value="htdemucs", info="Select the splitter model (Default: htdemucs)")
- vc_split_log = gr.Textbox(label="Output Information", visible=True, interactive=False)
- vc_split_yt = gr.Button("Split Audio", variant="primary", visible=False)
- vc_split = gr.Button("Split Audio", variant="primary", visible=True)
- vc_vocal_preview = gr.Audio(label="Vocal Preview", interactive=False, visible=True)
- vc_inst_preview = gr.Audio(label="Instrumental Preview", interactive=False, visible=True)
- with gr.Column():
- vc_transform0 = gr.Number(
- label="Transpose",
- info='Type "12" to change from male to female convertion or Type "-12" to change female to male convertion.',
- value=0
- )
- f0method0 = gr.Radio(
- label="Pitch extraction algorithm",
- info=f0method_info,
- choices=f0method_mode,
- value="pm",
- interactive=True,
- )
- index_rate0 = gr.Slider(
- minimum=0,
- maximum=1,
- label="Retrieval feature ratio",
- value=0.7,
- interactive=True,
- )
- filter_radius0 = gr.Slider(
- minimum=0,
- maximum=7,
- label="Apply Median Filtering",
- info="The value represents the filter radius and can reduce breathiness.",
- value=3,
- step=1,
- interactive=True,
- )
- resample_sr0 = gr.Slider(
- minimum=0,
- maximum=48000,
- label="Resample the output audio",
- info="Resample the output audio in post-processing to the final sample rate. Set to 0 for no resampling",
- value=0,
- step=1,
- interactive=True,
- )
- rms_mix_rate0 = gr.Slider(
- minimum=0,
- maximum=1,
- label="Volume Envelope",
- info="Use the volume envelope of the input to replace or mix with the volume envelope of the output. The closer the ratio is to 1, the more the output envelope is used",
- value=1,
- interactive=True,
- )
- protect0 = gr.Slider(
- minimum=0,
- maximum=0.5,
- label="Voice Protection",
- info="Protect voiceless consonants and breath sounds to prevent artifacts such as tearing in electronic music. Set to 0.5 to disable. Decrease the value to increase protection, but it may reduce indexing accuracy",
- value=0.5,
- step=0.01,
- interactive=True,
- )
- f0_file0 = gr.File(
- label="F0 curve file (Optional)",
- info="One pitch per line, Replace the default F0 and pitch modulation"
- )
- with gr.Column():
- vc_log = gr.Textbox(label="Output Information", interactive=False)
- vc_output = gr.Audio(label="Output Audio", interactive=False)
- vc_convert = gr.Button("Convert", variant="primary")
- vc_vocal_volume = gr.Slider(
- minimum=0,
- maximum=10,
- label="Vocal volume",
- value=1,
- interactive=True,
- step=1,
- info="Adjust vocal volume (Default: 1}",
- visible=True
- )
- vc_inst_volume = gr.Slider(
- minimum=0,
- maximum=10,
- label="Instrument volume",
- value=1,
- interactive=True,
- step=1,
- info="Adjust instrument volume (Default: 1}",
- visible=True
- )
- vc_combined_output = gr.Audio(label="Output Combined Audio", visible=True)
- vc_combine = gr.Button("Combine",variant="primary", visible=True)
- vc_convert.click(
- vc_single,
- [
- spk_item,
- vc_audio_mode,
- vc_input,
- vc_upload,
- vc_vocal_preview,
- tts_text,
- tts_voice,
- vc_transform0,
- f0_file0,
- f0method0,
- file_index,
- index_rate0,
- filter_radius0,
- resample_sr0,
- rms_mix_rate0,
- protect0,
- ],
- [vc_log, vc_output],
- )
- vc_download_button.click(
- fn=download_audio,
- inputs=[vc_link, vc_download_audio],
- outputs=[vc_audio_preview, vc_log_yt]
- )
- vc_split_yt.click(
- fn=cut_vocal_and_inst_yt,
- inputs=[vc_split_model],
- outputs=[vc_split_log, vc_vocal_preview, vc_inst_preview, vc_input]
- )
- vc_split.click(
- fn=cut_vocal_and_inst,
- inputs=[vc_split_model, vc_upload],
- outputs=[vc_split_log, vc_vocal_preview, vc_inst_preview]
- )
- vc_combine.click(
- fn=combine_vocal_and_inst,
- inputs=[vc_output, vc_vocal_volume, vc_inst_volume, vc_split_model],
- outputs=[vc_combined_output]
- )
- vc_microphone_mode.change(
- fn=use_microphone,
- inputs=vc_microphone_mode,
- outputs=vc_upload
- )
- vc_audio_mode.change(
- fn=change_audio_mode,
- inputs=[vc_audio_mode],
- outputs=[
- # Input & Upload
- vc_input,
- vc_microphone_mode,
- vc_upload,
- # Youtube
- vc_download_audio,
- vc_link,
- vc_log_yt,
- vc_download_button,
- # Splitter
- vc_split_model,
- vc_split_log,
- vc_split_yt,
- vc_split,
- vc_audio_preview,
- vc_vocal_preview,
- vc_inst_preview,
- vc_vocal_volume,
- vc_inst_volume,
- vc_combined_output,
- vc_combine,
- # TTS
- tts_text,
- tts_voice
- ]
- )
- sid.change(fn=get_vc, inputs=[sid, protect0], outputs=[spk_item, protect0, file_index, selected_model])
- with gr.TabItem("Batch Inference"):
- with gr.Row():
- with gr.Column():
- vc_input_bat = gr.Textbox(label="Input audio path (folder)", visible=True)
- vc_output_bat = gr.Textbox(label="Output audio path (folder)", value="result/batch", visible=True)
- with gr.Column():
- vc_transform0_bat = gr.Number(
- label="Transpose",
- info='Type "12" to change from male to female convertion or Type "-12" to change female to male convertion.',
- value=0
- )
- f0method0_bat = gr.Radio(
- label="Pitch extraction algorithm",
- info=f0method_info,
- choices=f0method_mode,
- value="pm",
- interactive=True,
- )
- index_rate0_bat = gr.Slider(
- minimum=0,
- maximum=1,
- label="Retrieval feature ratio",
- value=0.7,
- interactive=True,
- )
- filter_radius0_bat = gr.Slider(
- minimum=0,
- maximum=7,
- label="Apply Median Filtering",
- info="The value represents the filter radius and can reduce breathiness.",
- value=3,
- step=1,
- interactive=True,
- )
- resample_sr0_bat = gr.Slider(
- minimum=0,
- maximum=48000,
- label="Resample the output audio",
- info="Resample the output audio in post-processing to the final sample rate. Set to 0 for no resampling",
- value=0,
- step=1,
- interactive=True,
- )
- rms_mix_rate0_bat = gr.Slider(
- minimum=0,
- maximum=1,
- label="Volume Envelope",
- info="Use the volume envelope of the input to replace or mix with the volume envelope of the output. The closer the ratio is to 1, the more the output envelope is used",
- value=1,
- interactive=True,
- )
- protect0_bat = gr.Slider(
- minimum=0,
- maximum=0.5,
- label="Voice Protection",
- info="Protect voiceless consonants and breath sounds to prevent artifacts such as tearing in electronic music. Set to 0.5 to disable. Decrease the value to increase protection, but it may reduce indexing accuracy",
- value=0.5,
- step=0.01,
- interactive=True,
- )
- with gr.Column():
- vc_log_bat = gr.Textbox(label="Output Information", interactive=False)
- vc_convert_bat = gr.Button("Convert", variant="primary")
- vc_convert_bat.click(
- vc_multi,
- [
- spk_item,
- vc_input_bat,
- vc_output_bat,
- vc_transform0_bat,
- f0method0_bat,
- file_index,
- index_rate0_bat,
- filter_radius0_bat,
- resample_sr0_bat,
- rms_mix_rate0_bat,
- protect0_bat,
- ],
- [vc_log_bat],
- )
- with gr.TabItem("Model Downloader"):
- gr.Markdown(
- "# <center> Model Downloader (Beta)\n"+
- "#### <center> To download multi link you have to put your link to the textbox and every link separated by space\n"+
- "#### <center> Support Direct Link, Mega, Google Drive, etc"
- )
- with gr.Column():
- md_text = gr.Textbox(label="URL")
- with gr.Row():
- md_download = gr.Button(label="Convert", variant="primary")
- md_download_logs = gr.Textbox(label="Output information", interactive=False)
- md_download.click(
- fn=download_and_extract_models,
- inputs=[md_text],
- outputs=[md_download_logs]
- )
- with gr.TabItem("Settings"):
- gr.Markdown(
- "# <center> Settings\n"+
- "#### <center> Work in progress"
- )
- app.queue(concurrency_count=1, max_size=50, api_open=config.api).launch(share=config.colab)
\ No newline at end of file
diff --git a/spaces/Legal-ease/legal-ease/README.md b/spaces/Legal-ease/legal-ease/README.md
deleted file mode 100644
index 2c6723456406729b298d525047bf5b65f4b8af5d..0000000000000000000000000000000000000000
--- a/spaces/Legal-ease/legal-ease/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Legal Ease
-emoji: 🏢
-colorFrom: pink
-colorTo: red
-sdk: gradio
-sdk_version: 3.24.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/Loren/Streamlit_OCR_comparator/configs/_base_/recog_datasets/ST_SA_MJ_real_train.py b/spaces/Loren/Streamlit_OCR_comparator/configs/_base_/recog_datasets/ST_SA_MJ_real_train.py
deleted file mode 100644
index 87dab3352d92c3105684908f50b9b8f6bcc71a16..0000000000000000000000000000000000000000
--- a/spaces/Loren/Streamlit_OCR_comparator/configs/_base_/recog_datasets/ST_SA_MJ_real_train.py
+++ /dev/null
@@ -1,81 +0,0 @@
-# Text Recognition Training set, including:
-# Synthetic Datasets: SynthText, SynthAdd, Syn90k
-# Real Dataset: IC11, IC13, IC15, COCO-Test, IIIT5k
-
-train_prefix = 'data/mixture'
-
-train_img_prefix1 = f'{train_prefix}/icdar_2011'
-train_img_prefix2 = f'{train_prefix}/icdar_2013'
-train_img_prefix3 = f'{train_prefix}/icdar_2015'
-train_img_prefix4 = f'{train_prefix}/coco_text'
-train_img_prefix5 = f'{train_prefix}/IIIT5K'
-train_img_prefix6 = f'{train_prefix}/SynthText_Add'
-train_img_prefix7 = f'{train_prefix}/SynthText'
-train_img_prefix8 = f'{train_prefix}/Syn90k'
-
-train_ann_file1 = f'{train_prefix}/icdar_2011/train_label.txt',
-train_ann_file2 = f'{train_prefix}/icdar_2013/train_label.txt',
-train_ann_file3 = f'{train_prefix}/icdar_2015/train_label.txt',
-train_ann_file4 = f'{train_prefix}/coco_text/train_label.txt',
-train_ann_file5 = f'{train_prefix}/IIIT5K/train_label.txt',
-train_ann_file6 = f'{train_prefix}/SynthText_Add/label.txt',
-train_ann_file7 = f'{train_prefix}/SynthText/shuffle_labels.txt',
-train_ann_file8 = f'{train_prefix}/Syn90k/shuffle_labels.txt'
-
-train1 = dict(
- type='OCRDataset',
- img_prefix=train_img_prefix1,
- ann_file=train_ann_file1,
- loader=dict(
- type='AnnFileLoader',
- repeat=20,
- file_format='txt',
- parser=dict(
- type='LineStrParser',
- keys=['filename', 'text'],
- keys_idx=[0, 1],
- separator=' ')),
- pipeline=None,
- test_mode=False)
-
-train2 = {key: value for key, value in train1.items()}
-train2['img_prefix'] = train_img_prefix2
-train2['ann_file'] = train_ann_file2
-
-train3 = {key: value for key, value in train1.items()}
-train3['img_prefix'] = train_img_prefix3
-train3['ann_file'] = train_ann_file3
-
-train4 = {key: value for key, value in train1.items()}
-train4['img_prefix'] = train_img_prefix4
-train4['ann_file'] = train_ann_file4
-
-train5 = {key: value for key, value in train1.items()}
-train5['img_prefix'] = train_img_prefix5
-train5['ann_file'] = train_ann_file5
-
-train6 = dict(
- type='OCRDataset',
- img_prefix=train_img_prefix6,
- ann_file=train_ann_file6,
- loader=dict(
- type='AnnFileLoader',
- repeat=1,
- file_format='txt',
- parser=dict(
- type='LineStrParser',
- keys=['filename', 'text'],
- keys_idx=[0, 1],
- separator=' ')),
- pipeline=None,
- test_mode=False)
-
-train7 = {key: value for key, value in train6.items()}
-train7['img_prefix'] = train_img_prefix7
-train7['ann_file'] = train_ann_file7
-
-train8 = {key: value for key, value in train6.items()}
-train8['img_prefix'] = train_img_prefix8
-train8['ann_file'] = train_ann_file8
-
-train_list = [train1, train2, train3, train4, train5, train6, train7, train8]
diff --git a/spaces/Loren/Streamlit_OCR_comparator/configs/textdet/panet/panet_r18_fpem_ffm_600e_icdar2015.py b/spaces/Loren/Streamlit_OCR_comparator/configs/textdet/panet/panet_r18_fpem_ffm_600e_icdar2015.py
deleted file mode 100644
index 1183974024cf33d814f635ddb1454895fbd3c02c..0000000000000000000000000000000000000000
--- a/spaces/Loren/Streamlit_OCR_comparator/configs/textdet/panet/panet_r18_fpem_ffm_600e_icdar2015.py
+++ /dev/null
@@ -1,35 +0,0 @@
-_base_ = [
- '../../_base_/default_runtime.py',
- '../../_base_/schedules/schedule_adam_600e.py',
- '../../_base_/det_models/panet_r18_fpem_ffm.py',
- '../../_base_/det_datasets/icdar2015.py',
- '../../_base_/det_pipelines/panet_pipeline.py'
-]
-
-model = {{_base_.model_quad}}
-
-train_list = {{_base_.train_list}}
-test_list = {{_base_.test_list}}
-
-train_pipeline_icdar2015 = {{_base_.train_pipeline_icdar2015}}
-test_pipeline_icdar2015 = {{_base_.test_pipeline_icdar2015}}
-
-data = dict(
- samples_per_gpu=8,
- workers_per_gpu=2,
- val_dataloader=dict(samples_per_gpu=1),
- test_dataloader=dict(samples_per_gpu=1),
- train=dict(
- type='UniformConcatDataset',
- datasets=train_list,
- pipeline=train_pipeline_icdar2015),
- val=dict(
- type='UniformConcatDataset',
- datasets=test_list,
- pipeline=test_pipeline_icdar2015),
- test=dict(
- type='UniformConcatDataset',
- datasets=test_list,
- pipeline=test_pipeline_icdar2015))
-
-evaluation = dict(interval=10, metric='hmean-iou')
diff --git a/spaces/Luckya/MyGenAi/app.py b/spaces/Luckya/MyGenAi/app.py
deleted file mode 100644
index a362dcc7d0ddd1eee86961f1bc3db6d894fbd3d5..0000000000000000000000000000000000000000
--- a/spaces/Luckya/MyGenAi/app.py
+++ /dev/null
@@ -1,34 +0,0 @@
-import os
-import gradio as gr
-from langchain.chat_models import ChatOpenAI
-from langchain import LLMChain, PromptTemplate
-from langchain.memory import ConversationBufferMemory
-
-OPENAI_API_KEY=os.getenv('OPENAI_API_KEY')
-
-template = """You are a helpful assistant to answer all user queries.
-{chat_history}
-User: {user_message}
-Chatbot:"""
-
-prompt = PromptTemplate(
- input_variables=["chat_history", "user_message"], template=template
-)
-
-memory = ConversationBufferMemory(memory_key="chat_history")
-
-llm_chain = LLMChain(
- llm=ChatOpenAI(temperature='0.5', model_name="gpt-3.5-turbo"),
- prompt=prompt,
- verbose=True,
- memory=memory,
-)
-
-def get_text_response(user_message,history):
- response = llm_chain.predict(user_message = user_message)
- return response
-
-demo = gr.ChatInterface(get_text_response)
-
-if __name__ == "__main__":
- demo.launch() #To create a public link, set `share=True` in `launch()`. To enable errors and logs, set `debug=True` in `launch()`.
diff --git a/spaces/Mahiruoshi/MyGO_VIts-bert/text/japanese_bert.py b/spaces/Mahiruoshi/MyGO_VIts-bert/text/japanese_bert.py
deleted file mode 100644
index 5dd196483da4355746383253879190ce538b9df9..0000000000000000000000000000000000000000
--- a/spaces/Mahiruoshi/MyGO_VIts-bert/text/japanese_bert.py
+++ /dev/null
@@ -1,38 +0,0 @@
-import torch
-from transformers import AutoTokenizer, AutoModelForMaskedLM
-import sys
-
-tokenizer = AutoTokenizer.from_pretrained("./bert/bert-base-japanese-v3")
-
-models = dict()
-
-
-def get_bert_feature(text, word2ph, device=None):
- if (
- sys.platform == "darwin"
- and torch.backends.mps.is_available()
- and device == "cpu"
- ):
- device = "mps"
- if not device:
- device = "cuda"
- if device not in models.keys():
- models[device] = AutoModelForMaskedLM.from_pretrained(
- "./bert/bert-base-japanese-v3"
- ).to(device)
- with torch.no_grad():
- inputs = tokenizer(text, return_tensors="pt")
- for i in inputs:
- inputs[i] = inputs[i].to(device)
- res = models[device](**inputs, output_hidden_states=True)
- res = torch.cat(res["hidden_states"][-3:-2], -1)[0].cpu()
- assert inputs["input_ids"].shape[-1] == len(word2ph)
- word2phone = word2ph
- phone_level_feature = []
- for i in range(len(word2phone)):
- repeat_feature = res[i].repeat(word2phone[i], 1)
- phone_level_feature.append(repeat_feature)
-
- phone_level_feature = torch.cat(phone_level_feature, dim=0)
-
- return phone_level_feature.T
diff --git a/spaces/Marshalls/testmtd/analysis/pymo/preprocessing.py b/spaces/Marshalls/testmtd/analysis/pymo/preprocessing.py
deleted file mode 100644
index f752ece6e85caf219e8dd6811d61d6fb7c6cb0b6..0000000000000000000000000000000000000000
--- a/spaces/Marshalls/testmtd/analysis/pymo/preprocessing.py
+++ /dev/null
@@ -1,1330 +0,0 @@
-'''
-Preprocessing Tranformers Based on sci-kit's API
-
-By Omid Alemi
-Created on June 12, 2017
-'''
-import copy
-import pandas as pd
-import numpy as np
-import transforms3d as t3d
-import scipy.ndimage.filters as filters
-
-from sklearn.base import BaseEstimator, TransformerMixin
-
-from analysis.pymo.rotation_tools import Rotation, euler2expmap, euler2expmap2, expmap2euler, euler_reorder, unroll
-from analysis.pymo.Quaternions import Quaternions
-from analysis.pymo.Pivots import Pivots
-
-class MocapParameterizer(BaseEstimator, TransformerMixin):
- def __init__(self, param_type = 'euler'):
- '''
-
- param_type = {'euler', 'quat', 'expmap', 'position', 'expmap2pos'}
- '''
- self.param_type = param_type
-
- def fit(self, X, y=None):
- return self
-
- def transform(self, X, y=None):
- print("MocapParameterizer: " + self.param_type)
- if self.param_type == 'euler':
- return X
- elif self.param_type == 'expmap':
- return self._to_expmap(X)
- elif self.param_type == 'quat':
- return X
- elif self.param_type == 'position':
- return self._to_pos(X)
- elif self.param_type == 'expmap2pos':
- return self._expmap_to_pos(X)
- else:
- raise 'param types: euler, quat, expmap, position, expmap2pos'
-
-# return X
-
- def inverse_transform(self, X, copy=None):
- if self.param_type == 'euler':
- return X
- elif self.param_type == 'expmap':
- return self._expmap_to_euler(X)
- elif self.param_type == 'quat':
- raise 'quat2euler is not supported'
- elif self.param_type == 'position':
- # raise 'positions 2 eulers is not supported'
- print('positions 2 eulers is not supported')
- return X
- else:
- raise 'param types: euler, quat, expmap, position'
-
- def _to_pos(self, X):
- '''Converts joints rotations in Euler angles to joint positions'''
-
- Q = []
- for track in X:
- channels = []
- titles = []
- euler_df = track.values
-
- # Create a new DataFrame to store the exponential map rep
- pos_df = pd.DataFrame(index=euler_df.index)
-
- # Copy the root rotations into the new DataFrame
- # rxp = '%s_Xrotation'%track.root_name
- # ryp = '%s_Yrotation'%track.root_name
- # rzp = '%s_Zrotation'%track.root_name
- # pos_df[rxp] = pd.Series(data=euler_df[rxp], index=pos_df.index)
- # pos_df[ryp] = pd.Series(data=euler_df[ryp], index=pos_df.index)
- # pos_df[rzp] = pd.Series(data=euler_df[rzp], index=pos_df.index)
-
- # List the columns that contain rotation channels
- rot_cols = [c for c in euler_df.columns if ('rotation' in c)]
-
- # List the columns that contain position channels
- pos_cols = [c for c in euler_df.columns if ('position' in c)]
-
- # List the joints that are not end sites, i.e., have channels
- joints = (joint for joint in track.skeleton)
-
- tree_data = {}
-
- for joint in track.traverse():
- parent = track.skeleton[joint]['parent']
- rot_order = track.skeleton[joint]['order']
- #print("rot_order:" + joint + " :" + rot_order)
-
- # Get the rotation columns that belong to this joint
- rc = euler_df[[c for c in rot_cols if joint in c]]
-
- # Get the position columns that belong to this joint
- pc = euler_df[[c for c in pos_cols if joint in c]]
-
- # Make sure the columns are organized in xyz order
- if rc.shape[1] < 3:
- euler_values = np.zeros((euler_df.shape[0], 3))
- rot_order = "XYZ"
- else:
- euler_values = np.pi/180.0*np.transpose(np.array([track.values['%s_%srotation'%(joint, rot_order[0])], track.values['%s_%srotation'%(joint, rot_order[1])], track.values['%s_%srotation'%(joint, rot_order[2])]]))
-
- if pc.shape[1] < 3:
- pos_values = np.asarray([[0,0,0] for f in pc.iterrows()])
- else:
- pos_values =np.asarray([[f[1]['%s_Xposition'%joint],
- f[1]['%s_Yposition'%joint],
- f[1]['%s_Zposition'%joint]] for f in pc.iterrows()])
-
- quats = Quaternions.from_euler(np.asarray(euler_values), order=rot_order.lower(), world=False)
-
- tree_data[joint]=[
- [], # to store the rotation matrix
- [] # to store the calculated position
- ]
- if track.root_name == joint:
- tree_data[joint][0] = quats#rotmats
- # tree_data[joint][1] = np.add(pos_values, track.skeleton[joint]['offsets'])
- tree_data[joint][1] = pos_values
- else:
- # for every frame i, multiply this joint's rotmat to the rotmat of its parent
- tree_data[joint][0] = tree_data[parent][0]*quats# np.matmul(rotmats, tree_data[parent][0])
-
- # add the position channel to the offset and store it in k, for every frame i
- k = pos_values + np.asarray(track.skeleton[joint]['offsets'])
-
- # multiply k to the rotmat of the parent for every frame i
- q = tree_data[parent][0]*k #np.matmul(k.reshape(k.shape[0],1,3), tree_data[parent][0])
-
- # add q to the position of the parent, for every frame i
- tree_data[joint][1] = tree_data[parent][1] + q #q.reshape(k.shape[0],3) + tree_data[parent][1]
-
- # Create the corresponding columns in the new DataFrame
- pos_df['%s_Xposition'%joint] = pd.Series(data=[e[0] for e in tree_data[joint][1]], index=pos_df.index)
- pos_df['%s_Yposition'%joint] = pd.Series(data=[e[1] for e in tree_data[joint][1]], index=pos_df.index)
- pos_df['%s_Zposition'%joint] = pd.Series(data=[e[2] for e in tree_data[joint][1]], index=pos_df.index)
-
-
- new_track = track.clone()
- new_track.values = pos_df
- Q.append(new_track)
- return Q
-
- def _expmap2rot(self, expmap):
-
- theta = np.linalg.norm(expmap, axis=1, keepdims=True)
- nz = np.nonzero(theta)[0]
-
- expmap[nz,:] = expmap[nz,:]/theta[nz]
-
- nrows=expmap.shape[0]
- x = expmap[:,0]
- y = expmap[:,1]
- z = expmap[:,2]
-
- s = np.sin(theta*0.5).reshape(nrows)
- c = np.cos(theta*0.5).reshape(nrows)
-
- rotmats = np.zeros((nrows, 3, 3))
-
- rotmats[:,0,0] = 2*(x*x-1)*s*s+1
- rotmats[:,0,1] = 2*x*y*s*s-2*z*c*s
- rotmats[:,0,2] = 2*x*z*s*s+2*y*c*s
- rotmats[:,1,0] = 2*x*y*s*s+2*z*c*s
- rotmats[:,1,1] = 2*(y*y-1)*s*s+1
- rotmats[:,1,2] = 2*y*z*s*s-2*x*c*s
- rotmats[:,2,0] = 2*x*z*s*s-2*y*c*s
- rotmats[:,2,1] = 2*y*z*s*s+2*x*c*s
- rotmats[:,2,2] = 2*(z*z-1)*s*s+1
-
- return rotmats
-
- def _expmap_to_pos(self, X):
- '''Converts joints rotations in expmap notation to joint positions'''
-
- Q = []
- for track in X:
- channels = []
- titles = []
- exp_df = track.values
-
- # Create a new DataFrame to store the exponential map rep
- pos_df = pd.DataFrame(index=exp_df.index)
-
- # Copy the root rotations into the new DataFrame
- # rxp = '%s_Xrotation'%track.root_name
- # ryp = '%s_Yrotation'%track.root_name
- # rzp = '%s_Zrotation'%track.root_name
- # pos_df[rxp] = pd.Series(data=euler_df[rxp], index=pos_df.index)
- # pos_df[ryp] = pd.Series(data=euler_df[ryp], index=pos_df.index)
- # pos_df[rzp] = pd.Series(data=euler_df[rzp], index=pos_df.index)
-
- # List the columns that contain rotation channels
- exp_params = [c for c in exp_df.columns if ( any(p in c for p in ['alpha', 'beta','gamma']) and 'Nub' not in c)]
-
- # List the joints that are not end sites, i.e., have channels
- joints = (joint for joint in track.skeleton)
-
- tree_data = {}
-
- for joint in track.traverse():
- parent = track.skeleton[joint]['parent']
-
- if 'Nub' not in joint:
- r = exp_df[[c for c in exp_params if joint in c]] # Get the columns that belong to this joint
- expmap = r.values
- #expmap = [[f[1]['%s_alpha'%joint], f[1]['%s_beta'%joint], f[1]['%s_gamma'%joint]] for f in r.iterrows()]
- else:
- expmap = np.zeros((exp_df.shape[0], 3))
-
- # Convert the eulers to rotation matrices
- #rotmats = np.asarray([Rotation(f, 'expmap').rotmat for f in expmap])
- #angs = np.linalg.norm(expmap,axis=1, keepdims=True)
- rotmats = self._expmap2rot(expmap)
-
- tree_data[joint]=[
- [], # to store the rotation matrix
- [] # to store the calculated position
- ]
- pos_values = np.zeros((exp_df.shape[0], 3))
-
- if track.root_name == joint:
- tree_data[joint][0] = rotmats
- # tree_data[joint][1] = np.add(pos_values, track.skeleton[joint]['offsets'])
- tree_data[joint][1] = pos_values
- else:
- # for every frame i, multiply this joint's rotmat to the rotmat of its parent
- tree_data[joint][0] = np.matmul(rotmats, tree_data[parent][0])
-
- # add the position channel to the offset and store it in k, for every frame i
- k = pos_values + track.skeleton[joint]['offsets']
-
- # multiply k to the rotmat of the parent for every frame i
- q = np.matmul(k.reshape(k.shape[0],1,3), tree_data[parent][0])
-
- # add q to the position of the parent, for every frame i
- tree_data[joint][1] = q.reshape(k.shape[0],3) + tree_data[parent][1]
-
-
- # Create the corresponding columns in the new DataFrame
- pos_df['%s_Xposition'%joint] = pd.Series(data=tree_data[joint][1][:,0], index=pos_df.index)
- pos_df['%s_Yposition'%joint] = pd.Series(data=tree_data[joint][1][:,1], index=pos_df.index)
- pos_df['%s_Zposition'%joint] = pd.Series(data=tree_data[joint][1][:,2], index=pos_df.index)
-
- new_track = track.clone()
- new_track.values = pos_df
- Q.append(new_track)
- return Q
-
- def _to_expmap(self, X):
- '''Converts Euler angles to Exponential Maps'''
-
- Q = []
- for track in X:
- channels = []
- titles = []
- euler_df = track.values
-
- # Create a new DataFrame to store the exponential map rep
- exp_df = euler_df.copy()# pd.DataFrame(index=euler_df.index)
-
- # Copy the root positions into the new DataFrame
- #rxp = '%s_Xposition'%track.root_name
- #ryp = '%s_Yposition'%track.root_name
- #rzp = '%s_Zposition'%track.root_name
- #exp_df[rxp] = pd.Series(data=euler_df[rxp], index=exp_df.index)
- #exp_df[ryp] = pd.Series(data=euler_df[ryp], index=exp_df.index)
- #exp_df[rzp] = pd.Series(data=euler_df[rzp], index=exp_df.index)
-
- # List the columns that contain rotation channels
- rots = [c for c in euler_df.columns if ('rotation' in c and 'Nub' not in c)]
-
- # List the joints that are not end sites, i.e., have channels
- joints = (joint for joint in track.skeleton if 'Nub' not in joint)
-
- for joint in joints:
- #print(joint)
- r = euler_df[[c for c in rots if joint in c]] # Get the columns that belong to this joint
- rot_order = track.skeleton[joint]['order']
- r1_col = '%s_%srotation'%(joint, rot_order[0])
- r2_col = '%s_%srotation'%(joint, rot_order[1])
- r3_col = '%s_%srotation'%(joint, rot_order[2])
-
- exp_df.drop([r1_col, r2_col, r3_col], axis=1, inplace=True)
- euler = [[f[1][r1_col], f[1][r2_col], f[1][r3_col]] for f in r.iterrows()]
- #exps = [Rotation(f, 'euler', from_deg=True, order=rot_order).to_expmap() for f in euler] # Convert the eulers to exp maps
- exps = unroll(np.array([euler2expmap(f, rot_order, True) for f in euler])) # Convert the exp maps to eulers
- # exps = np.array([euler2expmap(f, rot_order, True) for f in euler]) # Convert the exp maps to eulers
- #exps = euler2expmap2(euler, rot_order, True) # Convert the eulers to exp maps
-
- # Create the corresponding columns in the new DataFrame
-
- exp_df.insert(loc=0, column='%s_gamma'%joint, value=pd.Series(data=[e[2] for e in exps], index=exp_df.index))
- exp_df.insert(loc=0, column='%s_beta'%joint, value=pd.Series(data=[e[1] for e in exps], index=exp_df.index))
- exp_df.insert(loc=0, column='%s_alpha'%joint, value=pd.Series(data=[e[0] for e in exps], index=exp_df.index))
-
- #print(exp_df.columns)
- new_track = track.clone()
- new_track.values = exp_df
- Q.append(new_track)
-
- return Q
-
- def _expmap_to_euler(self, X):
- Q = []
- for track in X:
- channels = []
- titles = []
- exp_df = track.values
-
- # Create a new DataFrame to store the exponential map rep
- #euler_df = pd.DataFrame(index=exp_df.index)
- euler_df = exp_df.copy()
-
- # Copy the root positions into the new DataFrame
- #rxp = '%s_Xposition'%track.root_name
- #ryp = '%s_Yposition'%track.root_name
- #rzp = '%s_Zposition'%track.root_name
- #euler_df[rxp] = pd.Series(data=exp_df[rxp], index=euler_df.index)
- #euler_df[ryp] = pd.Series(data=exp_df[ryp], index=euler_df.index)
- #euler_df[rzp] = pd.Series(data=exp_df[rzp], index=euler_df.index)
-
- # List the columns that contain rotation channels
- exp_params = [c for c in exp_df.columns if ( any(p in c for p in ['alpha', 'beta','gamma']) and 'Nub' not in c)]
-
- # List the joints that are not end sites, i.e., have channels
- joints = (joint for joint in track.skeleton if 'Nub' not in joint)
-
- for joint in joints:
- r = exp_df[[c for c in exp_params if joint in c]] # Get the columns that belong to this joint
-
- euler_df.drop(['%s_alpha'%joint, '%s_beta'%joint, '%s_gamma'%joint], axis=1, inplace=True)
- expmap = [[f[1]['%s_alpha'%joint], f[1]['%s_beta'%joint], f[1]['%s_gamma'%joint]] for f in r.iterrows()] # Make sure the columsn are organized in xyz order
- rot_order = track.skeleton[joint]['order']
- #euler_rots = [Rotation(f, 'expmap').to_euler(True, rot_order) for f in expmap] # Convert the exp maps to eulers
- euler_rots = [expmap2euler(f, rot_order, True) for f in expmap] # Convert the exp maps to eulers
-
- # Create the corresponding columns in the new DataFrame
-
- euler_df['%s_%srotation'%(joint, rot_order[0])] = pd.Series(data=[e[0] for e in euler_rots], index=euler_df.index)
- euler_df['%s_%srotation'%(joint, rot_order[1])] = pd.Series(data=[e[1] for e in euler_rots], index=euler_df.index)
- euler_df['%s_%srotation'%(joint, rot_order[2])] = pd.Series(data=[e[2] for e in euler_rots], index=euler_df.index)
-
- new_track = track.clone()
- new_track.values = euler_df
- Q.append(new_track)
-
- return Q
-
-class Mirror(BaseEstimator, TransformerMixin):
- def __init__(self, axis="X", append=True):
- """
- Mirrors the data
- """
- self.axis = axis
- self.append = append
-
-
- def fit(self, X, y=None):
- return self
-
- def transform(self, X, y=None):
- print("Mirror: " + self.axis)
- Q = []
-
- if self.append:
- for track in X:
- Q.append(track)
-
- for track in X:
- channels = []
- titles = []
-
- if self.axis == "X":
- signs = np.array([1,-1,-1])
- if self.axis == "Y":
- signs = np.array([-1,1,-1])
- if self.axis == "Z":
- signs = np.array([-1,-1,1])
-
- euler_df = track.values
-
- # Create a new DataFrame to store the exponential map rep
- new_df = pd.DataFrame(index=euler_df.index)
-
- # Copy the root positions into the new DataFrame
- rxp = '%s_Xposition'%track.root_name
- ryp = '%s_Yposition'%track.root_name
- rzp = '%s_Zposition'%track.root_name
- new_df[rxp] = pd.Series(data=-signs[0]*euler_df[rxp], index=new_df.index)
- new_df[ryp] = pd.Series(data=-signs[1]*euler_df[ryp], index=new_df.index)
- new_df[rzp] = pd.Series(data=-signs[2]*euler_df[rzp], index=new_df.index)
-
- # List the columns that contain rotation channels
- rots = [c for c in euler_df.columns if ('rotation' in c and 'Nub' not in c)]
- #lft_rots = [c for c in euler_df.columns if ('Left' in c and 'rotation' in c and 'Nub' not in c)]
- #rgt_rots = [c for c in euler_df.columns if ('Right' in c and 'rotation' in c and 'Nub' not in c)]
- lft_joints = (joint for joint in track.skeleton if 'Left' in joint and 'Nub' not in joint)
- rgt_joints = (joint for joint in track.skeleton if 'Right' in joint and 'Nub' not in joint)
-
- new_track = track.clone()
-
- for lft_joint in lft_joints:
- #lr = euler_df[[c for c in rots if lft_joint + "_" in c]]
- #rot_order = track.skeleton[lft_joint]['order']
- #lft_eulers = [[f[1]['%s_Xrotation'%lft_joint], f[1]['%s_Yrotation'%lft_joint], f[1]['%s_Zrotation'%lft_joint]] for f in lr.iterrows()]
-
- rgt_joint = lft_joint.replace('Left', 'Right')
- #rr = euler_df[[c for c in rots if rgt_joint + "_" in c]]
- #rot_order = track.skeleton[rgt_joint]['order']
-# rgt_eulers = [[f[1]['%s_Xrotation'%rgt_joint], f[1]['%s_Yrotation'%rgt_joint], f[1]['%s_Zrotation'%rgt_joint]] for f in rr.iterrows()]
-
- # Create the corresponding columns in the new DataFrame
-
- new_df['%s_Xrotation'%lft_joint] = pd.Series(data=signs[0]*track.values['%s_Xrotation'%rgt_joint], index=new_df.index)
- new_df['%s_Yrotation'%lft_joint] = pd.Series(data=signs[1]*track.values['%s_Yrotation'%rgt_joint], index=new_df.index)
- new_df['%s_Zrotation'%lft_joint] = pd.Series(data=signs[2]*track.values['%s_Zrotation'%rgt_joint], index=new_df.index)
-
- new_df['%s_Xrotation'%rgt_joint] = pd.Series(data=signs[0]*track.values['%s_Xrotation'%lft_joint], index=new_df.index)
- new_df['%s_Yrotation'%rgt_joint] = pd.Series(data=signs[1]*track.values['%s_Yrotation'%lft_joint], index=new_df.index)
- new_df['%s_Zrotation'%rgt_joint] = pd.Series(data=signs[2]*track.values['%s_Zrotation'%lft_joint], index=new_df.index)
-
- # List the joints that are not left or right, i.e. are on the trunk
- joints = (joint for joint in track.skeleton if 'Nub' not in joint and 'Left' not in joint and 'Right' not in joint)
-
- for joint in joints:
- #r = euler_df[[c for c in rots if joint in c]] # Get the columns that belong to this joint
- #rot_order = track.skeleton[joint]['order']
-
- #eulers = [[f[1]['%s_Xrotation'%joint], f[1]['%s_Yrotation'%joint], f[1]['%s_Zrotation'%joint]] for f in r.iterrows()]
-
- # Create the corresponding columns in the new DataFrame
- new_df['%s_Xrotation'%joint] = pd.Series(data=signs[0]*track.values['%s_Xrotation'%joint], index=new_df.index)
- new_df['%s_Yrotation'%joint] = pd.Series(data=signs[1]*track.values['%s_Yrotation'%joint], index=new_df.index)
- new_df['%s_Zrotation'%joint] = pd.Series(data=signs[2]*track.values['%s_Zrotation'%joint], index=new_df.index)
-
- new_track.values = new_df
- Q.append(new_track)
-
- return Q
-
- def inverse_transform(self, X, copy=None, start_pos=None):
- return X
-
-class EulerReorder(BaseEstimator, TransformerMixin):
- def __init__(self, new_order):
- """
- Add a
- """
- self.new_order = new_order
-
-
- def fit(self, X, y=None):
- self.orig_skeleton = copy.deepcopy(X[0].skeleton)
- print(self.orig_skeleton)
- return self
-
- def transform(self, X, y=None):
- Q = []
-
- for track in X:
- channels = []
- titles = []
- euler_df = track.values
-
- # Create a new DataFrame to store the exponential map rep
- new_df = pd.DataFrame(index=euler_df.index)
-
- # Copy the root positions into the new DataFrame
- rxp = '%s_Xposition'%track.root_name
- ryp = '%s_Yposition'%track.root_name
- rzp = '%s_Zposition'%track.root_name
- new_df[rxp] = pd.Series(data=euler_df[rxp], index=new_df.index)
- new_df[ryp] = pd.Series(data=euler_df[ryp], index=new_df.index)
- new_df[rzp] = pd.Series(data=euler_df[rzp], index=new_df.index)
-
- # List the columns that contain rotation channels
- rots = [c for c in euler_df.columns if ('rotation' in c and 'Nub' not in c)]
-
- # List the joints that are not end sites, i.e., have channels
- joints = (joint for joint in track.skeleton if 'Nub' not in joint)
-
- new_track = track.clone()
- for joint in joints:
- r = euler_df[[c for c in rots if joint in c]] # Get the columns that belong to this joint
- rot_order = track.skeleton[joint]['order']
-
- euler = [[f[1]['%s_Xrotation'%(joint)], f[1]['%s_Yrotation'%(joint)], f[1]['%s_Zrotation'%(joint)]] for f in r.iterrows()]
- new_euler = [euler_reorder(f, rot_order, self.new_order, True) for f in euler]
- #new_euler = euler_reorder2(np.array(euler), rot_order, self.new_order, True)
-
- # Create the corresponding columns in the new DataFrame
- new_df['%s_%srotation'%(joint, self.new_order[0])] = pd.Series(data=[e[0] for e in new_euler], index=new_df.index)
- new_df['%s_%srotation'%(joint, self.new_order[1])] = pd.Series(data=[e[1] for e in new_euler], index=new_df.index)
- new_df['%s_%srotation'%(joint, self.new_order[2])] = pd.Series(data=[e[2] for e in new_euler], index=new_df.index)
-
- new_track.skeleton[joint]['order'] = self.new_order
-
- new_track.values = new_df
- Q.append(new_track)
-
- return Q
-
- def inverse_transform(self, X, copy=None, start_pos=None):
- return X
-# Q = []
-#
-# for track in X:
-# channels = []
-# titles = []
-# euler_df = track.values
-#
-# # Create a new DataFrame to store the exponential map rep
-# new_df = pd.DataFrame(index=euler_df.index)
-#
-# # Copy the root positions into the new DataFrame
-# rxp = '%s_Xposition'%track.root_name
-# ryp = '%s_Yposition'%track.root_name
-# rzp = '%s_Zposition'%track.root_name
-# new_df[rxp] = pd.Series(data=euler_df[rxp], index=new_df.index)
-# new_df[ryp] = pd.Series(data=euler_df[ryp], index=new_df.index)
-# new_df[rzp] = pd.Series(data=euler_df[rzp], index=new_df.index)
-#
-# # List the columns that contain rotation channels
-# rots = [c for c in euler_df.columns if ('rotation' in c and 'Nub' not in c)]
-#
-# # List the joints that are not end sites, i.e., have channels
-# joints = (joint for joint in track.skeleton if 'Nub' not in joint)
-#
-# new_track = track.clone()
-# for joint in joints:
-# r = euler_df[[c for c in rots if joint in c]] # Get the columns that belong to this joint
-# rot_order = track.skeleton[joint]['order']
-# new_order = self.orig_skeleton[joint]['order']
-# print("rot_order:" + str(rot_order))
-# print("new_order:" + str(new_order))
-#
-# euler = [[f[1]['%s_%srotation'%(joint, rot_order[0])], f[1]['%s_%srotation'%(joint, rot_order[1])], f[1]['%s_%srotation'%(joint, rot_order[2])]] for f in r.iterrows()]
-# #new_euler = [euler_reorder(f, rot_order, new_order, True) for f in euler]
-# new_euler = euler_reorder2(np.array(euler), rot_order, self.new_order, True)
-#
-# # Create the corresponding columns in the new DataFrame
-# new_df['%s_%srotation'%(joint, new_order[0])] = pd.Series(data=[e[0] for e in new_euler], index=new_df.index)
-# new_df['%s_%srotation'%(joint, new_order[1])] = pd.Series(data=[e[1] for e in new_euler], index=new_df.index)
-# new_df['%s_%srotation'%(joint, new_order[2])] = pd.Series(data=[e[2] for e in new_euler], index=new_df.index)
-#
-# new_track.skeleton[joint]['order'] = new_order
-#
-# new_track.values = new_df
-# Q.append(new_track)
-# return Q
-
-class JointSelector(BaseEstimator, TransformerMixin):
- '''
- Allows for filtering the mocap data to include only the selected joints
- '''
- def __init__(self, joints, include_root=False):
- self.joints = joints
- self.include_root = include_root
-
- def fit(self, X, y=None):
- selected_joints = []
- selected_channels = []
-
- if self.include_root:
- selected_joints.append(X[0].root_name)
-
- selected_joints.extend(self.joints)
-
- for joint_name in selected_joints:
- selected_channels.extend([o for o in X[0].values.columns if (joint_name + "_") in o and 'Nub' not in o])
-
- self.selected_joints = selected_joints
- self.selected_channels = selected_channels
- self.not_selected = X[0].values.columns.difference(selected_channels)
- self.not_selected_values = {c:X[0].values[c].values[0] for c in self.not_selected}
-
- self.orig_skeleton = X[0].skeleton
- return self
-
- def transform(self, X, y=None):
- print("JointSelector")
- Q = []
- for track in X:
- t2 = track.clone()
- for key in track.skeleton.keys():
- if key not in self.selected_joints:
- parent = t2.skeleton[key]['parent']
- if parent in t2.skeleton:
- t2.skeleton[parent]['children'].remove(key)
- t2.skeleton.pop(key)
- t2.values = track.values[self.selected_channels]
-
- Q.append(t2)
-
-
- return Q
-
- def inverse_transform(self, X, copy=None):
- Q = []
-
- for track in X:
- t2 = track.clone()
- t2.skeleton = self.orig_skeleton
- for d in self.not_selected:
- t2.values[d] = self.not_selected_values[d]
- Q.append(t2)
-
- return Q
-
-
-class Numpyfier(BaseEstimator, TransformerMixin):
- '''
- Just converts the values in a MocapData object into a numpy array
- Useful for the final stage of a pipeline before training
- '''
- def __init__(self):
- pass
-
- def fit(self, X, y=None):
- self.org_mocap_ = X[0].clone()
- self.org_mocap_.values.drop(self.org_mocap_.values.index, inplace=True)
-
- return self
-
- def transform(self, X, y=None):
- print("Numpyfier")
- Q = []
-
- for track in X:
- Q.append(track.values.values)
- #print("Numpyfier:" + str(track.values.columns))
-
- return np.array(Q)
-
- def inverse_transform(self, X, copy=None):
- Q = []
-
- for track in X:
-
- new_mocap = self.org_mocap_.clone()
- time_index = pd.to_timedelta([f for f in range(track.shape[0])], unit='s')
-
- # print(self.org_mocap_.values.columns)
- # import pdb;pdb.set_trace()
- new_df = pd.DataFrame(data=track, index=time_index, columns=self.org_mocap_.values.columns)
-
- new_mocap.values = new_df
-
-
- Q.append(new_mocap)
-
- return Q
-
-class Slicer(BaseEstimator, TransformerMixin):
- '''
- Slice the data into intervals of equal size
- '''
- def __init__(self, window_size, overlap=0.5):
- self.window_size = window_size
- self.overlap = overlap
- pass
-
- def fit(self, X, y=None):
- self.org_mocap_ = X[0].clone()
- self.org_mocap_.values.drop(self.org_mocap_.values.index, inplace=True)
-
- return self
-
- def transform(self, X, y=None):
- print("Slicer")
- Q = []
-
- for track in X:
- vals = track.values.values
- nframes = vals.shape[0]
- overlap_frames = (int)(self.overlap*self.window_size)
-
- n_sequences = (nframes-overlap_frames)//(self.window_size-overlap_frames)
-
- if n_sequences>0:
- y = np.zeros((n_sequences, self.window_size, vals.shape[1]))
-
- # extract sequences from the input data
- for i in range(0,n_sequences):
- frameIdx = (self.window_size-overlap_frames) * i
- Q.append(vals[frameIdx:frameIdx+self.window_size,:])
-
- return np.array(Q)
-
- def inverse_transform(self, X, copy=None):
- Q = []
-
- for track in X:
-
- new_mocap = self.org_mocap_.clone()
- time_index = pd.to_timedelta([f for f in range(track.shape[0])], unit='s')
-
- new_df = pd.DataFrame(data=track, index=time_index, columns=self.org_mocap_.values.columns)
-
- new_mocap.values = new_df
-
-
- Q.append(new_mocap)
-
- return Q
-
-class RootTransformer(BaseEstimator, TransformerMixin):
- def __init__(self, method, position_smoothing=0, rotation_smoothing=0):
- """
- Accepted methods:
- abdolute_translation_deltas
- pos_rot_deltas
- """
- self.method = method
- self.position_smoothing=position_smoothing
- self.rotation_smoothing=rotation_smoothing
-
- def fit(self, X, y=None):
- return self
-
- def transform(self, X, y=None):
- print("RootTransformer")
- Q = []
-
- for track in X:
- if self.method == 'abdolute_translation_deltas':
- new_df = track.values.copy()
- xpcol = '%s_Xposition'%track.root_name
- ypcol = '%s_Yposition'%track.root_name
- zpcol = '%s_Zposition'%track.root_name
-
-
- dxpcol = '%s_dXposition'%track.root_name
- dzpcol = '%s_dZposition'%track.root_name
-
- x=track.values[xpcol].copy()
- z=track.values[zpcol].copy()
-
- if self.position_smoothing>0:
- x_sm = filters.gaussian_filter1d(x, self.position_smoothing, axis=0, mode='nearest')
- z_sm = filters.gaussian_filter1d(z, self.position_smoothing, axis=0, mode='nearest')
- dx = pd.Series(data=x_sm, index=new_df.index).diff()
- dz = pd.Series(data=z_sm, index=new_df.index).diff()
- new_df[xpcol] = x-x_sm
- new_df[zpcol] = z-z_sm
- else:
- dx = x.diff()
- dz = z.diff()
- new_df.drop([xpcol, zpcol], axis=1, inplace=True)
-
- dx[0] = dx[1]
- dz[0] = dz[1]
-
- new_df[dxpcol] = dx
- new_df[dzpcol] = dz
-
- new_track = track.clone()
- new_track.values = new_df
- # end of abdolute_translation_deltas
-
- elif self.method == 'pos_rot_deltas':
- new_track = track.clone()
-
- # Absolute columns
- xp_col = '%s_Xposition'%track.root_name
- yp_col = '%s_Yposition'%track.root_name
- zp_col = '%s_Zposition'%track.root_name
-
- #rot_order = track.skeleton[track.root_name]['order']
- #%(joint, rot_order[0])
-
- rot_order = track.skeleton[track.root_name]['order']
- r1_col = '%s_%srotation'%(track.root_name, rot_order[0])
- r2_col = '%s_%srotation'%(track.root_name, rot_order[1])
- r3_col = '%s_%srotation'%(track.root_name, rot_order[2])
-
- # Delta columns
- dxp_col = '%s_dXposition'%track.root_name
- dzp_col = '%s_dZposition'%track.root_name
-
- dxr_col = '%s_dXrotation'%track.root_name
- dyr_col = '%s_dYrotation'%track.root_name
- dzr_col = '%s_dZrotation'%track.root_name
-
- positions = np.transpose(np.array([track.values[xp_col], track.values[yp_col], track.values[zp_col]]))
- rotations = np.pi/180.0*np.transpose(np.array([track.values[r1_col], track.values[r2_col], track.values[r3_col]]))
-
- """ Get Trajectory and smooth it"""
- trajectory_filterwidth = self.position_smoothing
- reference = positions.copy()*np.array([1,0,1])
- if trajectory_filterwidth>0:
- reference = filters.gaussian_filter1d(reference, trajectory_filterwidth, axis=0, mode='nearest')
-
- """ Get Root Velocity """
- velocity = np.diff(reference, axis=0)
- velocity = np.vstack((velocity[0,:], velocity))
-
- """ Remove Root Translation """
- positions = positions-reference
-
- """ Get Forward Direction along the x-z plane, assuming character is facig z-forward """
- #forward = [Rotation(f, 'euler', from_deg=True, order=rot_order).rotmat[:,2] for f in rotations] # get the z-axis of the rotation matrix, assuming character is facig z-forward
- #print("order:" + rot_order.lower())
- quats = Quaternions.from_euler(rotations, order=rot_order.lower(), world=False)
- forward = quats*np.array([[0,0,1]])
- forward[:,1] = 0
-
- """ Smooth Forward Direction """
- direction_filterwidth = self.rotation_smoothing
- if direction_filterwidth>0:
- forward = filters.gaussian_filter1d(forward, direction_filterwidth, axis=0, mode='nearest')
-
- forward = forward / np.sqrt((forward**2).sum(axis=-1))[...,np.newaxis]
-
- """ Remove Y Rotation """
- target = np.array([[0,0,1]]).repeat(len(forward), axis=0)
- rotation = Quaternions.between(target, forward)[:,np.newaxis]
- positions = (-rotation[:,0]) * positions
- new_rotations = (-rotation[:,0]) * quats
- velocity = (-rotation[:,0]) * velocity
-
- """ Get Root Rotation """
- #print(rotation[:,0])
- rvelocity = Pivots.from_quaternions(rotation[1:] * -rotation[:-1]).ps
- rvelocity = np.vstack((rvelocity[0], rvelocity))
-
- eulers = np.array([t3d.euler.quat2euler(q, axes=('s'+rot_order.lower()[::-1]))[::-1] for q in new_rotations])*180.0/np.pi
-
- new_df = track.values.copy()
-
- root_pos_x = pd.Series(data=positions[:,0], index=new_df.index)
- root_pos_y = pd.Series(data=positions[:,1], index=new_df.index)
- root_pos_z = pd.Series(data=positions[:,2], index=new_df.index)
- root_pos_x_diff = pd.Series(data=velocity[:,0], index=new_df.index)
- root_pos_z_diff = pd.Series(data=velocity[:,2], index=new_df.index)
-
- root_rot_1 = pd.Series(data=eulers[:,0], index=new_df.index)
- root_rot_2 = pd.Series(data=eulers[:,1], index=new_df.index)
- root_rot_3 = pd.Series(data=eulers[:,2], index=new_df.index)
- root_rot_y_diff = pd.Series(data=rvelocity[:,0], index=new_df.index)
-
- #new_df.drop([xr_col, yr_col, zr_col, xp_col, zp_col], axis=1, inplace=True)
-
- new_df[xp_col] = root_pos_x
- new_df[yp_col] = root_pos_y
- new_df[zp_col] = root_pos_z
- new_df[dxp_col] = root_pos_x_diff
- new_df[dzp_col] = root_pos_z_diff
-
- new_df[r1_col] = root_rot_1
- new_df[r2_col] = root_rot_2
- new_df[r3_col] = root_rot_3
- #new_df[dxr_col] = root_rot_x_diff
- new_df[dyr_col] = root_rot_y_diff
- #new_df[dzr_col] = root_rot_z_diff
-
- new_track.values = new_df
-
-
- elif self.method == 'hip_centric':
- new_track = track.clone()
-
- # Absolute columns
- xp_col = '%s_Xposition'%track.root_name
- yp_col = '%s_Yposition'%track.root_name
- zp_col = '%s_Zposition'%track.root_name
-
- xr_col = '%s_Xrotation'%track.root_name
- yr_col = '%s_Yrotation'%track.root_name
- zr_col = '%s_Zrotation'%track.root_name
-
- new_df = track.values.copy()
-
- all_zeros = np.zeros(track.values[xp_col].values.shape)
-
- new_df[xp_col] = pd.Series(data=all_zeros, index=new_df.index)
- new_df[yp_col] = pd.Series(data=all_zeros, index=new_df.index)
- new_df[zp_col] = pd.Series(data=all_zeros, index=new_df.index)
-
- new_df[xr_col] = pd.Series(data=all_zeros, index=new_df.index)
- new_df[yr_col] = pd.Series(data=all_zeros, index=new_df.index)
- new_df[zr_col] = pd.Series(data=all_zeros, index=new_df.index)
-
- new_track.values = new_df
-
- #print(new_track.values.columns)
- Q.append(new_track)
-
- return Q
-
- def inverse_transform(self, X, copy=None, start_pos=None):
- Q = []
-
- #TODO: simplify this implementation
-
- startx = 0
- startz = 0
-
- if start_pos is not None:
- startx, startz = start_pos
-
- for track in X:
- new_track = track.clone()
- if self.method == 'abdolute_translation_deltas':
- new_df = new_track.values
- xpcol = '%s_Xposition'%track.root_name
- ypcol = '%s_Yposition'%track.root_name
- zpcol = '%s_Zposition'%track.root_name
-
-
- dxpcol = '%s_dXposition'%track.root_name
- dzpcol = '%s_dZposition'%track.root_name
-
- dx = track.values[dxpcol].values
- dz = track.values[dzpcol].values
-
- recx = [startx]
- recz = [startz]
-
- for i in range(dx.shape[0]-1):
- recx.append(recx[i]+dx[i+1])
- recz.append(recz[i]+dz[i+1])
-
- # recx = [recx[i]+dx[i+1] for i in range(dx.shape[0]-1)]
- # recz = [recz[i]+dz[i+1] for i in range(dz.shape[0]-1)]
- # recx = dx[:-1] + dx[1:]
- # recz = dz[:-1] + dz[1:]
- if self.position_smoothing > 0:
- new_df[xpcol] = pd.Series(data=new_df[xpcol]+recx, index=new_df.index)
- new_df[zpcol] = pd.Series(data=new_df[zpcol]+recz, index=new_df.index)
- else:
- new_df[xpcol] = pd.Series(data=recx, index=new_df.index)
- new_df[zpcol] = pd.Series(data=recz, index=new_df.index)
-
- new_df.drop([dxpcol, dzpcol], axis=1, inplace=True)
-
- new_track.values = new_df
- # end of abdolute_translation_deltas
-
- elif self.method == 'pos_rot_deltas':
- # Absolute columns
- rot_order = track.skeleton[track.root_name]['order']
- xp_col = '%s_Xposition'%track.root_name
- yp_col = '%s_Yposition'%track.root_name
- zp_col = '%s_Zposition'%track.root_name
-
- xr_col = '%s_Xrotation'%track.root_name
- yr_col = '%s_Yrotation'%track.root_name
- zr_col = '%s_Zrotation'%track.root_name
- r1_col = '%s_%srotation'%(track.root_name, rot_order[0])
- r2_col = '%s_%srotation'%(track.root_name, rot_order[1])
- r3_col = '%s_%srotation'%(track.root_name, rot_order[2])
-
- # Delta columns
- dxp_col = '%s_dXposition'%track.root_name
- dzp_col = '%s_dZposition'%track.root_name
-
- dyr_col = '%s_dYrotation'%track.root_name
-
- positions = np.transpose(np.array([track.values[xp_col], track.values[yp_col], track.values[zp_col]]))
- rotations = np.pi/180.0*np.transpose(np.array([track.values[r1_col], track.values[r2_col], track.values[r3_col]]))
- quats = Quaternions.from_euler(rotations, order=rot_order.lower(), world=False)
-
- new_df = track.values.copy()
-
- dx = track.values[dxp_col].values
- dz = track.values[dzp_col].values
-
- dry = track.values[dyr_col].values
-
- #rec_p = np.array([startx, 0, startz])+positions[0,:]
- rec_ry = Quaternions.id(quats.shape[0])
- rec_xp = [0]
- rec_zp = [0]
-
- #rec_r = Quaternions.id(quats.shape[0])
-
- for i in range(dx.shape[0]-1):
- #print(dry[i])
- q_y = Quaternions.from_angle_axis(np.array(dry[i+1]), np.array([0,1,0]))
- rec_ry[i+1] = q_y*rec_ry[i]
- #print("dx: + " + str(dx[i+1]))
- dp = rec_ry[i+1]*np.array([dx[i+1], 0, dz[i+1]])
- rec_xp.append(rec_xp[i]+dp[0,0])
- rec_zp.append(rec_zp[i]+dp[0,2])
-
- rec_r=rec_ry*quats
- pp=rec_ry*positions
- rec_xp = rec_xp + pp[:,0]
- rec_zp = rec_zp + pp[:,2]
-
- eulers = np.array([t3d.euler.quat2euler(q, axes=('s'+rot_order.lower()[::-1]))[::-1] for q in rec_r])*180.0/np.pi
-
- new_df = track.values.copy()
-
- root_rot_1 = pd.Series(data=eulers[:,0], index=new_df.index)
- root_rot_2 = pd.Series(data=eulers[:,1], index=new_df.index)
- root_rot_3 = pd.Series(data=eulers[:,2], index=new_df.index)
-
- new_df[xp_col] = pd.Series(data=rec_xp, index=new_df.index)
- new_df[zp_col] = pd.Series(data=rec_zp, index=new_df.index)
-
- new_df[r1_col] = pd.Series(data=root_rot_1, index=new_df.index)
- new_df[r2_col] = pd.Series(data=root_rot_2, index=new_df.index)
- new_df[r3_col] = pd.Series(data=root_rot_3, index=new_df.index)
-
- new_df.drop([dyr_col, dxp_col, dzp_col], axis=1, inplace=True)
-
-
- new_track.values = new_df
-
- #print(new_track.values.columns)
- Q.append(new_track)
-
- return Q
-
-
-class RootCentricPositionNormalizer(BaseEstimator, TransformerMixin):
- def __init__(self):
- pass
-
- def fit(self, X, y=None):
- return self
-
- def transform(self, X, y=None):
- Q = []
-
- for track in X:
- new_track = track.clone()
-
- rxp = '%s_Xposition'%track.root_name
- ryp = '%s_Yposition'%track.root_name
- rzp = '%s_Zposition'%track.root_name
-
- projected_root_pos = track.values[[rxp, ryp, rzp]]
-
- projected_root_pos.loc[:,ryp] = 0 # we want the root's projection on the floor plane as the ref
-
- new_df = pd.DataFrame(index=track.values.index)
-
- all_but_root = [joint for joint in track.skeleton if track.root_name not in joint]
- # all_but_root = [joint for joint in track.skeleton]
- for joint in all_but_root:
- new_df['%s_Xposition'%joint] = pd.Series(data=track.values['%s_Xposition'%joint]-projected_root_pos[rxp], index=new_df.index)
- new_df['%s_Yposition'%joint] = pd.Series(data=track.values['%s_Yposition'%joint]-projected_root_pos[ryp], index=new_df.index)
- new_df['%s_Zposition'%joint] = pd.Series(data=track.values['%s_Zposition'%joint]-projected_root_pos[rzp], index=new_df.index)
-
-
- # keep the root as it is now
- new_df[rxp] = track.values[rxp]
- new_df[ryp] = track.values[ryp]
- new_df[rzp] = track.values[rzp]
-
- new_track.values = new_df
-
- Q.append(new_track)
-
- return Q
-
- def inverse_transform(self, X, copy=None):
- Q = []
-
- for track in X:
- new_track = track.clone()
-
- rxp = '%s_Xposition'%track.root_name
- ryp = '%s_Yposition'%track.root_name
- rzp = '%s_Zposition'%track.root_name
-
- projected_root_pos = track.values[[rxp, ryp, rzp]]
-
- projected_root_pos.loc[:,ryp] = 0 # we want the root's projection on the floor plane as the ref
-
- new_df = pd.DataFrame(index=track.values.index)
-
- for joint in track.skeleton:
- new_df['%s_Xposition'%joint] = pd.Series(data=track.values['%s_Xposition'%joint]+projected_root_pos[rxp], index=new_df.index)
- new_df['%s_Yposition'%joint] = pd.Series(data=track.values['%s_Yposition'%joint]+projected_root_pos[ryp], index=new_df.index)
- new_df['%s_Zposition'%joint] = pd.Series(data=track.values['%s_Zposition'%joint]+projected_root_pos[rzp], index=new_df.index)
-
-
- new_track.values = new_df
-
- Q.append(new_track)
-
- return Q
-
-class Flattener(BaseEstimator, TransformerMixin):
- def __init__(self):
- pass
-
- def fit(self, X, y=None):
- return self
-
- def transform(self, X, y=None):
- return np.concatenate(X, axis=0)
-
-class ConstantsRemover(BaseEstimator, TransformerMixin):
- '''
- For now it just looks at the first track
- '''
-
- def __init__(self, eps = 1e-6, only_cols=None):
- self.eps = eps
- self.only_cols = only_cols
-
-
- def fit(self, X, y=None):
- stds = X[0].values.std()
- cols = X[0].values.columns.values
- if self.only_cols is not None:
- self.const_dims_ = [c for c in cols if ((stds[c] < self.eps).any()) and c in self.only_cols]
- else:
- self.const_dims_ = [c for c in cols if (stds[c] < self.eps).any()]
- # self.const_values_ = {c:X[0].values[c].values[0] for c in cols if (stds[c] < self.eps).any()}
- self.const_values_ = {c:X[0].values[c].values[0] for c in cols if self.const_dims_}
- return self
-
- def transform(self, X, y=None):
- Q = []
-
-
- for track in X:
- t2 = track.clone()
- #for key in t2.skeleton.keys():
- # if key in self.ConstDims_:
- # t2.skeleton.pop(key)
- #print(track.values.columns.difference(self.const_dims_))
- t2.values.drop(self.const_dims_, axis=1, inplace=True)
- #t2.values = track.values[track.values.columns.difference(self.const_dims_)]
- Q.append(t2)
-
- return Q
-
- def inverse_transform(self, X, copy=None):
- Q = []
-
- for track in X:
- t2 = track.clone()
- for d in self.const_dims_:
- t2.values[d] = self.const_values_[d]
-# t2.values.assign(d=pd.Series(data=self.const_values_[d], index = t2.values.index))
- Q.append(t2)
-
- return Q
-
-class ListStandardScaler(BaseEstimator, TransformerMixin):
- def __init__(self, is_DataFrame=False):
- self.is_DataFrame = is_DataFrame
-
- def fit(self, X, y=None):
- if self.is_DataFrame:
- X_train_flat = np.concatenate([m.values for m in X], axis=0)
- else:
- X_train_flat = np.concatenate([m for m in X], axis=0)
-
- self.data_mean_ = np.mean(X_train_flat, axis=0)
- self.data_std_ = np.std(X_train_flat, axis=0)
-
- return self
-
- def transform(self, X, y=None):
- Q = []
-
- for track in X:
- if self.is_DataFrame:
- normalized_track = track.copy()
- normalized_track.values = (track.values - self.data_mean_) / self.data_std_
- else:
- normalized_track = (track - self.data_mean_) / self.data_std_
-
- Q.append(normalized_track)
-
- if self.is_DataFrame:
- return Q
- else:
- return np.array(Q)
-
- def inverse_transform(self, X, copy=None):
- Q = []
-
- for track in X:
-
- if self.is_DataFrame:
- unnormalized_track = track.copy()
- unnormalized_track.values = (track.values * self.data_std_) + self.data_mean_
- else:
- unnormalized_track = (track * self.data_std_) + self.data_mean_
-
- Q.append(unnormalized_track)
-
- if self.is_DataFrame:
- return Q
- else:
- return np.array(Q)
-
-class ListMinMaxScaler(BaseEstimator, TransformerMixin):
- def __init__(self, is_DataFrame=False):
- self.is_DataFrame = is_DataFrame
-
- def fit(self, X, y=None):
- if self.is_DataFrame:
- X_train_flat = np.concatenate([m.values for m in X], axis=0)
- else:
- X_train_flat = np.concatenate([m for m in X], axis=0)
-
- self.data_max_ = np.max(X_train_flat, axis=0)
- self.data_min_ = np.min(X_train_flat, axis=0)
-
- return self
-
- def transform(self, X, y=None):
- Q = []
-
- for track in X:
- if self.is_DataFrame:
- normalized_track = track.copy()
- normalized_track.values = (track.values - self.data_min_) / (self.data_max_ - self.data_min_)
- else:
- normalized_track = (track - self.data_min_) / (self.data_max_ - self.data_min_)
-
- Q.append(normalized_track)
-
- if self.is_DataFrame:
- return Q
- else:
- return np.array(Q)
-
- def inverse_transform(self, X, copy=None):
- Q = []
-
- for track in X:
-
- if self.is_DataFrame:
- unnormalized_track = track.copy()
- unnormalized_track.values = (track.values * (self.data_max_ - self.data_min_)) + self.data_min_
- else:
- unnormalized_track = (track * (self.data_max_ - self.data_min_)) + self.data_min_
-
- Q.append(unnormalized_track)
-
- if self.is_DataFrame:
- return Q
- else:
- return np.array(Q)
-
-class DownSampler(BaseEstimator, TransformerMixin):
- def __init__(self, tgt_fps, keep_all=False):
- self.tgt_fps = tgt_fps
- self.keep_all = keep_all
-
-
- def fit(self, X, y=None):
-
- return self
-
- def transform(self, X, y=None):
- Q = []
-
- for track in X:
- orig_fps=round(1.0/track.framerate)
- rate = orig_fps//self.tgt_fps
- if orig_fps%self.tgt_fps!=0:
- print("error orig_fps (" + str(orig_fps) + ") is not dividable with tgt_fps (" + str(self.tgt_fps) + ")")
- else:
- print("downsampling with rate: " + str(rate))
-
- #print(track.values.size)
- for ii in range(0,rate):
- new_track = track.clone()
- new_track.values = track.values[ii:-1:rate].copy()
- #print(new_track.values.size)
- #new_track = track[0:-1:self.rate]
- new_track.framerate = 1.0/self.tgt_fps
- Q.append(new_track)
- if not self.keep_all:
- break
-
- return Q
-
- def inverse_transform(self, X, copy=None):
- return X
-
-class ReverseTime(BaseEstimator, TransformerMixin):
- def __init__(self, append=True):
- self.append = append
-
-
- def fit(self, X, y=None):
-
- return self
-
- def transform(self, X, y=None):
- Q = []
- if self.append:
- for track in X:
- Q.append(track)
- for track in X:
- new_track = track.clone()
- new_track.values = track.values[-1::-1]
- Q.append(new_track)
-
- return Q
-
- def inverse_transform(self, X, copy=None):
- return X
-
-#TODO: JointsSelector (x)
-#TODO: SegmentMaker
-#TODO: DynamicFeaturesAdder
-#TODO: ShapeFeaturesAdder
-#TODO: DataFrameNumpier (x)
-
-class TemplateTransform(BaseEstimator, TransformerMixin):
- def __init__(self):
- pass
-
- def fit(self, X, y=None):
- return self
-
- def transform(self, X, y=None):
- return X
diff --git a/spaces/Marshalls/testmtd/training/__init__.py b/spaces/Marshalls/testmtd/training/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/Masa-digital-art/movie-trailer-16k/constraints.md b/spaces/Masa-digital-art/movie-trailer-16k/constraints.md
deleted file mode 100644
index a9232b265193e6ceedcf11327b62f3e51200c82e..0000000000000000000000000000000000000000
--- a/spaces/Masa-digital-art/movie-trailer-16k/constraints.md
+++ /dev/null
@@ -1,59 +0,0 @@
-# instructions
-
-- you are an excellent creative director
-- Split user input into strings of appropriate length, abstractly interpret them, and set keywords that can be used as movie ideas without losing important context
-- Follow the task below to suggest content for your movie trailer
-
-# tasks
-
-- Using keywords that are the source of movie ideas, perform the following tasks in order, structure them in markdown format, and output them according to the template.
-
-## 1. Generate logo/film company animation (0-5 seconds)
-
-- Display movie company logos and animations
-- Emphasize the brand image of the film company and give viewers a sense of the quality of the film
-- Generate impressive lines of characters, narration that makes you feel like a big hit, landscape descriptions in the play, camera angles, impressive productions, and sound effects.
-
-## 2. Generate the opening shot (5-10 seconds)
-
-- The first shot shows the viewer the setting and tone of the movie
-- It can be a city skyline in the background of a movie or a close-up of the main character
-- Generate impressive lines of characters, narration that makes you feel like a big hit, landscape descriptions in the play, camera angles, impressive productions, and sound effects.
-
-## 3. Generate movie theme (10-20 seconds)
-
-- Introduce movie themes
-- Includes the film's major conflicts and narrative central themes
-- Characters and locations are also initialized.
-- Generate impressive lines of characters, narration that makes you feel like a big hit, landscape descriptions in the play, camera angles, impressive productions, and sound effects.
-
-## 4. Generate the main cast and their roles (20-45 seconds)
-
-- Introduce the main cast and their roles
-- Show your audience the faces and names of your cast members to make them anticipate their performance
-- Generate impressive lines of characters, narration that makes you feel like a big hit, landscape descriptions in the play, camera angles, impressive productions, and sound effects.
-
-## 5. Generate movie highlights (45-80 seconds)
-- Extract the most exciting parts of the movie and get the audience excited
-- Can contain action scenes, touching moments and important plot points
-- Generate impressive lines of characters, narration that makes you feel like a big hit, landscape descriptions in the play, camera angles, impressive productions, and sound effects.
-
-## 6. Generate a premonition of the climax (80-90 seconds)
-
-- Display the scene leading to the climax of the movie as a teaser
-- However, avoid revealing the ending and pique the viewer's curiosity
-- Generate impressive lines of characters, narration that makes you feel like a big hit, landscape descriptions in the play, camera angles, impressive productions, and sound effects.
-
-## 7. Generate movie title and release date (90-100 seconds)
-
-- Show movie title and release date
-- Keeps viewers excited and motivated to watch the movie
-- Generate impressive lines of characters, narration that makes you feel like a big hit, landscape descriptions in the play, camera angles, impressive productions, and sound effects.
-
-## 8. Generate end card (100-120 seconds)
-
-- Displays links to the movie's official website, official hashtags, and the movie's official SNS accounts.
-- Provide an avenue for viewers to learn more about movies or participate in conversations about movies
-- Generate impressive lines of characters, narration that makes you feel like a big hit, landscape descriptions in the play, camera angles, impressive productions, and sound effects.
-
-# template
\ No newline at end of file
diff --git a/spaces/MashiroSA/sovits-emu-voice-transform/CppDataProcess/Wav.hpp b/spaces/MashiroSA/sovits-emu-voice-transform/CppDataProcess/Wav.hpp
deleted file mode 100644
index c633366256a47fad29f8a385e03f847c0c94d1cb..0000000000000000000000000000000000000000
--- a/spaces/MashiroSA/sovits-emu-voice-transform/CppDataProcess/Wav.hpp
+++ /dev/null
@@ -1,99 +0,0 @@
-class Wav {
-public:
-
- struct WAV_HEADER {
- char RIFF[4] = { 'R','I','F','F' }; //RIFF��ʶ
- unsigned long ChunkSize; //�ļ���С-8
- char WAVE[4] = { 'W','A','V','E' }; //WAVE��
- char fmt[4] = { 'f','m','t',' ' }; //fmt��
- unsigned long Subchunk1Size; //fmt���С
- unsigned short AudioFormat; //�����ʽ
- unsigned short NumOfChan; //������
- unsigned long SamplesPerSec; //������
- unsigned long bytesPerSec; //ÿ�����ֽ���
- unsigned short blockAlign; //�������ֽ�
- unsigned short bitsPerSample; //�������
- char Subchunk2ID[4] = { 'd','a','t','a' }; //���ݿ�
- unsigned long Subchunk2Size; //���ݿ��С
- WAV_HEADER(unsigned long cs = 36, unsigned long sc1s = 16, unsigned short af = 1, unsigned short nc = 1, unsigned long sr = 22050, unsigned long bps = 44100, unsigned short ba = 2, unsigned short bips = 16, unsigned long sc2s = 0) :ChunkSize(cs), Subchunk1Size(sc1s), AudioFormat(af), NumOfChan(nc), SamplesPerSec(sr), bytesPerSec(bps), blockAlign(ba), bitsPerSample(bips), Subchunk2Size(sc2s) {}
- };
- using iterator = int16_t*;
- Wav(unsigned long cs = 36, unsigned long sc1s = 16, unsigned short af = 1, unsigned short nc = 1, unsigned long sr = 22050, unsigned long bps = 44100, unsigned short ba = 2, unsigned short bips = 16, unsigned long sc2s = 0) :header({
- cs,
- sc1s,
- af,
- nc,
- sr,
- bps,
- ba,
- bips,
- sc2s
- }), Data(nullptr), StartPos(44) {
- dataSize = 0;
- SData = nullptr;
- }
- Wav(unsigned long sr, unsigned long length, const void* data) :header({
- 36,
- 16,
- 1,
- 1,
- sr,
- sr * 2,
- 2,
- 16,
- length
- }), Data(new char[length + 1]), StartPos(44)
- {
- header.ChunkSize = 36 + length;
- memcpy(Data, data, length);
- SData = reinterpret_cast<int16_t*>(Data);
- dataSize = length / 2;
- }
- Wav(const wchar_t* Path);
- Wav(const Wav& input);
- Wav(Wav&& input) noexcept;
- Wav& operator=(const Wav& input) = delete;
- Wav& operator=(Wav&& input) noexcept;
- ~Wav() { destory(); }
- Wav& cat(const Wav& input);
- bool isEmpty() const { return this->header.Subchunk2Size == 0; }
- const char* getData() const { return Data; }
- char* getData() { return Data; }
- WAV_HEADER getHeader() const { return header; }
- WAV_HEADER& Header() { return header; }
- void destory() const { delete[] Data; }
- void changeData(const void* indata,long length,int sr)
- {
- delete[] Data;
- Data = new char[length];
- memcpy(Data, indata, length);
- header.ChunkSize = 36 + length;
- header.Subchunk2Size = length;
- header.SamplesPerSec = sr;
- header.bytesPerSec = 2 * sr;
- }
- int16_t& operator[](const size_t index) const
- {
- if (index < dataSize)
- return *(SData + index);
- return *(SData + dataSize - 1);
- }
- iterator begin() const
- {
- return reinterpret_cast<int16_t*>(Data);
- }
- iterator end() const
- {
- return reinterpret_cast<int16_t*>(Data + header.Subchunk2Size);
- }
- int64_t getDataLen()const
- {
- return static_cast<int64_t>(dataSize);
- }
-private:
- WAV_HEADER header;
- char* Data;
- int16_t* SData;
- size_t dataSize;
- int StartPos;
-};
diff --git a/spaces/Mellow-ai/PhotoAI_Mellow/cldm/ddim_hacked.py b/spaces/Mellow-ai/PhotoAI_Mellow/cldm/ddim_hacked.py
deleted file mode 100644
index 25b1bc947272ad14d7f7e5e4d1809005253b63d0..0000000000000000000000000000000000000000
--- a/spaces/Mellow-ai/PhotoAI_Mellow/cldm/ddim_hacked.py
+++ /dev/null
@@ -1,317 +0,0 @@
-"""SAMPLING ONLY."""
-
-import torch
-import numpy as np
-from tqdm import tqdm
-
-from ldm.modules.diffusionmodules.util import make_ddim_sampling_parameters, make_ddim_timesteps, noise_like, extract_into_tensor
-
-
-class DDIMSampler(object):
- def __init__(self, model, schedule="linear", **kwargs):
- super().__init__()
- self.model = model
- self.ddpm_num_timesteps = model.num_timesteps
- self.schedule = schedule
-
- def register_buffer(self, name, attr):
- if type(attr) == torch.Tensor:
- if attr.device != torch.device("cuda"):
- attr = attr.to(torch.device("cuda"))
- setattr(self, name, attr)
-
- def make_schedule(self, ddim_num_steps, ddim_discretize="uniform", ddim_eta=0., verbose=True):
- self.ddim_timesteps = make_ddim_timesteps(ddim_discr_method=ddim_discretize, num_ddim_timesteps=ddim_num_steps,
- num_ddpm_timesteps=self.ddpm_num_timesteps,verbose=verbose)
- alphas_cumprod = self.model.alphas_cumprod
- assert alphas_cumprod.shape[0] == self.ddpm_num_timesteps, 'alphas have to be defined for each timestep'
- to_torch = lambda x: x.clone().detach().to(torch.float32).to(self.model.device)
-
- self.register_buffer('betas', to_torch(self.model.betas))
- self.register_buffer('alphas_cumprod', to_torch(alphas_cumprod))
- self.register_buffer('alphas_cumprod_prev', to_torch(self.model.alphas_cumprod_prev))
-
- # calculations for diffusion q(x_t | x_{t-1}) and others
- self.register_buffer('sqrt_alphas_cumprod', to_torch(np.sqrt(alphas_cumprod.cpu())))
- self.register_buffer('sqrt_one_minus_alphas_cumprod', to_torch(np.sqrt(1. - alphas_cumprod.cpu())))
- self.register_buffer('log_one_minus_alphas_cumprod', to_torch(np.log(1. - alphas_cumprod.cpu())))
- self.register_buffer('sqrt_recip_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod.cpu())))
- self.register_buffer('sqrt_recipm1_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod.cpu() - 1)))
-
- # ddim sampling parameters
- ddim_sigmas, ddim_alphas, ddim_alphas_prev = make_ddim_sampling_parameters(alphacums=alphas_cumprod.cpu(),
- ddim_timesteps=self.ddim_timesteps,
- eta=ddim_eta,verbose=verbose)
- self.register_buffer('ddim_sigmas', ddim_sigmas)
- self.register_buffer('ddim_alphas', ddim_alphas)
- self.register_buffer('ddim_alphas_prev', ddim_alphas_prev)
- self.register_buffer('ddim_sqrt_one_minus_alphas', np.sqrt(1. - ddim_alphas))
- sigmas_for_original_sampling_steps = ddim_eta * torch.sqrt(
- (1 - self.alphas_cumprod_prev) / (1 - self.alphas_cumprod) * (
- 1 - self.alphas_cumprod / self.alphas_cumprod_prev))
- self.register_buffer('ddim_sigmas_for_original_num_steps', sigmas_for_original_sampling_steps)
-
- @torch.no_grad()
- def sample(self,
- S,
- batch_size,
- shape,
- conditioning=None,
- callback=None,
- normals_sequence=None,
- img_callback=None,
- quantize_x0=False,
- eta=0.,
- mask=None,
- x0=None,
- temperature=1.,
- noise_dropout=0.,
- score_corrector=None,
- corrector_kwargs=None,
- verbose=True,
- x_T=None,
- log_every_t=100,
- unconditional_guidance_scale=1.,
- unconditional_conditioning=None, # this has to come in the same format as the conditioning, # e.g. as encoded tokens, ...
- dynamic_threshold=None,
- ucg_schedule=None,
- **kwargs
- ):
- if conditioning is not None:
- if isinstance(conditioning, dict):
- ctmp = conditioning[list(conditioning.keys())[0]]
- while isinstance(ctmp, list): ctmp = ctmp[0]
- cbs = ctmp.shape[0]
- if cbs != batch_size:
- print(f"Warning: Got {cbs} conditionings but batch-size is {batch_size}")
-
- elif isinstance(conditioning, list):
- for ctmp in conditioning:
- if ctmp.shape[0] != batch_size:
- print(f"Warning: Got {cbs} conditionings but batch-size is {batch_size}")
-
- else:
- if conditioning.shape[0] != batch_size:
- print(f"Warning: Got {conditioning.shape[0]} conditionings but batch-size is {batch_size}")
-
- self.make_schedule(ddim_num_steps=S, ddim_eta=eta, verbose=verbose)
- # sampling
- C, H, W = shape
- size = (batch_size, C, H, W)
- print(f'Data shape for DDIM sampling is {size}, eta {eta}')
-
- samples, intermediates = self.ddim_sampling(conditioning, size,
- callback=callback,
- img_callback=img_callback,
- quantize_denoised=quantize_x0,
- mask=mask, x0=x0,
- ddim_use_original_steps=False,
- noise_dropout=noise_dropout,
- temperature=temperature,
- score_corrector=score_corrector,
- corrector_kwargs=corrector_kwargs,
- x_T=x_T,
- log_every_t=log_every_t,
- unconditional_guidance_scale=unconditional_guidance_scale,
- unconditional_conditioning=unconditional_conditioning,
- dynamic_threshold=dynamic_threshold,
- ucg_schedule=ucg_schedule
- )
- return samples, intermediates
-
- @torch.no_grad()
- def ddim_sampling(self, cond, shape,
- x_T=None, ddim_use_original_steps=False,
- callback=None, timesteps=None, quantize_denoised=False,
- mask=None, x0=None, img_callback=None, log_every_t=100,
- temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None,
- unconditional_guidance_scale=1., unconditional_conditioning=None, dynamic_threshold=None,
- ucg_schedule=None):
- device = self.model.betas.device
- b = shape[0]
- if x_T is None:
- img = torch.randn(shape, device=device)
- else:
- img = x_T
-
- if timesteps is None:
- timesteps = self.ddpm_num_timesteps if ddim_use_original_steps else self.ddim_timesteps
- elif timesteps is not None and not ddim_use_original_steps:
- subset_end = int(min(timesteps / self.ddim_timesteps.shape[0], 1) * self.ddim_timesteps.shape[0]) - 1
- timesteps = self.ddim_timesteps[:subset_end]
-
- intermediates = {'x_inter': [img], 'pred_x0': [img]}
- time_range = reversed(range(0,timesteps)) if ddim_use_original_steps else np.flip(timesteps)
- total_steps = timesteps if ddim_use_original_steps else timesteps.shape[0]
- print(f"Running DDIM Sampling with {total_steps} timesteps")
-
- iterator = tqdm(time_range, desc='DDIM Sampler', total=total_steps)
-
- for i, step in enumerate(iterator):
- index = total_steps - i - 1
- ts = torch.full((b,), step, device=device, dtype=torch.long)
-
- if mask is not None:
- assert x0 is not None
- img_orig = self.model.q_sample(x0, ts) # TODO: deterministic forward pass?
- img = img_orig * mask + (1. - mask) * img
-
- if ucg_schedule is not None:
- assert len(ucg_schedule) == len(time_range)
- unconditional_guidance_scale = ucg_schedule[i]
-
- outs = self.p_sample_ddim(img, cond, ts, index=index, use_original_steps=ddim_use_original_steps,
- quantize_denoised=quantize_denoised, temperature=temperature,
- noise_dropout=noise_dropout, score_corrector=score_corrector,
- corrector_kwargs=corrector_kwargs,
- unconditional_guidance_scale=unconditional_guidance_scale,
- unconditional_conditioning=unconditional_conditioning,
- dynamic_threshold=dynamic_threshold)
- img, pred_x0 = outs
- if callback: callback(i)
- if img_callback: img_callback(pred_x0, i)
-
- if index % log_every_t == 0 or index == total_steps - 1:
- intermediates['x_inter'].append(img)
- intermediates['pred_x0'].append(pred_x0)
-
- return img, intermediates
-
- @torch.no_grad()
- def p_sample_ddim(self, x, c, t, index, repeat_noise=False, use_original_steps=False, quantize_denoised=False,
- temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None,
- unconditional_guidance_scale=1., unconditional_conditioning=None,
- dynamic_threshold=None):
- b, *_, device = *x.shape, x.device
-
- if unconditional_conditioning is None or unconditional_guidance_scale == 1.:
- model_output = self.model.apply_model(x, t, c)
- else:
- model_t = self.model.apply_model(x, t, c)
- model_uncond = self.model.apply_model(x, t, unconditional_conditioning)
- model_output = model_uncond + unconditional_guidance_scale * (model_t - model_uncond)
-
- if self.model.parameterization == "v":
- e_t = self.model.predict_eps_from_z_and_v(x, t, model_output)
- else:
- e_t = model_output
-
- if score_corrector is not None:
- assert self.model.parameterization == "eps", 'not implemented'
- e_t = score_corrector.modify_score(self.model, e_t, x, t, c, **corrector_kwargs)
-
- alphas = self.model.alphas_cumprod if use_original_steps else self.ddim_alphas
- alphas_prev = self.model.alphas_cumprod_prev if use_original_steps else self.ddim_alphas_prev
- sqrt_one_minus_alphas = self.model.sqrt_one_minus_alphas_cumprod if use_original_steps else self.ddim_sqrt_one_minus_alphas
- sigmas = self.model.ddim_sigmas_for_original_num_steps if use_original_steps else self.ddim_sigmas
- # select parameters corresponding to the currently considered timestep
- a_t = torch.full((b, 1, 1, 1), alphas[index], device=device)
- a_prev = torch.full((b, 1, 1, 1), alphas_prev[index], device=device)
- sigma_t = torch.full((b, 1, 1, 1), sigmas[index], device=device)
- sqrt_one_minus_at = torch.full((b, 1, 1, 1), sqrt_one_minus_alphas[index],device=device)
-
- # current prediction for x_0
- if self.model.parameterization != "v":
- pred_x0 = (x - sqrt_one_minus_at * e_t) / a_t.sqrt()
- else:
- pred_x0 = self.model.predict_start_from_z_and_v(x, t, model_output)
-
- if quantize_denoised:
- pred_x0, _, *_ = self.model.first_stage_model.quantize(pred_x0)
-
- if dynamic_threshold is not None:
- raise NotImplementedError()
-
- # direction pointing to x_t
- dir_xt = (1. - a_prev - sigma_t**2).sqrt() * e_t
- noise = sigma_t * noise_like(x.shape, device, repeat_noise) * temperature
- if noise_dropout > 0.:
- noise = torch.nn.functional.dropout(noise, p=noise_dropout)
- x_prev = a_prev.sqrt() * pred_x0 + dir_xt + noise
- return x_prev, pred_x0
-
- @torch.no_grad()
- def encode(self, x0, c, t_enc, use_original_steps=False, return_intermediates=None,
- unconditional_guidance_scale=1.0, unconditional_conditioning=None, callback=None):
- timesteps = np.arange(self.ddpm_num_timesteps) if use_original_steps else self.ddim_timesteps
- num_reference_steps = timesteps.shape[0]
-
- assert t_enc <= num_reference_steps
- num_steps = t_enc
-
- if use_original_steps:
- alphas_next = self.alphas_cumprod[:num_steps]
- alphas = self.alphas_cumprod_prev[:num_steps]
- else:
- alphas_next = self.ddim_alphas[:num_steps]
- alphas = torch.tensor(self.ddim_alphas_prev[:num_steps])
-
- x_next = x0
- intermediates = []
- inter_steps = []
- for i in tqdm(range(num_steps), desc='Encoding Image'):
- t = torch.full((x0.shape[0],), timesteps[i], device=self.model.device, dtype=torch.long)
- if unconditional_guidance_scale == 1.:
- noise_pred = self.model.apply_model(x_next, t, c)
- else:
- assert unconditional_conditioning is not None
- e_t_uncond, noise_pred = torch.chunk(
- self.model.apply_model(torch.cat((x_next, x_next)), torch.cat((t, t)),
- torch.cat((unconditional_conditioning, c))), 2)
- noise_pred = e_t_uncond + unconditional_guidance_scale * (noise_pred - e_t_uncond)
-
- xt_weighted = (alphas_next[i] / alphas[i]).sqrt() * x_next
- weighted_noise_pred = alphas_next[i].sqrt() * (
- (1 / alphas_next[i] - 1).sqrt() - (1 / alphas[i] - 1).sqrt()) * noise_pred
- x_next = xt_weighted + weighted_noise_pred
- if return_intermediates and i % (
- num_steps // return_intermediates) == 0 and i < num_steps - 1:
- intermediates.append(x_next)
- inter_steps.append(i)
- elif return_intermediates and i >= num_steps - 2:
- intermediates.append(x_next)
- inter_steps.append(i)
- if callback: callback(i)
-
- out = {'x_encoded': x_next, 'intermediate_steps': inter_steps}
- if return_intermediates:
- out.update({'intermediates': intermediates})
- return x_next, out
-
- @torch.no_grad()
- def stochastic_encode(self, x0, t, use_original_steps=False, noise=None):
- # fast, but does not allow for exact reconstruction
- # t serves as an index to gather the correct alphas
- if use_original_steps:
- sqrt_alphas_cumprod = self.sqrt_alphas_cumprod
- sqrt_one_minus_alphas_cumprod = self.sqrt_one_minus_alphas_cumprod
- else:
- sqrt_alphas_cumprod = torch.sqrt(self.ddim_alphas)
- sqrt_one_minus_alphas_cumprod = self.ddim_sqrt_one_minus_alphas
-
- if noise is None:
- noise = torch.randn_like(x0)
- return (extract_into_tensor(sqrt_alphas_cumprod, t, x0.shape) * x0 +
- extract_into_tensor(sqrt_one_minus_alphas_cumprod, t, x0.shape) * noise)
-
- @torch.no_grad()
- def decode(self, x_latent, cond, t_start, unconditional_guidance_scale=1.0, unconditional_conditioning=None,
- use_original_steps=False, callback=None):
-
- timesteps = np.arange(self.ddpm_num_timesteps) if use_original_steps else self.ddim_timesteps
- timesteps = timesteps[:t_start]
-
- time_range = np.flip(timesteps)
- total_steps = timesteps.shape[0]
- print(f"Running DDIM Sampling with {total_steps} timesteps")
-
- iterator = tqdm(time_range, desc='Decoding image', total=total_steps)
- x_dec = x_latent
- for i, step in enumerate(iterator):
- index = total_steps - i - 1
- ts = torch.full((x_latent.shape[0],), step, device=x_latent.device, dtype=torch.long)
- x_dec, _ = self.p_sample_ddim(x_dec, cond, ts, index=index, use_original_steps=use_original_steps,
- unconditional_guidance_scale=unconditional_guidance_scale,
- unconditional_conditioning=unconditional_conditioning)
- if callback: callback(i)
- return x_dec
diff --git a/spaces/NingKanae/anime-voice-generator/monotonic_align/core.py b/spaces/NingKanae/anime-voice-generator/monotonic_align/core.py
deleted file mode 100644
index 5ff728cd74c9228346a82ec64a9829cb98ad315e..0000000000000000000000000000000000000000
--- a/spaces/NingKanae/anime-voice-generator/monotonic_align/core.py
+++ /dev/null
@@ -1,36 +0,0 @@
-import numba
-
-
-@numba.jit(numba.void(numba.int32[:, :, ::1], numba.float32[:, :, ::1], numba.int32[::1], numba.int32[::1]),
- nopython=True, nogil=True)
-def maximum_path_jit(paths, values, t_ys, t_xs):
- b = paths.shape[0]
- max_neg_val = -1e9
- for i in range(int(b)):
- path = paths[i]
- value = values[i]
- t_y = t_ys[i]
- t_x = t_xs[i]
-
- v_prev = v_cur = 0.0
- index = t_x - 1
-
- for y in range(t_y):
- for x in range(max(0, t_x + y - t_y), min(t_x, y + 1)):
- if x == y:
- v_cur = max_neg_val
- else:
- v_cur = value[y - 1, x]
- if x == 0:
- if y == 0:
- v_prev = 0.
- else:
- v_prev = max_neg_val
- else:
- v_prev = value[y - 1, x - 1]
- value[y, x] += max(v_prev, v_cur)
-
- for y in range(t_y - 1, -1, -1):
- path[y, index] = 1
- if index != 0 and (index == y or value[y - 1, index] < value[y - 1, index - 1]):
- index = index - 1
\ No newline at end of file
diff --git a/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/fairseq/modules/adaptive_softmax.py b/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/fairseq/modules/adaptive_softmax.py
deleted file mode 100644
index ae0c77ba0f6ee98501306d66cbc4a948b4ade0f7..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/fairseq/modules/adaptive_softmax.py
+++ /dev/null
@@ -1,268 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import functools
-import operator
-
-import torch
-import torch.nn.functional as F
-from fairseq.modules.fairseq_dropout import FairseqDropout
-from fairseq.modules.quant_noise import quant_noise
-from torch import nn
-
-
-class TiedLinear(nn.Module):
- def __init__(self, weight, transpose):
- super().__init__()
- self.weight = weight
- self.transpose = transpose
-
- def forward(self, input):
- return F.linear(input, self.weight.t() if self.transpose else self.weight)
-
-
-class TiedHeadModule(nn.Module):
- def __init__(self, weights, input_dim, num_classes, q_noise, qn_block_size):
- super().__init__()
- tied_emb, _ = weights
- self.num_words, emb_dim = tied_emb.size()
-
- self.word_proj = quant_noise(
- TiedLinear(tied_emb, transpose=False), q_noise, qn_block_size
- )
- if input_dim != emb_dim:
- self.word_proj = nn.Sequential(
- quant_noise(
- nn.Linear(input_dim, emb_dim, bias=False), q_noise, qn_block_size
- ),
- self.word_proj,
- )
-
- self.class_proj = quant_noise(
- nn.Linear(input_dim, num_classes, bias=False), q_noise, qn_block_size
- )
- self.out_dim = self.num_words + num_classes
-
- self.register_buffer("_float_tensor", torch.FloatTensor(1))
-
- def forward(self, input):
- inp_sz = functools.reduce(operator.mul, input.shape[:-1], 1)
- out = self._float_tensor.new(inp_sz, self.out_dim)
- out[:, : self.num_words] = self.word_proj(input.view(inp_sz, -1))
- out[:, self.num_words :] = self.class_proj(input.view(inp_sz, -1))
- return out
-
-
-class AdaptiveSoftmax(nn.Module):
- """
- This is an implementation of the efficient softmax approximation for
- graphical processing units (GPU), described in the paper "Efficient softmax
- approximation for GPUs" (http://arxiv.org/abs/1609.04309).
- """
-
- def __init__(
- self,
- vocab_size,
- input_dim,
- cutoff,
- dropout,
- factor=4.0,
- adaptive_inputs=None,
- tie_proj=False,
- q_noise=0,
- qn_block_size=8,
- ):
- super().__init__()
-
- if vocab_size > cutoff[-1]:
- cutoff = cutoff + [vocab_size]
- else:
- assert (
- vocab_size == cutoff[-1]
- ), "cannot specify cutoff larger than vocab size"
-
- output_dim = cutoff[0] + len(cutoff) - 1
-
- self.vocab_size = vocab_size
- self.cutoff = cutoff
- self.dropout_module = FairseqDropout(
- dropout, module_name=self.__class__.__name__
- )
- self.input_dim = input_dim
- self.factor = factor
- self.q_noise = q_noise
- self.qn_block_size = qn_block_size
-
- self.lsm = nn.LogSoftmax(dim=1)
-
- if adaptive_inputs is not None:
- self.head = TiedHeadModule(
- adaptive_inputs.weights_for_band(0),
- input_dim,
- len(cutoff) - 1,
- self.q_noise,
- self.qn_block_size,
- )
- else:
- self.head = quant_noise(
- nn.Linear(input_dim, output_dim, bias=False),
- self.q_noise,
- self.qn_block_size,
- )
-
- self._make_tail(adaptive_inputs, tie_proj)
-
- def init_weights(m):
- if (
- hasattr(m, "weight")
- and not isinstance(m, TiedLinear)
- and not isinstance(m, TiedHeadModule)
- ):
- nn.init.xavier_uniform_(m.weight)
-
- self.apply(init_weights)
-
- self.register_buffer("version", torch.LongTensor([1]))
-
- def _make_tail(self, adaptive_inputs=None, tie_proj=False):
- self.tail = nn.ModuleList()
- for i in range(len(self.cutoff) - 1):
- dim = int(self.input_dim // self.factor ** (i + 1))
-
- tied_emb, tied_proj = (
- adaptive_inputs.weights_for_band(i + 1)
- if adaptive_inputs is not None
- else (None, None)
- )
-
- if tied_proj is not None:
- if tie_proj:
- proj = quant_noise(
- TiedLinear(tied_proj, transpose=True),
- self.q_noise,
- self.qn_block_size,
- )
- else:
- proj = quant_noise(
- nn.Linear(tied_proj.size(0), tied_proj.size(1), bias=False),
- self.q_noise,
- self.qn_block_size,
- )
- else:
- proj = quant_noise(
- nn.Linear(self.input_dim, dim, bias=False),
- self.q_noise,
- self.qn_block_size,
- )
-
- if tied_emb is None:
- out_proj = nn.Linear(
- dim, self.cutoff[i + 1] - self.cutoff[i], bias=False
- )
- else:
- out_proj = TiedLinear(tied_emb, transpose=False)
-
- m = nn.Sequential(
- proj,
- nn.Dropout(self.dropout_module.p),
- quant_noise(out_proj, self.q_noise, self.qn_block_size),
- )
-
- self.tail.append(m)
-
- def upgrade_state_dict_named(self, state_dict, name):
- version_name = name + ".version"
- if version_name not in state_dict:
- raise Exception("This version of the model is no longer supported")
-
- def adapt_target(self, target):
- """
- In order to be efficient, the AdaptiveSoftMax does not compute the
- scores for all the word of the vocabulary for all the examples. It is
- thus necessary to call the method adapt_target of the AdaptiveSoftMax
- layer inside each forward pass.
- """
-
- target = target.view(-1)
- new_target = [target.clone()]
- target_idxs = []
-
- for i in range(len(self.cutoff) - 1):
- mask = target.ge(self.cutoff[i]).mul(target.lt(self.cutoff[i + 1]))
- new_target[0][mask] = self.cutoff[0] + i
-
- if mask.any():
- target_idxs.append(mask.nonzero(as_tuple=False).squeeze(1))
- new_target.append(target[mask].add(-self.cutoff[i]))
- else:
- target_idxs.append(None)
- new_target.append(None)
-
- return new_target, target_idxs
-
- def forward(self, input, target):
- """
- Args:
- input: (b x t x d)
- target: (b x t)
- Returns:
- 2 lists: output for each cutoff section and new targets by cut off
- """
-
- input = input.contiguous().view(-1, input.size(-1))
- input = self.dropout_module(input)
-
- new_target, target_idxs = self.adapt_target(target)
- output = [self.head(input)]
-
- for i in range(len(target_idxs)):
- if target_idxs[i] is not None:
- output.append(self.tail[i](input.index_select(0, target_idxs[i])))
- else:
- output.append(None)
-
- return output, new_target
-
- def get_log_prob(self, input, target):
- """
- Computes the log probabilities for all the words of the vocabulary,
- given a 2D tensor of hidden vectors.
- """
-
- bsz, length, dim = input.size()
- input = input.contiguous().view(-1, dim)
-
- if target is not None:
- _, target_idxs = self.adapt_target(target)
- else:
- target_idxs = None
-
- head_y = self.head(input)
- log_probs = head_y.new_zeros(input.size(0), self.vocab_size)
-
- head_sz = self.cutoff[0] + len(self.tail)
- log_probs[:, :head_sz] = self.lsm(head_y)
- tail_priors = log_probs[:, self.cutoff[0] : head_sz].clone()
-
- for i in range(len(self.tail)):
- start = self.cutoff[i]
- end = self.cutoff[i + 1]
-
- if target_idxs is None:
- tail_out = log_probs[:, start:end]
- tail_out.copy_(self.tail[i](input))
- log_probs[:, start:end] = self.lsm(tail_out).add_(
- tail_priors[:, i, None]
- )
- elif target_idxs[i] is not None:
- idxs = target_idxs[i]
- tail_out = log_probs[idxs, start:end]
- tail_out.copy_(self.tail[i](input[idxs]))
- log_probs[idxs, start:end] = self.lsm(tail_out).add_(
- tail_priors[idxs, i, None]
- )
-
- log_probs = log_probs.view(bsz, length, -1)
- return log_probs
diff --git a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/examples/translation_moe/translation_moe_src/__init__.py b/spaces/OFA-Sys/OFA-Image_Caption/fairseq/examples/translation_moe/translation_moe_src/__init__.py
deleted file mode 100644
index c0abe53e973b4bb31cfb062708965d002c79b6e7..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/examples/translation_moe/translation_moe_src/__init__.py
+++ /dev/null
@@ -1,6 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-from . import translation_moe # noqa
diff --git a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/examples/unsupervised_quality_estimation/meteor.py b/spaces/OFA-Sys/OFA-Image_Caption/fairseq/examples/unsupervised_quality_estimation/meteor.py
deleted file mode 100644
index 2ee0448cf1f167f6f3ecee56ad807922cffb0956..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/examples/unsupervised_quality_estimation/meteor.py
+++ /dev/null
@@ -1,109 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import argparse
-import math
-import os
-import subprocess
-import sys
-import tempfile
-from collections import defaultdict
-from itertools import combinations
-
-
-def read_translations(path, n_repeats):
- segment_counter = 0
- segment_translations = []
- translations = defaultdict(list)
- for line in open(path):
- segment_translations.append(" ".join(line.split()))
- if len(segment_translations) == n_repeats:
- translations[segment_counter] = segment_translations
- segment_translations = []
- segment_counter += 1
- return translations
-
-
-def generate_input(translations, n_repeats):
- _, ref_path = tempfile.mkstemp()
- _, mt_path = tempfile.mkstemp()
- ref_fh = open(ref_path, "w")
- mt_fh = open(mt_path, "w")
- for segid in sorted(translations.keys()):
- assert len(translations[segid]) == n_repeats
- indexes = combinations(range(n_repeats), 2)
- for idx1, idx2 in indexes:
- mt_fh.write(translations[segid][idx1].strip() + "\n")
- ref_fh.write(translations[segid][idx2].strip() + "\n")
- sys.stderr.write("\nSaved translations to %s and %s" % (ref_path, mt_path))
- return ref_path, mt_path
-
-
-def run_meteor(ref_path, mt_path, metric_path, lang="en"):
- _, out_path = tempfile.mkstemp()
- subprocess.call(
- [
- "java",
- "-Xmx2G",
- "-jar",
- metric_path,
- mt_path,
- ref_path,
- "-p",
- "0.5 0.2 0.6 0.75", # default parameters, only changed alpha to give equal weight to P and R
- "-norm",
- "-l",
- lang,
- ],
- stdout=open(out_path, "w"),
- )
- os.remove(ref_path)
- os.remove(mt_path)
- sys.stderr.write("\nSaved Meteor output to %s" % out_path)
- return out_path
-
-
-def read_output(meteor_output_path, n_repeats):
- n_combinations = math.factorial(n_repeats) / (
- math.factorial(2) * math.factorial(n_repeats - 2)
- )
- raw_scores = []
- average_scores = []
- for line in open(meteor_output_path):
- if not line.startswith("Segment "):
- continue
- score = float(line.strip().split("\t")[1])
- raw_scores.append(score)
- if len(raw_scores) == n_combinations:
- average_scores.append(sum(raw_scores) / n_combinations)
- raw_scores = []
- os.remove(meteor_output_path)
- return average_scores
-
-
-def main():
- parser = argparse.ArgumentParser()
- parser.add_argument("-i", "--infile")
- parser.add_argument("-n", "--repeat_times", type=int)
- parser.add_argument("-m", "--meteor")
- parser.add_argument("-o", "--output")
- args = parser.parse_args()
-
- translations = read_translations(args.infile, args.repeat_times)
- sys.stderr.write("\nGenerating input for Meteor...")
- ref_path, mt_path = generate_input(translations, args.repeat_times)
- sys.stderr.write("\nRunning Meteor...")
- out_path = run_meteor(ref_path, mt_path, args.meteor)
- sys.stderr.write("\nReading output...")
- scores = read_output(out_path, args.repeat_times)
- sys.stderr.write("\nWriting results...")
- with open(args.output, "w") as o:
- for scr in scores:
- o.write("{}\n".format(scr))
- o.close()
-
-
-if __name__ == "__main__":
- main()
diff --git a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/fairseq/modules/dynamicconv_layer/setup.py b/spaces/OFA-Sys/OFA-Image_Caption/fairseq/fairseq/modules/dynamicconv_layer/setup.py
deleted file mode 100644
index 6a21f7e2ee0840a3b251522275a0b32a856951d7..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/fairseq/modules/dynamicconv_layer/setup.py
+++ /dev/null
@@ -1,23 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-from setuptools import setup
-from torch.utils.cpp_extension import BuildExtension, CUDAExtension
-
-
-setup(
- name="dynamicconv_layer",
- ext_modules=[
- CUDAExtension(
- name="dynamicconv_cuda",
- sources=[
- "dynamicconv_cuda.cpp",
- "dynamicconv_cuda_kernel.cu",
- ],
- ),
- ],
- cmdclass={"build_ext": BuildExtension},
-)
diff --git a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/fairseq/modules/sparse_multihead_attention.py b/spaces/OFA-Sys/OFA-Image_Caption/fairseq/fairseq/modules/sparse_multihead_attention.py
deleted file mode 100644
index 3cbd9d6785886e319aab0601517e27df733b6f97..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/fairseq/modules/sparse_multihead_attention.py
+++ /dev/null
@@ -1,140 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import math
-
-import torch
-
-from .multihead_attention import MultiheadAttention
-
-
-class SparseMultiheadAttention(MultiheadAttention):
- """Sparse Multi-Headed Attention.
-
- "Generating Long Sequences with Sparse Transformers". Implements
- fixed factorized self attention, where l=stride and c=expressivity.
- A(1) includes all words in the stride window and A(2) takes a summary of c
- words from the end of each stride window.
- If is_bidirectional=False, we do not include any words past the current word,
- as in the paper.
- """
-
- def __init__(
- self,
- embed_dim,
- num_heads,
- kdim=None,
- vdim=None,
- dropout=0.0,
- bias=True,
- add_bias_kv=False,
- add_zero_attn=False,
- self_attention=False,
- encoder_decoder_attention=False,
- stride=32,
- expressivity=8,
- is_bidirectional=True,
- ):
-
- super().__init__(
- embed_dim,
- num_heads,
- kdim,
- vdim,
- dropout,
- bias,
- add_bias_kv,
- add_zero_attn,
- self_attention,
- encoder_decoder_attention,
- )
-
- self.is_bidirectional = is_bidirectional
- self.stride = stride
- self.expressivity = expressivity
- assert self.stride > 0 and self.stride >= self.expressivity
-
- # Used for Ai(2) calculations - beginning of [l-c, l] range
- def compute_checkpoint(self, word_index):
- if word_index % self.stride == 0 and word_index != 0:
- checkpoint_index = word_index - self.expressivity
- else:
- checkpoint_index = (
- math.floor(word_index / self.stride) * self.stride
- + self.stride
- - self.expressivity
- )
- return checkpoint_index
-
- # Computes Ai(2)
- def compute_subset_summaries(self, absolute_max):
- checkpoint_index = self.compute_checkpoint(0)
- subset_two = set()
- while checkpoint_index <= absolute_max - 1:
- summary = set(
- range(
- checkpoint_index,
- min(checkpoint_index + self.expressivity + 1, absolute_max),
- )
- )
- subset_two = subset_two.union(summary)
- checkpoint_index = self.compute_checkpoint(checkpoint_index + self.stride)
- return subset_two
-
- # Sparse Transformer Fixed Attention Pattern: https://arxiv.org/pdf/1904.10509.pdf
- def compute_fixed_attention_subset(self, word_index, tgt_len):
- # +1s account for range function; [min, max) -> [min, max]
- if not self.is_bidirectional:
- absolute_max = word_index + 1
- else:
- absolute_max = tgt_len
-
- # Subset 1 - whole window
- rounded_index = (
- math.floor((word_index + self.stride) / self.stride) * self.stride
- )
- if word_index % self.stride == 0 and word_index != 0:
- subset_one = set(
- range(word_index - self.stride, min(absolute_max, word_index + 1))
- )
- else:
- subset_one = set(
- range(
- max(0, rounded_index - self.stride),
- min(absolute_max, rounded_index + 1),
- )
- )
-
- # Subset 2 - summary per window
- # If bidirectional, subset 2 is the same for every index
- subset_two = set()
- if not self.is_bidirectional:
- subset_two = self.compute_subset_summaries(absolute_max)
-
- return subset_one.union(subset_two)
-
- # Compute sparse mask - if bidirectional, can pre-compute and store
- def buffered_sparse_mask(self, tensor, tgt_len, src_len):
- assert tgt_len > self.stride
- sparse_mask = torch.empty((tgt_len, src_len)).float().fill_(float("-inf"))
-
- # If bidirectional, subset 2 is the same for every index
- subset_summaries = set()
- if self.is_bidirectional:
- subset_summaries = self.compute_subset_summaries(tgt_len)
-
- for i in range(tgt_len):
- fixed_attention_subset = self.compute_fixed_attention_subset(i, tgt_len)
- fixed_attention_subset = fixed_attention_subset.union(subset_summaries)
- included_word_indices = torch.LongTensor(list(fixed_attention_subset))
- sparse_mask[i].index_fill_(0, included_word_indices, 0)
- return sparse_mask.type_as(tensor)
-
- def apply_sparse_mask(self, attn_weights, tgt_len, src_len, bsz):
- sparse_mask = self.buffered_sparse_mask(attn_weights, tgt_len, src_len)
- sparse_mask = sparse_mask.unsqueeze(0).expand(
- bsz * self.num_heads, tgt_len, src_len
- )
- attn_weights += sparse_mask
diff --git a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/fairseq/tasks/sentence_ranking.py b/spaces/OFA-Sys/OFA-Image_Caption/fairseq/fairseq/tasks/sentence_ranking.py
deleted file mode 100644
index bed44f34e5f8e506b6ae7ba30ddaa661bf4a7522..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/fairseq/tasks/sentence_ranking.py
+++ /dev/null
@@ -1,219 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import logging
-import os
-
-import numpy as np
-from fairseq import utils
-from fairseq.data import (
- ConcatSentencesDataset,
- Dictionary,
- IdDataset,
- NestedDictionaryDataset,
- NumelDataset,
- NumSamplesDataset,
- PrependTokenDataset,
- RawLabelDataset,
- RightPadDataset,
- SortDataset,
- TruncateDataset,
- data_utils,
-)
-from fairseq.data.shorten_dataset import maybe_shorten_dataset
-from fairseq.tasks import LegacyFairseqTask, register_task
-
-
-logger = logging.getLogger(__name__)
-
-
-@register_task("sentence_ranking")
-class SentenceRankingTask(LegacyFairseqTask):
- """
- Ranking task on multiple sentences.
-
- Args:
- dictionary (Dictionary): the dictionary for the input of the task
- """
-
- @staticmethod
- def add_args(parser):
- """Add task-specific arguments to the parser."""
- parser.add_argument("data", metavar="FILE", help="file prefix for data")
- parser.add_argument(
- "--num-classes", type=int, help="number of sentences to be ranked"
- )
- parser.add_argument(
- "--init-token",
- type=int,
- help="add token at the beginning of each batch item",
- )
- parser.add_argument(
- "--separator-token", type=int, help="add separator token between inputs"
- )
- parser.add_argument("--no-shuffle", action="store_true")
- parser.add_argument(
- "--shorten-method",
- default="none",
- choices=["none", "truncate", "random_crop"],
- help="if not none, shorten sequences that exceed --tokens-per-sample",
- )
- parser.add_argument(
- "--shorten-data-split-list",
- default="",
- help="comma-separated list of dataset splits to apply shortening to, "
- 'e.g., "train,valid" (default: all dataset splits)',
- )
- parser.add_argument(
- "--max-option-length", type=int, help="max length for each option"
- )
-
- def __init__(self, args, dictionary):
- super().__init__(args)
- self.dictionary = dictionary
-
- @classmethod
- def load_dictionary(cls, args, filename, source=True):
- """Load the dictionary from the filename
-
- Args:
- filename (str): the filename
- """
- dictionary = Dictionary.load(filename)
- dictionary.add_symbol("<mask>")
- return dictionary
-
- @classmethod
- def setup_task(cls, args, **kwargs):
- assert (
- args.criterion == "sentence_ranking"
- ), "Must set --criterion=sentence_ranking"
-
- # load data dictionary
- data_dict = cls.load_dictionary(
- args,
- os.path.join(args.data, "input0", "dict.txt"),
- source=True,
- )
- logger.info("[input] dictionary: {} types".format(len(data_dict)))
- return SentenceRankingTask(args, data_dict)
-
- def load_dataset(self, split, combine=False, **kwargs):
- """Load a given dataset split (e.g., train, valid, test)."""
-
- def get_path(type, split):
- return os.path.join(self.args.data, type, split)
-
- def make_dataset(type, dictionary):
- split_path = get_path(type, split)
-
- dataset = data_utils.load_indexed_dataset(
- split_path,
- self.source_dictionary,
- self.args.dataset_impl,
- combine=combine,
- )
- return dataset
-
- input0 = make_dataset("input0", self.source_dictionary)
- input_options = [
- make_dataset("input{idx}".format(idx=idx + 1), self.source_dictionary)
- for idx in range(self.args.num_classes)
- ]
-
- if self.args.separator_token is not None:
- input0 = PrependTokenDataset(input0, self.args.separator_token)
-
- src_tokens = []
- for input_option in input_options:
- if self.args.init_token is not None:
- input_option = PrependTokenDataset(input_option, self.args.init_token)
- if self.args.max_option_length is not None:
- input_option = TruncateDataset(
- input_option, self.args.max_option_length
- )
- src_token = ConcatSentencesDataset(input_option, input0)
- src_token = maybe_shorten_dataset(
- src_token,
- split,
- self.args.shorten_data_split_list,
- self.args.shorten_method,
- self.args.max_positions,
- self.args.seed,
- )
- src_tokens.append(src_token)
-
- with data_utils.numpy_seed(self.args.seed):
- shuffle = np.random.permutation(len(src_tokens[0]))
-
- dataset = {
- "id": IdDataset(),
- "nsentences": NumSamplesDataset(),
- "ntokens": NumelDataset(src_tokens[0], reduce=True),
- }
-
- for src_token_idx in range(len(src_tokens)):
- dataset.update(
- {
- "net_input{idx}".format(idx=src_token_idx + 1): {
- "src_tokens": RightPadDataset(
- src_tokens[src_token_idx],
- pad_idx=self.source_dictionary.pad(),
- ),
- "src_lengths": NumelDataset(
- src_tokens[src_token_idx], reduce=False
- ),
- }
- }
- )
-
- label_path = "{}.label".format(get_path("label", split))
- if os.path.exists(label_path):
- with open(label_path) as h:
- dataset.update(
- target=RawLabelDataset([int(x.strip()) for x in h.readlines()])
- )
-
- nested_dataset = NestedDictionaryDataset(
- dataset,
- sizes=[np.maximum.reduce([src_token.sizes for src_token in src_tokens])],
- )
-
- if self.args.no_shuffle:
- dataset = nested_dataset
- else:
- dataset = SortDataset(
- nested_dataset,
- # shuffle
- sort_order=[shuffle],
- )
-
- logger.info("Loaded {0} with #samples: {1}".format(split, len(dataset)))
-
- self.datasets[split] = dataset
- return self.datasets[split]
-
- def build_model(self, args):
- from fairseq import models
-
- model = models.build_model(args, self)
-
- model.register_classification_head(
- getattr(args, "ranking_head_name", "sentence_classification_head"),
- num_classes=1,
- )
-
- return model
-
- def max_positions(self):
- return self.args.max_positions
-
- @property
- def source_dictionary(self):
- return self.dictionary
-
- @property
- def target_dictionary(self):
- return self.dictionary
diff --git a/spaces/OFA-Sys/OFA-vqa/fairseq/fairseq/data/resampling_dataset.py b/spaces/OFA-Sys/OFA-vqa/fairseq/fairseq/data/resampling_dataset.py
deleted file mode 100644
index 3d3b993164dc3962df48bacff26714328e843e80..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-vqa/fairseq/fairseq/data/resampling_dataset.py
+++ /dev/null
@@ -1,139 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import logging
-
-import numpy as np
-from fairseq.data import BaseWrapperDataset, plasma_utils
-
-
-logger = logging.getLogger(__name__)
-
-
-class ResamplingDataset(BaseWrapperDataset):
- """Randomly samples from a given dataset at each epoch.
-
- Sampling is done with or without replacement, depending on the "replace"
- parameter.
-
- Optionally, the epoch size can be rescaled. This is potentially desirable
- to increase per-epoch coverage of the base dataset (since sampling with
- replacement means that many items in the dataset will be left out). In the
- case of sampling without replacement, size_ratio should be strictly less
- than 1.
-
- Args:
- dataset (~torch.utils.data.Dataset): dataset on which to sample.
- weights (List[float]): list of probability weights
- (default: None, which corresponds to uniform sampling).
- replace (bool): sampling mode; True for "with replacement", or False
- for "without replacement" (default: True)
- size_ratio (float): the ratio to subsample to; must be positive
- (default: 1.0).
- batch_by_size (bool): whether or not to batch by sequence length
- (default: True).
- seed (int): RNG seed to use (default: 0).
- epoch (int): starting epoch number (default: 1).
- """
-
- def __init__(
- self,
- dataset,
- weights=None,
- replace=True,
- size_ratio=1.0,
- batch_by_size=True,
- seed=0,
- epoch=1,
- ):
- super().__init__(dataset)
-
- if weights is None:
- self.weights = None
-
- else:
- assert len(weights) == len(dataset)
- weights_arr = np.array(weights, dtype=np.float64)
- weights_arr /= weights_arr.sum()
- self.weights = plasma_utils.PlasmaArray(weights_arr)
-
- self.replace = replace
-
- assert size_ratio > 0.0
- if not self.replace:
- assert size_ratio < 1.0
- self.size_ratio = float(size_ratio)
- self.actual_size = np.ceil(len(dataset) * self.size_ratio).astype(int)
-
- self.batch_by_size = batch_by_size
- self.seed = seed
-
- self._cur_epoch = None
- self._cur_indices = None
-
- self.set_epoch(epoch)
-
- def __getitem__(self, index):
- return self.dataset[self._cur_indices.array[index]]
-
- def __len__(self):
- return self.actual_size
-
- @property
- def sizes(self):
- if isinstance(self.dataset.sizes, list):
- return [s[self._cur_indices.array] for s in self.dataset.sizes]
- return self.dataset.sizes[self._cur_indices.array]
-
- def num_tokens(self, index):
- return self.dataset.num_tokens(self._cur_indices.array[index])
-
- def size(self, index):
- return self.dataset.size(self._cur_indices.array[index])
-
- def ordered_indices(self):
- if self.batch_by_size:
- order = [
- np.arange(len(self)),
- self.sizes,
- ] # No need to handle `self.shuffle == True`
- return np.lexsort(order)
- else:
- return np.arange(len(self))
-
- def prefetch(self, indices):
- self.dataset.prefetch(self._cur_indices.array[indices])
-
- @property
- def can_reuse_epoch_itr_across_epochs(self):
- return False
-
- def set_epoch(self, epoch):
- logger.debug("ResamplingDataset.set_epoch: {}".format(epoch))
- super().set_epoch(epoch)
-
- if epoch == self._cur_epoch:
- return
-
- self._cur_epoch = epoch
-
- # Generate a weighted sample of indices as a function of the
- # random seed and the current epoch.
-
- rng = np.random.RandomState(
- [
- 42, # magic number
- self.seed % (2 ** 32), # global seed
- self._cur_epoch, # epoch index
- ]
- )
- self._cur_indices = plasma_utils.PlasmaArray(
- rng.choice(
- len(self.dataset),
- self.actual_size,
- replace=self.replace,
- p=(None if self.weights is None else self.weights.array),
- )
- )
diff --git a/spaces/OFA-Sys/OFA-vqa/fairseq/fairseq/search.py b/spaces/OFA-Sys/OFA-vqa/fairseq/fairseq/search.py
deleted file mode 100644
index d5ea68b4ce04409c504c1d22098b7968a9ce596a..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-vqa/fairseq/fairseq/search.py
+++ /dev/null
@@ -1,814 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import math
-from typing import List, Optional
-
-import torch
-import torch.nn as nn
-from fairseq.token_generation_constraints import (
- ConstraintState,
- OrderedConstraintState,
- UnorderedConstraintState,
-)
-from torch import Tensor
-
-
-class Search(nn.Module):
- def __init__(self, tgt_dict):
- super().__init__()
- self.pad = tgt_dict.pad()
- self.unk = tgt_dict.unk()
- self.eos = tgt_dict.eos()
- self.vocab_size = len(tgt_dict)
- self.src_lengths = torch.tensor(-1)
- self.supports_constraints = False
- self.stop_on_max_len = False
-
- def step(
- self, step, lprobs, scores, prev_output_tokens=None, original_batch_idxs=None
- ):
- """Take a single search step.
-
- Args:
- step: the current search step, starting at 0
- lprobs: (bsz x input_beam_size x vocab_size)
- the model's log-probabilities over the vocabulary at the current step
- scores: (bsz x input_beam_size x step)
- the historical model scores of each hypothesis up to this point
- prev_output_tokens: (bsz x step)
- the previously generated oputput tokens
- original_batch_idxs: (bsz)
- the tensor with the batch indices, in the range [0, bsz)
- this is useful in case there has been applied a re-ordering
- and we need to know the orignal indices
-
- Return: A tuple of (scores, indices, beams) where:
- scores: (bsz x output_beam_size)
- the scores of the chosen elements; output_beam_size can be
- larger than input_beam_size, e.g., we may return
- 2*input_beam_size to account for EOS
- indices: (bsz x output_beam_size)
- the indices of the chosen elements
- beams: (bsz x output_beam_size)
- the hypothesis ids of the chosen elements, in the range [0, input_beam_size)
- """
- raise NotImplementedError
-
- @torch.jit.export
- def set_src_lengths(self, src_lengths):
- self.src_lengths = src_lengths
-
- @torch.jit.export
- def init_constraints(self, batch_constraints: Optional[Tensor], beam_size: int):
- """Initialize constraint states for constrained decoding (if supported).
-
- Args:
- batch_constraints: (torch.Tensor, optional)
- the list of constraints, in packed form
- beam_size: (int)
- the beam size
- Returns:
- *encoder_out* rearranged according to *new_order*
- """
- pass
-
- def prune_sentences(self, batch_idxs: Tensor):
- """
- Removes constraint states for completed sentences (if supported).
- This is called from sequence_generator._generate() when sentences are
- deleted from the batch.
-
- Args:
- batch_idxs: Indices of *sentences* whose constraint state should be *kept*.
- """
- pass
-
- def update_constraints(self, active_hypos: Tensor):
- """
- Updates the constraint states by selecting the beam items that are retained.
- This is called at each time step of sequence_generator._generate() when
- the set of 2 * {beam_size} candidate hypotheses are reduced to the beam size.
-
- Args:
- active_hypos: (batch size, beam size)
- list of integers denoting, for each sentence, which beam candidate items
- should be kept.
- """
- pass
-
-
-class BeamSearch(Search):
- def __init__(self, tgt_dict):
- super().__init__(tgt_dict)
- self.constraint_states = None
-
- @torch.jit.export
- def step(
- self,
- step: int,
- lprobs,
- scores: Optional[Tensor],
- prev_output_tokens: Optional[Tensor] = None,
- original_batch_idxs: Optional[Tensor] = None,
- ):
- bsz, beam_size, vocab_size = lprobs.size()
-
- if step == 0:
- # at the first step all hypotheses are equally likely, so use
- # only the first beam
- lprobs = lprobs[:, ::beam_size, :].contiguous()
- else:
- # make probs contain cumulative scores for each hypothesis
- assert scores is not None
- lprobs = lprobs + scores[:, :, step - 1].unsqueeze(-1)
-
- top_prediction = torch.topk(
- lprobs.view(bsz, -1),
- k=min(
- # Take the best 2 x beam_size predictions. We'll choose the first
- # beam_size of these which don't predict eos to continue with.
- beam_size * 2,
- lprobs.view(bsz, -1).size(1) - 1, # -1 so we never select pad
- ),
- )
- scores_buf = top_prediction[0]
- indices_buf = top_prediction[1]
- # Project back into relative indices and beams
- beams_buf = indices_buf // vocab_size
- indices_buf = indices_buf.fmod(vocab_size)
-
- # At this point, beams_buf and indices_buf are single-dim and contain relative indices
- return scores_buf, indices_buf, beams_buf
-
-
-class PrefixConstrainedBeamSearch(Search):
- def __init__(self, tgt_dict, prefix_allowed_tokens_fn):
- super().__init__(tgt_dict)
- self.prefix_allowed_tokens_fn = prefix_allowed_tokens_fn
- self.stop_on_max_len = True
-
- @torch.jit.export
- def apply_mask(self, x, prev_output_tokens, original_batch_idxs):
- beam_size = x.shape[0] // original_batch_idxs.shape[0]
- original_batch_idxs = (
- original_batch_idxs.unsqueeze(-1).repeat((1, beam_size)).flatten().tolist()
- )
-
- mask = torch.full_like(x, -math.inf)
- for sent_i, (sent, batch_i) in enumerate(
- zip(prev_output_tokens, original_batch_idxs)
- ):
- mask[sent_i, :, self.prefix_allowed_tokens_fn(batch_i, sent)] = 0
-
- return mask
-
- @torch.jit.export
- def step(
- self,
- step: int,
- lprobs: Tensor,
- scores: Tensor,
- prev_output_tokens: Tensor,
- original_batch_idxs: Tensor,
- ):
- bsz, beam_size, vocab_size = lprobs.size()
-
- lprobs += self.apply_mask(
- lprobs.view(bsz * beam_size, 1, vocab_size),
- prev_output_tokens,
- original_batch_idxs,
- ).view(bsz, beam_size, vocab_size)
-
- if step == 0:
- # at the first step all hypotheses are equally likely, so use
- # only the first beam
- lprobs = lprobs[:, ::beam_size, :].contiguous()
- else:
- # make probs contain cumulative scores for each hypothesis
- assert scores is not None
- lprobs = lprobs + scores[:, :, step - 1].unsqueeze(-1)
-
- top_prediction = torch.topk(
- lprobs.view(bsz, -1),
- k=min(
- # Take the best beam_size predictions. We'll choose the first
- # beam_size of these which don't predict eos to continue with.
- beam_size,
- lprobs.view(bsz, -1).size(1) - 1, # -1 so we never select pad
- ),
- )
- scores_buf = top_prediction[0]
- indices_buf = top_prediction[1]
- beams_buf = indices_buf // vocab_size
- indices_buf = indices_buf.fmod(vocab_size)
- return scores_buf, indices_buf, beams_buf
-
-
-class LexicallyConstrainedBeamSearch(Search):
- """Implements lexically constrained beam search as described in
-
- Fast Lexically Constrained Decoding with Dynamic Beam
- Allocation for Neural Machine Translation. Post & Vilar,
- NAACL 2018. https://www.aclweb.org/anthology/N18-1119/
-
- and
-
- Improved Lexically Constrained Decoding for Translation and
- Monolingual Rewriting. Hu et al, NAACL
- 2019. https://www.aclweb.org/anthology/N19-1090/
-
- This is accomplished by maintaining, for each beam hypothesis, a
- ConstraintState object (see constraints.py) that tracks which
- constraints have been generated and using this information to
- shape the beam for each input sentence.
- """
-
- def __init__(self, tgt_dict, representation):
- super().__init__(tgt_dict)
- self.representation = representation
- self.vocab_size = len(tgt_dict)
- self.num_cands = 0
- self.supports_constraints = True
-
- @torch.jit.export
- def init_constraints(self, batch_constraints: Optional[Tensor], beam_size: int):
- self.constraint_states = []
- for constraint_tensor in batch_constraints:
- if self.representation == "ordered":
- constraint_state = OrderedConstraintState.create(constraint_tensor)
- elif self.representation == "unordered":
- constraint_state = UnorderedConstraintState.create(constraint_tensor)
-
- self.constraint_states.append([constraint_state for i in range(beam_size)])
-
- @torch.jit.export
- def prune_sentences(self, batch_idxs: Tensor):
- self.constraint_states = [
- self.constraint_states[i] for i in batch_idxs.tolist()
- ]
-
- @torch.jit.export
- def update_constraints(self, active_hypos: Tensor):
- if self.constraint_states:
- batch_size = active_hypos.size(0)
- for sentid in range(batch_size):
- self.constraint_states[sentid] = [
- self.constraint_states[sentid][i] for i in active_hypos[sentid]
- ]
-
- @torch.jit.export
- def step(
- self,
- step: int,
- lprobs: Tensor,
- scores: Optional[Tensor],
- prev_output_tokens: Optional[Tensor] = None,
- original_batch_idxs: Optional[Tensor] = None,
- ):
- """
- A constrained step builds a large candidates list from the following:
- - the top 2 * {beam_size} items over the whole beam
- - for each item in the beam
- - the top {each_k} (default 1)
- - all next constraints
- We then compute the constrained state of each beam item, and assign
- stripe codes: 0 to the best in each bank, 1 to the 2nd-best, and so
- on. We then sort by (stripe, score), and truncate the list at
- 2 * beam size.
-
- Args:
- step: the decoder step
- lprobs: (batch size, beam size, target vocab)
- the target-vocab distributions for each item in the beam.
- Retrun: A tuple of (scores, indices, beams, constraints) where:
- scores: (batch, output beam size)
- the scores of the chosen elements
- indices: (batch, output beam size)
- the target vocab indices of the chosen elements
- beams: (batch, output beam size)
- the 0-indexed hypothesis ids of the chosen elements
- constraints: (batch, output beam size)
- the new constraint states
- """
- each_k = 1
- device = lprobs.device
-
- batch_size, beam_size, vocab_size = lprobs.size()
-
- self.num_cands = min(
- # Just take the k-best. We'll get another k from the 1-best from each
- # row, plus more from the constraints
- beam_size * 2,
- lprobs.view(batch_size, -1).size(1) - 1, # -1 so we never select pad
- )
-
- # STEP 0: Preliminary. Prevent EOS for unfinished hyps across all batch items
- constraint_states = self.constraint_states
- if constraint_states and step > 0:
- not_finished_indices = []
- for sentno, sent_constraints in enumerate(constraint_states):
- for beamno, state in enumerate(sent_constraints):
- index = sentno * beam_size + beamno
- if not state.finished:
- not_finished_indices.append(index)
- not_finished_indices = torch.tensor(not_finished_indices)
- if not_finished_indices.numel() > 0:
- lprobs.view(batch_size * beam_size, -1)[
- not_finished_indices, self.eos
- ] = -math.inf
-
- if step == 0:
- # at the first step all hypotheses are equally likely, so use
- # only the first beam entry for each batch item
- lprobs = lprobs[:, ::beam_size, :].contiguous()
- else:
- # make probs contain cumulative scores for each hypothesis
- assert scores is not None
- lprobs = lprobs + scores[:, :, step - 1].unsqueeze(-1)
-
- top_prediction = torch.topk(
- lprobs.view(batch_size, -1),
- self.num_cands,
- )
- scores_buf, indices_buf = top_prediction
- # Project back into relative indices and beams
- beams_buf = indices_buf // vocab_size
- indices_buf = indices_buf.fmod(vocab_size)
-
- # Short circuit if there are no constraints in this batch
- if not constraint_states:
- return scores_buf, indices_buf, beams_buf
-
- # STEP 1: get top-1 from each hypothesis across all sentences in the batch
- if step > 0:
- top_scores, top_indices = torch.topk(
- lprobs.view(batch_size * beam_size, -1),
- k=each_k,
- dim=1,
- )
- top_scores = top_scores.view(batch_size, -1)
- top_indices = top_indices.view(batch_size, -1)
- scores_buf = torch.cat((scores_buf, top_scores), dim=1)
- indices_buf = torch.cat((indices_buf, top_indices), dim=1)
- new_beams = torch.arange(0, beam_size, device=device).repeat(batch_size, 1)
- beams_buf = torch.cat((beams_buf, new_beams), dim=1)
-
- # Now, process sentences in the batch one by one.
- new_scores_buf = torch.zeros((batch_size, 2 * beam_size), device=device)
- new_indices_buf = torch.zeros((batch_size, 2 * beam_size), device=device).long()
- new_beams_buf = torch.zeros((batch_size, 2 * beam_size), device=device).long()
- for sentno, states in enumerate(constraint_states):
- scores, indices, beams, new_states = self.step_sentence(
- step,
- sentno,
- lprobs[sentno],
- constraint_states[sentno],
- beams_buf[sentno].clone(),
- indices_buf[sentno].clone(),
- scores_buf[sentno].clone(),
- )
- new_scores_buf[sentno] = scores
- new_indices_buf[sentno] = indices
- new_beams_buf[sentno] = beams
- self.constraint_states[sentno] = new_states
-
- return new_scores_buf, new_indices_buf, new_beams_buf
-
- @torch.jit.export
- def step_sentence(
- self,
- step: int,
- sentno: int,
- lprobs: Tensor,
- constraint_states: List[List[ConstraintState]],
- beams_buf: Tensor,
- indices_buf: Tensor,
- scores_buf: Tensor,
- ):
- """Does per-sentence processing. Adds all constraints for each
- hypothesis to the list of candidates; then removes duplicates,
- sorts, and dynamically stripes across the banks. All tensor inputs
- are collapsed to those pertaining to a single input sentence.
- """
- device = lprobs.device
-
- # STEP 2: Add all constraints for each beam item
- for beamno, state in enumerate(constraint_states):
- next_tokens = torch.tensor(list(state.next_tokens()), device=device).long()
- if next_tokens.numel() != 0:
- indices_buf = torch.cat((indices_buf, next_tokens))
- next_beams = (
- torch.tensor(beamno, device=device)
- .repeat(next_tokens.size(0))
- .long()
- )
- beams_buf = torch.cat((beams_buf, next_beams))
- next_values = lprobs[beamno].take(next_tokens.view(-1))
- scores_buf = torch.cat((scores_buf, next_values))
-
- # At the 0th time step, there is just one beam item
- if step == 0:
- break
-
- # STEP 3: Compute the "bank" for each candidate. This is the
- # number of constraints it's generated. We need this so that
- # we can do round-robin allocation of the beam across these
- # banks. If C is the number of constraints, we select the best
- # item in bank C, then the best in bank C-1, etc, followed by
- # the 2nd-best in bank C, the 2nd-best in bank C-1, etc, and so
- # on, until the maximum beam size. We accomplish this by
- # creating a sort key and striping across the banks.
-
- # Compute the new states for all candidates
- cands_size = indices_buf.size(0)
- constraint_states = [
- constraint_states[beams_buf[i]].advance(indices_buf[i])
- for i in range(cands_size)
- ]
-
- banks = torch.tensor([state.bank for state in constraint_states], device=device)
-
- # STEP 4: Sort
- num_constraint_tokens = len(state.tokens)
-
- # Sort by keys (bank, score) (i.e., sort banks together, and scores
- # within banks). AFAIK pytorch doesn't support either stable sort or
- # multi-key sorting, so we have to hack this.
- MAX_SCORE = -100
- sort_key = (num_constraint_tokens - banks) * MAX_SCORE + scores_buf
- sort_values, sort_indices = sort_key.sort(dim=0, descending=True)
- scores_buf = scores_buf[sort_indices]
- indices_buf = indices_buf[sort_indices]
- beams_buf = beams_buf[sort_indices]
- banks = banks[sort_indices]
-
- # Sort the constraints to follow suit
- constraint_states = [constraint_states[i] for i in sort_indices]
-
- # STEP 5: Remove duplicates. The topk calls (overall and
- # per-row) plus the per-row generation of constraints will
- # produce duplicates. Here we remove them.
-
- def roll(t):
- """Rolls a 1d tensor left by 1.
-
- [0, 1, 2, 3, 4] becomes [4, 0, 1, 2, 3]
- """
- return torch.cat((t[-1].unsqueeze(0), t[0:-1]), dim=0)
-
- # We map candidates (beam, token_id) to a single dimension.
- # This is then shifted by 1. We can then easily identify
- # duplicates and create a mask that identifies unique
- # extensions.
- uniques_mask = beams_buf * (self.vocab_size + 1) + indices_buf
- uniques_mask = roll(uniques_mask) != uniques_mask
-
- # Use the mask to pare down the data structures
- scores_buf = torch.masked_select(scores_buf, uniques_mask)
- indices_buf = torch.masked_select(indices_buf, uniques_mask)
- beams_buf = torch.masked_select(beams_buf, uniques_mask)
- banks = torch.masked_select(banks, uniques_mask)
- i = 1
- for mask in uniques_mask[1:]:
- if not mask:
- constraint_states.pop(i)
- i += mask
-
- # STEP 6: Assign IDs round-robin across banks, sort, and
- # truncate. Now that the candidates are sorted by (bank,
- # score) and uniqed, we dynamically allocate the {beam_size}
- # beam by striping across the candidates. These stripes will
- # be used as sort keys to do round-robin selection. This is
- # accomplished in a single pass with offsets. Sorting by
- # highest-banks (furthest-along hypotheses) first ensures
- # progress through the constraints.
- #
- # e.g., BANKS: 3 3 3 2 2 2 2 1 1 1 0 0
- # OLD STRIPES: 0 1 2 0 1 2 3 0 1 2 0 1
- # NEW STRIPES: 0 1+4 2+8 0+1 1+5 2+9 3+11 0+2 1+6 2+10 0+3 1+7
- # = 0 5 10 1 6 11 13 2 7 12 3 8
- #
- # Sorting by this then gives the following banks:
- #
- # 3 2 1 0 3 2 1 0 3 2 1 2
- #
- # We'll take the top {beam_size} of these.
- stripe_offsets = [offset * (len(banks) + 1) for offset in range(len(banks) + 1)]
- stripes = torch.zeros_like(banks)
- cur_bank_count = -1
- cur_bank = banks[0]
- for i, bank in enumerate(banks):
- if bank != cur_bank:
- cur_bank_count = 0
- cur_bank = bank
- else:
- cur_bank_count += 1
- stripes[i] = num_constraint_tokens - bank + stripe_offsets[cur_bank_count]
-
- # STEP 7: Sort by the stripes values
- sort_values, sort_indices = stripes.sort(dim=0)
- scores_buf = scores_buf[sort_indices]
- indices_buf = indices_buf[sort_indices]
- beams_buf = beams_buf[sort_indices]
- constraint_states = [constraint_states[i] for i in sort_indices]
-
- # STEP 8: Truncate to the candidates size!
- scores_buf = scores_buf[: self.num_cands]
- indices_buf = indices_buf[: self.num_cands]
- beams_buf = beams_buf[: self.num_cands]
-
- return scores_buf, indices_buf, beams_buf, constraint_states
-
-
-class LengthConstrainedBeamSearch(Search):
- def __init__(self, tgt_dict, min_len_a, min_len_b, max_len_a, max_len_b):
- super().__init__(tgt_dict)
- self.min_len_a = min_len_a
- self.min_len_b = min_len_b
- self.max_len_a = max_len_a
- self.max_len_b = max_len_b
- self.beam = BeamSearch(tgt_dict)
- self.needs_src_lengths = True
-
- def step(
- self,
- step: int,
- lprobs,
- scores,
- prev_output_tokens: Optional[Tensor] = None,
- original_batch_idxs: Optional[Tensor] = None,
- ):
- min_lens = self.min_len_a * self.src_lengths + self.min_len_b
- max_lens = self.max_len_a * self.src_lengths + self.max_len_b
- lprobs[step < min_lens, :, self.eos] = -math.inf
- lprobs[step >= max_lens, :, self.eos] = 0
- return self.beam.step(step, lprobs, scores)
-
-
-class DiverseBeamSearch(Search):
- """Diverse Beam Search.
-
- See "Diverse Beam Search: Decoding Diverse Solutions from Neural Sequence
- Models" for details.
-
- We only implement the Hamming Diversity penalty here, which performed best
- in the original paper.
- """
-
- def __init__(self, tgt_dict, num_groups, diversity_strength):
- super().__init__(tgt_dict)
- self.num_groups = num_groups
- self.diversity_strength = -diversity_strength
- self.beam = BeamSearch(tgt_dict)
-
- @torch.jit.export
- def step(
- self,
- step: int,
- lprobs,
- scores,
- prev_output_tokens: Optional[Tensor] = None,
- original_batch_idxs: Optional[Tensor] = None,
- ):
- bsz, beam_size, vocab_size = lprobs.size()
- if beam_size % self.num_groups != 0:
- raise ValueError(
- "DiverseBeamSearch requires --beam to be divisible by the number of groups"
- )
-
- # initialize diversity penalty
- diversity_buf = torch.zeros(lprobs[:, 0, :].size()).to(lprobs)
-
- scores_G, indices_G, beams_G = [], [], []
- for g in range(self.num_groups):
- lprobs_g = lprobs[:, g :: self.num_groups, :]
- scores_g = scores[:, g :: self.num_groups, :] if step > 0 else None
-
- # apply diversity penalty
- if g > 0:
- lprobs_g = torch.add(
- lprobs_g,
- other=diversity_buf.unsqueeze(1),
- alpha=self.diversity_strength,
- )
- else:
- lprobs_g = lprobs_g.contiguous()
-
- scores_buf, indices_buf, beams_buf = self.beam.step(
- step, lprobs_g, scores_g
- )
- beams_buf.mul_(self.num_groups).add_(g)
-
- scores_G.append(scores_buf.clone())
- indices_G.append(indices_buf.clone())
- beams_G.append(beams_buf.clone())
-
- # update diversity penalty
- diversity_buf.scatter_add_(
- 1, indices_buf, torch.ones(indices_buf.size()).to(diversity_buf)
- )
-
- # interleave results from different groups
- scores_buf = torch.stack(scores_G, dim=2).view(bsz, -1)
- indices_buf = torch.stack(indices_G, dim=2).view(bsz, -1)
- beams_buf = torch.stack(beams_G, dim=2).view(bsz, -1)
- return scores_buf, indices_buf, beams_buf
-
-
-class Sampling(Search):
- sampling_topk: int
- sampling_topp: float
-
- def __init__(self, tgt_dict, sampling_topk=-1, sampling_topp=-1.0):
- super().__init__(tgt_dict)
- self.sampling_topk = sampling_topk
- self.sampling_topp = sampling_topp
-
- def _sample_topp(self, lprobs):
- """Sample among the smallest set of elements whose cumulative probability mass exceeds p.
-
- See `"The Curious Case of Neural Text Degeneration"
- (Holtzman et al., 2019) <https://arxiv.org/abs/1904.09751>`_.
-
- Args:
- lprobs: (bsz x input_beam_size x vocab_size)
- the model's log-probabilities over the vocabulary at the current step
-
- Return: A tuple of (trimed_probs, truncated_indices) where:
- trimed_probs: (bsz x input_beam_size x ?)
- the model's probabilities over the elements selected to sample from. The
- width of the third dimension is determined by top-P.
- truncated_indices: (bsz x input_beam_size x ?)
- the indices of the chosen elements.
- """
- probs = lprobs.exp_()
-
- # sort the last dimension (vocab dimension) in descending order
- sorted_probs, sorted_indices = probs.sort(descending=True)
-
- # compute a mask to indicate the words to be included in the top-P set.
- cumsum_probs = sorted_probs.cumsum(dim=2)
- mask = cumsum_probs.lt(self.sampling_topp)
-
- # note that mask was computed by 'lt'. One more word needs to be included
- # so that the cumulative probability mass can exceed p.
- cumsum_mask = mask.cumsum(dim=2)
- last_included = cumsum_mask[:, :, -1:]
- last_included.clamp_(0, mask.size()[2] - 1)
- mask = mask.scatter_(2, last_included, 1)
-
- # truncate unnecessary dims.
- max_dim = last_included.max()
- truncated_mask = mask[:, :, : max_dim + 1]
- truncated_probs = sorted_probs[:, :, : max_dim + 1]
- truncated_indices = sorted_indices[:, :, : max_dim + 1]
-
- # trim the words that are not in top-P by setting their probabilities
- # to 0, so that they would not be sampled later.
- trim_mask = ~truncated_mask
- trimed_probs = truncated_probs.masked_fill_(trim_mask, 0)
- return trimed_probs, truncated_indices
-
- @torch.jit.export
- def step(
- self,
- step: int,
- lprobs,
- scores,
- prev_output_tokens: Optional[Tensor] = None,
- original_batch_idxs: Optional[Tensor] = None,
- ):
- bsz, beam_size, vocab_size = lprobs.size()
-
- if step == 0:
- # at the first step all hypotheses are equally likely, so use
- # only the first beam
- lprobs = lprobs[:, ::beam_size, :].contiguous()
-
- if self.sampling_topp > 0:
- # only sample from the smallest set of words whose cumulative probability mass exceeds p
- probs, top_indices = self._sample_topp(lprobs)
- elif self.sampling_topk > 0:
- # only sample from top-k candidates
- lprobs, top_indices = lprobs.topk(self.sampling_topk)
- probs = lprobs.exp_()
- else:
- probs = lprobs.exp_()
-
- # dummy data to be consistent with true branch for type check
- top_indices = torch.empty(0).to(probs)
- # sample
- if step == 0:
- indices_buf = torch.multinomial(
- probs.view(bsz, -1),
- beam_size,
- replacement=True,
- ).view(bsz, beam_size)
- else:
- indices_buf = torch.multinomial(
- probs.view(bsz * beam_size, -1),
- 1,
- replacement=True,
- ).view(bsz, beam_size)
-
- if step == 0:
- # expand to beam size
- probs = probs.expand(bsz, beam_size, -1)
-
- # gather scores
- scores_buf = torch.gather(probs, dim=2, index=indices_buf.unsqueeze(-1))
- scores_buf = scores_buf.log_().view(bsz, -1)
-
- # remap indices if using top-k or top-P sampling
- if self.sampling_topk > 0 or self.sampling_topp > 0:
- indices_buf = torch.gather(
- top_indices.expand(bsz, beam_size, -1),
- dim=2,
- index=indices_buf.unsqueeze(-1),
- ).squeeze(2)
-
- if step == 0:
- beams_buf = indices_buf.new_zeros(bsz, beam_size)
- else:
- beams_buf = torch.arange(0, beam_size).to(indices_buf).repeat(bsz, 1)
- # make scores cumulative
- scores_buf.add_(
- torch.gather(scores[:, :, step - 1], dim=1, index=beams_buf)
- )
-
- return scores_buf, indices_buf, beams_buf
-
-
-class DiverseSiblingsSearch(Search):
- """
- Beam search with diverse siblings.
-
- See "A Simple, Fast Diverse Decoding Algorithm for Neural Generation" for details.
- https://arxiv.org/abs/1611.08562
-
- 1/ Calculate hypotheses for each beam
- 2/ Intra-sibling ordering
- 3/ Rewrite scores
- 4/ Choose top K hypotheses
-
- if diversity_rate == 0 is equivalent to BeamSearch
- """
-
- def __init__(self, tgt_dict, diversity_rate):
- super().__init__(tgt_dict)
- self.diversity_rate = diversity_rate
- self.beam = BeamSearch(tgt_dict)
-
- def step(
- self,
- step: int,
- lprobs,
- scores,
- prev_output_tokens: Optional[Tensor] = None,
- original_batch_idxs: Optional[Tensor] = None,
- ):
- bsz, beam_size, vocab_size = lprobs.size()
- k = min(
- # Take the best 2 x beam_size predictions. We'll choose the first
- # beam_size of these which don't predict eos to continue with.
- beam_size * 2,
- lprobs.view(bsz, -1).size(1) - 1, # -1 so we never select pad
- )
- s_list: List[Tensor]
- i_list: List[Tensor]
- s_list = [torch.empty(0).to(lprobs) for i in range(beam_size)]
- i_list = [torch.LongTensor().to(device=lprobs.device) for i in range(beam_size)]
- sibling_score = torch.arange(1, k + 1).to(lprobs) * self.diversity_rate
-
- if step == 0:
- return self.beam.step(step, lprobs, scores)
- lprobs.add_(scores[:, :, step - 1].unsqueeze(-1))
-
- # 1/ Calculate hypotheses for each beam
- for i in range(beam_size):
- torch.topk(lprobs[:, i, :].view(bsz, -1), k, out=(s_list[i], i_list[i]))
- i_list[i].fmod_(vocab_size)
-
- # 2/ Intra-sibling ordering by default from topk + 3/ Rewrite scores
- s_list[i].sub_(sibling_score)
-
- # 4/ Choose top K hypotheses
- indices = torch.stack(i_list, dim=1).view(bsz, -1)
-
- final_scores = torch.empty(0).to(lprobs)
- final_indices = torch.LongTensor().to(device=lprobs.device)
- final_beams = torch.LongTensor().to(device=lprobs.device)
- (final_scores, final_indices) = torch.topk(
- torch.stack(s_list, dim=1).view(bsz, -1),
- k,
- )
-
- final_beams = final_indices // k
-
- for i in range(bsz):
- final_indices[i] = indices[i][final_indices[i]]
-
- return final_scores, final_indices, final_beams
diff --git a/spaces/OFA-Sys/OFA-vqa/fairseq/fairseq/tasks/frm_text_to_speech.py b/spaces/OFA-Sys/OFA-vqa/fairseq/fairseq/tasks/frm_text_to_speech.py
deleted file mode 100644
index 1fa9b0f83e742aefce764e2858a81f99db911afd..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-vqa/fairseq/fairseq/tasks/frm_text_to_speech.py
+++ /dev/null
@@ -1,56 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import logging
-
-from fairseq.data.audio.frm_text_to_speech_dataset import FrmTextToSpeechDatasetCreator
-from fairseq.tasks import register_task
-from fairseq.tasks.text_to_speech import TextToSpeechTask
-
-
-logging.basicConfig(
- format='%(asctime)s | %(levelname)s | %(name)s | %(message)s',
- datefmt='%Y-%m-%d %H:%M:%S', level=logging.INFO
-)
-logger = logging.getLogger(__name__)
-
-
-@register_task('frm_text_to_speech')
-class FrmTextToSpeechTask(TextToSpeechTask):
- @staticmethod
- def add_args(parser):
- TextToSpeechTask.add_args(parser)
- parser.add_argument(
- "--do_chunk", action="store_true", help="train on chunks"
- )
- parser.add_argument("--chunk_bound", default=-1, type=int)
- parser.add_argument("--chunk_init", default=50, type=int)
- parser.add_argument("--chunk_incr", default=5, type=int)
- parser.add_argument("--add_eos", action="store_true")
- parser.add_argument("--dedup", action="store_true")
- parser.add_argument("--ref_fpu", default=-1, type=float)
-
- def load_dataset(self, split, **unused_kwargs):
- is_train_split = split.startswith("train")
- pre_tokenizer = self.build_tokenizer(self.args)
- bpe_tokenizer = self.build_bpe(self.args)
- self.datasets[split] = FrmTextToSpeechDatasetCreator.from_tsv(
- self.args.data,
- self.data_cfg,
- split,
- self.src_dict,
- pre_tokenizer,
- bpe_tokenizer,
- is_train_split=is_train_split,
- n_frames_per_step=self.args.n_frames_per_step,
- speaker_to_id=self.speaker_to_id,
- do_chunk=self.args.do_chunk,
- chunk_bound=self.args.chunk_bound,
- chunk_init=self.args.chunk_init,
- chunk_incr=self.args.chunk_incr,
- add_eos=self.args.add_eos,
- dedup=self.args.dedup,
- ref_fpu=self.args.ref_fpu
- )
diff --git a/spaces/OFA-Sys/OFA-vqa/fairseq/tests/test_train.py b/spaces/OFA-Sys/OFA-vqa/fairseq/tests/test_train.py
deleted file mode 100644
index 02ef94cc5b80c05485144db67501b2acedbaf291..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-vqa/fairseq/tests/test_train.py
+++ /dev/null
@@ -1,247 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import contextlib
-import logging
-import unittest
-from io import StringIO
-from unittest.mock import MagicMock, patch
-
-import torch
-from fairseq import checkpoint_utils, data
-from omegaconf import OmegaConf
-
-
-def mock_trainer(epoch, num_updates, iterations_in_epoch):
- trainer = MagicMock()
- trainer.load_checkpoint.return_value = {
- "train_iterator": {
- "epoch": epoch,
- "iterations_in_epoch": iterations_in_epoch,
- "shuffle": False,
- },
- }
- trainer.get_num_updates.return_value = num_updates
- return trainer
-
-
-def mock_dict():
- d = MagicMock()
- d.pad.return_value = 1
- d.eos.return_value = 2
- d.unk.return_value = 3
- return d
-
-
-def get_trainer_and_epoch_itr(epoch, epoch_size, num_updates, iterations_in_epoch):
- tokens = torch.LongTensor(list(range(epoch_size))).view(1, -1)
- tokens_ds = data.TokenBlockDataset(
- tokens,
- sizes=[tokens.size(-1)],
- block_size=1,
- pad=0,
- eos=1,
- include_targets=False,
- )
- trainer = mock_trainer(epoch, num_updates, iterations_in_epoch)
- dataset = data.LanguagePairDataset(
- tokens_ds, tokens_ds.sizes, mock_dict(), shuffle=False
- )
- epoch_itr = data.EpochBatchIterator(
- dataset=dataset,
- collate_fn=dataset.collater,
- batch_sampler=[[i] for i in range(epoch_size)],
- )
- return trainer, epoch_itr
-
-
-def get_mock_cfg(finetune_from_model):
- cfg_mock = OmegaConf.create(
- {
- "checkpoint": {
- "save_dir": None,
- "optimizer_overrides": "{}",
- "reset_dataloader": False,
- "reset_meters": False,
- "reset_optimizer": False,
- "reset_lr_scheduler": False,
- "finetune_from_model": finetune_from_model,
- "model_parallel_size": 1,
- "restore_file": "checkpoint_last.pt",
- },
- "common": {
- "model_parallel_size": 1,
- },
- }
- )
- return cfg_mock
-
-
-class TestLoadCheckpoint(unittest.TestCase):
- def setUp(self):
- self.cfg_mock = get_mock_cfg(None)
- self.patches = {
- "os.makedirs": MagicMock(),
- "os.path.join": MagicMock(),
- "os.path.isfile": MagicMock(return_value=True),
- "os.path.isabs": MagicMock(return_value=False),
- "fairseq.file_io.PathManager.exists": MagicMock(return_value=False),
- }
- self.applied_patches = [patch(p, d) for p, d in self.patches.items()]
- [p.start() for p in self.applied_patches]
- logging.disable(logging.CRITICAL)
-
- def tearDown(self):
- patch.stopall()
- logging.disable(logging.NOTSET)
-
- def test_load_partial_checkpoint(self):
- with contextlib.redirect_stdout(StringIO()):
- trainer, epoch_itr = get_trainer_and_epoch_itr(2, 150, 200, 50)
- trainer.get_train_iterator = MagicMock(return_value=epoch_itr)
-
- _, epoch_itr = checkpoint_utils.load_checkpoint(
- self.cfg_mock.checkpoint, trainer
- )
-
- self.assertEqual(epoch_itr.epoch, 2)
- self.assertEqual(epoch_itr.iterations_in_epoch, 50)
-
- itr = epoch_itr.next_epoch_itr(shuffle=False)
- self.assertEqual(epoch_itr.epoch, 2)
- self.assertEqual(epoch_itr.iterations_in_epoch, 50)
-
- self.assertEqual(next(itr)["net_input"]["src_tokens"][0].item(), 50)
- self.assertEqual(epoch_itr.iterations_in_epoch, 51)
-
- for _ in range(150 - 52):
- next(itr)
- self.assertEqual(epoch_itr.iterations_in_epoch, 149)
- self.assertTrue(itr.has_next())
- next(itr)
- self.assertFalse(itr.has_next())
-
- itr = epoch_itr.next_epoch_itr(shuffle=False)
- self.assertTrue(itr.has_next())
- self.assertEqual(epoch_itr.epoch, 3)
- self.assertEqual(epoch_itr.iterations_in_epoch, 0)
-
- def test_load_full_checkpoint(self):
- with contextlib.redirect_stdout(StringIO()):
- trainer, epoch_itr = get_trainer_and_epoch_itr(2, 150, 300, 150)
- trainer.get_train_iterator = MagicMock(return_value=epoch_itr)
-
- _, epoch_itr = checkpoint_utils.load_checkpoint(
- self.cfg_mock.checkpoint, trainer
- )
- itr = epoch_itr.next_epoch_itr(shuffle=False)
-
- self.assertEqual(epoch_itr.epoch, 3)
- self.assertEqual(epoch_itr.iterations_in_epoch, 0)
- self.assertEqual(next(itr)["net_input"]["src_tokens"][0].item(), 0)
-
- def test_load_no_checkpoint(self):
- with contextlib.redirect_stdout(StringIO()):
- trainer, epoch_itr = get_trainer_and_epoch_itr(1, 150, 0, 0)
- trainer.get_train_iterator = MagicMock(return_value=epoch_itr)
- self.patches["os.path.isfile"].return_value = False
-
- _, epoch_itr = checkpoint_utils.load_checkpoint(
- self.cfg_mock.checkpoint, trainer
- )
- itr = epoch_itr.next_epoch_itr(shuffle=False)
-
- self.assertEqual(epoch_itr.epoch, 1)
- self.assertEqual(epoch_itr.iterations_in_epoch, 0)
- self.assertEqual(next(itr)["net_input"]["src_tokens"][0].item(), 0)
-
- def test_finetune_from_model_args_conflict(self):
- with contextlib.redirect_stdout(StringIO()):
- trainer, epoch_itr = get_trainer_and_epoch_itr(1, 150, 0, 0)
- trainer.get_train_iterator = MagicMock(return_value=epoch_itr)
-
- for arg in [
- "reset_optimizer",
- "reset_lr_scheduler",
- "reset_meters",
- "reset_dataloader",
- ]:
- with self.subTest(arg=arg):
- cfg_mock = get_mock_cfg("/temp/checkpoint_pretrained.pt")
- cfg_mock["checkpoint"][arg] = True
- with self.assertRaises(Exception) as context:
- _, _ = checkpoint_utils.load_checkpoint(
- cfg_mock.checkpoint, trainer
- )
-
- self.assertTrue(
- "--finetune-from-model can not be set together with either --reset-optimizer"
- " or reset_lr_scheduler or reset_meters or reset_dataloader"
- in str(context.exception)
- )
-
- def test_finetune_from_model(self):
- with contextlib.redirect_stdout(StringIO()):
- trainer, epoch_itr = get_trainer_and_epoch_itr(1, 150, 0, 0)
- trainer.get_train_iterator = MagicMock(return_value=epoch_itr)
- from_model_path = "/temp/checkpoint_pretrained.pt"
-
- def mock_finetune_exist(path):
- if path == from_model_path:
- return True
- else:
- return False
-
- self.patches[
- "fairseq.file_io.PathManager.exists"
- ].side_effect = mock_finetune_exist
- cfg_mock = get_mock_cfg(from_model_path)
- cfg_mock.checkpoint.restore_file = "checkpoint_last.pt"
- _, _ = checkpoint_utils.load_checkpoint(cfg_mock.checkpoint, trainer)
- (
- checkpoint_path,
- reset_optimizer,
- reset_lr_scheduler,
- optimizer_overrides,
- ) = trainer.load_checkpoint.call_args[0]
- reset_meters = trainer.load_checkpoint.call_args[1]["reset_meters"]
- self.assertTrue(reset_optimizer)
- self.assertTrue(reset_lr_scheduler)
- self.assertTrue(reset_meters)
-
- def test_finetune_from_model_resume(self):
- with contextlib.redirect_stdout(StringIO()):
- trainer, epoch_itr = get_trainer_and_epoch_itr(1, 150, 0, 0)
- trainer.get_train_iterator = MagicMock(return_value=epoch_itr)
- from_model_path = "/temp/checkpoint_pretrained.pt"
-
- # launch second time
- # both restore_file=checkpoint_last.pt and finetune_from_model are set
- def mock_finetune_exist(path):
- if path == from_model_path or path.endsWith("checkpoint_last.pt"):
- return True
- else:
- return False
-
- self.patches[
- "fairseq.file_io.PathManager.exists"
- ].side_effect = mock_finetune_exist
- cfg_mock = get_mock_cfg(from_model_path)
- cfg_mock.checkpoint.restore_file = "checkpoint_last.pt"
- _, _ = checkpoint_utils.load_checkpoint(cfg_mock.checkpoint, trainer)
- (
- checkpoint_path,
- reset_optimizer,
- reset_lr_scheduler,
- optimizer_overrides,
- ) = trainer.load_checkpoint.call_args[0]
- reset_meters = trainer.load_checkpoint.call_args[1]["reset_meters"]
- self.assertFalse(reset_optimizer)
- self.assertFalse(reset_lr_scheduler)
- self.assertFalse(reset_meters)
-
-
-if __name__ == "__main__":
- unittest.main()
diff --git a/spaces/ORI-Muchim/PowerTTS/commons.py b/spaces/ORI-Muchim/PowerTTS/commons.py
deleted file mode 100644
index 40fcc05364d4815971f5c6f9dbb8dcef8e3ec1e9..0000000000000000000000000000000000000000
--- a/spaces/ORI-Muchim/PowerTTS/commons.py
+++ /dev/null
@@ -1,172 +0,0 @@
-import math
-import torch
-from torch.nn import functional as F
-import torch.jit
-
-
-def script_method(fn, _rcb=None):
- return fn
-
-
-def script(obj, optimize=True, _frames_up=0, _rcb=None):
- return obj
-
-
-torch.jit.script_method = script_method
-torch.jit.script = script
-
-
-def init_weights(m, mean=0.0, std=0.01):
- classname = m.__class__.__name__
- if classname.find("Conv") != -1:
- m.weight.data.normal_(mean, std)
-
-
-def get_padding(kernel_size, dilation=1):
- return int((kernel_size*dilation - dilation)/2)
-
-
-def convert_pad_shape(pad_shape):
- l = pad_shape[::-1]
- pad_shape = [item for sublist in l for item in sublist]
- return pad_shape
-
-
-def intersperse(lst, item):
- result = [item] * (len(lst) * 2 + 1)
- result[1::2] = lst
- return result
-
-
-def kl_divergence(m_p, logs_p, m_q, logs_q):
- """KL(P||Q)"""
- kl = (logs_q - logs_p) - 0.5
- kl += 0.5 * (torch.exp(2. * logs_p) + ((m_p - m_q)**2)) * torch.exp(-2. * logs_q)
- return kl
-
-
-def rand_gumbel(shape):
- """Sample from the Gumbel distribution, protect from overflows."""
- uniform_samples = torch.rand(shape) * 0.99998 + 0.00001
- return -torch.log(-torch.log(uniform_samples))
-
-
-def rand_gumbel_like(x):
- g = rand_gumbel(x.size()).to(dtype=x.dtype, device=x.device)
- return g
-
-
-def slice_segments(x, ids_str, segment_size=4):
- ret = torch.zeros_like(x[:, :, :segment_size])
- for i in range(x.size(0)):
- idx_str = ids_str[i]
- idx_end = idx_str + segment_size
- ret[i] = x[i, :, idx_str:idx_end]
- return ret
-
-
-def rand_slice_segments(x, x_lengths=None, segment_size=4):
- b, d, t = x.size()
- if x_lengths is None:
- x_lengths = t
- ids_str_max = x_lengths - segment_size + 1
- ids_str = (torch.rand([b]).to(device=x.device) * ids_str_max).to(dtype=torch.long)
- ret = slice_segments(x, ids_str, segment_size)
- return ret, ids_str
-
-
-def get_timing_signal_1d(
- length, channels, min_timescale=1.0, max_timescale=1.0e4):
- position = torch.arange(length, dtype=torch.float)
- num_timescales = channels // 2
- log_timescale_increment = (
- math.log(float(max_timescale) / float(min_timescale)) /
- (num_timescales - 1))
- inv_timescales = min_timescale * torch.exp(
- torch.arange(num_timescales, dtype=torch.float) * -log_timescale_increment)
- scaled_time = position.unsqueeze(0) * inv_timescales.unsqueeze(1)
- signal = torch.cat([torch.sin(scaled_time), torch.cos(scaled_time)], 0)
- signal = F.pad(signal, [0, 0, 0, channels % 2])
- signal = signal.view(1, channels, length)
- return signal
-
-
-def add_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4):
- b, channels, length = x.size()
- signal = get_timing_signal_1d(length, channels, min_timescale, max_timescale)
- return x + signal.to(dtype=x.dtype, device=x.device)
-
-
-def cat_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4, axis=1):
- b, channels, length = x.size()
- signal = get_timing_signal_1d(length, channels, min_timescale, max_timescale)
- return torch.cat([x, signal.to(dtype=x.dtype, device=x.device)], axis)
-
-
-def subsequent_mask(length):
- mask = torch.tril(torch.ones(length, length)).unsqueeze(0).unsqueeze(0)
- return mask
-
-
-@torch.jit.script
-def fused_add_tanh_sigmoid_multiply(input_a, input_b, n_channels):
- n_channels_int = n_channels[0]
- in_act = input_a + input_b
- t_act = torch.tanh(in_act[:, :n_channels_int, :])
- s_act = torch.sigmoid(in_act[:, n_channels_int:, :])
- acts = t_act * s_act
- return acts
-
-
-def convert_pad_shape(pad_shape):
- l = pad_shape[::-1]
- pad_shape = [item for sublist in l for item in sublist]
- return pad_shape
-
-
-def shift_1d(x):
- x = F.pad(x, convert_pad_shape([[0, 0], [0, 0], [1, 0]]))[:, :, :-1]
- return x
-
-
-def sequence_mask(length, max_length=None):
- if max_length is None:
- max_length = length.max()
- x = torch.arange(max_length, dtype=length.dtype, device=length.device)
- return x.unsqueeze(0) < length.unsqueeze(1)
-
-
-def generate_path(duration, mask):
- """
- duration: [b, 1, t_x]
- mask: [b, 1, t_y, t_x]
- """
- device = duration.device
-
- b, _, t_y, t_x = mask.shape
- cum_duration = torch.cumsum(duration, -1)
-
- cum_duration_flat = cum_duration.view(b * t_x)
- path = sequence_mask(cum_duration_flat, t_y).to(mask.dtype)
- path = path.view(b, t_x, t_y)
- path = path - F.pad(path, convert_pad_shape([[0, 0], [1, 0], [0, 0]]))[:, :-1]
- path = path.unsqueeze(1).transpose(2,3) * mask
- return path
-
-
-def clip_grad_value_(parameters, clip_value, norm_type=2):
- if isinstance(parameters, torch.Tensor):
- parameters = [parameters]
- parameters = list(filter(lambda p: p.grad is not None, parameters))
- norm_type = float(norm_type)
- if clip_value is not None:
- clip_value = float(clip_value)
-
- total_norm = 0
- for p in parameters:
- param_norm = p.grad.data.norm(norm_type)
- total_norm += param_norm.item() ** norm_type
- if clip_value is not None:
- p.grad.data.clamp_(min=-clip_value, max=clip_value)
- total_norm = total_norm ** (1. / norm_type)
- return total_norm
diff --git a/spaces/PAIR/PAIR-Diffusion/annotator/util.py b/spaces/PAIR/PAIR-Diffusion/annotator/util.py
deleted file mode 100644
index 8fd735a5d3d5dd900d0b84b37a4ca123f9408ec0..0000000000000000000000000000000000000000
--- a/spaces/PAIR/PAIR-Diffusion/annotator/util.py
+++ /dev/null
@@ -1,41 +0,0 @@
-import numpy as np
-import cv2
-import os
-
-
-annotator_ckpts_path = os.path.join(os.path.dirname(__file__), 'ckpts')
-
-
-def HWC3(x):
- assert x.dtype == np.uint8
- if x.ndim == 2:
- x = x[:, :, None]
- assert x.ndim == 3
- H, W, C = x.shape
- assert C == 1 or C == 3 or C == 4
- if C == 3:
- return x
- if C == 1:
- return np.concatenate([x, x, x], axis=2)
- if C == 4:
- color = x[:, :, 0:3].astype(np.float32)
- alpha = x[:, :, 3:4].astype(np.float32) / 255.0
- y = color * alpha + 255.0 * (1.0 - alpha)
- y = y.clip(0, 255).astype(np.uint8)
- return y
-
-
-def resize_image(input_image, resolution):
- if len(input_image.shape) == 3:
- H, W, C = input_image.shape
- else:
- H, W = input_image.shape
- H = float(H)
- W = float(W)
- k = float(resolution) / min(H, W)
- H *= k
- W *= k
- H = int(np.round(H / 64.0)) * 64
- W = int(np.round(W / 64.0)) * 64
- img = cv2.resize(input_image, (W, H), interpolation=cv2.INTER_LANCZOS4 if k > 1 else cv2.INTER_AREA)
- return img
diff --git a/spaces/PAIR/Text2Video-Zero/annotator/uniformer/mmcv/cnn/utils/flops_counter.py b/spaces/PAIR/Text2Video-Zero/annotator/uniformer/mmcv/cnn/utils/flops_counter.py
deleted file mode 100644
index d10af5feca7f4b8c0ba359b7b1c826f754e048be..0000000000000000000000000000000000000000
--- a/spaces/PAIR/Text2Video-Zero/annotator/uniformer/mmcv/cnn/utils/flops_counter.py
+++ /dev/null
@@ -1,599 +0,0 @@
-# Modified from flops-counter.pytorch by Vladislav Sovrasov
-# original repo: https://github.com/sovrasov/flops-counter.pytorch
-
-# MIT License
-
-# Copyright (c) 2018 Vladislav Sovrasov
-
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-
-import sys
-from functools import partial
-
-import numpy as np
-import torch
-import torch.nn as nn
-
-import annotator.uniformer.mmcv as mmcv
-
-
-def get_model_complexity_info(model,
- input_shape,
- print_per_layer_stat=True,
- as_strings=True,
- input_constructor=None,
- flush=False,
- ost=sys.stdout):
- """Get complexity information of a model.
-
- This method can calculate FLOPs and parameter counts of a model with
- corresponding input shape. It can also print complexity information for
- each layer in a model.
-
- Supported layers are listed as below:
- - Convolutions: ``nn.Conv1d``, ``nn.Conv2d``, ``nn.Conv3d``.
- - Activations: ``nn.ReLU``, ``nn.PReLU``, ``nn.ELU``, ``nn.LeakyReLU``,
- ``nn.ReLU6``.
- - Poolings: ``nn.MaxPool1d``, ``nn.MaxPool2d``, ``nn.MaxPool3d``,
- ``nn.AvgPool1d``, ``nn.AvgPool2d``, ``nn.AvgPool3d``,
- ``nn.AdaptiveMaxPool1d``, ``nn.AdaptiveMaxPool2d``,
- ``nn.AdaptiveMaxPool3d``, ``nn.AdaptiveAvgPool1d``,
- ``nn.AdaptiveAvgPool2d``, ``nn.AdaptiveAvgPool3d``.
- - BatchNorms: ``nn.BatchNorm1d``, ``nn.BatchNorm2d``,
- ``nn.BatchNorm3d``, ``nn.GroupNorm``, ``nn.InstanceNorm1d``,
- ``InstanceNorm2d``, ``InstanceNorm3d``, ``nn.LayerNorm``.
- - Linear: ``nn.Linear``.
- - Deconvolution: ``nn.ConvTranspose2d``.
- - Upsample: ``nn.Upsample``.
-
- Args:
- model (nn.Module): The model for complexity calculation.
- input_shape (tuple): Input shape used for calculation.
- print_per_layer_stat (bool): Whether to print complexity information
- for each layer in a model. Default: True.
- as_strings (bool): Output FLOPs and params counts in a string form.
- Default: True.
- input_constructor (None | callable): If specified, it takes a callable
- method that generates input. otherwise, it will generate a random
- tensor with input shape to calculate FLOPs. Default: None.
- flush (bool): same as that in :func:`print`. Default: False.
- ost (stream): same as ``file`` param in :func:`print`.
- Default: sys.stdout.
-
- Returns:
- tuple[float | str]: If ``as_strings`` is set to True, it will return
- FLOPs and parameter counts in a string format. otherwise, it will
- return those in a float number format.
- """
- assert type(input_shape) is tuple
- assert len(input_shape) >= 1
- assert isinstance(model, nn.Module)
- flops_model = add_flops_counting_methods(model)
- flops_model.eval()
- flops_model.start_flops_count()
- if input_constructor:
- input = input_constructor(input_shape)
- _ = flops_model(**input)
- else:
- try:
- batch = torch.ones(()).new_empty(
- (1, *input_shape),
- dtype=next(flops_model.parameters()).dtype,
- device=next(flops_model.parameters()).device)
- except StopIteration:
- # Avoid StopIteration for models which have no parameters,
- # like `nn.Relu()`, `nn.AvgPool2d`, etc.
- batch = torch.ones(()).new_empty((1, *input_shape))
-
- _ = flops_model(batch)
-
- flops_count, params_count = flops_model.compute_average_flops_cost()
- if print_per_layer_stat:
- print_model_with_flops(
- flops_model, flops_count, params_count, ost=ost, flush=flush)
- flops_model.stop_flops_count()
-
- if as_strings:
- return flops_to_string(flops_count), params_to_string(params_count)
-
- return flops_count, params_count
-
-
-def flops_to_string(flops, units='GFLOPs', precision=2):
- """Convert FLOPs number into a string.
-
- Note that Here we take a multiply-add counts as one FLOP.
-
- Args:
- flops (float): FLOPs number to be converted.
- units (str | None): Converted FLOPs units. Options are None, 'GFLOPs',
- 'MFLOPs', 'KFLOPs', 'FLOPs'. If set to None, it will automatically
- choose the most suitable unit for FLOPs. Default: 'GFLOPs'.
- precision (int): Digit number after the decimal point. Default: 2.
-
- Returns:
- str: The converted FLOPs number with units.
-
- Examples:
- >>> flops_to_string(1e9)
- '1.0 GFLOPs'
- >>> flops_to_string(2e5, 'MFLOPs')
- '0.2 MFLOPs'
- >>> flops_to_string(3e-9, None)
- '3e-09 FLOPs'
- """
- if units is None:
- if flops // 10**9 > 0:
- return str(round(flops / 10.**9, precision)) + ' GFLOPs'
- elif flops // 10**6 > 0:
- return str(round(flops / 10.**6, precision)) + ' MFLOPs'
- elif flops // 10**3 > 0:
- return str(round(flops / 10.**3, precision)) + ' KFLOPs'
- else:
- return str(flops) + ' FLOPs'
- else:
- if units == 'GFLOPs':
- return str(round(flops / 10.**9, precision)) + ' ' + units
- elif units == 'MFLOPs':
- return str(round(flops / 10.**6, precision)) + ' ' + units
- elif units == 'KFLOPs':
- return str(round(flops / 10.**3, precision)) + ' ' + units
- else:
- return str(flops) + ' FLOPs'
-
-
-def params_to_string(num_params, units=None, precision=2):
- """Convert parameter number into a string.
-
- Args:
- num_params (float): Parameter number to be converted.
- units (str | None): Converted FLOPs units. Options are None, 'M',
- 'K' and ''. If set to None, it will automatically choose the most
- suitable unit for Parameter number. Default: None.
- precision (int): Digit number after the decimal point. Default: 2.
-
- Returns:
- str: The converted parameter number with units.
-
- Examples:
- >>> params_to_string(1e9)
- '1000.0 M'
- >>> params_to_string(2e5)
- '200.0 k'
- >>> params_to_string(3e-9)
- '3e-09'
- """
- if units is None:
- if num_params // 10**6 > 0:
- return str(round(num_params / 10**6, precision)) + ' M'
- elif num_params // 10**3:
- return str(round(num_params / 10**3, precision)) + ' k'
- else:
- return str(num_params)
- else:
- if units == 'M':
- return str(round(num_params / 10.**6, precision)) + ' ' + units
- elif units == 'K':
- return str(round(num_params / 10.**3, precision)) + ' ' + units
- else:
- return str(num_params)
-
-
-def print_model_with_flops(model,
- total_flops,
- total_params,
- units='GFLOPs',
- precision=3,
- ost=sys.stdout,
- flush=False):
- """Print a model with FLOPs for each layer.
-
- Args:
- model (nn.Module): The model to be printed.
- total_flops (float): Total FLOPs of the model.
- total_params (float): Total parameter counts of the model.
- units (str | None): Converted FLOPs units. Default: 'GFLOPs'.
- precision (int): Digit number after the decimal point. Default: 3.
- ost (stream): same as `file` param in :func:`print`.
- Default: sys.stdout.
- flush (bool): same as that in :func:`print`. Default: False.
-
- Example:
- >>> class ExampleModel(nn.Module):
-
- >>> def __init__(self):
- >>> super().__init__()
- >>> self.conv1 = nn.Conv2d(3, 8, 3)
- >>> self.conv2 = nn.Conv2d(8, 256, 3)
- >>> self.conv3 = nn.Conv2d(256, 8, 3)
- >>> self.avg_pool = nn.AdaptiveAvgPool2d((1, 1))
- >>> self.flatten = nn.Flatten()
- >>> self.fc = nn.Linear(8, 1)
-
- >>> def forward(self, x):
- >>> x = self.conv1(x)
- >>> x = self.conv2(x)
- >>> x = self.conv3(x)
- >>> x = self.avg_pool(x)
- >>> x = self.flatten(x)
- >>> x = self.fc(x)
- >>> return x
-
- >>> model = ExampleModel()
- >>> x = (3, 16, 16)
- to print the complexity information state for each layer, you can use
- >>> get_model_complexity_info(model, x)
- or directly use
- >>> print_model_with_flops(model, 4579784.0, 37361)
- ExampleModel(
- 0.037 M, 100.000% Params, 0.005 GFLOPs, 100.000% FLOPs,
- (conv1): Conv2d(0.0 M, 0.600% Params, 0.0 GFLOPs, 0.959% FLOPs, 3, 8, kernel_size=(3, 3), stride=(1, 1)) # noqa: E501
- (conv2): Conv2d(0.019 M, 50.020% Params, 0.003 GFLOPs, 58.760% FLOPs, 8, 256, kernel_size=(3, 3), stride=(1, 1))
- (conv3): Conv2d(0.018 M, 49.356% Params, 0.002 GFLOPs, 40.264% FLOPs, 256, 8, kernel_size=(3, 3), stride=(1, 1))
- (avg_pool): AdaptiveAvgPool2d(0.0 M, 0.000% Params, 0.0 GFLOPs, 0.017% FLOPs, output_size=(1, 1))
- (flatten): Flatten(0.0 M, 0.000% Params, 0.0 GFLOPs, 0.000% FLOPs, )
- (fc): Linear(0.0 M, 0.024% Params, 0.0 GFLOPs, 0.000% FLOPs, in_features=8, out_features=1, bias=True)
- )
- """
-
- def accumulate_params(self):
- if is_supported_instance(self):
- return self.__params__
- else:
- sum = 0
- for m in self.children():
- sum += m.accumulate_params()
- return sum
-
- def accumulate_flops(self):
- if is_supported_instance(self):
- return self.__flops__ / model.__batch_counter__
- else:
- sum = 0
- for m in self.children():
- sum += m.accumulate_flops()
- return sum
-
- def flops_repr(self):
- accumulated_num_params = self.accumulate_params()
- accumulated_flops_cost = self.accumulate_flops()
- return ', '.join([
- params_to_string(
- accumulated_num_params, units='M', precision=precision),
- '{:.3%} Params'.format(accumulated_num_params / total_params),
- flops_to_string(
- accumulated_flops_cost, units=units, precision=precision),
- '{:.3%} FLOPs'.format(accumulated_flops_cost / total_flops),
- self.original_extra_repr()
- ])
-
- def add_extra_repr(m):
- m.accumulate_flops = accumulate_flops.__get__(m)
- m.accumulate_params = accumulate_params.__get__(m)
- flops_extra_repr = flops_repr.__get__(m)
- if m.extra_repr != flops_extra_repr:
- m.original_extra_repr = m.extra_repr
- m.extra_repr = flops_extra_repr
- assert m.extra_repr != m.original_extra_repr
-
- def del_extra_repr(m):
- if hasattr(m, 'original_extra_repr'):
- m.extra_repr = m.original_extra_repr
- del m.original_extra_repr
- if hasattr(m, 'accumulate_flops'):
- del m.accumulate_flops
-
- model.apply(add_extra_repr)
- print(model, file=ost, flush=flush)
- model.apply(del_extra_repr)
-
-
-def get_model_parameters_number(model):
- """Calculate parameter number of a model.
-
- Args:
- model (nn.module): The model for parameter number calculation.
-
- Returns:
- float: Parameter number of the model.
- """
- num_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
- return num_params
-
-
-def add_flops_counting_methods(net_main_module):
- # adding additional methods to the existing module object,
- # this is done this way so that each function has access to self object
- net_main_module.start_flops_count = start_flops_count.__get__(
- net_main_module)
- net_main_module.stop_flops_count = stop_flops_count.__get__(
- net_main_module)
- net_main_module.reset_flops_count = reset_flops_count.__get__(
- net_main_module)
- net_main_module.compute_average_flops_cost = compute_average_flops_cost.__get__( # noqa: E501
- net_main_module)
-
- net_main_module.reset_flops_count()
-
- return net_main_module
-
-
-def compute_average_flops_cost(self):
- """Compute average FLOPs cost.
-
- A method to compute average FLOPs cost, which will be available after
- `add_flops_counting_methods()` is called on a desired net object.
-
- Returns:
- float: Current mean flops consumption per image.
- """
- batches_count = self.__batch_counter__
- flops_sum = 0
- for module in self.modules():
- if is_supported_instance(module):
- flops_sum += module.__flops__
- params_sum = get_model_parameters_number(self)
- return flops_sum / batches_count, params_sum
-
-
-def start_flops_count(self):
- """Activate the computation of mean flops consumption per image.
-
- A method to activate the computation of mean flops consumption per image.
- which will be available after ``add_flops_counting_methods()`` is called on
- a desired net object. It should be called before running the network.
- """
- add_batch_counter_hook_function(self)
-
- def add_flops_counter_hook_function(module):
- if is_supported_instance(module):
- if hasattr(module, '__flops_handle__'):
- return
-
- else:
- handle = module.register_forward_hook(
- get_modules_mapping()[type(module)])
-
- module.__flops_handle__ = handle
-
- self.apply(partial(add_flops_counter_hook_function))
-
-
-def stop_flops_count(self):
- """Stop computing the mean flops consumption per image.
-
- A method to stop computing the mean flops consumption per image, which will
- be available after ``add_flops_counting_methods()`` is called on a desired
- net object. It can be called to pause the computation whenever.
- """
- remove_batch_counter_hook_function(self)
- self.apply(remove_flops_counter_hook_function)
-
-
-def reset_flops_count(self):
- """Reset statistics computed so far.
-
- A method to Reset computed statistics, which will be available after
- `add_flops_counting_methods()` is called on a desired net object.
- """
- add_batch_counter_variables_or_reset(self)
- self.apply(add_flops_counter_variable_or_reset)
-
-
-# ---- Internal functions
-def empty_flops_counter_hook(module, input, output):
- module.__flops__ += 0
-
-
-def upsample_flops_counter_hook(module, input, output):
- output_size = output[0]
- batch_size = output_size.shape[0]
- output_elements_count = batch_size
- for val in output_size.shape[1:]:
- output_elements_count *= val
- module.__flops__ += int(output_elements_count)
-
-
-def relu_flops_counter_hook(module, input, output):
- active_elements_count = output.numel()
- module.__flops__ += int(active_elements_count)
-
-
-def linear_flops_counter_hook(module, input, output):
- input = input[0]
- output_last_dim = output.shape[
- -1] # pytorch checks dimensions, so here we don't care much
- module.__flops__ += int(np.prod(input.shape) * output_last_dim)
-
-
-def pool_flops_counter_hook(module, input, output):
- input = input[0]
- module.__flops__ += int(np.prod(input.shape))
-
-
-def norm_flops_counter_hook(module, input, output):
- input = input[0]
-
- batch_flops = np.prod(input.shape)
- if (getattr(module, 'affine', False)
- or getattr(module, 'elementwise_affine', False)):
- batch_flops *= 2
- module.__flops__ += int(batch_flops)
-
-
-def deconv_flops_counter_hook(conv_module, input, output):
- # Can have multiple inputs, getting the first one
- input = input[0]
-
- batch_size = input.shape[0]
- input_height, input_width = input.shape[2:]
-
- kernel_height, kernel_width = conv_module.kernel_size
- in_channels = conv_module.in_channels
- out_channels = conv_module.out_channels
- groups = conv_module.groups
-
- filters_per_channel = out_channels // groups
- conv_per_position_flops = (
- kernel_height * kernel_width * in_channels * filters_per_channel)
-
- active_elements_count = batch_size * input_height * input_width
- overall_conv_flops = conv_per_position_flops * active_elements_count
- bias_flops = 0
- if conv_module.bias is not None:
- output_height, output_width = output.shape[2:]
- bias_flops = out_channels * batch_size * output_height * output_height
- overall_flops = overall_conv_flops + bias_flops
-
- conv_module.__flops__ += int(overall_flops)
-
-
-def conv_flops_counter_hook(conv_module, input, output):
- # Can have multiple inputs, getting the first one
- input = input[0]
-
- batch_size = input.shape[0]
- output_dims = list(output.shape[2:])
-
- kernel_dims = list(conv_module.kernel_size)
- in_channels = conv_module.in_channels
- out_channels = conv_module.out_channels
- groups = conv_module.groups
-
- filters_per_channel = out_channels // groups
- conv_per_position_flops = int(
- np.prod(kernel_dims)) * in_channels * filters_per_channel
-
- active_elements_count = batch_size * int(np.prod(output_dims))
-
- overall_conv_flops = conv_per_position_flops * active_elements_count
-
- bias_flops = 0
-
- if conv_module.bias is not None:
-
- bias_flops = out_channels * active_elements_count
-
- overall_flops = overall_conv_flops + bias_flops
-
- conv_module.__flops__ += int(overall_flops)
-
-
-def batch_counter_hook(module, input, output):
- batch_size = 1
- if len(input) > 0:
- # Can have multiple inputs, getting the first one
- input = input[0]
- batch_size = len(input)
- else:
- pass
- print('Warning! No positional inputs found for a module, '
- 'assuming batch size is 1.')
- module.__batch_counter__ += batch_size
-
-
-def add_batch_counter_variables_or_reset(module):
-
- module.__batch_counter__ = 0
-
-
-def add_batch_counter_hook_function(module):
- if hasattr(module, '__batch_counter_handle__'):
- return
-
- handle = module.register_forward_hook(batch_counter_hook)
- module.__batch_counter_handle__ = handle
-
-
-def remove_batch_counter_hook_function(module):
- if hasattr(module, '__batch_counter_handle__'):
- module.__batch_counter_handle__.remove()
- del module.__batch_counter_handle__
-
-
-def add_flops_counter_variable_or_reset(module):
- if is_supported_instance(module):
- if hasattr(module, '__flops__') or hasattr(module, '__params__'):
- print('Warning: variables __flops__ or __params__ are already '
- 'defined for the module' + type(module).__name__ +
- ' ptflops can affect your code!')
- module.__flops__ = 0
- module.__params__ = get_model_parameters_number(module)
-
-
-def is_supported_instance(module):
- if type(module) in get_modules_mapping():
- return True
- return False
-
-
-def remove_flops_counter_hook_function(module):
- if is_supported_instance(module):
- if hasattr(module, '__flops_handle__'):
- module.__flops_handle__.remove()
- del module.__flops_handle__
-
-
-def get_modules_mapping():
- return {
- # convolutions
- nn.Conv1d: conv_flops_counter_hook,
- nn.Conv2d: conv_flops_counter_hook,
- mmcv.cnn.bricks.Conv2d: conv_flops_counter_hook,
- nn.Conv3d: conv_flops_counter_hook,
- mmcv.cnn.bricks.Conv3d: conv_flops_counter_hook,
- # activations
- nn.ReLU: relu_flops_counter_hook,
- nn.PReLU: relu_flops_counter_hook,
- nn.ELU: relu_flops_counter_hook,
- nn.LeakyReLU: relu_flops_counter_hook,
- nn.ReLU6: relu_flops_counter_hook,
- # poolings
- nn.MaxPool1d: pool_flops_counter_hook,
- nn.AvgPool1d: pool_flops_counter_hook,
- nn.AvgPool2d: pool_flops_counter_hook,
- nn.MaxPool2d: pool_flops_counter_hook,
- mmcv.cnn.bricks.MaxPool2d: pool_flops_counter_hook,
- nn.MaxPool3d: pool_flops_counter_hook,
- mmcv.cnn.bricks.MaxPool3d: pool_flops_counter_hook,
- nn.AvgPool3d: pool_flops_counter_hook,
- nn.AdaptiveMaxPool1d: pool_flops_counter_hook,
- nn.AdaptiveAvgPool1d: pool_flops_counter_hook,
- nn.AdaptiveMaxPool2d: pool_flops_counter_hook,
- nn.AdaptiveAvgPool2d: pool_flops_counter_hook,
- nn.AdaptiveMaxPool3d: pool_flops_counter_hook,
- nn.AdaptiveAvgPool3d: pool_flops_counter_hook,
- # normalizations
- nn.BatchNorm1d: norm_flops_counter_hook,
- nn.BatchNorm2d: norm_flops_counter_hook,
- nn.BatchNorm3d: norm_flops_counter_hook,
- nn.GroupNorm: norm_flops_counter_hook,
- nn.InstanceNorm1d: norm_flops_counter_hook,
- nn.InstanceNorm2d: norm_flops_counter_hook,
- nn.InstanceNorm3d: norm_flops_counter_hook,
- nn.LayerNorm: norm_flops_counter_hook,
- # FC
- nn.Linear: linear_flops_counter_hook,
- mmcv.cnn.bricks.Linear: linear_flops_counter_hook,
- # Upscale
- nn.Upsample: upsample_flops_counter_hook,
- # Deconvolution
- nn.ConvTranspose2d: deconv_flops_counter_hook,
- mmcv.cnn.bricks.ConvTranspose2d: deconv_flops_counter_hook,
- }
diff --git a/spaces/PSLD/PSLD/stable-diffusion/scripts/sample_diffusion.py b/spaces/PSLD/PSLD/stable-diffusion/scripts/sample_diffusion.py
deleted file mode 100644
index 876fe3c3642fcc8c7209e4f763c0134166615f78..0000000000000000000000000000000000000000
--- a/spaces/PSLD/PSLD/stable-diffusion/scripts/sample_diffusion.py
+++ /dev/null
@@ -1,313 +0,0 @@
-import argparse, os, sys, glob, datetime, yaml
-import torch
-import time
-import numpy as np
-from tqdm import trange
-
-from omegaconf import OmegaConf
-from PIL import Image
-
-from ldm.models.diffusion.ddim import DDIMSampler
-from ldm.util import instantiate_from_config
-
-rescale = lambda x: (x + 1.) / 2.
-
-def custom_to_pil(x):
- x = x.detach().cpu()
- x = torch.clamp(x, -1., 1.)
- x = (x + 1.) / 2.
- x = x.permute(1, 2, 0).numpy()
- x = (255 * x).astype(np.uint8)
- x = Image.fromarray(x)
- if not x.mode == "RGB":
- x = x.convert("RGB")
- return x
-
-
-def custom_to_np(x):
- # saves the batch in adm style as in https://github.com/openai/guided-diffusion/blob/main/scripts/image_sample.py
- sample = x.detach().cpu()
- sample = ((sample + 1) * 127.5).clamp(0, 255).to(torch.uint8)
- sample = sample.permute(0, 2, 3, 1)
- sample = sample.contiguous()
- return sample
-
-
-def logs2pil(logs, keys=["sample"]):
- imgs = dict()
- for k in logs:
- try:
- if len(logs[k].shape) == 4:
- img = custom_to_pil(logs[k][0, ...])
- elif len(logs[k].shape) == 3:
- img = custom_to_pil(logs[k])
- else:
- print(f"Unknown format for key {k}. ")
- img = None
- except:
- img = None
- imgs[k] = img
- return imgs
-
-
-@torch.no_grad()
-def convsample(model, shape, return_intermediates=True,
- verbose=True,
- make_prog_row=False):
-
-
- if not make_prog_row:
- return model.p_sample_loop(None, shape,
- return_intermediates=return_intermediates, verbose=verbose)
- else:
- return model.progressive_denoising(
- None, shape, verbose=True
- )
-
-
-@torch.no_grad()
-def convsample_ddim(model, steps, shape, eta=1.0
- ):
- ddim = DDIMSampler(model)
- bs = shape[0]
- shape = shape[1:]
- samples, intermediates = ddim.sample(steps, batch_size=bs, shape=shape, eta=eta, verbose=False,)
- return samples, intermediates
-
-
-@torch.no_grad()
-def make_convolutional_sample(model, batch_size, vanilla=False, custom_steps=None, eta=1.0,):
-
-
- log = dict()
-
- shape = [batch_size,
- model.model.diffusion_model.in_channels,
- model.model.diffusion_model.image_size,
- model.model.diffusion_model.image_size]
-
- with model.ema_scope("Plotting"):
- t0 = time.time()
- if vanilla:
- sample, progrow = convsample(model, shape,
- make_prog_row=True)
- else:
- sample, intermediates = convsample_ddim(model, steps=custom_steps, shape=shape,
- eta=eta)
-
- t1 = time.time()
-
- x_sample = model.decode_first_stage(sample)
-
- log["sample"] = x_sample
- log["time"] = t1 - t0
- log['throughput'] = sample.shape[0] / (t1 - t0)
- print(f'Throughput for this batch: {log["throughput"]}')
- return log
-
-def run(model, logdir, batch_size=50, vanilla=False, custom_steps=None, eta=None, n_samples=50000, nplog=None):
- if vanilla:
- print(f'Using Vanilla DDPM sampling with {model.num_timesteps} sampling steps.')
- else:
- print(f'Using DDIM sampling with {custom_steps} sampling steps and eta={eta}')
-
-
- tstart = time.time()
- n_saved = len(glob.glob(os.path.join(logdir,'*.png')))-1
- # path = logdir
- if model.cond_stage_model is None:
- all_images = []
-
- print(f"Running unconditional sampling for {n_samples} samples")
- for _ in trange(n_samples // batch_size, desc="Sampling Batches (unconditional)"):
- logs = make_convolutional_sample(model, batch_size=batch_size,
- vanilla=vanilla, custom_steps=custom_steps,
- eta=eta)
- n_saved = save_logs(logs, logdir, n_saved=n_saved, key="sample")
- all_images.extend([custom_to_np(logs["sample"])])
- if n_saved >= n_samples:
- print(f'Finish after generating {n_saved} samples')
- break
- all_img = np.concatenate(all_images, axis=0)
- all_img = all_img[:n_samples]
- shape_str = "x".join([str(x) for x in all_img.shape])
- nppath = os.path.join(nplog, f"{shape_str}-samples.npz")
- np.savez(nppath, all_img)
-
- else:
- raise NotImplementedError('Currently only sampling for unconditional models supported.')
-
- print(f"sampling of {n_saved} images finished in {(time.time() - tstart) / 60.:.2f} minutes.")
-
-
-def save_logs(logs, path, n_saved=0, key="sample", np_path=None):
- for k in logs:
- if k == key:
- batch = logs[key]
- if np_path is None:
- for x in batch:
- img = custom_to_pil(x)
- imgpath = os.path.join(path, f"{key}_{n_saved:06}.png")
- img.save(imgpath)
- n_saved += 1
- else:
- npbatch = custom_to_np(batch)
- shape_str = "x".join([str(x) for x in npbatch.shape])
- nppath = os.path.join(np_path, f"{n_saved}-{shape_str}-samples.npz")
- np.savez(nppath, npbatch)
- n_saved += npbatch.shape[0]
- return n_saved
-
-
-def get_parser():
- parser = argparse.ArgumentParser()
- parser.add_argument(
- "-r",
- "--resume",
- type=str,
- nargs="?",
- help="load from logdir or checkpoint in logdir",
- )
- parser.add_argument(
- "-n",
- "--n_samples",
- type=int,
- nargs="?",
- help="number of samples to draw",
- default=50000
- )
- parser.add_argument(
- "-e",
- "--eta",
- type=float,
- nargs="?",
- help="eta for ddim sampling (0.0 yields deterministic sampling)",
- default=1.0
- )
- parser.add_argument(
- "-v",
- "--vanilla_sample",
- default=False,
- action='store_true',
- help="vanilla sampling (default option is DDIM sampling)?",
- )
- parser.add_argument(
- "-l",
- "--logdir",
- type=str,
- nargs="?",
- help="extra logdir",
- default="none"
- )
- parser.add_argument(
- "-c",
- "--custom_steps",
- type=int,
- nargs="?",
- help="number of steps for ddim and fastdpm sampling",
- default=50
- )
- parser.add_argument(
- "--batch_size",
- type=int,
- nargs="?",
- help="the bs",
- default=10
- )
- return parser
-
-
-def load_model_from_config(config, sd):
- model = instantiate_from_config(config)
- model.load_state_dict(sd,strict=False)
- model.cuda()
- model.eval()
- return model
-
-
-def load_model(config, ckpt, gpu, eval_mode):
- if ckpt:
- print(f"Loading model from {ckpt}")
- pl_sd = torch.load(ckpt, map_location="cpu")
- global_step = pl_sd["global_step"]
- else:
- pl_sd = {"state_dict": None}
- global_step = None
- model = load_model_from_config(config.model,
- pl_sd["state_dict"])
-
- return model, global_step
-
-
-if __name__ == "__main__":
- now = datetime.datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
- sys.path.append(os.getcwd())
- command = " ".join(sys.argv)
-
- parser = get_parser()
- opt, unknown = parser.parse_known_args()
- ckpt = None
-
- if not os.path.exists(opt.resume):
- raise ValueError("Cannot find {}".format(opt.resume))
- if os.path.isfile(opt.resume):
- # paths = opt.resume.split("/")
- try:
- logdir = '/'.join(opt.resume.split('/')[:-1])
- # idx = len(paths)-paths[::-1].index("logs")+1
- print(f'Logdir is {logdir}')
- except ValueError:
- paths = opt.resume.split("/")
- idx = -2 # take a guess: path/to/logdir/checkpoints/model.ckpt
- logdir = "/".join(paths[:idx])
- ckpt = opt.resume
- else:
- assert os.path.isdir(opt.resume), f"{opt.resume} is not a directory"
- logdir = opt.resume.rstrip("/")
- ckpt = os.path.join(logdir, "model.ckpt")
-
- base_configs = sorted(glob.glob(os.path.join(logdir, "config.yaml")))
- opt.base = base_configs
-
- configs = [OmegaConf.load(cfg) for cfg in opt.base]
- cli = OmegaConf.from_dotlist(unknown)
- config = OmegaConf.merge(*configs, cli)
-
- gpu = True
- eval_mode = True
-
- if opt.logdir != "none":
- locallog = logdir.split(os.sep)[-1]
- if locallog == "": locallog = logdir.split(os.sep)[-2]
- print(f"Switching logdir from '{logdir}' to '{os.path.join(opt.logdir, locallog)}'")
- logdir = os.path.join(opt.logdir, locallog)
-
- print(config)
-
- model, global_step = load_model(config, ckpt, gpu, eval_mode)
- print(f"global step: {global_step}")
- print(75 * "=")
- print("logging to:")
- logdir = os.path.join(logdir, "samples", f"{global_step:08}", now)
- imglogdir = os.path.join(logdir, "img")
- numpylogdir = os.path.join(logdir, "numpy")
-
- os.makedirs(imglogdir)
- os.makedirs(numpylogdir)
- print(logdir)
- print(75 * "=")
-
- # write config out
- sampling_file = os.path.join(logdir, "sampling_config.yaml")
- sampling_conf = vars(opt)
-
- with open(sampling_file, 'w') as f:
- yaml.dump(sampling_conf, f, default_flow_style=False)
- print(sampling_conf)
-
-
- run(model, imglogdir, eta=opt.eta,
- vanilla=opt.vanilla_sample, n_samples=opt.n_samples, custom_steps=opt.custom_steps,
- batch_size=opt.batch_size, nplog=numpylogdir)
-
- print("done.")
diff --git a/spaces/Parantonio/IA_voices/index.html b/spaces/Parantonio/IA_voices/index.html
deleted file mode 100644
index 58275de3b1c343a98420342baa076b9baaafa157..0000000000000000000000000000000000000000
--- a/spaces/Parantonio/IA_voices/index.html
+++ /dev/null
@@ -1,19 +0,0 @@
-<!DOCTYPE html>
-<html>
- <head>
- <meta charset="utf-8" />
- <meta name="viewport" content="width=device-width" />
- <title>My static Space
-
-
-
-
-
Welcome to your static Space!
-
You can modify this app directly by editing index.html in the Files and versions tab.