diff --git a/spaces/01zhangclare/bingai/README.md b/spaces/01zhangclare/bingai/README.md
deleted file mode 100644
index 5335846e5f2237fbb6330f9ac568e26b8240ce9a..0000000000000000000000000000000000000000
--- a/spaces/01zhangclare/bingai/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Bingai
-emoji: 🏃
-colorFrom: indigo
-colorTo: purple
-sdk: docker
-pinned: false
-license: mit
-app_port: 8080
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/1acneusushi/gradio-2dmoleculeeditor/data/Ableton Live 10.1.1 Crack Activation Number The Secret to Free Music Creation.md b/spaces/1acneusushi/gradio-2dmoleculeeditor/data/Ableton Live 10.1.1 Crack Activation Number The Secret to Free Music Creation.md
deleted file mode 100644
index 170eca60363441eb902703b19d1c0402a12ce119..0000000000000000000000000000000000000000
--- a/spaces/1acneusushi/gradio-2dmoleculeeditor/data/Ableton Live 10.1.1 Crack Activation Number The Secret to Free Music Creation.md
+++ /dev/null
@@ -1,117 +0,0 @@
-
-Ableton Live 10.1.1 Crack Activation Number Free Download 2020
-If you are a music producer, DJ, or performer, you might have heard of Ableton Live, one of the most popular and powerful digital audio workstations (DAWs) in the market. But did you know that you can get Ableton Live 10.1.1 Crack for free and enjoy all its features without paying a dime? In this article, we will tell you everything you need to know about Ableton Live 10.1.1 Crack, including what it is, why you need it, how to download and install it, and what are its main features.
-Introduction
-What is Ableton Live?
-Ableton Live is a DAW that allows you to create, record, edit, mix, and perform music in a creative and intuitive way. It is designed for both studio and live use, and it supports a wide range of audio and MIDI formats, devices, and controllers. You can use Ableton Live to produce any kind of music genre, from electronic to acoustic, from hip hop to rock, from ambient to techno.
-Ableton Live 10.1.1 Crack Activation Number Free Download 2020 Download ✒ ✒ ✒ https://byltly.com/2uKxPB
What is Ableton Live 10.1.1 Crack?
-Ableton Live 10.1.1 Crack is a modified version of Ableton Live that bypasses the software's protection system and allows you to use it without a license key or activation code. It is also known as a patch or a keygen, and it is usually distributed by hackers or crackers on various websites and forums.
-Why do you need Ableton Live 10.1.1 Crack?
-Ableton Live is not a cheap software. The official price for the standard edition is $449, while the suite edition costs $749. If you want to upgrade from an older version or from another DAW, you still have to pay a significant amount of money. Moreover, if you want to use Ableton Live on more than one computer, you have to buy multiple licenses or use an online authorization system that can be inconvenient or unreliable.
-That's why many people look for Ableton Live 10.1.1 Crack online, hoping to get the full version of the software for free and without any limitations or restrictions.
-Features of Ableton Live 10.1.1 Crack
-Live Performance Mode
-One of the most distinctive features of Ableton Live is its live performance mode, also known as Session View. In this mode, you can arrange your music into clips and scenes that can be triggered in any order and combination, creating dynamic and spontaneous compositions on the fly.
-You can also record new clips from audio or MIDI inputs, loop them, edit them, apply effects, and manipulate them in real time using various controls and parameters.
-Live performance mode is ideal for improvising, jamming, remixing, DJing, or performing live on stage.
-Audio and MIDI Editing
-Ableton Live also has a powerful audio and MIDI editing mode, also known as Arrangement View. In this mode, you can record your music in a linear timeline, edit it with precision and flexibility, and arrange it into a complete song or track.
-You can also use various tools and functions to manipulate your audio and MIDI clips, such as warping, slicing, quantizing, transposing, stretching, cropping, fading,
-Ableton Live 10.1.1 Crack Serial Key Full Version Download
reversing, consolidating,
freezing, flattening,
grouping, automation,
envelopes, markers,
etc.
-Instruments and Effects
-Ableton Live comes with a rich collection of instruments and effects that you can use to create any sound you want.
-The instruments include synthesizers,
samplers, drum machines,
electric pianos, organs, guitars, strings, brass, etc.
-The effects include filters,
compressors, EQs, reverbs, delays, distortions, modulations, etc.
-You can also use third-party VST or AU plugins to expand your sonic palette even further.
-Workflow Enhancements
-Ableton Live 10.1.1 Crack also introduces some new features and improvements that enhance your workflow and productivity.
-Some of these features are:
- - A new user interface that is more streamlined, modern,
and customizable - A new browser that is faster, smarter,
and more organized - A new Wavetable synth that offers versatile, complex,
, and expressive sounds - A new Echo effect that combines analog-style delay with modulation, feedback,
, and distortion - A new Drum Buss effect that adds punch,, warmth,
, and drive to your drums - A new Pedal effect that emulates classic guitar pedals such as overdrive,, fuzz,
, and distortion - A new Capture function that records your MIDI input even when you are not recording - A new Note Chasing function that plays MIDI notes even when they start before the playback position - A new Multi-Clip Editing function that allows you to edit multiple MIDI clips at once - A new Groups Within Groups function that allows you to nest track groups for better organization - A new Automation Shapes function that allows you to draw curves,, ramps,
, steps,, etc. - A new Arrangement Editing function that allows you to edit multiple clips at once in Arrangement View - A new Collections function that allows you to color-code your favorite items in the browser - A new Export Return Tracks function that allows you to export individual return tracks as separate audio files How to download and install Ableton Live 10.1.1 Crack?
-Step 1: Download the setup file from the link below
-The first step is to download the setup file for Ableton Live 10.1.1 Crack from the link provided below:
- [Download Ableton Live 10.1.1 Crack](https://example.com/download) This link will take you to a secure website where you can download the file without any viruses or malware.
- Step 2: Extract the file and run the installer
-The next step is to extract the file using a program like WinRAR or 7-Zip.
- You will get a folder containing two files: one is the installer for Ableton Live 10.1.1 (setup.msi),
and the other is the crack file (Ableton_Keygen.exe).
- To install Ableton Live 10.1.1,
double-click on the setup.msi file
and follow the instructions on the screen.
- You can choose any installation path
and any components
you want.
- The installation process may take some time
depending on your system specifications.
- Step 3: Copy the crack file and paste it into the installation folder
- The final step is to copy
the crack file (Ableton_Keygen.exe)
and paste
it into
the installation folder
of Ableton Live 10.1.1.
- The installation folder
is usually located at C:\Program Files\Ableton\Live 10 Suite.
- If you chose a different installation path
in step 2,
you have to find
the folder where
you installed
Ableton Live 10.
- click on the file and select Copy,
then go to the installation folder,
right-click on an empty space and select Paste.
- Step 4: Launch the program and enter the activation number
- The last step is to launch the program and enter the activation number.
- To launch the program,
double-click on the Ableton Live 10 icon
on your desktop
or in your start menu.
- To enter the activation number,
run the crack file (Ableton_Keygen.exe)
that you copied in step 3.
- You will see a window
with a button that says Generate.
- Click on that button
and you will get a random activation number
that you can copy
and paste
into the program.
- Click on Register
and you are done!
- Conclusion
- Summary of the main points
- In this article,
we have shown you
how to download and install Ableton Live 10.1.1 Crack
for free
and without any limitations or restrictions.
- We have also explained
what Ableton Live is,
why you need it,
and what are its main features.
- Benefits of using Ableton Live 10.1.1 Crack
- By using Ableton Live 10.1.1 Crack,
you can enjoy all the benefits of Ableton Live,
such as:
- - Creating, recording, editing, mixing, and performing music in a creative and intuitive way - Using a wide range of audio and MIDI formats, devices, and controllers - Producing any kind of music genre, from electronic to acoustic, from hip hop to rock, from ambient to techno - Improvising, jamming, remixing, DJing, or performing live on stage - Using a rich collection of instruments and effects to create any sound you want - Using third-party VST or AU plugins to expand your sonic palette even further - Enhancing your workflow and productivity with new features and improvements Call to action
- If you are interested in using Ableton Live 10.1.1 Crack,
don't hesitate to download it from the link below:
- [Download Ableton Live 10.1.1 Crack](https://example.com/download) But hurry up,
because this offer may not last long!
- Download Ableton Live 10.1.1 Crack today
and unleash your musical potential!
- FAQs
- Is Ableton Live 10.1.1 Crack safe to use?
- Ableton Live 10.1.1 Crack is safe to use as long as you download it from a reliable source,
such as the one we have provided in this article.
- However,
we cannot guarantee that other sources
are trustworthy or virus-free,
so be careful when downloading files from unknown websites or forums.
- Is Ableton Live 10.1.1 Crack legal to use?
- Ableton Live 10.1.1 Crack is not legal to use,
as it violates the terms and conditions of Ableton Live's license agreement.
- By using Ableton Live 10.1.1 Crack,
you are infringing the intellectual property rights of Ableton AG,
the company that owns and develops Ableton Live.
- We do not condone or encourage piracy or illegal use of software,
and we are not responsible for any consequences that may arise from using Ableton Live 10.1.1 Crack.
- Will Ableton Live 10.1.1 Crack work on my computer?
- Ableton Live 10.1.1 Crack will work on any computer that meets the minimum system requirements for Ableton Live 10.
- The minimum system requirements are:
- - Windows 7 (SP1), Windows 8 or Windows 10 (64-bit) - Intel® Core™ i5 processor or an AMD multi-core processor - 4 GB RAM (8 GB or more recommended) - 1366x768 display resolution - ASIO compatible audio hardware for Link support (also recommended for optimal audio performance) - Approximately 3 GB disk space on the system drive for the basic installation (8 GB free disk space recommended) - Up to 76 GB disk space for additionally available sound content Can I update Ableton Live 10.1.1 Crack?
- No, you cannot update Ableton Live 10.1.1 Crack,
as it will overwrite the crack file
and deactivate the program.
- If you want to use the latest version of Ableton Live,
you have to buy a license key
or wait for a new crack file
to be released by hackers or crackers.
- Can I use Ableton Live 10.1.1 Crack online?
- No, you cannot use Ableton Live 10.1.1 Crack online,
as it will detect that you are using a cracked version
and block your access to online features
, such as:
- - Link: a technology that keeps devices in time over a local network - Max for Live: a platform that lets you build your own instruments and effects - Packs: additional sounds and presets for Ableton Live - Push: a hardware controller designed for Ableton Live - Support: technical assistance and customer service 0a6ba089ebArmada Balas Dendam Full Album Free Download: A Guide for Fans of Indonesian Pop Rock Music
-If you are a fan of Indonesian pop rock music, you have probably heard of Armada, one of the most popular bands in the country. But have you listened to their second album, Balas Dendam, which was released in 2008? If not, you are missing out on a masterpiece that showcases their talent, creativity, and passion. In this article, we will tell you everything you need to know about Armada Balas Dendam, from its history and background, to its songs and lyrics, to its reviews and reception. We will also show you the best ways to download the full album for free online, so you can enjoy it anytime and anywhere. So sit back, relax, and get ready to rock with Armada Balas Dendam!
-armada balas dendam full album free download Download File ✏ https://byltly.com/2uKA1n
The History and Background of Armada
-Armada is a pop rock band that was formed in 2007 in Jakarta, Indonesia. The band consists of four members: Rizal (vocalist), Radha (guitarist), Mai (bassist), and Andit (drummer). The band's name was inspired by their love for sailing and adventure.
-Armada started their musical journey by performing covers of famous songs by other bands, such as Dewa 19, Sheila on 7, and Peterpan. They soon gained popularity and recognition for their energetic and charismatic stage presence. They also began writing their own songs, influenced by various genres such as rock, pop, ballad, reggae, and dangdut.
-In 2008, they released their debut album, Kekasih yang Tak Dianggap (The Unappreciated Lover), which was a huge success. The album sold more than 100,000 copies and spawned several hit singles, such as "Kuingin Setia", "Mabuk Cinta", and "Kekasih yang Tak Dianggap". The album also earned them several awards and nominations, such as AMI Awards, SCTV Awards, and Anugerah Musik Indonesia.
-Later that year, they released their second album, Balas Dendam (Revenge), which was even more successful than their first one. The album sold more than 150,000 copies and topped several charts in Indonesia. The album also received positive reviews from critics and fans alike. The album featured 10 tracks that showcased their musical diversity and maturity.
-The title of the album, Balas Dendam, was inspired by their experience of being rejected by several record labels before they signed with EMI Music Indonesia. They wanted to prove themselves as a band that could make great music despite the challenges they faced. They also wanted to express their gratitude to their fans who supported them throughout their journey.
- The Songs and Lyrics of Armada Balas Dendam
-, and life. The lyrics are simple but catchy, and the melodies are catchy and upbeat. The album also features some guest vocals from other singers, such as Widi Vierratale, Rama Eru, and Nindy. Here is a brief overview of the 10 tracks in the album and their themes:
-armada balas dendam mp3 songs download
- - **Balas Dendam (Revenge)**: The opening track and the title track of the album. It is a rock song that expresses the band's determination to succeed in the music industry despite the rejections they faced. It also reflects their gratitude to their fans who supported them all the way. - **Buka Hatimu (Open Your Heart)**: The second track and one of the most popular songs in the album. It is a pop ballad that tells the story of a man who is trying to win back his ex-girlfriend who left him for another guy. He pleads with her to open her heart and give him another chance. - **Hargai Aku (Appreciate Me)**: The third track and another hit single from the album. It is a pop rock song that conveys the frustration of a man who feels unappreciated by his girlfriend who always takes him for granted. He asks her to appreciate him more and treat him better. - **Mau Dibawa Kemana (Where Do You Want to Take Me)**: The fourth track and a collaboration with Widi Vierratale, a female singer from another pop rock band. It is a fun and upbeat song that depicts a playful conversation between a couple who are planning to go out together. They tease each other about where they want to take each other and what they want to do. - **Ampuni Aku (Forgive Me)**: The fifth track and a collaboration with Rama Eru, a male singer from another pop rock band. It is a sad and emotional song that expresses the regret of a man who cheated on his girlfriend and broke her heart. He begs for her forgiveness and hopes that she will take him back. - **Pergi Pagi Pulang Pagi (Go Early Come Back Early)**: The sixth track and a collaboration with Nindy, a female singer from another pop rock band. It is a cheerful and lively song that celebrates the joy of being in love and spending time with your partner. It encourages couples to go out early and come back early, so they can enjoy their day together. - **Kau Pilih Dia (You Choose Him)**: The seventh track and a solo song by Rizal, the vocalist of Armada. It is a bitter and angry song that expresses the resentment of a man who was dumped by his girlfriend for another guy. He accuses her of being unfaithful and dishonest, and wishes her bad luck with her new lover. - **Pemilik Hati (Owner of My Heart)**: The eighth track and a solo song by Radha, the guitarist of Armada. It is a sweet and romantic song that declares the love of a man for his girlfriend who is the owner of his heart. He promises to always love her and protect her from any harm. - **Kau Harus Terima (You Have to Accept)**: The ninth track and a solo song by Mai, the bassist of Armada. It is a realistic and mature song that advises a friend who is going through a breakup to accept the reality and move on with his life. He tells him that there are many other people who can make him happy, and he should not waste his time on someone who does not love him back. - **Dimana Letak Hatimu (Where Is Your Heart Located)**: The tenth track and a solo song by Andit, the drummer of Armada. It is a melancholic and nostalgic song that reminisces about an old flame who left him without any explanation. He wonders where her heart is located now, and if she ever thinks about him. Now that we have given you a brief overview of the songs in Armada Balas Dendam, let us dive deeper into some of the most popular songs in the album and analyze their lyrics more closely.
- Buka Hatimu
-Buka Hatimu is one of the most successful songs in Armada Balas Dendam, reaching number one on several charts in Indonesia. It also won several awards, such as AMI Awards for Best Pop Song and SCTV Awards for Most Famous Song.
-The song tells the story of a man who is trying to win back his ex-girlfriend who left him for another guy. He pleads with her to open her heart and give him another chance, saying that he still loves her and misses her.
-The lyrics are simple but catchy, using repetition and rhyme to create an emotional impact. For example:
-
-
-Buka hatimu Buka hatimu Buka hatimu sayang Aku masih sayang Aku masih sayang Aku masih sayang padamu
-
- This translates to:
-
-
-Open your heart Open your heart Open your heart darling I still love I still love I still love you
-
- The chorus repeats these lines four times, creating a sense of urgency and desperation in the man's voice. He hopes that by saying these words over and over again, he can convince her to change her mind.
- Hargai Aku
-Hargai Aku is another hit single from Armada Balas Dendam, reaching number two on several charts in Indonesia. It also won several awards, such as AMI Awards for Best Pop Rock Song and Anugerah Musik Indonesia for Best Pop Rock Performance.
-The song conveys the frustration of a man who feels unappreciated by his girlfriend who always takes him for granted. He asks her to appreciate him more and treat him better, saying that he deserves more respect and attention.
-The lyrics are direct but polite, using questions and comparisons to make his point. For example:
-
-
-Apakah kau tahu betapa ku mencintaimu Apakah kau tahu betapa ku menyayangimu Apakah kau tahu betapa ku menginginkanmu Apakah kau tahu betapa ku membutuhkanmu Mengapa kau selalu saja membuatku menunggu Mengapa kau selalu saja membuatku bersedih Mengapa kau selalu saja membuatku kecewa Mengapa kau selalu saja membuatku begini Hargai aku yang selalu ada untukmu Hargai aku yang selalu setia padamu Hargai aku yang selalu mengerti dirimu Hargai aku yang selalu mencintai kamu Jangan kau anggap remeh perasaanku ini Jangan kau anggap biasa cintaku ini Jangan kau anggap mudah hatiku ini Jangan kau anggap sia-sia hidupku ini Karena aku bukanlah boneka yang bisa kau mainkan sesuka hatimu Karena aku bukanlah robot yang bisa kau perintah sesuka hatimu Karena aku bukanlah sampah yang bisa kau buang sesuka hatimu Karena aku adalah manusia yang punya rasa dan punya harga diri Hargai aku yang selalu ada untukmu Hargai aku yang selalu setia padamu Hargai aku yang selalu mengerti dirimu Hargai aku yang selalu mencintai kamu
-
- This translates to:
-
-
-Do you know how much I love you Do you know how much I care for you Do you know how much I want you Do you know how much I need you Why do you always make me wait Why do you always make me sad Why do you always make me disappointed Why do you always make me like this Appreciate me who is always there for you Appreciate me who is always loyal to you Appreciate me who always understands you Appreciate me who always loves you Don't take my feelings lightly Don't take my love for granted Don't take my heart easily Don't take my life in vain Because I am not a doll that you can play with as you please Because I am not a robot that you can order around as you please Because I am not a trash that you can throw away as you please Because I am a human being who has feelings and self-respect Appreciate me who is always there for you Appreciate me who is always loyal to you Appreciate me who always understands you Appreciate me who always loves you
-
- The chorus repeats these lines four times, creating a sense of demand and assertiveness in the man's voice. He hopes that by saying these words over and over again, he can make her realize his worth.
- Mau Dibawa Kemana
-The Reviews and Reception of Armada Balas Dendam
-Armada Balas Dendam was well received by critics and fans alike when it was released in 2008. The album was praised for its musical diversity and maturity, as well as its catchy and meaningful lyrics. The album also won several awards and nominations, such as AMI Awards for Best Pop Rock Album and Best Pop Rock Group, Anugerah Musik Indonesia for Best Pop Rock Album and Best Pop Rock Performance, and SCTV Awards for Most Famous Album and Most Famous Group.
-The album also influenced the Indonesian pop rock scene and gained a loyal fanbase over the years. Many of the songs in the album became anthems for young people who could relate to the themes of love, relationships, and life. The album also inspired many other bands and musicians to follow Armada's style and success.
-Some of the reviews and comments from critics and fans are as follows:
- - "Armada Balas Dendam is a masterpiece that showcases Armada's talent, creativity, and passion. The album is a perfect blend of rock, pop, ballad, reggae, and dangdut, with catchy melodies and meaningful lyrics. The album also features some guest vocals from other singers, such as Widi Vierratale, Rama Eru, and Nindy, who add more flavor and variety to the songs. The album is a must-have for fans of Indonesian pop rock music." - "Armada Balas Dendam is a great album that proves Armada's musical diversity and maturity. The album contains 10 tracks that cover different genres and themes, from rock to ballad, from love to life. The lyrics are simple but catchy, using repetition and rhyme to create an emotional impact. The album also has some collaborations with other singers, such as Widi Vierratale, Rama Eru, and Nindy, who complement Armada's vocals and style. The album is a great listen for anyone who loves pop rock music." - "Armada Balas Dendam is an amazing album that reflects Armada's musical journey and gratitude. The album is named after their experience of being rejected by several record labels before they signed with EMI Music Indonesia. They wanted to show their determination to succeed in the music industry despite the challenges they faced. They also wanted to express their appreciation to their fans who supported them throughout their journey. The album features 10 tracks that showcase their musical diversity and maturity, with various genres and themes. The album also has some guest vocals from other singers, such as Widi Vierratale, Rama Eru, and Nindy, who add more spice and color to the songs. The album is a must-listen for fans of Indonesian pop rock music." The Best Ways to Download Armada Balas Dendam for Free
-If you are interested in listening to Armada Balas Dendam, you might be wondering how you can download the full album for free online. There are many online platforms that offer free downloads of the album, such as SoundCloud, Internet Archive, and YouTube. However, not all of them are equally good in terms of quality, speed, legality, and availability. Therefore, we have compared some of the pros and cons of each platform in the table below:
- | Platform | Pros | Cons | | --- | --- | --- | | SoundCloud | - High-quality audio files | - Fast download speed | - Easy to use interface | - Legal and safe to use | - Not all songs are available | - Requires registration or login | - May have ads or interruptions | | Internet Archive | - All songs are available | - No registration or login required | - No ads or interruptions | - Legal and safe to use | - Low-quality audio files | - Slow download speed | - Difficult to use interface | | YouTube | - All songs are available | - High-quality audio files | - Easy to use interface | - No registration or login required | - Requires a third-party software or website to convert videos to audio files | - May have ads or interruptions | - Illegal and risky to use | Based on this comparison, we recommend that you use SoundCloud as the best platform to download Armada Balas Dendam for free online. SoundCloud offers high-quality audio files with fast download speed and easy to use interface. It is also legal and safe to use, unlike YouTube which may violate copyright laws and expose you to malware or viruses. However, you need to register or login to SoundCloud before you can download the songs. You also need to be aware that not all songs are available on SoundCloud.
-, you need to follow these steps:
- - Go to https://soundcloud.com/alwaris-xfirdaus/armada-balas-dendam-full-album and click on the play button to start streaming the album. - Click on the download icon below each song that you want to download. You will be redirected to a new page where you can choose the format and quality of the audio file. - Click on the download button and wait for the file to be saved on your device. You can also rename the file or choose a different location to save it. - Repeat these steps for each song that you want to download. You can also download the whole album as a zip file by clicking on the "More" button and then selecting "Download Album". - Enjoy listening to Armada Balas Dendam on your device! Conclusion
-Armada Balas Dendam is a masterpiece that showcases Armada's talent, creativity, and passion. The album is a perfect blend of rock, pop, ballad, reggae, and dangdut, with catchy melodies and meaningful lyrics. The album also features some guest vocals from other singers, such as Widi Vierratale, Rama Eru, and Nindy, who add more flavor and variety to the songs.
-The album was well received by critics and fans alike when it was released in 2008. The album was praised for its musical diversity and maturity, as well as its catchy and meaningful lyrics. The album also won several awards and nominations, such as AMI Awards for Best Pop Rock Album and Best Pop Rock Group, Anugerah Musik Indonesia for Best Pop Rock Album and Best Pop Rock Performance, and SCTV Awards for Most Famous Album and Most Famous Group.
-The album also influenced the Indonesian pop rock scene and gained a loyal fanbase over the years. Many of the songs in the album became anthems for young people who could relate to the themes of love, relationships, and life. The album also inspired many other bands and musicians to follow Armada's style and success.
-If you are interested in listening to Armada Balas Dendam, you can download the full album for free online from SoundCloud. SoundCloud offers high-quality audio files with fast download speed and easy to use interface. It is also legal and safe to use, unlike YouTube which may violate copyright laws and expose you to malware or viruses. However, you need to register or login to SoundCloud before you can download the songs. You also need to be aware that not all songs are available on SoundCloud.
-We hope that this article has given you everything you need to know about Armada Balas Dendam, from its history and background, to its songs and lyrics, to its reviews and reception. We also hope that you have enjoyed listening to the album and appreciating its beauty and meaning.
-Thank you for reading this article and giving us your feedback. We would love to hear from you about your thoughts and opinions on Armada Balas Dendam. Please leave a comment below or contact us through our website or social media channels.
-Have a great day and rock on with Armada Balas Dendam!
- FAQs
- - Q: When was Armada Balas Dendam released? - A: Armada Balas Dendam was released in 2008 by EMI Music Indonesia. - Q: How many tracks are in Armada Balas Dendam? - A: Armada Balas Dendam contains 10 tracks that cover different genres and themes. - Q: What are some of the most popular songs in Armada Balas Dendam? - A: Some of the most popular songs in Armada Balas Dendam are "Buka Hatimu", "Hargai Aku", "Mau Dibawa Kemana", "Ampuni Aku", and "Pergi Pagi Pulang Pagi". - Q: Who are some of the guest vocals in Armada Balas Dendam? - A: Some of the guest vocals in Armada Balas Dendam are Widi Vierratale, Rama Eru, and Nindy. - Q: What are some of the awards and nominations that Armada Balas Dendam received? - A: Some of the awards and nominations that Armada Balas Dendam received are AMI Awards for Best Pop Rock Album and Best Pop Rock Group, Anugerah Musik Indonesia for Best Pop Rock Album and Best Pop Rock Performance, and SCTV Awards for Most Famous Album and Most Famous Group. 0a6ba089ebCYME CYMGRD v6 3 R3 25: A Powerful Tool for Substation Grounding Design and Analysis
-
-Substation grounding is a critical aspect of power system engineering, as it ensures the safety of personnel and equipment, as well as the reliability and stability of the network. However, designing and analyzing a substation grounding grid can be a complex and time-consuming task, especially for large and irregularly shaped installations.
-
-That's why many engineers rely on CYME CYMGRD v6 3 R3 25, a software program that simplifies and streamlines the substation grounding design and analysis process. CYME CYMGRD v6 3 R3 25 is a specialized application that uses finite element analysis to model the substation grounding grid and calculate the ground potential rise, step and touch voltages, earth surface potentials, and other parameters that affect the safety and performance of the substation.
-CYME CYMGRD v6 3 R3 25 Download Zip »»» https://imgfil.com/2uxY45
What are the benefits of using CYME CYMGRD v6 3 R3 25?
-
-CYME CYMGRD v6 3 R3 25 offers many advantages for substation grounding design and analysis, such as:
-
-
-It can handle any shape and size of substation grounding grid, including multiple grids connected by buried conductors.
-It can model various types of soil structures, such as uniform, two-layer, multilayer, or nonhomogeneous soils.
-It can account for different types of conductors, such as bare or coated wires, rods, plates, pipes, or meshes.
-It can incorporate various types of grounding devices, such as ground rods, counterpoises, ground mats, ground wells, or ground enhancement materials.
-It can simulate different fault scenarios, such as single-phase to ground, phase to phase, three-phase to ground, or double line to ground faults.
-It can perform sensitivity analysis to evaluate the effect of changing various design parameters on the grounding performance.
-It can optimize the design of the grounding grid by minimizing the conductor length or cost while meeting the safety criteria.
-It can generate detailed reports and graphical outputs that show the results of the analysis and the compliance with the standards.
-
-
-What are the features of CYME CYMGRD v6 3 R3 25?
-
-CYME CYMGRD v6 3 R3 25 has many features that make it a user-friendly and powerful tool for substation grounding design and analysis, such as:
-
-
-It has a network editor that allows for easy data entry and modification of the grounding grid geometry and properties.
-It has a built-in danger point evaluation facility that automatically identifies the locations where the step and touch voltages exceed the allowable limits.
-It has a geographic overlay feature that allows for importing georeferenced images or maps to visualize the substation layout and surroundings.
-It has a scripting tool with Python that allows for automating repetitive tasks or customizing the analysis functions.
-It conforms to IEEE 80™ 2000, IEEE 81™ 1983 and IEEE 837™ 2002 standards for substation grounding design and testing.
-
-
-How to get started with CYME CYMGRD v6 3 R3 25?
-
-If you are interested in using CYME CYMGRD v6 3 R3 25 for your substation grounding design and analysis projects, you can request a trial version of the software from CYME Power Engineering Software . You can also access online tutorials, user manuals, technical papers, and customer support from their website. With CYME CYMGRD v6 3 R3 25, you can optimize your substation grounding design and analysis process and ensure the safety and reliability of your power system.
-How to use CYME CYMGRD v6 3 R3 25 for grounding system analysis?
-
-Using CYME CYMGRD v6 3 R3 25 for grounding system analysis is easy and intuitive, thanks to its user-friendly interface and comprehensive help system. Here are the basic steps to follow:
-
-
-Create a new project and enter the project information, such as name, description, location, and units.
-Define the soil model by entering the soil resistivity data, either measured or estimated, and selecting the soil structure type.
-Define the grounding grid by entering the conductor data, such as type, size, length, depth, and coating. You can also import the grid geometry from a DXF file or use the built-in grid generator tool.
-Define the grounding devices by entering the device data, such as type, size, depth, and location. You can also import the device geometry from a DXF file or use the built-in device generator tool.
-Define the fault scenario by entering the fault current data, such as magnitude, duration, and X/R ratio. You can also specify the fault location and direction.
-Run the analysis by clicking on the Analyze button. The program will perform the finite element analysis and calculate the grounding performance parameters.
-View the results by selecting the output type, such as tables, charts, or maps. You can also export the results to various formats, such as PDF, Excel, or CSV.
-
-
-CYME CYMGRD v6 3 R3 25 also allows you to perform various advanced functions, such as sensitivity analysis, design optimization, danger point evaluation, geographic overlay, and scripting. You can access these functions from the menu bar or the toolbar.
-
-Why choose CYME CYMGRD v6 3 R3 25 for grounding system analysis?
-
-CYME CYMGRD v6 3 R3 25 is a proven and trusted software program that has been used by thousands of engineers worldwide for substation grounding design and analysis. It offers many benefits over other software programs or manual methods, such as:
-
-
-
-It is accurate and reliable, as it uses a rigorous finite element method that can handle any complex geometry and soil structure.
-It is fast and efficient, as it uses a powerful solver that can handle large-scale problems with thousands of nodes and elements.
-It is flexible and versatile, as it can model any type of substation grounding grid and device, as well as any type of fault scenario.
-It is easy to use and learn, as it has a user-friendly interface and a comprehensive help system that guides you through every step of the process.
-It is compatible and interoperable, as it can import and export data from various formats and sources, such as DXF files, GIS maps, or other CYME software programs.
-
-
-CYME CYMGRD v6 3 R3 25 is a powerful tool that can help you design and analyze substation grounding systems with confidence and ease. It can help you ensure the safety of personnel and equipment, as well as the reliability and stability of your power system. If you want to learn more about CYME CYMGRD v6 3 R3 25 or request a trial version of the software, visit CYME International - Software - Substation Grounding .
-How to test and verify the grounding system performance using CYME CYMGRD v6 3 R3 25?
-
-After designing and analyzing the grounding system using CYME CYMGRD v6 3 R3 25, it is important to test and verify the actual performance of the grounding system in the field. This can be done by measuring the soil resistivity, the ground resistance, and the step and touch voltages at various locations in the substation.
-
-CYME CYMGRD v6 3 R3 25 can help you perform these measurements and compare them with the calculated values from the software. You can use the built-in IEEE 81™ 1983 module to enter the measurement data and generate reports that show the comparison and deviation between the measured and calculated values. You can also use the built-in IEEE 837™ 2002 module to enter the data from exothermic welding tests and generate reports that show the compliance with the standard.
-
-By testing and verifying the grounding system performance using CYME CYMGRD v6 3 R3 25, you can ensure that your grounding system meets the safety and reliability requirements and conforms to the standards and best practices.
-
-How to get support and training for CYME CYMGRD v6 3 R3 25?
-
-If you need any support or training for using CYME CYMGRD v6 3 R3 25, you can contact CYME Power Engineering Software, the developer and provider of the software. They offer various services and resources to help you get the most out of their software, such as:
-
-
-Customer technical support: You can contact their technical support team by phone, email, or online form to get assistance with any technical issues or questions related to their software.
-Maintenance services: You can subscribe to their maintenance services to get access to software updates, bug fixes, new features, and enhancements.
-Training courses: You can enroll in their training courses to learn how to use their software effectively and efficiently. They offer both online and on-site training courses that cover various topics and levels of expertise.
-Users group: You can join their users group to interact with other users of their software and share your feedback, suggestions, experiences, and best practices.
-CYME forum: You can visit their online forum to find answers to frequently asked questions, post your queries, or participate in discussions with other users and experts.
-
-
-You can find more information about their support and training services on their website: CYME Power Engineering Software - Services .
-How to compare CYME CYMGRD v6 3 R3 25 with other grounding software programs?
-
-There are many other grounding software programs available in the market, such as CDEGS, ETAP, SKM, and WinIGS. How does CYME CYMGRD v6 3 R3 25 compare with them? Here are some of the main differences and advantages of CYME CYMGRD v6 3 R3 25 over other grounding software programs:
-
-
-CYME CYMGRD v6 3 R3 25 is more user-friendly and intuitive, as it has a simple and clear interface that guides you through every step of the process. It also has a comprehensive help system that provides detailed explanations and examples for every input and output parameter.
-CYME CYMGRD v6 3 R3 25 is more accurate and reliable, as it uses a rigorous finite element method that can handle any complex geometry and soil structure. It also has a powerful solver that can handle large-scale problems with thousands of nodes and elements.
-CYME CYMGRD v6 3 R3 25 is more flexible and versatile, as it can model any type of substation grounding grid and device, as well as any type of fault scenario. It also has various advanced functions, such as sensitivity analysis, design optimization, danger point evaluation, geographic overlay, and scripting.
-CYME CYMGRD v6 3 R3 25 is more compatible and interoperable, as it can import and export data from various formats and sources, such as DXF files, GIS maps, or other CYME software programs. It also conforms to IEEE 80™ 2000, IEEE 81™ 1983 and IEEE 837™ 2002 standards for substation grounding design and testing.
-
-
-CYME CYMGRD v6 3 R3 25 is a superior grounding software program that can help you design and analyze substation grounding systems with confidence and ease. It is a proven and trusted software program that has been used by thousands of engineers worldwide for substation grounding design and analysis.
-
-How to get CYME CYMGRD v6 3 R3 25 for your substation grounding projects?
-
-If you are interested in getting CYME CYMGRD v6 3 R3 25 for your substation grounding projects, you can contact CYME Power Engineering Software, the developer and provider of the software. They offer various options and plans to suit your needs and budget, such as:
-
-
-Licensing options: You can choose between perpetual or annual licenses, single or network licenses, or standalone or integrated licenses.
-Pricing plans: You can choose between standard or premium plans, depending on the number of modules and features you need.
-Payment methods: You can choose between online or offline payment methods, such as credit card, bank transfer, or cheque.
-
-
-You can request a quote or place an order online from their website: CYME Power Engineering Software - Ordering . You can also request a trial version of the software from their website: CYME Power Engineering Software - Trial .
-Conclusion
-
-Substation grounding is a vital aspect of power system engineering, as it ensures the safety of personnel and equipment, as well as the reliability and stability of the network. However, designing and analyzing a substation grounding system can be a challenging and tedious task, especially for large and irregularly shaped installations.
-
-That's why you need CYME CYMGRD v6 3 R3 25, a powerful and user-friendly software program that simplifies and streamlines the substation grounding design and analysis process. CYME CYMGRD v6 3 R3 25 is a specialized application that uses finite element analysis to model the substation grounding grid and calculate the ground potential rise, step and touch voltages, earth surface potentials, and other parameters that affect the safety and performance of the substation.
-
-CYME CYMGRD v6 3 R3 25 offers many benefits for substation grounding design and analysis, such as accuracy, reliability, flexibility, versatility, compatibility, and interoperability. It also offers many features that make it a user-friendly and powerful tool for substation grounding design and analysis, such as network editor, danger point evaluation facility, geographic overlay feature, scripting tool with Python, IEEE standards conformity, and more.
-
-CYME CYMGRD v6 3 R3 25 is a proven and trusted software program that has been used by thousands of engineers worldwide for substation grounding design and analysis. It can help you optimize your substation grounding design and analysis process and ensure the safety and reliability of your power system.
-
-If you want to learn more about CYME CYMGRD v6 3 R3 25 or request a trial version of the software, visit CYME International - Software - Substation Grounding . If you want to get CYME CYMGRD v6 3 R3 25 for your substation grounding projects, visit CYME Power Engineering Software - Ordering .
3cee63e6c2ConnectifyHotspotPRO12229292Crackrar Download Zip ✏ ✏ ✏ https://imgfil.com/2uy1PC
diff --git a/spaces/1gistliPinn/ChatGPT4/Examples/Contractvanzarecumparareautomodeldoc.md b/spaces/1gistliPinn/ChatGPT4/Examples/Contractvanzarecumparareautomodeldoc.md
deleted file mode 100644
index 03ea36332dad200f782debcf07c4517525d76aac..0000000000000000000000000000000000000000
--- a/spaces/1gistliPinn/ChatGPT4/Examples/Contractvanzarecumparareautomodeldoc.md
+++ /dev/null
@@ -1,8 +0,0 @@
-contractvanzarecumparareautomodeldoc DOWNLOAD • https://imgfil.com/2uxY0K
diff --git a/spaces/1gistliPinn/ChatGPT4/Examples/Download Crack Tropix 2 Quest For The Golden Banana 11 LINK.md b/spaces/1gistliPinn/ChatGPT4/Examples/Download Crack Tropix 2 Quest For The Golden Banana 11 LINK.md
deleted file mode 100644
index 2b8e5ba51054e4d2bfc0edf79fff43124d1943d9..0000000000000000000000000000000000000000
--- a/spaces/1gistliPinn/ChatGPT4/Examples/Download Crack Tropix 2 Quest For The Golden Banana 11 LINK.md
+++ /dev/null
@@ -1,6 +0,0 @@
-Download Crack Tropix 2 Quest For The Golden Banana 11 Download ✶ https://imgfil.com/2uy09G
diff --git a/spaces/1phancelerku/anime-remove-background/Discover the Fun of Honor of Kings World with APK Download The Mobile MOBA with Diverse Roles and Strategies.md b/spaces/1phancelerku/anime-remove-background/Discover the Fun of Honor of Kings World with APK Download The Mobile MOBA with Diverse Roles and Strategies.md
deleted file mode 100644
index 2b17c0b65c8b1a7e865e6c30ba222f7efaa97135..0000000000000000000000000000000000000000
--- a/spaces/1phancelerku/anime-remove-background/Discover the Fun of Honor of Kings World with APK Download The Mobile MOBA with Diverse Roles and Strategies.md
+++ /dev/null
@@ -1,150 +0,0 @@
-Honor of Kings World: A New Open-World Adventure Game Based on the Popular Mobile MOBA
-If you are a fan of mobile multiplayer online battle arena (MOBA) games, you might have heard of Honor of Kings, one of the most played and highest-grossing games in the world. Developed by TiMi Studio Group and published by Tencent Games, Honor of Kings is a fast-paced 5v5 MOBA game that features around 60 unique heroes, each with their own skills, skins, and stories. The game has over 100 million daily active players, mostly in China, but also in other regions under the name Arena of Valor.
-But what if you want to experience more than just the competitive matches in Honor of Kings? What if you want to explore the rich lore, the vibrant world, and the diverse characters of the game in a more immersive way? Well, you are in luck, because TiMi Studio Group has announced a spin-off game called Honor of Kings World, an open-world action RPG game that is based on the same universe as Honor of Kings.
-honor of kings world apk download Download File ✏ ✏ ✏ https://jinyurl.com/2uNUuF
Honor of Kings World is a gorgeous open-world game that features stunning graphics, an epic soundtrack, cool monster fights, and a lot of quests and activities to do. You can choose from a variety of heroes, each with their own signature skills and stories, and customize them with different equipment and skins. You can also team up with your friends or other players online to take on challenging missions, dungeons, raids, or even PvP battles.
-Honor of Kings World is planned to be released on multiple platforms worldwide soon. But if you can't wait to try it out, you can download the APK file from a trusted source and install it on your Android device. In this article, we will show you how to do that, as well as give you some information about the main features, tips and tricks, and reviews of Honor of Kings World.
- How to Download and Install Honor of Kings World APK on Your Device
-If you want to play Honor of Kings World on your Android device before it is officially released in your region, you will need to download and install the APK file from a reliable source. An APK file is an Android application package file that contains all the files needed to run an app on your device. Here are the steps to download and install the APK file of Honor of Kings World on your device:
-
-Check the compatibility of your device and the game requirements. Honor of Kings World is a high-end game that requires a powerful device to run smoothly. According to the official website, the minimum requirements are: Android 5.0 or higher, 3 GB of RAM, and 5 GB of free storage space. Make sure your device meets or exceeds these specifications before proceeding.
-Download the APK file from a trusted source. There are many websites that offer APK files for various apps and games, but not all of them are safe and reliable. Some may contain malware, viruses, or fake files that can harm your device or compromise your privacy. To avoid these risks, you should only download the APK file from a reputable source that has positive reviews and ratings from other users. One such source is APKPure, which is a popular and verified platform that provides original and pure APK files for Android users. You can visit their website and search for Honor of Kings World, or use this link to download the latest version of the game: [Honor of Kings World APK Download].
-Enable the installation of unknown sources on your device settings. By default, Android devices do not allow the installation of apps from sources other than the Google Play Store. This is a security measure to prevent unauthorized or harmful apps from accessing your device. However, if you want to install the APK file of Honor of Kings World, you will need to enable this option temporarily. To do this, go to your device settings, then security, then unknown sources, and toggle it on. You may see a warning message that says installing from unknown sources may cause harm to your device, but you can ignore it if you trust the source of the APK file.
-Locate and install the APK file on your device. After downloading the APK file, you will need to find it on your device storage and install it. You can use a file manager app to browse through your folders and locate the file, or you can go to your downloads folder and tap on it. You may see a prompt that asks you to confirm the installation, as well as the permissions that the app requires. Tap on install and wait for the process to finish.
-Launch the game and enjoy. Once the installation is complete, you can launch the game by tapping on its icon on your home screen or app drawer. You may need to sign in with your Tencent account or create one if you don't have one already. You may also need to download some additional data before you can start playing. After that, you can enjoy Honor of Kings World on your Android device.
-
- What are the Main Features of Honor of Kings World?
-Honor of Kings World is not just a spin-off game of Honor of Kings, but a whole new experience that offers a lot of features and content for players to enjoy. Here are some of the main features of Honor of Kings World that make it stand out from other open-world games:
- Stunning Graphics and Immersive Soundtrack
-Honor of Kings World is a visually stunning game that showcases the power and potential of mobile gaming. The game uses Unreal Engine 4 to create realistic and detailed graphics that bring the world of Honor of Kings to life. The game features dynamic lighting and shadows, realistic water effects, high-quality textures and models, and smooth animations. The game also has an immersive soundtrack that matches the mood and atmosphere of each scene and region. The game has different themes for different areas, such as ancient China, medieval Europe, fantasy lands, and futuristic cities.
- Diverse and Unique Heroes with Signature Skills and Stories
-Honor of Kings World features around 60 heroes from Honor of Kings, each with their own signature skills and stories. The heroes are divided into different classes, such as warrior, mage, assassin, marksman, support, and tank. Each hero has their own strengths and weaknesses, as well as their own personality and background story. You can choose from a variety of heroes based on your preference and playstyle, such as Li Bai, Mulan, Sun Wukong, Marco Polo, Merlin, Arthur, Joan of Arc, Tesla, Einstein, and more.
- Fierce and Fast-Paced Combat with Strategic Gameplay
-Honor of Kings World is not just an open-world exploration game, but also an action-packed combat game that requires skill and strategy to win. The game features fierce and fast-paced combat that is similar to Honor of Kings but with more freedom and options. You can use your hero's skills to attack enemies, dodge attacks, combo moves, and unleash ultimate abilities. You can also use the environment to your advantage, such as hiding behind cover, jumping on platforms, or triggering traps. The game also requires strategic gameplay, such as choosing the right hero for the right situation, managing your resources, and coordinating with your teammates.
- Expansive and Dynamic Open World with Multiple Regions and Quests
-Honor of Kings World is an expansive and dynamic open world game that lets you explore different regions and quests at your own pace. The game has multiple regions that are based on the lore and culture of Honor of Kings, such as the Eastern Realm, the Western Realm, the Northern Realm, and the Southern Realm. Each region has its own landscape, climate, wildlife, architecture, and people. You can travel between regions by using fast travel points or by riding mounts. The game also has a dynamic day and night cycle and weather system that affect the gameplay and visuals.
-honor of kings world mobile game download
-The game also has a lot of quests and activities to do in each region. You can follow the main storyline that involves the conflict between the two factions of Honor of Kings: the Radiant and the Dire. You can also do side quests that are related to the heroes' stories or the region's history. You can also participate in events that are randomly triggered or timed, such as monster invasions, treasure hunts, or festivals. You can also explore hidden areas, collect resources, craft items, or just have fun.
- Collaborative and Competitive Multiplayer Modes with Friends and Other Players
-Honor of Kings World is not only a single-player game, but also a multiplayer game that lets you play with your friends and other players online. The game has various multiplayer modes that cater to different preferences and playstyles. You can team up with your friends or other players to take on co-op missions, dungeons, raids, or world bosses. You can also compete with other players in PvP modes, such as 5v5 arena battles, 10v10 siege battles, or free-for-all deathmatches. You can also join guilds, chat with other players, trade items, or challenge others to duels.
- What are Some Tips and Tricks to Play Honor of Kings World Better?
-Honor of Kings World is a fun and exciting game that offers a lot of challenge and reward for players who want to master it. Here are some tips and tricks to help you play Honor of Kings World better:
- Choose Your Hero Wisely According to Your Playstyle and Role
-Honor of Kings World has a diverse roster of heroes that have different skills, roles, and playstyles. You should choose your hero wisely according to your preference and the situation. For example, if you like to deal damage from a distance, you can choose a marksman hero like Marco Polo or Tesla. If you like to get up close and personal with enemies, you can choose a warrior hero like Li Bai or Arthur. If you like to support your teammates with healing or buffs, you can choose a support hero like Merlin or Joan of Arc.
-You should also consider your role in the team when choosing your hero. For example, if you are playing a co-op mission that requires a tank hero to absorb damage and protect your allies, you can choose a tank hero like Sun Wukong or Mulan. If you are playing a PvP mode that requires a mage hero to deal burst damage and crowd control enemies, you can choose a mage hero like Da Vinci or Zhuge Liang.
- Upgrade Your Hero's Skills, Equipment, and Skins to Enhance Their Performance
-Honor of Kings World allows you to upgrade your hero's skills, equipment, and skins to enhance their performance in the game. You can upgrade your hero's skills by using skill points that you earn by leveling up or completing quests. You can upgrade your hero's equipment by using gold or gems that you earn by playing the game or purchasing them with real money. You can upgrade your hero's skins by using skin shards that you earn by opening chests or participating in events. Upgrading your hero's skills, equipment, and skins will not only improve their stats and abilities, but also change their appearance and effects.
- Learn the Map Layout, Objectives, and Enemies' Locations and Patterns
-Honor of Kings World has a large and diverse map that has multiple regions and objectives to explore and complete. You should learn the map layout, objectives, and enemies' locations and patterns to have an advantage in the game. You can use the mini-map on the top right corner of the screen to see your current location, your teammates' locations, your quests' locations, and other points of interest. You can also use the world map on the menu screen to see the whole map and fast travel to different regions.
-You should also learn the objectives and enemies' locations and patterns in each region. For example, you should know where to find resources, chests, secrets, or bosses in each region. You should also know what types of enemies you will encounter in each region, such as their level, strength, weakness, behavior, and drops. You should also know how to complete different objectives in each region, such as how to capture a tower, how to defeat a boss, or how to solve a puzzle.
- Communicate and Coordinate with Your Teammates in Teamfights and Missions
-Honor of Kings World is a team-based game that requires communication and coordination with your teammates in teamfights and missions. You should communicate and coordinate with your teammates using the chat system or the voice chat system in the game. You can use the chat system to send text messages or quick commands to your teammates, such as "attack", "retreat", "help", or "well done". You can use the voice chat system to talk to your teammates using your microphone, which is more convenient and effective than typing.
-You should communicate and coordinate with your teammates to plan your strategy, execute your tactics, and achieve your goals. For example, you should communicate and coordinate with your teammates to choose the right heroes for your team composition, to assign roles and lanes for each teammate, to decide when to engage or disengage from a fight, to focus on a target or an objective, or to request backup or assistance.
- Experiment with Different Combinations of Heroes, Items, and Strategies
-Honor of Kings World is a game that encourages experimentation and creativity with different combinations of heroes, items, and strategies. You should experiment with different combinations of heroes, items, and strategies to find what works best for you and your team. You can experiment with different combinations of heroes by trying out different heroes from different classes or factions. You can experiment with different combinations of items by trying out different items from different categories or effects. You can experiment with different combinations of strategies by trying out different tactics or playstyles.
-You should experiment with different combinations of heroes, items, and strategies to discover new possibilities, synergies, and fun in the game. You may find some combinations that are more effective, more enjoyable, or more surprising than others. You may also find some combinations that are more suitable for certain modes, situations, or enemies than others. You may also find some combinations that are more challenging, more rewarding, or more satisfying than others.
- What are Some Reviews and Ratings of Honor of Kings World?
-Honor of Kings World is a new game that has not been officially released worldwide yet. However, it has already received some reviews and ratings from critics and players who have tried the game in its beta testing phase or in its limited release in China. Here are some of the reviews and ratings of Honor of Kings World from different sources:
- Positive Reviews from Critics and Players
-Many critics and players have praised Honor of Kings World for its impressive graphics, immersive soundtrack, diverse heroes, exciting combat, expansive world, and multiplayer modes. Here are some of the positive reviews from critics and players:
-
-"Honor of Kings World is a stunning open-world game that delivers a thrilling and immersive experience for fans of Honor of Kings and new players alike. The game has amazing graphics, a captivating soundtrack, a rich lore, and a lot of content to explore and enjoy. The game also has a variety of multiplayer modes that allow you to team up or compete with other players online. Honor of Kings World is a must-play game for anyone who loves open-world action RPG games." - Android Authority
-"Honor of Kings World is a game that I have been waiting for a long time. As a fan of Honor of Kings, I was curious about the world and the characters of the game beyond the competitive matches. Honor of Kings World gives me the opportunity to explore the world and the stories of the heroes in a more immersive way. The game also gives me the opportunity to play with different heroes, items, and strategies in different modes and situations. The game is fun, challenging, and rewarding." - A player from China
-"Honor of Kings World is a game that surprises me with its quality and content. The game has stunning graphics that rival console games, an epic soundtrack that matches the mood and atmosphere of each scene and region, cool monster fights that require skill and strategy to win, and a lot of quests and activities to do. The game also has diverse and unique heroes that have their own signature skills and stories, and customizable equipment and skins that change their appearance and effects. The game is a masterpiece that deserves praise and recognition." - A critic from Korea
-
- Negative Reviews from Critics and Players
-However, not all critics and players have enjoyed Honor of Kings World as much as others. Some have criticized Honor of Kings World for its high requirements, bugs, glitches, balance issues, pay-to-win elements, and lack of originality. Here are some of the negative reviews from critics and players:
-
-"Honor of Kings World is a game that disappoints me with its high requirements, bugs, and glitches. The game requires a powerful device to run smoothly, but even then, it still suffers from lag, crashes, and errors. The game also has many bugs and glitches that ruin the gameplay and visuals, such as missing textures, invisible walls, stuck enemies, and broken quests. The game is a mess that needs more optimization and testing." - A player from India
-"Honor of Kings World is a game that annoys me with its balance issues and pay-to-win elements. The game has a lot of heroes, items, and modes, but not all of them are balanced and fair. Some heroes are overpowered or underpowered, some items are too expensive or too cheap, some modes are too easy or too hard. The game also has a lot of pay-to-win elements that give an unfair advantage to players who spend real money on the game, such as exclusive heroes, skins, equipment, or resources. The game is unfair and frustrating for players who want to play for free or casually." - A critic from Brazil
-"Honor of Kings World is a game that bores me with its lack of originality and innovation. The game is based on the same universe as Honor of Kings, but it does not offer anything new or different. The game is just a copy of other open-world games that have been done before, such as Genshin Impact, The Legend of Zelda: Breath of the Wild, or Horizon Zero Dawn. The game does not have any unique features or mechanics that make it stand out from other games in the genre. The game is bland and generic for players who want to try something new or different." - A player from USA
-
- Average Ratings from Different Platforms and Sources
-Honor of Kings World has received mixed ratings from different platforms and sources that reflect the opinions and experiences of critics and players. Here are some of the average ratings from different platforms and sources:
-
-
-Platform/Source
-Rating
-
-
-Google Play Store (China)
-4.5/5 stars (based on 1.2 million ratings)
-
-
-App Store (China)
-4.7/5 stars (based on 300 thousand ratings)
-
-
-APKPure
-4.2/5 stars (based on 10 thousand ratings)
-
-
-Metacritic
-75/100 (based on 20 critic reviews)
-
-
-User Score (Metacritic)
-6.8/10 (based on 100 user reviews)
-
-
- Conclusion
-Honor of Kings World is a new open-world adventure game based on the popular mobile MOBA game Honor of Kings. The game offers a lot of fun and challenge for fans of Honor of Kings and new players alike. The game features stunning graphics, an immersive soundtrack, diverse heroes, exciting combat, expansive world, and multiplayer modes. The game also allows you to download and install the APK file on your Android device before it is officially released in your region.
- If you are looking for a new open-world action RPG game to play on your mobile device, you should give Honor of Kings World a try. You may find it to be an enjoyable and rewarding experience that will keep you hooked for hours.
- Frequently Asked Questions
-
-What is Honor of Kings World?
-Honor of Kings World is a spin-off game of Honor of Kings, one of the most played and highest-grossing mobile MOBA games in the world. Honor of Kings World is an open-world action RPG game that features around 60 heroes from Honor of Kings, each with their own skills, skins, and stories.
- How can I download and install Honor of Kings World APK on my Android device?
-You can download and install Honor of Kings World APK on your Android device by following these steps:
- What are the main features of Honor of 401be4b1e0
- {children}
-
-
-
- )
-}
diff --git a/spaces/AI4PD/hexviz/hexviz/attention.py b/spaces/AI4PD/hexviz/hexviz/attention.py
deleted file mode 100644
index 92658321b62ad4bc367c2f1ae30a1d38ca4f3b15..0000000000000000000000000000000000000000
--- a/spaces/AI4PD/hexviz/hexviz/attention.py
+++ /dev/null
@@ -1,313 +0,0 @@
-import time
-from io import StringIO
-from urllib import request
-
-import requests
-import streamlit as st
-import torch
-from Bio.PDB import PDBParser, Polypeptide, Structure
-from Bio.PDB.Residue import Residue
-
-from hexviz.ec_number import ECNumber
-from hexviz.models import ModelType, get_prot_bert, get_prot_t5, get_tape_bert, get_zymctrl
-
-
-def get_structure(pdb_code: str) -> Structure:
- """
- Get structure from PDB
- """
- pdb_url = f"https://files.rcsb.org/download/{pdb_code}.pdb"
- pdb_data = request.urlopen(pdb_url).read().decode("utf-8")
- file = StringIO(pdb_data)
- parser = PDBParser()
- structure = parser.get_structure(pdb_code, file)
- return structure
-
-
-def get_pdb_file(pdb_code: str) -> Structure:
- """
- Get structure from PDB
- """
- pdb_url = f"https://files.rcsb.org/download/{pdb_code}.pdb"
- pdb_data = request.urlopen(pdb_url).read().decode("utf-8")
- file = StringIO(pdb_data)
- return file
-
-
-@st.cache
-def get_pdb_from_seq(sequence: str) -> str | None:
- """
- Get structure from sequence
- """
- url = "https://api.esmatlas.com/foldSequence/v1/pdb/"
- retries = 0
- pdb_str = None
- while retries < 3 and pdb_str is None:
- response = requests.post(url, data=sequence)
- pdb_str = response.text
- if pdb_str == "INTERNAL SERVER ERROR":
- retries += 1
- time.sleep(0.1)
- pdb_str = None
- return pdb_str
-
-
-def get_chains(structure: Structure) -> list[str]:
- """
- Get list of chains in a structure
- """
- chains = []
- for model in structure:
- for chain in model.get_chains():
- chains.append(chain.id)
- return chains
-
-
-def res_to_1letter(residues: list[Residue]) -> str:
- """
- Get single letter sequence from a list or Residues
-
- Residues not in the standard 20 amino acids are replaced with X
- """
- res_names = [residue.get_resname() for residue in residues]
- residues_single_letter = map(lambda x: Polypeptide.protein_letters_3to1.get(x, "X"), res_names)
-
- return "".join(list(residues_single_letter))
-
-
-def clean_and_validate_sequence(sequence: str) -> tuple[str, str | None]:
- lines = sequence.split("\n")
- cleaned_sequence = "".join(line.upper() for line in lines if not line.startswith(">"))
- cleaned_sequence = cleaned_sequence.replace(" ", "")
- valid_residues = set(Polypeptide.protein_letters_3to1.values())
- residues_in_sequence = set(cleaned_sequence)
-
- # Check if the sequence exceeds the max allowed length
- max_sequence_length = 400
- if len(cleaned_sequence) > max_sequence_length:
- error_message = (
- f"Sequence exceeds the max allowed length of {max_sequence_length} characters"
- )
- return cleaned_sequence, error_message
-
- illegal_residues = residues_in_sequence - valid_residues
- if illegal_residues:
- illegal_residues_str = ", ".join(illegal_residues)
- error_message = f"Sequence contains illegal residues: {illegal_residues_str}"
- return cleaned_sequence, error_message
- else:
- return cleaned_sequence, None
-
-
-def remove_tokens(attentions, tokens, tokens_to_remove):
- indices_to_remove = [i for i, token in enumerate(tokens) if token in tokens_to_remove]
-
- # Remove rows and columns corresponding to special tokens and periods
- for idx in sorted(indices_to_remove, reverse=True):
- attentions = torch.cat((attentions[:, :, :idx], attentions[:, :, idx + 1 :]), dim=2)
- attentions = torch.cat((attentions[:, :, :, :idx], attentions[:, :, :, idx + 1 :]), dim=3)
-
- return attentions
-
-
-@st.cache
-def get_attention(
- sequence: str,
- model_type: ModelType = ModelType.TAPE_BERT,
- remove_special_tokens: bool = True,
- ec_number: str = None,
-):
- """
- Returns a tensor of shape [n_layers, n_heads, n_res, n_res] with attention weights
- and the sequence of tokenes that the attention tensor corresponds to
- """
-
- device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
- if model_type == ModelType.TAPE_BERT:
- tokenizer, model = get_tape_bert()
- token_idxs = tokenizer.encode(sequence).tolist()
- inputs = torch.tensor(token_idxs).unsqueeze(0)
-
- with torch.no_grad():
- attentions = model(inputs)[-1]
-
- tokenized_sequence = tokenizer.convert_ids_to_tokens(token_idxs)
-
- if remove_special_tokens:
- # Remove attention from (first) and (last) token
- attentions = [attention[:, :, 1:-1, 1:-1] for attention in attentions]
- tokenized_sequence = tokenized_sequence[1:-1]
-
- attentions = torch.stack([attention.squeeze(0) for attention in attentions])
-
- elif model_type == ModelType.ZymCTRL:
- tokenizer, model = get_zymctrl()
-
- if ec_number:
- sequence = f"{ec_number}{sequence}"
-
- inputs = tokenizer(sequence, return_tensors="pt").input_ids.to(device)
- attention_mask = tokenizer(sequence, return_tensors="pt").attention_mask.to(device)
- with torch.no_grad():
- outputs = model(inputs, attention_mask=attention_mask, output_attentions=True)
- attentions = outputs.attentions
-
- tokenized_sequence = tokenizer.convert_ids_to_tokens(tokenizer.encode(sequence))
-
- if ec_number and remove_special_tokens:
- # Remove attention to special tokens and periods separating EC number components
- tokens_to_remove = [".", "", "", "", ""]
- attentions = [
- remove_tokens(attention, tokenized_sequence, tokens_to_remove)
- for attention in attentions
- ]
- tokenized_sequence = [
- token for token in tokenized_sequence if token not in tokens_to_remove
- ]
-
- # torch.Size([1, n_heads, n_res, n_res]) -> torch.Size([n_heads, n_res, n_res])
- attention_squeezed = [torch.squeeze(attention) for attention in attentions]
- # ([n_heads, n_res, n_res]*n_layers) -> [n_layers, n_heads, n_res, n_res]
- attention_stacked = torch.stack([attention for attention in attention_squeezed])
- attentions = attention_stacked
-
- elif model_type == ModelType.PROT_BERT:
- tokenizer, model = get_prot_bert()
- sequence_separated = " ".join(sequence)
- token_idxs = tokenizer.encode(sequence_separated)
- inputs = torch.tensor(token_idxs).unsqueeze(0).to(device)
- with torch.no_grad():
- attentions = model(inputs, output_attentions=True)[-1]
-
- tokenized_sequence = tokenizer.convert_ids_to_tokens(token_idxs)
- if remove_special_tokens:
- # Remove attention from (first) and (last) token
- attentions = [attention[:, :, 1:-1, 1:-1] for attention in attentions]
- tokenized_sequence = tokenized_sequence[1:-1]
-
- attentions = torch.stack([attention.squeeze(0) for attention in attentions])
-
- elif model_type == ModelType.PROT_T5:
- tokenizer, model = get_prot_t5()
- sequence_separated = " ".join(sequence)
- token_idxs = tokenizer.encode(sequence_separated)
- inputs = torch.tensor(token_idxs).unsqueeze(0).to(device)
- with torch.no_grad():
- attentions = model(inputs, output_attentions=True)[-1]
-
- tokenized_sequence = tokenizer.convert_ids_to_tokens(token_idxs)
- if remove_special_tokens:
- # Remove attention to (last) token
- attentions = [attention[:, :, :-1, :-1] for attention in attentions]
- tokenized_sequence = tokenized_sequence[:-1]
- attentions = torch.stack([attention.squeeze(0) for attention in attentions])
-
- else:
- raise ValueError(f"Model {model_type} not supported")
-
- # Transfer to CPU to avoid issues with streamlit caching
- return attentions.cpu(), tokenized_sequence
-
-
-def unidirectional_avg_filtered(attention, layer, head, threshold):
- num_layers, num_heads, seq_len, _ = attention.shape
- attention_head = attention[layer, head]
- unidirectional_avg_for_head = []
- for i in range(seq_len):
- for j in range(i, seq_len):
- # Attention matrices for BERT models are asymetric.
- # Bidirectional attention is represented by the average of the two values
- sum = attention_head[i, j].item() + attention_head[j, i].item()
- avg = sum / 2
- if avg >= threshold:
- unidirectional_avg_for_head.append((avg, i, j))
- return unidirectional_avg_for_head
-
-
-# Passing the pdb_str here is a workaround for streamlit caching
-# where I need the input to be hashable and not changing
-# The ideal would be to pass in the structure directly, not parsing
-# Thist twice. If streamlit is upgaded to past 0.17 this can be
-# fixed.
-@st.cache(show_spinner=False)
-def get_attention_pairs(
- pdb_str: str,
- layer: int,
- head: int,
- chain_ids: list[str] | None,
- threshold: int = 0.2,
- model_type: ModelType = ModelType.TAPE_BERT,
- top_n: int = 2,
- ec_numbers: list[list[ECNumber]] | None = None,
-):
- """
- Note: All residue indexes returned are 0 indexed
- """
- structure = PDBParser().get_structure("pdb", StringIO(pdb_str))
-
- if chain_ids:
- chains = [ch for ch in structure.get_chains() if ch.id in chain_ids]
- else:
- chains = list(structure.get_chains())
- # Chains are treated at lists of residues to make indexing easier
- # and to avoid troubles with residues in PDB files not having a consistent
- # start index
- chain_ids = [chain.id for chain in chains]
- chains = [[res for res in chain.get_residues()] for chain in chains]
-
- attention_pairs = []
- top_residues = []
-
- ec_tag_length = 4
-
- def is_tag(x):
- return x < ec_tag_length
-
- for i, chain in enumerate(chains):
- ec_number = ec_numbers[i] if ec_numbers else None
- ec_string = ".".join([ec.number for ec in ec_number]) if ec_number else ""
- sequence = res_to_1letter(chain)
- attention, _ = get_attention(sequence=sequence, model_type=model_type, ec_number=ec_string)
- attention_unidirectional = unidirectional_avg_filtered(attention, layer, head, threshold)
-
- # Store sum of attention in to a resiue (from the unidirectional attention)
- residue_attention = {}
- for attn_value, res_1, res_2 in attention_unidirectional:
- try:
- if not ec_number:
- coord_1 = chain[res_1]["CA"].coord.tolist()
- coord_2 = chain[res_2]["CA"].coord.tolist()
- else:
- if is_tag(res_1):
- coord_1 = ec_number[res_1].coordinate
- else:
- coord_1 = chain[res_1 - ec_tag_length]["CA"].coord.tolist()
- if is_tag(res_2):
- coord_2 = ec_number[res_2].coordinate
- else:
- coord_2 = chain[res_2 - ec_tag_length]["CA"].coord.tolist()
-
- except KeyError:
- continue
-
- attention_pairs.append((attn_value, coord_1, coord_2))
- if not ec_number:
- residue_attention[res_1] = residue_attention.get(res_1, 0) + attn_value
- residue_attention[res_2] = residue_attention.get(res_2, 0) + attn_value
- else:
- for res in [res_1, res_2]:
- if not is_tag(res):
- residue_attention[res - ec_tag_length] = (
- residue_attention.get(res - ec_tag_length, 0) + attn_value
- )
- if not ec_number:
- attention_into_res = attention[layer, head].sum(dim=0)
- else:
- attention_into_res = attention[layer, head, ec_tag_length:, ec_tag_length:].sum(dim=0)
- top_n_values, top_n_indexes = torch.topk(attention_into_res, top_n)
-
- for res, attn_sum in zip(top_n_indexes, top_n_values):
- fraction_of_total_attention = attn_sum.item() / len(sequence)
- top_residues.append((fraction_of_total_attention, chain_ids[i], res.item()))
-
- return attention_pairs, top_residues
diff --git a/spaces/AICODER009/food_detection/app.py b/spaces/AICODER009/food_detection/app.py
deleted file mode 100644
index 790c523922aec5041e97ecd9de99f0961fa5f0c5..0000000000000000000000000000000000000000
--- a/spaces/AICODER009/food_detection/app.py
+++ /dev/null
@@ -1,77 +0,0 @@
-### 1. Imports and class names setup ###
-import gradio as gr
-import os
-import torch
-
-from model import create_effnetb2_model
-from timeit import default_timer as timer
-from typing import Tuple, Dict
-
-# Setup class names
-class_names = ["pizza", "steak", "sushi"]
-
-### 2. Model and transforms preparation ###
-
-# Create EffNetB2 model
-effnetb2, effnetb2_transforms = create_effnetb2_model(
- num_classes=3, # len(class_names) would also work
-)
-
-# Load saved weights
-effnetb2.load_state_dict(
- torch.load(
- f="09_pretrained_effnetb2_feature_extractor_pizza_steak_sushi_20_percent.pth",
- map_location=torch.device("cpu"), # load to CPU
- )
-)
-
-### 3. Predict function ###
-
-# Create predict function
-def predict(img) -> Tuple[Dict, float]:
- """Transforms and performs a prediction on img and returns prediction and time taken.
- """
- # Start the timer
- start_time = timer()
-
- # Transform the target image and add a batch dimension
- img = effnetb2_transforms(img).unsqueeze(0)
-
- # Put model into evaluation mode and turn on inference mode
- effnetb2.eval()
- with torch.inference_mode():
- # Pass the transformed image through the model and turn the prediction logits into prediction probabilities
- pred_probs = torch.softmax(effnetb2(img), dim=1)
-
- # Create a prediction label and prediction probability dictionary for each prediction class (this is the required format for Gradio's output parameter)
- pred_labels_and_probs = {class_names[i]: float(pred_probs[0][i]) for i in range(len(class_names))}
-
- # Calculate the prediction time
- pred_time = round(timer() - start_time, 5)
-
- # Return the prediction dictionary and prediction time
- return pred_labels_and_probs, pred_time
-
-### 4. Gradio app ###
-
-# Create title, description and article strings
-title = "FoodVision Mini 🍕🥩🍣"
-description = "An EfficientNetB2 feature extractor computer vision model to classify images of food as pizza, steak or sushi."
-article = "Created at [09. PyTorch Model Deployment](https://www.learnpytorch.io/09_pytorch_model_deployment/)."
-
-# Create examples list from "examples/" directory
-example_list = [["examples/" + example] for example in os.listdir("examples")]
-
-# Create the Gradio demo
-demo = gr.Interface(fn=predict, # mapping function from input to output
- inputs=gr.Image(type="pil"), # what are the inputs?
- outputs=[gr.Label(num_top_classes=3, label="Predictions"), # what are the outputs?
- gr.Number(label="Prediction time (s)")], # our fn has two outputs, therefore we have two outputs
- # Create examples list from "examples/" directory
- examples=example_list,
- title=title,
- description=description,
- article=article)
-
-# Launch the demo!
-demo.launch()
diff --git a/spaces/AIConsultant/MusicGen/audiocraft/utils/utils.py b/spaces/AIConsultant/MusicGen/audiocraft/utils/utils.py
deleted file mode 100644
index 3135d70e949a058095ef84dd87b49384546c465c..0000000000000000000000000000000000000000
--- a/spaces/AIConsultant/MusicGen/audiocraft/utils/utils.py
+++ /dev/null
@@ -1,298 +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 concurrent.futures import ProcessPoolExecutor
-from contextlib import contextmanager
-from functools import wraps, lru_cache
-import hashlib
-import json
-import logging
-from pathlib import Path
-import typing as tp
-
-import flashy
-import flashy.distrib
-import omegaconf
-import torch
-from torch.nn.utils.rnn import pad_sequence
-
-
-logger = logging.getLogger(__name__)
-
-
-def model_hash(model: torch.nn.Module) -> str:
- """Return a model hash. This should allow us to track regressions in model init
- from the logs of past experiments.
- """
- hasher = hashlib.sha1()
- for p in model.parameters():
- hasher.update(p.data.cpu().numpy().tobytes())
- return hasher.hexdigest()
-
-
-def dict_from_config(cfg: omegaconf.DictConfig) -> dict:
- """Convenience function to map an omegaconf configuration to a dictionary.
-
- Args:
- cfg (omegaconf.DictConfig): Original configuration to map to dict.
- Returns:
- dict: Config as dictionary object.
- """
- dct = omegaconf.OmegaConf.to_container(cfg, resolve=True)
- assert isinstance(dct, dict)
- return dct
-
-
-def random_subset(dataset, max_samples: int, seed: int = 42) -> torch.utils.data.Subset:
- if max_samples >= len(dataset):
- return dataset
-
- generator = torch.Generator().manual_seed(seed)
- perm = torch.randperm(len(dataset), generator=generator)
- return torch.utils.data.Subset(dataset, perm[:max_samples].tolist())
-
-
-def get_loader(dataset, num_samples: tp.Optional[int], batch_size: int,
- num_workers: int, seed: int, **kwargs) -> torch.utils.data.DataLoader:
- """Convenience function to load dataset into a dataloader with optional subset sampling.
-
- Args:
- dataset: Dataset to load.
- num_samples (Optional[int]): Number of samples to limit subset size.
- batch_size (int): Batch size.
- num_workers (int): Number of workers for data loading.
- seed (int): Random seed.
- """
- if num_samples is not None:
- dataset = random_subset(dataset, num_samples, seed)
-
- dataloader = flashy.distrib.loader(
- dataset,
- batch_size=batch_size,
- num_workers=num_workers,
- **kwargs
- )
- return dataloader
-
-
-def get_dataset_from_loader(dataloader):
- dataset = dataloader.dataset
- if isinstance(dataset, torch.utils.data.Subset):
- return dataset.dataset
- else:
- return dataset
-
-
-def multinomial(input: torch.Tensor, num_samples: int, replacement=False, *, generator=None):
- """torch.multinomial with arbitrary number of dimensions, and number of candidates on the last dimension.
-
- Args:
- input (torch.Tensor): The input tensor containing probabilities.
- num_samples (int): Number of samples to draw.
- replacement (bool): Whether to draw with replacement or not.
- Keywords args:
- generator (torch.Generator): A pseudorandom number generator for sampling.
- Returns:
- torch.Tensor: Last dimension contains num_samples indices
- sampled from the multinomial probability distribution
- located in the last dimension of tensor input.
- """
- input_ = input.reshape(-1, input.shape[-1])
- output_ = torch.multinomial(input_, num_samples=num_samples, replacement=replacement, generator=generator)
- output = output_.reshape(*list(input.shape[:-1]), -1)
- return output
-
-
-def sample_top_k(probs: torch.Tensor, k: int) -> torch.Tensor:
- """Sample next token from top K values along the last dimension of the input probs tensor.
-
- Args:
- probs (torch.Tensor): Input probabilities with token candidates on the last dimension.
- k (int): The k in “top-k”.
- Returns:
- torch.Tensor: Sampled tokens.
- """
- top_k_value, _ = torch.topk(probs, k, dim=-1)
- min_value_top_k = top_k_value[..., [-1]]
- probs *= (probs >= min_value_top_k).float()
- probs.div_(probs.sum(dim=-1, keepdim=True))
- next_token = multinomial(probs, num_samples=1)
- return next_token
-
-
-def sample_top_p(probs: torch.Tensor, p: float) -> torch.Tensor:
- """Sample next token from top P probabilities along the last dimension of the input probs tensor.
-
- Args:
- probs (torch.Tensor): Input probabilities with token candidates on the last dimension.
- p (int): The p in “top-p”.
- Returns:
- torch.Tensor: Sampled tokens.
- """
- probs_sort, probs_idx = torch.sort(probs, dim=-1, descending=True)
- probs_sum = torch.cumsum(probs_sort, dim=-1)
- mask = probs_sum - probs_sort > p
- probs_sort *= (~mask).float()
- probs_sort.div_(probs_sort.sum(dim=-1, keepdim=True))
- next_token = multinomial(probs_sort, num_samples=1)
- next_token = torch.gather(probs_idx, -1, next_token)
- return next_token
-
-
-class DummyPoolExecutor:
- """Dummy pool executor to use when we actually have only 1 worker.
- (e.g. instead of ProcessPoolExecutor).
- """
- class DummyResult:
- def __init__(self, func, *args, **kwargs):
- self.func = func
- self.args = args
- self.kwargs = kwargs
-
- def result(self):
- return self.func(*self.args, **self.kwargs)
-
- def __init__(self, workers, mp_context=None):
- pass
-
- def submit(self, func, *args, **kwargs):
- return DummyPoolExecutor.DummyResult(func, *args, **kwargs)
-
- def __enter__(self):
- return self
-
- def __exit__(self, exc_type, exc_value, exc_tb):
- return
-
-
-def get_pool_executor(num_workers: int, mp_context=None):
- return ProcessPoolExecutor(num_workers, mp_context) if num_workers > 1 else DummyPoolExecutor(1)
-
-
-def length_to_mask(lengths: torch.Tensor, max_len: tp.Optional[int] = None) -> torch.Tensor:
- """Utility function to convert a tensor of sequence lengths to a mask (useful when working on padded sequences).
- For example: [3, 5] => [[1, 1, 1, 0, 0], [1, 1, 1, 1, 1]]
-
- Args:
- lengths (torch.Tensor): tensor with lengths
- max_len (int): can set the max length manually. Defaults to None.
- Returns:
- torch.Tensor: mask with 0s where there is pad tokens else 1s
- """
- assert len(lengths.shape) == 1, "Length shape should be 1 dimensional."
- final_length = lengths.max().item() if not max_len else max_len
- final_length = max(final_length, 1) # if all seqs are of len zero we don't want a zero-size tensor
- return torch.arange(final_length)[None, :].to(lengths.device) < lengths[:, None]
-
-
-def hash_trick(word: str, vocab_size: int) -> int:
- """Hash trick to pair each word with an index
-
- Args:
- word (str): word we wish to convert to an index
- vocab_size (int): size of the vocabulary
- Returns:
- int: index of the word in the embedding LUT
- """
- hash = int(hashlib.sha256(word.encode("utf-8")).hexdigest(), 16)
- return hash % vocab_size
-
-
-def with_rank_rng(base_seed: int = 1234):
- """Decorator for a function so that the function will use a Random Number Generator
- whose state depend on the GPU rank. The original RNG state is restored upon returning.
-
- Args:
- base_seed (int): Random seed.
- """
- def _decorator(fun: tp.Callable):
- @wraps(fun)
- def _decorated(*args, **kwargs):
- state = torch.get_rng_state()
- seed = base_seed ^ flashy.distrib.rank()
- torch.manual_seed(seed)
- logger.debug('Rank dependent seed set to %d', seed)
- try:
- return fun(*args, **kwargs)
- finally:
- torch.set_rng_state(state)
- logger.debug('RNG state restored.')
- return _decorated
- return _decorator
-
-
-def collate(tensors: tp.List[torch.Tensor], dim: int = 0) -> tp.Tuple[torch.Tensor, torch.Tensor]:
- """Get a list of tensors and collate them to a single tensor. according to the following logic:
- - `dim` specifies the time dimension which will be stacked and padded.
- - The output will contain 1 new dimension (dimension index 0) which will be the size of
- of the original list.
-
- Args:
- tensors (tp.List[torch.Tensor]): List of tensors to collate.
- dim (int): Dimension which will be stacked and padded.
- Returns:
- tp.Tuple[torch.Tensor, torch.Tensor]:
- torch.Tensor: Stacked and padded tensor. The output will contain 1 new dimension
- (dimension index 0) which will be the size of the original list.
- torch.Tensor: Tensor containing length of original tensor sizes (without padding).
- """
- tensors = [x.transpose(0, dim) for x in tensors]
- lens = torch.LongTensor([len(x) for x in tensors])
- padded_tensors = pad_sequence(tensors)
- padded_tensors = padded_tensors.transpose(0, 1)
- padded_tensors = padded_tensors.transpose(1, dim + 1)
- return padded_tensors, lens
-
-
-# TODO: Move to flashy?
-def copy_state(state: tp.Any, device: tp.Union[torch.device, str] = 'cpu',
- dtype: tp.Optional[torch.dtype] = None) -> tp.Any:
- if isinstance(state, torch.Tensor):
- if dtype is None or not state.is_floating_point():
- dtype = state.dtype
- return state.detach().to(device=device, dtype=dtype, copy=True)
- elif isinstance(state, dict):
- return {k: copy_state(v, device, dtype) for k, v in state.items()}
- elif isinstance(state, list):
- return [copy_state(v, device, dtype) for v in state]
-
-
-# TODO: Move to flashy?
-@contextmanager
-def swap_state(model, state, **kwargs):
- old_state = copy_state(model.state_dict())
- model.load_state_dict(state, **kwargs)
- try:
- yield
- finally:
- model.load_state_dict(old_state)
-
-
-@lru_cache(None)
-def warn_once(logger, msg):
- """Warn about a given message only once."""
- logger.warning(msg)
-
-
-def is_jsonable(x: tp.Any):
- """Check if an object can be serialized into a json:"""
- try:
- json.dumps(x)
- return True
- except (TypeError, OverflowError):
- return False
-
-
-def load_clap_state_dict(clap_model, path: tp.Union[str, Path]):
- """Wrapper around state dict loading of CLAP model
- addressing compatibility issues between CLAP and AudioCraft
- HuggingFace transformer version.
- See: https://github.com/LAION-AI/CLAP/issues/118
- """
- from clap_module.factory import load_state_dict # type: ignore
- pkg = load_state_dict(path)
- pkg.pop('text_branch.embeddings.position_ids', None)
- clap_model.model.load_state_dict(pkg)
diff --git a/spaces/AIGC-Audio/AudioGPT/NeuralSeq/modules/parallel_wavegan/models/melgan.py b/spaces/AIGC-Audio/AudioGPT/NeuralSeq/modules/parallel_wavegan/models/melgan.py
deleted file mode 100644
index e021ae4817a8c1c97338e61b00b230c881836fd8..0000000000000000000000000000000000000000
--- a/spaces/AIGC-Audio/AudioGPT/NeuralSeq/modules/parallel_wavegan/models/melgan.py
+++ /dev/null
@@ -1,427 +0,0 @@
-# -*- coding: utf-8 -*-
-
-# Copyright 2020 Tomoki Hayashi
-# MIT License (https://opensource.org/licenses/MIT)
-
-"""MelGAN Modules."""
-
-import logging
-
-import numpy as np
-import torch
-
-from modules.parallel_wavegan.layers import CausalConv1d
-from modules.parallel_wavegan.layers import CausalConvTranspose1d
-from modules.parallel_wavegan.layers import ResidualStack
-
-
-class MelGANGenerator(torch.nn.Module):
- """MelGAN generator module."""
-
- def __init__(self,
- in_channels=80,
- out_channels=1,
- kernel_size=7,
- channels=512,
- bias=True,
- upsample_scales=[8, 8, 2, 2],
- stack_kernel_size=3,
- stacks=3,
- nonlinear_activation="LeakyReLU",
- nonlinear_activation_params={"negative_slope": 0.2},
- pad="ReflectionPad1d",
- pad_params={},
- use_final_nonlinear_activation=True,
- use_weight_norm=True,
- use_causal_conv=False,
- ):
- """Initialize MelGANGenerator module.
-
- Args:
- in_channels (int): Number of input channels.
- out_channels (int): Number of output channels.
- kernel_size (int): Kernel size of initial and final conv layer.
- channels (int): Initial number of channels for conv layer.
- bias (bool): Whether to add bias parameter in convolution layers.
- upsample_scales (list): List of upsampling scales.
- stack_kernel_size (int): Kernel size of dilated conv layers in residual stack.
- stacks (int): Number of stacks in a single residual stack.
- nonlinear_activation (str): Activation function module name.
- nonlinear_activation_params (dict): Hyperparameters for activation function.
- pad (str): Padding function module name before dilated convolution layer.
- pad_params (dict): Hyperparameters for padding function.
- use_final_nonlinear_activation (torch.nn.Module): Activation function for the final layer.
- use_weight_norm (bool): Whether to use weight norm.
- If set to true, it will be applied to all of the conv layers.
- use_causal_conv (bool): Whether to use causal convolution.
-
- """
- super(MelGANGenerator, self).__init__()
-
- # check hyper parameters is valid
- assert channels >= np.prod(upsample_scales)
- assert channels % (2 ** len(upsample_scales)) == 0
- if not use_causal_conv:
- assert (kernel_size - 1) % 2 == 0, "Not support even number kernel size."
-
- # add initial layer
- layers = []
- if not use_causal_conv:
- layers += [
- getattr(torch.nn, pad)((kernel_size - 1) // 2, **pad_params),
- torch.nn.Conv1d(in_channels, channels, kernel_size, bias=bias),
- ]
- else:
- layers += [
- CausalConv1d(in_channels, channels, kernel_size,
- bias=bias, pad=pad, pad_params=pad_params),
- ]
-
- for i, upsample_scale in enumerate(upsample_scales):
- # add upsampling layer
- layers += [getattr(torch.nn, nonlinear_activation)(**nonlinear_activation_params)]
- if not use_causal_conv:
- layers += [
- torch.nn.ConvTranspose1d(
- channels // (2 ** i),
- channels // (2 ** (i + 1)),
- upsample_scale * 2,
- stride=upsample_scale,
- padding=upsample_scale // 2 + upsample_scale % 2,
- output_padding=upsample_scale % 2,
- bias=bias,
- )
- ]
- else:
- layers += [
- CausalConvTranspose1d(
- channels // (2 ** i),
- channels // (2 ** (i + 1)),
- upsample_scale * 2,
- stride=upsample_scale,
- bias=bias,
- )
- ]
-
- # add residual stack
- for j in range(stacks):
- layers += [
- ResidualStack(
- kernel_size=stack_kernel_size,
- channels=channels // (2 ** (i + 1)),
- dilation=stack_kernel_size ** j,
- bias=bias,
- nonlinear_activation=nonlinear_activation,
- nonlinear_activation_params=nonlinear_activation_params,
- pad=pad,
- pad_params=pad_params,
- use_causal_conv=use_causal_conv,
- )
- ]
-
- # add final layer
- layers += [getattr(torch.nn, nonlinear_activation)(**nonlinear_activation_params)]
- if not use_causal_conv:
- layers += [
- getattr(torch.nn, pad)((kernel_size - 1) // 2, **pad_params),
- torch.nn.Conv1d(channels // (2 ** (i + 1)), out_channels, kernel_size, bias=bias),
- ]
- else:
- layers += [
- CausalConv1d(channels // (2 ** (i + 1)), out_channels, kernel_size,
- bias=bias, pad=pad, pad_params=pad_params),
- ]
- if use_final_nonlinear_activation:
- layers += [torch.nn.Tanh()]
-
- # define the model as a single function
- self.melgan = torch.nn.Sequential(*layers)
-
- # apply weight norm
- if use_weight_norm:
- self.apply_weight_norm()
-
- # reset parameters
- self.reset_parameters()
-
- def forward(self, c):
- """Calculate forward propagation.
-
- Args:
- c (Tensor): Input tensor (B, channels, T).
-
- Returns:
- Tensor: Output tensor (B, 1, T ** prod(upsample_scales)).
-
- """
- return self.melgan(c)
-
- def remove_weight_norm(self):
- """Remove weight normalization module from all of the layers."""
- def _remove_weight_norm(m):
- try:
- logging.debug(f"Weight norm is removed from {m}.")
- torch.nn.utils.remove_weight_norm(m)
- except ValueError: # this module didn't have weight norm
- return
-
- self.apply(_remove_weight_norm)
-
- def apply_weight_norm(self):
- """Apply weight normalization module from all of the layers."""
- def _apply_weight_norm(m):
- if isinstance(m, torch.nn.Conv1d) or isinstance(m, torch.nn.ConvTranspose1d):
- torch.nn.utils.weight_norm(m)
- logging.debug(f"Weight norm is applied to {m}.")
-
- self.apply(_apply_weight_norm)
-
- def reset_parameters(self):
- """Reset parameters.
-
- This initialization follows official implementation manner.
- https://github.com/descriptinc/melgan-neurips/blob/master/spec2wav/modules.py
-
- """
- def _reset_parameters(m):
- if isinstance(m, torch.nn.Conv1d) or isinstance(m, torch.nn.ConvTranspose1d):
- m.weight.data.normal_(0.0, 0.02)
- logging.debug(f"Reset parameters in {m}.")
-
- self.apply(_reset_parameters)
-
-
-class MelGANDiscriminator(torch.nn.Module):
- """MelGAN discriminator module."""
-
- def __init__(self,
- in_channels=1,
- out_channels=1,
- kernel_sizes=[5, 3],
- channels=16,
- max_downsample_channels=1024,
- bias=True,
- downsample_scales=[4, 4, 4, 4],
- nonlinear_activation="LeakyReLU",
- nonlinear_activation_params={"negative_slope": 0.2},
- pad="ReflectionPad1d",
- pad_params={},
- ):
- """Initilize MelGAN discriminator module.
-
- Args:
- in_channels (int): Number of input channels.
- out_channels (int): Number of output channels.
- kernel_sizes (list): List of two kernel sizes. The prod will be used for the first conv layer,
- and the first and the second kernel sizes will be used for the last two layers.
- For example if kernel_sizes = [5, 3], the first layer kernel size will be 5 * 3 = 15,
- the last two layers' kernel size will be 5 and 3, respectively.
- channels (int): Initial number of channels for conv layer.
- max_downsample_channels (int): Maximum number of channels for downsampling layers.
- bias (bool): Whether to add bias parameter in convolution layers.
- downsample_scales (list): List of downsampling scales.
- nonlinear_activation (str): Activation function module name.
- nonlinear_activation_params (dict): Hyperparameters for activation function.
- pad (str): Padding function module name before dilated convolution layer.
- pad_params (dict): Hyperparameters for padding function.
-
- """
- super(MelGANDiscriminator, self).__init__()
- self.layers = torch.nn.ModuleList()
-
- # check kernel size is valid
- assert len(kernel_sizes) == 2
- assert kernel_sizes[0] % 2 == 1
- assert kernel_sizes[1] % 2 == 1
-
- # add first layer
- self.layers += [
- torch.nn.Sequential(
- getattr(torch.nn, pad)((np.prod(kernel_sizes) - 1) // 2, **pad_params),
- torch.nn.Conv1d(in_channels, channels, np.prod(kernel_sizes), bias=bias),
- getattr(torch.nn, nonlinear_activation)(**nonlinear_activation_params),
- )
- ]
-
- # add downsample layers
- in_chs = channels
- for downsample_scale in downsample_scales:
- out_chs = min(in_chs * downsample_scale, max_downsample_channels)
- self.layers += [
- torch.nn.Sequential(
- torch.nn.Conv1d(
- in_chs, out_chs,
- kernel_size=downsample_scale * 10 + 1,
- stride=downsample_scale,
- padding=downsample_scale * 5,
- groups=in_chs // 4,
- bias=bias,
- ),
- getattr(torch.nn, nonlinear_activation)(**nonlinear_activation_params),
- )
- ]
- in_chs = out_chs
-
- # add final layers
- out_chs = min(in_chs * 2, max_downsample_channels)
- self.layers += [
- torch.nn.Sequential(
- torch.nn.Conv1d(
- in_chs, out_chs, kernel_sizes[0],
- padding=(kernel_sizes[0] - 1) // 2,
- bias=bias,
- ),
- getattr(torch.nn, nonlinear_activation)(**nonlinear_activation_params),
- )
- ]
- self.layers += [
- torch.nn.Conv1d(
- out_chs, out_channels, kernel_sizes[1],
- padding=(kernel_sizes[1] - 1) // 2,
- bias=bias,
- ),
- ]
-
- def forward(self, x):
- """Calculate forward propagation.
-
- Args:
- x (Tensor): Input noise signal (B, 1, T).
-
- Returns:
- List: List of output tensors of each layer.
-
- """
- outs = []
- for f in self.layers:
- x = f(x)
- outs += [x]
-
- return outs
-
-
-class MelGANMultiScaleDiscriminator(torch.nn.Module):
- """MelGAN multi-scale discriminator module."""
-
- def __init__(self,
- in_channels=1,
- out_channels=1,
- scales=3,
- downsample_pooling="AvgPool1d",
- # follow the official implementation setting
- downsample_pooling_params={
- "kernel_size": 4,
- "stride": 2,
- "padding": 1,
- "count_include_pad": False,
- },
- kernel_sizes=[5, 3],
- channels=16,
- max_downsample_channels=1024,
- bias=True,
- downsample_scales=[4, 4, 4, 4],
- nonlinear_activation="LeakyReLU",
- nonlinear_activation_params={"negative_slope": 0.2},
- pad="ReflectionPad1d",
- pad_params={},
- use_weight_norm=True,
- ):
- """Initilize MelGAN multi-scale discriminator module.
-
- Args:
- in_channels (int): Number of input channels.
- out_channels (int): Number of output channels.
- downsample_pooling (str): Pooling module name for downsampling of the inputs.
- downsample_pooling_params (dict): Parameters for the above pooling module.
- kernel_sizes (list): List of two kernel sizes. The sum will be used for the first conv layer,
- and the first and the second kernel sizes will be used for the last two layers.
- channels (int): Initial number of channels for conv layer.
- max_downsample_channels (int): Maximum number of channels for downsampling layers.
- bias (bool): Whether to add bias parameter in convolution layers.
- downsample_scales (list): List of downsampling scales.
- nonlinear_activation (str): Activation function module name.
- nonlinear_activation_params (dict): Hyperparameters for activation function.
- pad (str): Padding function module name before dilated convolution layer.
- pad_params (dict): Hyperparameters for padding function.
- use_causal_conv (bool): Whether to use causal convolution.
-
- """
- super(MelGANMultiScaleDiscriminator, self).__init__()
- self.discriminators = torch.nn.ModuleList()
-
- # add discriminators
- for _ in range(scales):
- self.discriminators += [
- MelGANDiscriminator(
- in_channels=in_channels,
- out_channels=out_channels,
- kernel_sizes=kernel_sizes,
- channels=channels,
- max_downsample_channels=max_downsample_channels,
- bias=bias,
- downsample_scales=downsample_scales,
- nonlinear_activation=nonlinear_activation,
- nonlinear_activation_params=nonlinear_activation_params,
- pad=pad,
- pad_params=pad_params,
- )
- ]
- self.pooling = getattr(torch.nn, downsample_pooling)(**downsample_pooling_params)
-
- # apply weight norm
- if use_weight_norm:
- self.apply_weight_norm()
-
- # reset parameters
- self.reset_parameters()
-
- def forward(self, x):
- """Calculate forward propagation.
-
- Args:
- x (Tensor): Input noise signal (B, 1, T).
-
- Returns:
- List: List of list of each discriminator outputs, which consists of each layer output tensors.
-
- """
- outs = []
- for f in self.discriminators:
- outs += [f(x)]
- x = self.pooling(x)
-
- return outs
-
- def remove_weight_norm(self):
- """Remove weight normalization module from all of the layers."""
- def _remove_weight_norm(m):
- try:
- logging.debug(f"Weight norm is removed from {m}.")
- torch.nn.utils.remove_weight_norm(m)
- except ValueError: # this module didn't have weight norm
- return
-
- self.apply(_remove_weight_norm)
-
- def apply_weight_norm(self):
- """Apply weight normalization module from all of the layers."""
- def _apply_weight_norm(m):
- if isinstance(m, torch.nn.Conv1d) or isinstance(m, torch.nn.ConvTranspose1d):
- torch.nn.utils.weight_norm(m)
- logging.debug(f"Weight norm is applied to {m}.")
-
- self.apply(_apply_weight_norm)
-
- def reset_parameters(self):
- """Reset parameters.
-
- This initialization follows official implementation manner.
- https://github.com/descriptinc/melgan-neurips/blob/master/spec2wav/modules.py
-
- """
- def _reset_parameters(m):
- if isinstance(m, torch.nn.Conv1d) or isinstance(m, torch.nn.ConvTranspose1d):
- m.weight.data.normal_(0.0, 0.02)
- logging.debug(f"Reset parameters in {m}.")
-
- self.apply(_reset_parameters)
diff --git a/spaces/AIGC-Audio/AudioGPT/text_to_speech/tasks/tts/fs.py b/spaces/AIGC-Audio/AudioGPT/text_to_speech/tasks/tts/fs.py
deleted file mode 100644
index 295e35083df2a056ca71c171fef732958be12685..0000000000000000000000000000000000000000
--- a/spaces/AIGC-Audio/AudioGPT/text_to_speech/tasks/tts/fs.py
+++ /dev/null
@@ -1,196 +0,0 @@
-import torch
-import torch.distributions
-import torch.nn.functional as F
-import torch.optim
-import torch.utils.data
-
-from text_to_speech.modules.tts.fs import FastSpeech
-from tasks.tts.dataset_utils import FastSpeechWordDataset
-from tasks.tts.speech_base import SpeechBaseTask
-from text_to_speech.utils.audio.align import mel2token_to_dur
-from text_to_speech.utils.audio.pitch.utils import denorm_f0
-from text_to_speech.utils.commons.hparams import hparams
-
-
-class FastSpeechTask(SpeechBaseTask):
- def __init__(self):
- super().__init__()
- self.dataset_cls = FastSpeechWordDataset
- self.sil_ph = self.token_encoder.sil_phonemes()
-
- def build_tts_model(self):
- dict_size = len(self.token_encoder)
- self.model = FastSpeech(dict_size, hparams)
-
- def run_model(self, sample, infer=False, *args, **kwargs):
- txt_tokens = sample['txt_tokens'] # [B, T_t]
- spk_embed = sample.get('spk_embed')
- spk_id = sample.get('spk_ids')
- if not infer:
- target = sample['mels'] # [B, T_s, 80]
- mel2ph = sample['mel2ph'] # [B, T_s]
- f0 = sample.get('f0')
- uv = sample.get('uv')
- output = self.model(txt_tokens, mel2ph=mel2ph, spk_embed=spk_embed, spk_id=spk_id,
- f0=f0, uv=uv, infer=False,
- ph2word=sample['ph2word'],
- graph_lst=sample.get('graph_lst'),
- etypes_lst=sample.get('etypes_lst'),
- bert_feats=sample.get("bert_feats"),
- cl_feats=sample.get("cl_feats")
- )
- losses = {}
- self.add_mel_loss(output['mel_out'], target, losses)
- self.add_dur_loss(output['dur'], mel2ph, txt_tokens, losses=losses)
- if hparams['use_pitch_embed']:
- self.add_pitch_loss(output, sample, losses)
- return losses, output
- else:
- use_gt_dur = kwargs.get('infer_use_gt_dur', hparams['use_gt_dur'])
- use_gt_f0 = kwargs.get('infer_use_gt_f0', hparams['use_gt_f0'])
- mel2ph, uv, f0 = None, None, None
- if use_gt_dur:
- mel2ph = sample['mel2ph']
- if use_gt_f0:
- f0 = sample['f0']
- uv = sample['uv']
- output = self.model(txt_tokens, mel2ph=mel2ph, spk_embed=spk_embed, spk_id=spk_id,
- f0=f0, uv=uv, infer=True,
- ph2word=sample['ph2word'],
- graph_lst=sample.get('graph_lst'),
- etypes_lst=sample.get('etypes_lst'),
- bert_feats=sample.get("bert_feats"),
- cl_feats=sample.get("cl_feats")
- )
- return output
-
- def add_dur_loss(self, dur_pred, mel2ph, txt_tokens, losses=None):
- """
-
- :param dur_pred: [B, T], float, log scale
- :param mel2ph: [B, T]
- :param txt_tokens: [B, T]
- :param losses:
- :return:
- """
- B, T = txt_tokens.shape
- nonpadding = (txt_tokens != 0).float()
- dur_gt = mel2token_to_dur(mel2ph, T).float() * nonpadding
- is_sil = torch.zeros_like(txt_tokens).bool()
- for p in self.sil_ph:
- is_sil = is_sil | (txt_tokens == self.token_encoder.encode(p)[0])
- is_sil = is_sil.float() # [B, T_txt]
- losses['pdur'] = F.mse_loss((dur_pred + 1).log(), (dur_gt + 1).log(), reduction='none')
- losses['pdur'] = (losses['pdur'] * nonpadding).sum() / nonpadding.sum()
- losses['pdur'] = losses['pdur'] * hparams['lambda_ph_dur']
- # use linear scale for sentence and word duration
- if hparams['lambda_word_dur'] > 0:
- word_id = (is_sil.cumsum(-1) * (1 - is_sil)).long()
- word_dur_p = dur_pred.new_zeros([B, word_id.max() + 1]).scatter_add(1, word_id, dur_pred)[:, 1:]
- word_dur_g = dur_gt.new_zeros([B, word_id.max() + 1]).scatter_add(1, word_id, dur_gt)[:, 1:]
- wdur_loss = F.mse_loss((word_dur_p + 1).log(), (word_dur_g + 1).log(), reduction='none')
- word_nonpadding = (word_dur_g > 0).float()
- wdur_loss = (wdur_loss * word_nonpadding).sum() / word_nonpadding.sum()
- losses['wdur'] = wdur_loss * hparams['lambda_word_dur']
- if hparams['lambda_sent_dur'] > 0:
- sent_dur_p = dur_pred.sum(-1)
- sent_dur_g = dur_gt.sum(-1)
- sdur_loss = F.mse_loss((sent_dur_p + 1).log(), (sent_dur_g + 1).log(), reduction='mean')
- losses['sdur'] = sdur_loss.mean() * hparams['lambda_sent_dur']
-
- def add_pitch_loss(self, output, sample, losses):
- mel2ph = sample['mel2ph'] # [B, T_s]
- f0 = sample['f0']
- uv = sample['uv']
- nonpadding = (mel2ph != 0).float() if hparams['pitch_type'] == 'frame' \
- else (sample['txt_tokens'] != 0).float()
- p_pred = output['pitch_pred']
- assert p_pred[..., 0].shape == f0.shape
- if hparams['use_uv'] and hparams['pitch_type'] == 'frame':
- assert p_pred[..., 1].shape == uv.shape, (p_pred.shape, uv.shape)
- losses['uv'] = (F.binary_cross_entropy_with_logits(
- p_pred[:, :, 1], uv, reduction='none') * nonpadding).sum() \
- / nonpadding.sum() * hparams['lambda_uv']
- nonpadding = nonpadding * (uv == 0).float()
- f0_pred = p_pred[:, :, 0]
- losses['f0'] = (F.l1_loss(f0_pred, f0, reduction='none') * nonpadding).sum() \
- / nonpadding.sum() * hparams['lambda_f0']
-
- def save_valid_result(self, sample, batch_idx, model_out):
- sr = hparams['audio_sample_rate']
- f0_gt = None
- mel_out = model_out['mel_out']
- if sample.get('f0') is not None:
- f0_gt = denorm_f0(sample['f0'][0].cpu(), sample['uv'][0].cpu())
- self.plot_mel(batch_idx, sample['mels'], mel_out, f0s=f0_gt)
- if self.global_step > 0:
- wav_pred = self.vocoder.spec2wav(mel_out[0].cpu(), f0=f0_gt)
- self.logger.add_audio(f'wav_val_{batch_idx}', wav_pred, self.global_step, sr)
- # with gt duration
- model_out = self.run_model(sample, infer=True, infer_use_gt_dur=True)
- dur_info = self.get_plot_dur_info(sample, model_out)
- del dur_info['dur_pred']
- wav_pred = self.vocoder.spec2wav(model_out['mel_out'][0].cpu(), f0=f0_gt)
- self.logger.add_audio(f'wav_gdur_{batch_idx}', wav_pred, self.global_step, sr)
- self.plot_mel(batch_idx, sample['mels'], model_out['mel_out'][0], f'mel_gdur_{batch_idx}',
- dur_info=dur_info, f0s=f0_gt)
-
- # with pred duration
- if not hparams['use_gt_dur']:
- model_out = self.run_model(sample, infer=True, infer_use_gt_dur=False)
- dur_info = self.get_plot_dur_info(sample, model_out)
- self.plot_mel(batch_idx, sample['mels'], model_out['mel_out'][0], f'mel_pdur_{batch_idx}',
- dur_info=dur_info, f0s=f0_gt)
- wav_pred = self.vocoder.spec2wav(model_out['mel_out'][0].cpu(), f0=f0_gt)
- self.logger.add_audio(f'wav_pdur_{batch_idx}', wav_pred, self.global_step, sr)
- # gt wav
- if self.global_step <= hparams['valid_infer_interval']:
- mel_gt = sample['mels'][0].cpu()
- wav_gt = self.vocoder.spec2wav(mel_gt, f0=f0_gt)
- self.logger.add_audio(f'wav_gt_{batch_idx}', wav_gt, self.global_step, sr)
-
- def get_plot_dur_info(self, sample, model_out):
- T_txt = sample['txt_tokens'].shape[1]
- dur_gt = mel2token_to_dur(sample['mel2ph'], T_txt)[0]
- dur_pred = model_out['dur'] if 'dur' in model_out else dur_gt
- txt = self.token_encoder.decode(sample['txt_tokens'][0].cpu().numpy())
- txt = txt.split(" ")
- return {'dur_gt': dur_gt, 'dur_pred': dur_pred, 'txt': txt}
-
- def test_step(self, sample, batch_idx):
- """
-
- :param sample:
- :param batch_idx:
- :return:
- """
- assert sample['txt_tokens'].shape[0] == 1, 'only support batch_size=1 in inference'
- outputs = self.run_model(sample, infer=True)
- text = sample['text'][0]
- item_name = sample['item_name'][0]
- tokens = sample['txt_tokens'][0].cpu().numpy()
- mel_gt = sample['mels'][0].cpu().numpy()
- mel_pred = outputs['mel_out'][0].cpu().numpy()
- mel2ph = sample['mel2ph'][0].cpu().numpy()
- mel2ph_pred = outputs['mel2ph'][0].cpu().numpy()
- str_phs = self.token_encoder.decode(tokens, strip_padding=True)
- base_fn = f'[{batch_idx:06d}][{item_name.replace("%", "_")}][%s]'
- if text is not None:
- base_fn += text.replace(":", "$3A")[:80]
- base_fn = base_fn.replace(' ', '_')
- gen_dir = self.gen_dir
- wav_pred = self.vocoder.spec2wav(mel_pred)
- self.saving_result_pool.add_job(self.save_result, args=[
- wav_pred, mel_pred, base_fn % 'P', gen_dir, str_phs, mel2ph_pred])
- if hparams['save_gt']:
- wav_gt = self.vocoder.spec2wav(mel_gt)
- self.saving_result_pool.add_job(self.save_result, args=[
- wav_gt, mel_gt, base_fn % 'G', gen_dir, str_phs, mel2ph])
- print(f"Pred_shape: {mel_pred.shape}, gt_shape: {mel_gt.shape}")
- return {
- 'item_name': item_name,
- 'text': text,
- 'ph_tokens': self.token_encoder.decode(tokens.tolist()),
- 'wav_fn_pred': base_fn % 'P',
- 'wav_fn_gt': base_fn % 'G',
- }
diff --git a/spaces/ALSv/FSW/README.md b/spaces/ALSv/FSW/README.md
deleted file mode 100644
index 42b0e9076cccb451550d991e0e1b486f2f7e50d8..0000000000000000000000000000000000000000
--- a/spaces/ALSv/FSW/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Apex_Face
-emoji: 🖤
-colorFrom: red
-colorTo: blue
-sdk: gradio
-sdk_version: 3.41.2
-app_file: app.py
-pinned: true
-license: bigcode-openrail-m
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
\ No newline at end of file
diff --git a/spaces/ATang0729/Forecast4Muses/Model/Model6/Model6_1_ClothesKeyPoint/work_dirs_1-x/td_hm_res50_4xb64-120e_deepfashion2_vest_256x192/td_hm_res50_4xb64-120e_deepfashion2_vest_256x192.py b/spaces/ATang0729/Forecast4Muses/Model/Model6/Model6_1_ClothesKeyPoint/work_dirs_1-x/td_hm_res50_4xb64-120e_deepfashion2_vest_256x192/td_hm_res50_4xb64-120e_deepfashion2_vest_256x192.py
deleted file mode 100644
index ff2c2e097cc87ac4ddd852b1ef8c2a91ed051fd6..0000000000000000000000000000000000000000
--- a/spaces/ATang0729/Forecast4Muses/Model/Model6/Model6_1_ClothesKeyPoint/work_dirs_1-x/td_hm_res50_4xb64-120e_deepfashion2_vest_256x192/td_hm_res50_4xb64-120e_deepfashion2_vest_256x192.py
+++ /dev/null
@@ -1,2861 +0,0 @@
-default_scope = 'mmpose'
-default_hooks = dict(
- timer=dict(type='IterTimerHook'),
- logger=dict(type='LoggerHook', interval=50),
- param_scheduler=dict(type='ParamSchedulerHook'),
- checkpoint=dict(
- type='CheckpointHook', interval=10, save_best='PCK', rule='greater'),
- sampler_seed=dict(type='DistSamplerSeedHook'),
- visualization=dict(type='PoseVisualizationHook', enable=False))
-custom_hooks = [dict(type='SyncBuffersHook')]
-env_cfg = dict(
- cudnn_benchmark=False,
- mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
- dist_cfg=dict(backend='nccl'))
-vis_backends = [dict(type='LocalVisBackend')]
-visualizer = dict(
- type='PoseLocalVisualizer',
- vis_backends=[dict(type='LocalVisBackend'),
- dict(type='WandbVisBackend')],
- name='visualizer')
-log_processor = dict(
- type='LogProcessor', window_size=50, by_epoch=True, num_digits=6)
-log_level = 'INFO'
-load_from = None
-resume = False
-backend_args = dict(backend='local')
-train_cfg = dict(by_epoch=True, max_epochs=120, val_interval=10)
-val_cfg = dict()
-test_cfg = dict()
-colors = dict(
- sss=[255, 128, 0],
- lss=[255, 0, 128],
- sso=[128, 0, 255],
- lso=[0, 128, 255],
- vest=[0, 128, 128],
- sling=[0, 0, 128],
- shorts=[128, 128, 128],
- trousers=[128, 0, 128],
- skirt=[64, 128, 128],
- ssd=[64, 64, 128],
- lsd=[128, 64, 0],
- vd=[128, 64, 255],
- sd=[128, 64, 0])
-dataset_info = dict(
- dataset_name='deepfashion2',
- paper_info=dict(
- author=
- 'Yuying Ge and Ruimao Zhang and Lingyun Wu and Xiaogang Wang and Xiaoou Tang and Ping Luo',
- title=
- 'DeepFashion2: A Versatile Benchmark for Detection, Pose Estimation, Segmentation and Re-Identification of Clothing Images',
- container=
- 'Proceedings of IEEE Conference on Computer Vision and Pattern Recognition (CVPR)',
- year='2019',
- homepage='https://github.com/switchablenorms/DeepFashion2'),
- keypoint_info=dict({
- 0:
- dict(name='sss_kpt1', id=0, color=[255, 128, 0], type='', swap=''),
- 1:
- dict(
- name='sss_kpt2',
- id=1,
- color=[255, 128, 0],
- type='',
- swap='sss_kpt6'),
- 2:
- dict(
- name='sss_kpt3',
- id=2,
- color=[255, 128, 0],
- type='',
- swap='sss_kpt5'),
- 3:
- dict(name='sss_kpt4', id=3, color=[255, 128, 0], type='', swap=''),
- 4:
- dict(
- name='sss_kpt5',
- id=4,
- color=[255, 128, 0],
- type='',
- swap='sss_kpt3'),
- 5:
- dict(
- name='sss_kpt6',
- id=5,
- color=[255, 128, 0],
- type='',
- swap='sss_kpt2'),
- 6:
- dict(
- name='sss_kpt7',
- id=6,
- color=[255, 128, 0],
- type='',
- swap='sss_kpt25'),
- 7:
- dict(
- name='sss_kpt8',
- id=7,
- color=[255, 128, 0],
- type='',
- swap='sss_kpt24'),
- 8:
- dict(
- name='sss_kpt9',
- id=8,
- color=[255, 128, 0],
- type='',
- swap='sss_kpt23'),
- 9:
- dict(
- name='sss_kpt10',
- id=9,
- color=[255, 128, 0],
- type='',
- swap='sss_kpt22'),
- 10:
- dict(
- name='sss_kpt11',
- id=10,
- color=[255, 128, 0],
- type='',
- swap='sss_kpt21'),
- 11:
- dict(
- name='sss_kpt12',
- id=11,
- color=[255, 128, 0],
- type='',
- swap='sss_kpt20'),
- 12:
- dict(
- name='sss_kpt13',
- id=12,
- color=[255, 128, 0],
- type='',
- swap='sss_kpt19'),
- 13:
- dict(
- name='sss_kpt14',
- id=13,
- color=[255, 128, 0],
- type='',
- swap='sss_kpt18'),
- 14:
- dict(
- name='sss_kpt15',
- id=14,
- color=[255, 128, 0],
- type='',
- swap='sss_kpt17'),
- 15:
- dict(name='sss_kpt16', id=15, color=[255, 128, 0], type='', swap=''),
- 16:
- dict(
- name='sss_kpt17',
- id=16,
- color=[255, 128, 0],
- type='',
- swap='sss_kpt15'),
- 17:
- dict(
- name='sss_kpt18',
- id=17,
- color=[255, 128, 0],
- type='',
- swap='sss_kpt14'),
- 18:
- dict(
- name='sss_kpt19',
- id=18,
- color=[255, 128, 0],
- type='',
- swap='sss_kpt13'),
- 19:
- dict(
- name='sss_kpt20',
- id=19,
- color=[255, 128, 0],
- type='',
- swap='sss_kpt12'),
- 20:
- dict(
- name='sss_kpt21',
- id=20,
- color=[255, 128, 0],
- type='',
- swap='sss_kpt11'),
- 21:
- dict(
- name='sss_kpt22',
- id=21,
- color=[255, 128, 0],
- type='',
- swap='sss_kpt10'),
- 22:
- dict(
- name='sss_kpt23',
- id=22,
- color=[255, 128, 0],
- type='',
- swap='sss_kpt9'),
- 23:
- dict(
- name='sss_kpt24',
- id=23,
- color=[255, 128, 0],
- type='',
- swap='sss_kpt8'),
- 24:
- dict(
- name='sss_kpt25',
- id=24,
- color=[255, 128, 0],
- type='',
- swap='sss_kpt7'),
- 25:
- dict(name='lss_kpt1', id=25, color=[255, 0, 128], type='', swap=''),
- 26:
- dict(
- name='lss_kpt2',
- id=26,
- color=[255, 0, 128],
- type='',
- swap='lss_kpt6'),
- 27:
- dict(
- name='lss_kpt3',
- id=27,
- color=[255, 0, 128],
- type='',
- swap='lss_kpt5'),
- 28:
- dict(name='lss_kpt4', id=28, color=[255, 0, 128], type='', swap=''),
- 29:
- dict(
- name='lss_kpt5',
- id=29,
- color=[255, 0, 128],
- type='',
- swap='lss_kpt3'),
- 30:
- dict(
- name='lss_kpt6',
- id=30,
- color=[255, 0, 128],
- type='',
- swap='lss_kpt2'),
- 31:
- dict(
- name='lss_kpt7',
- id=31,
- color=[255, 0, 128],
- type='',
- swap='lss_kpt33'),
- 32:
- dict(
- name='lss_kpt8',
- id=32,
- color=[255, 0, 128],
- type='',
- swap='lss_kpt32'),
- 33:
- dict(
- name='lss_kpt9',
- id=33,
- color=[255, 0, 128],
- type='',
- swap='lss_kpt31'),
- 34:
- dict(
- name='lss_kpt10',
- id=34,
- color=[255, 0, 128],
- type='',
- swap='lss_kpt30'),
- 35:
- dict(
- name='lss_kpt11',
- id=35,
- color=[255, 0, 128],
- type='',
- swap='lss_kpt29'),
- 36:
- dict(
- name='lss_kpt12',
- id=36,
- color=[255, 0, 128],
- type='',
- swap='lss_kpt28'),
- 37:
- dict(
- name='lss_kpt13',
- id=37,
- color=[255, 0, 128],
- type='',
- swap='lss_kpt27'),
- 38:
- dict(
- name='lss_kpt14',
- id=38,
- color=[255, 0, 128],
- type='',
- swap='lss_kpt26'),
- 39:
- dict(
- name='lss_kpt15',
- id=39,
- color=[255, 0, 128],
- type='',
- swap='lss_kpt25'),
- 40:
- dict(
- name='lss_kpt16',
- id=40,
- color=[255, 0, 128],
- type='',
- swap='lss_kpt24'),
- 41:
- dict(
- name='lss_kpt17',
- id=41,
- color=[255, 0, 128],
- type='',
- swap='lss_kpt23'),
- 42:
- dict(
- name='lss_kpt18',
- id=42,
- color=[255, 0, 128],
- type='',
- swap='lss_kpt22'),
- 43:
- dict(
- name='lss_kpt19',
- id=43,
- color=[255, 0, 128],
- type='',
- swap='lss_kpt21'),
- 44:
- dict(name='lss_kpt20', id=44, color=[255, 0, 128], type='', swap=''),
- 45:
- dict(
- name='lss_kpt21',
- id=45,
- color=[255, 0, 128],
- type='',
- swap='lss_kpt19'),
- 46:
- dict(
- name='lss_kpt22',
- id=46,
- color=[255, 0, 128],
- type='',
- swap='lss_kpt18'),
- 47:
- dict(
- name='lss_kpt23',
- id=47,
- color=[255, 0, 128],
- type='',
- swap='lss_kpt17'),
- 48:
- dict(
- name='lss_kpt24',
- id=48,
- color=[255, 0, 128],
- type='',
- swap='lss_kpt16'),
- 49:
- dict(
- name='lss_kpt25',
- id=49,
- color=[255, 0, 128],
- type='',
- swap='lss_kpt15'),
- 50:
- dict(
- name='lss_kpt26',
- id=50,
- color=[255, 0, 128],
- type='',
- swap='lss_kpt14'),
- 51:
- dict(
- name='lss_kpt27',
- id=51,
- color=[255, 0, 128],
- type='',
- swap='lss_kpt13'),
- 52:
- dict(
- name='lss_kpt28',
- id=52,
- color=[255, 0, 128],
- type='',
- swap='lss_kpt12'),
- 53:
- dict(
- name='lss_kpt29',
- id=53,
- color=[255, 0, 128],
- type='',
- swap='lss_kpt11'),
- 54:
- dict(
- name='lss_kpt30',
- id=54,
- color=[255, 0, 128],
- type='',
- swap='lss_kpt10'),
- 55:
- dict(
- name='lss_kpt31',
- id=55,
- color=[255, 0, 128],
- type='',
- swap='lss_kpt9'),
- 56:
- dict(
- name='lss_kpt32',
- id=56,
- color=[255, 0, 128],
- type='',
- swap='lss_kpt8'),
- 57:
- dict(
- name='lss_kpt33',
- id=57,
- color=[255, 0, 128],
- type='',
- swap='lss_kpt7'),
- 58:
- dict(name='sso_kpt1', id=58, color=[128, 0, 255], type='', swap=''),
- 59:
- dict(
- name='sso_kpt2',
- id=59,
- color=[128, 0, 255],
- type='',
- swap='sso_kpt26'),
- 60:
- dict(
- name='sso_kpt3',
- id=60,
- color=[128, 0, 255],
- type='',
- swap='sso_kpt5'),
- 61:
- dict(
- name='sso_kpt4',
- id=61,
- color=[128, 0, 255],
- type='',
- swap='sso_kpt6'),
- 62:
- dict(
- name='sso_kpt5',
- id=62,
- color=[128, 0, 255],
- type='',
- swap='sso_kpt3'),
- 63:
- dict(
- name='sso_kpt6',
- id=63,
- color=[128, 0, 255],
- type='',
- swap='sso_kpt4'),
- 64:
- dict(
- name='sso_kpt7',
- id=64,
- color=[128, 0, 255],
- type='',
- swap='sso_kpt25'),
- 65:
- dict(
- name='sso_kpt8',
- id=65,
- color=[128, 0, 255],
- type='',
- swap='sso_kpt24'),
- 66:
- dict(
- name='sso_kpt9',
- id=66,
- color=[128, 0, 255],
- type='',
- swap='sso_kpt23'),
- 67:
- dict(
- name='sso_kpt10',
- id=67,
- color=[128, 0, 255],
- type='',
- swap='sso_kpt22'),
- 68:
- dict(
- name='sso_kpt11',
- id=68,
- color=[128, 0, 255],
- type='',
- swap='sso_kpt21'),
- 69:
- dict(
- name='sso_kpt12',
- id=69,
- color=[128, 0, 255],
- type='',
- swap='sso_kpt20'),
- 70:
- dict(
- name='sso_kpt13',
- id=70,
- color=[128, 0, 255],
- type='',
- swap='sso_kpt19'),
- 71:
- dict(
- name='sso_kpt14',
- id=71,
- color=[128, 0, 255],
- type='',
- swap='sso_kpt18'),
- 72:
- dict(
- name='sso_kpt15',
- id=72,
- color=[128, 0, 255],
- type='',
- swap='sso_kpt17'),
- 73:
- dict(
- name='sso_kpt16',
- id=73,
- color=[128, 0, 255],
- type='',
- swap='sso_kpt29'),
- 74:
- dict(
- name='sso_kpt17',
- id=74,
- color=[128, 0, 255],
- type='',
- swap='sso_kpt15'),
- 75:
- dict(
- name='sso_kpt18',
- id=75,
- color=[128, 0, 255],
- type='',
- swap='sso_kpt14'),
- 76:
- dict(
- name='sso_kpt19',
- id=76,
- color=[128, 0, 255],
- type='',
- swap='sso_kpt13'),
- 77:
- dict(
- name='sso_kpt20',
- id=77,
- color=[128, 0, 255],
- type='',
- swap='sso_kpt12'),
- 78:
- dict(
- name='sso_kpt21',
- id=78,
- color=[128, 0, 255],
- type='',
- swap='sso_kpt11'),
- 79:
- dict(
- name='sso_kpt22',
- id=79,
- color=[128, 0, 255],
- type='',
- swap='sso_kpt10'),
- 80:
- dict(
- name='sso_kpt23',
- id=80,
- color=[128, 0, 255],
- type='',
- swap='sso_kpt9'),
- 81:
- dict(
- name='sso_kpt24',
- id=81,
- color=[128, 0, 255],
- type='',
- swap='sso_kpt8'),
- 82:
- dict(
- name='sso_kpt25',
- id=82,
- color=[128, 0, 255],
- type='',
- swap='sso_kpt7'),
- 83:
- dict(
- name='sso_kpt26',
- id=83,
- color=[128, 0, 255],
- type='',
- swap='sso_kpt2'),
- 84:
- dict(
- name='sso_kpt27',
- id=84,
- color=[128, 0, 255],
- type='',
- swap='sso_kpt30'),
- 85:
- dict(
- name='sso_kpt28',
- id=85,
- color=[128, 0, 255],
- type='',
- swap='sso_kpt31'),
- 86:
- dict(
- name='sso_kpt29',
- id=86,
- color=[128, 0, 255],
- type='',
- swap='sso_kpt16'),
- 87:
- dict(
- name='sso_kpt30',
- id=87,
- color=[128, 0, 255],
- type='',
- swap='sso_kpt27'),
- 88:
- dict(
- name='sso_kpt31',
- id=88,
- color=[128, 0, 255],
- type='',
- swap='sso_kpt28'),
- 89:
- dict(name='lso_kpt1', id=89, color=[0, 128, 255], type='', swap=''),
- 90:
- dict(
- name='lso_kpt2',
- id=90,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt6'),
- 91:
- dict(
- name='lso_kpt3',
- id=91,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt5'),
- 92:
- dict(
- name='lso_kpt4',
- id=92,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt34'),
- 93:
- dict(
- name='lso_kpt5',
- id=93,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt3'),
- 94:
- dict(
- name='lso_kpt6',
- id=94,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt2'),
- 95:
- dict(
- name='lso_kpt7',
- id=95,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt33'),
- 96:
- dict(
- name='lso_kpt8',
- id=96,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt32'),
- 97:
- dict(
- name='lso_kpt9',
- id=97,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt31'),
- 98:
- dict(
- name='lso_kpt10',
- id=98,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt30'),
- 99:
- dict(
- name='lso_kpt11',
- id=99,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt29'),
- 100:
- dict(
- name='lso_kpt12',
- id=100,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt28'),
- 101:
- dict(
- name='lso_kpt13',
- id=101,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt27'),
- 102:
- dict(
- name='lso_kpt14',
- id=102,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt26'),
- 103:
- dict(
- name='lso_kpt15',
- id=103,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt25'),
- 104:
- dict(
- name='lso_kpt16',
- id=104,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt24'),
- 105:
- dict(
- name='lso_kpt17',
- id=105,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt23'),
- 106:
- dict(
- name='lso_kpt18',
- id=106,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt22'),
- 107:
- dict(
- name='lso_kpt19',
- id=107,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt21'),
- 108:
- dict(
- name='lso_kpt20',
- id=108,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt37'),
- 109:
- dict(
- name='lso_kpt21',
- id=109,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt19'),
- 110:
- dict(
- name='lso_kpt22',
- id=110,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt18'),
- 111:
- dict(
- name='lso_kpt23',
- id=111,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt17'),
- 112:
- dict(
- name='lso_kpt24',
- id=112,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt16'),
- 113:
- dict(
- name='lso_kpt25',
- id=113,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt15'),
- 114:
- dict(
- name='lso_kpt26',
- id=114,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt14'),
- 115:
- dict(
- name='lso_kpt27',
- id=115,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt13'),
- 116:
- dict(
- name='lso_kpt28',
- id=116,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt12'),
- 117:
- dict(
- name='lso_kpt29',
- id=117,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt11'),
- 118:
- dict(
- name='lso_kpt30',
- id=118,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt10'),
- 119:
- dict(
- name='lso_kpt31',
- id=119,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt9'),
- 120:
- dict(
- name='lso_kpt32',
- id=120,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt8'),
- 121:
- dict(
- name='lso_kpt33',
- id=121,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt7'),
- 122:
- dict(
- name='lso_kpt34',
- id=122,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt4'),
- 123:
- dict(
- name='lso_kpt35',
- id=123,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt38'),
- 124:
- dict(
- name='lso_kpt36',
- id=124,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt39'),
- 125:
- dict(
- name='lso_kpt37',
- id=125,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt20'),
- 126:
- dict(
- name='lso_kpt38',
- id=126,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt35'),
- 127:
- dict(
- name='lso_kpt39',
- id=127,
- color=[0, 128, 255],
- type='',
- swap='lso_kpt36'),
- 128:
- dict(name='vest_kpt1', id=128, color=[0, 128, 128], type='', swap=''),
- 129:
- dict(
- name='vest_kpt2',
- id=129,
- color=[0, 128, 128],
- type='',
- swap='vest_kpt6'),
- 130:
- dict(
- name='vest_kpt3',
- id=130,
- color=[0, 128, 128],
- type='',
- swap='vest_kpt5'),
- 131:
- dict(name='vest_kpt4', id=131, color=[0, 128, 128], type='', swap=''),
- 132:
- dict(
- name='vest_kpt5',
- id=132,
- color=[0, 128, 128],
- type='',
- swap='vest_kpt3'),
- 133:
- dict(
- name='vest_kpt6',
- id=133,
- color=[0, 128, 128],
- type='',
- swap='vest_kpt2'),
- 134:
- dict(
- name='vest_kpt7',
- id=134,
- color=[0, 128, 128],
- type='',
- swap='vest_kpt15'),
- 135:
- dict(
- name='vest_kpt8',
- id=135,
- color=[0, 128, 128],
- type='',
- swap='vest_kpt14'),
- 136:
- dict(
- name='vest_kpt9',
- id=136,
- color=[0, 128, 128],
- type='',
- swap='vest_kpt13'),
- 137:
- dict(
- name='vest_kpt10',
- id=137,
- color=[0, 128, 128],
- type='',
- swap='vest_kpt12'),
- 138:
- dict(name='vest_kpt11', id=138, color=[0, 128, 128], type='', swap=''),
- 139:
- dict(
- name='vest_kpt12',
- id=139,
- color=[0, 128, 128],
- type='',
- swap='vest_kpt10'),
- 140:
- dict(name='vest_kpt13', id=140, color=[0, 128, 128], type='', swap=''),
- 141:
- dict(
- name='vest_kpt14',
- id=141,
- color=[0, 128, 128],
- type='',
- swap='vest_kpt8'),
- 142:
- dict(
- name='vest_kpt15',
- id=142,
- color=[0, 128, 128],
- type='',
- swap='vest_kpt7'),
- 143:
- dict(name='sling_kpt1', id=143, color=[0, 0, 128], type='', swap=''),
- 144:
- dict(
- name='sling_kpt2',
- id=144,
- color=[0, 0, 128],
- type='',
- swap='sling_kpt6'),
- 145:
- dict(
- name='sling_kpt3',
- id=145,
- color=[0, 0, 128],
- type='',
- swap='sling_kpt5'),
- 146:
- dict(name='sling_kpt4', id=146, color=[0, 0, 128], type='', swap=''),
- 147:
- dict(
- name='sling_kpt5',
- id=147,
- color=[0, 0, 128],
- type='',
- swap='sling_kpt3'),
- 148:
- dict(
- name='sling_kpt6',
- id=148,
- color=[0, 0, 128],
- type='',
- swap='sling_kpt2'),
- 149:
- dict(
- name='sling_kpt7',
- id=149,
- color=[0, 0, 128],
- type='',
- swap='sling_kpt15'),
- 150:
- dict(
- name='sling_kpt8',
- id=150,
- color=[0, 0, 128],
- type='',
- swap='sling_kpt14'),
- 151:
- dict(
- name='sling_kpt9',
- id=151,
- color=[0, 0, 128],
- type='',
- swap='sling_kpt13'),
- 152:
- dict(
- name='sling_kpt10',
- id=152,
- color=[0, 0, 128],
- type='',
- swap='sling_kpt12'),
- 153:
- dict(name='sling_kpt11', id=153, color=[0, 0, 128], type='', swap=''),
- 154:
- dict(
- name='sling_kpt12',
- id=154,
- color=[0, 0, 128],
- type='',
- swap='sling_kpt10'),
- 155:
- dict(
- name='sling_kpt13',
- id=155,
- color=[0, 0, 128],
- type='',
- swap='sling_kpt9'),
- 156:
- dict(
- name='sling_kpt14',
- id=156,
- color=[0, 0, 128],
- type='',
- swap='sling_kpt8'),
- 157:
- dict(
- name='sling_kpt15',
- id=157,
- color=[0, 0, 128],
- type='',
- swap='sling_kpt7'),
- 158:
- dict(
- name='shorts_kpt1',
- id=158,
- color=[128, 128, 128],
- type='',
- swap='shorts_kpt3'),
- 159:
- dict(
- name='shorts_kpt2',
- id=159,
- color=[128, 128, 128],
- type='',
- swap=''),
- 160:
- dict(
- name='shorts_kpt3',
- id=160,
- color=[128, 128, 128],
- type='',
- swap='shorts_kpt1'),
- 161:
- dict(
- name='shorts_kpt4',
- id=161,
- color=[128, 128, 128],
- type='',
- swap='shorts_kpt10'),
- 162:
- dict(
- name='shorts_kpt5',
- id=162,
- color=[128, 128, 128],
- type='',
- swap='shorts_kpt9'),
- 163:
- dict(
- name='shorts_kpt6',
- id=163,
- color=[128, 128, 128],
- type='',
- swap='shorts_kpt8'),
- 164:
- dict(
- name='shorts_kpt7',
- id=164,
- color=[128, 128, 128],
- type='',
- swap=''),
- 165:
- dict(
- name='shorts_kpt8',
- id=165,
- color=[128, 128, 128],
- type='',
- swap='shorts_kpt6'),
- 166:
- dict(
- name='shorts_kpt9',
- id=166,
- color=[128, 128, 128],
- type='',
- swap='shorts_kpt5'),
- 167:
- dict(
- name='shorts_kpt10',
- id=167,
- color=[128, 128, 128],
- type='',
- swap='shorts_kpt4'),
- 168:
- dict(
- name='trousers_kpt1',
- id=168,
- color=[128, 0, 128],
- type='',
- swap='trousers_kpt3'),
- 169:
- dict(
- name='trousers_kpt2',
- id=169,
- color=[128, 0, 128],
- type='',
- swap=''),
- 170:
- dict(
- name='trousers_kpt3',
- id=170,
- color=[128, 0, 128],
- type='',
- swap='trousers_kpt1'),
- 171:
- dict(
- name='trousers_kpt4',
- id=171,
- color=[128, 0, 128],
- type='',
- swap='trousers_kpt14'),
- 172:
- dict(
- name='trousers_kpt5',
- id=172,
- color=[128, 0, 128],
- type='',
- swap='trousers_kpt13'),
- 173:
- dict(
- name='trousers_kpt6',
- id=173,
- color=[128, 0, 128],
- type='',
- swap='trousers_kpt12'),
- 174:
- dict(
- name='trousers_kpt7',
- id=174,
- color=[128, 0, 128],
- type='',
- swap='trousers_kpt11'),
- 175:
- dict(
- name='trousers_kpt8',
- id=175,
- color=[128, 0, 128],
- type='',
- swap='trousers_kpt10'),
- 176:
- dict(
- name='trousers_kpt9',
- id=176,
- color=[128, 0, 128],
- type='',
- swap=''),
- 177:
- dict(
- name='trousers_kpt10',
- id=177,
- color=[128, 0, 128],
- type='',
- swap='trousers_kpt8'),
- 178:
- dict(
- name='trousers_kpt11',
- id=178,
- color=[128, 0, 128],
- type='',
- swap='trousers_kpt7'),
- 179:
- dict(
- name='trousers_kpt12',
- id=179,
- color=[128, 0, 128],
- type='',
- swap='trousers_kpt6'),
- 180:
- dict(
- name='trousers_kpt13',
- id=180,
- color=[128, 0, 128],
- type='',
- swap='trousers_kpt5'),
- 181:
- dict(
- name='trousers_kpt14',
- id=181,
- color=[128, 0, 128],
- type='',
- swap='trousers_kpt4'),
- 182:
- dict(
- name='skirt_kpt1',
- id=182,
- color=[64, 128, 128],
- type='',
- swap='skirt_kpt3'),
- 183:
- dict(
- name='skirt_kpt2', id=183, color=[64, 128, 128], type='', swap=''),
- 184:
- dict(
- name='skirt_kpt3',
- id=184,
- color=[64, 128, 128],
- type='',
- swap='skirt_kpt1'),
- 185:
- dict(
- name='skirt_kpt4',
- id=185,
- color=[64, 128, 128],
- type='',
- swap='skirt_kpt8'),
- 186:
- dict(
- name='skirt_kpt5',
- id=186,
- color=[64, 128, 128],
- type='',
- swap='skirt_kpt7'),
- 187:
- dict(
- name='skirt_kpt6', id=187, color=[64, 128, 128], type='', swap=''),
- 188:
- dict(
- name='skirt_kpt7',
- id=188,
- color=[64, 128, 128],
- type='',
- swap='skirt_kpt5'),
- 189:
- dict(
- name='skirt_kpt8',
- id=189,
- color=[64, 128, 128],
- type='',
- swap='skirt_kpt4'),
- 190:
- dict(name='ssd_kpt1', id=190, color=[64, 64, 128], type='', swap=''),
- 191:
- dict(
- name='ssd_kpt2',
- id=191,
- color=[64, 64, 128],
- type='',
- swap='ssd_kpt6'),
- 192:
- dict(
- name='ssd_kpt3',
- id=192,
- color=[64, 64, 128],
- type='',
- swap='ssd_kpt5'),
- 193:
- dict(name='ssd_kpt4', id=193, color=[64, 64, 128], type='', swap=''),
- 194:
- dict(
- name='ssd_kpt5',
- id=194,
- color=[64, 64, 128],
- type='',
- swap='ssd_kpt3'),
- 195:
- dict(
- name='ssd_kpt6',
- id=195,
- color=[64, 64, 128],
- type='',
- swap='ssd_kpt2'),
- 196:
- dict(
- name='ssd_kpt7',
- id=196,
- color=[64, 64, 128],
- type='',
- swap='ssd_kpt29'),
- 197:
- dict(
- name='ssd_kpt8',
- id=197,
- color=[64, 64, 128],
- type='',
- swap='ssd_kpt28'),
- 198:
- dict(
- name='ssd_kpt9',
- id=198,
- color=[64, 64, 128],
- type='',
- swap='ssd_kpt27'),
- 199:
- dict(
- name='ssd_kpt10',
- id=199,
- color=[64, 64, 128],
- type='',
- swap='ssd_kpt26'),
- 200:
- dict(
- name='ssd_kpt11',
- id=200,
- color=[64, 64, 128],
- type='',
- swap='ssd_kpt25'),
- 201:
- dict(
- name='ssd_kpt12',
- id=201,
- color=[64, 64, 128],
- type='',
- swap='ssd_kpt24'),
- 202:
- dict(
- name='ssd_kpt13',
- id=202,
- color=[64, 64, 128],
- type='',
- swap='ssd_kpt23'),
- 203:
- dict(
- name='ssd_kpt14',
- id=203,
- color=[64, 64, 128],
- type='',
- swap='ssd_kpt22'),
- 204:
- dict(
- name='ssd_kpt15',
- id=204,
- color=[64, 64, 128],
- type='',
- swap='ssd_kpt21'),
- 205:
- dict(
- name='ssd_kpt16',
- id=205,
- color=[64, 64, 128],
- type='',
- swap='ssd_kpt20'),
- 206:
- dict(
- name='ssd_kpt17',
- id=206,
- color=[64, 64, 128],
- type='',
- swap='ssd_kpt19'),
- 207:
- dict(name='ssd_kpt18', id=207, color=[64, 64, 128], type='', swap=''),
- 208:
- dict(
- name='ssd_kpt19',
- id=208,
- color=[64, 64, 128],
- type='',
- swap='ssd_kpt17'),
- 209:
- dict(
- name='ssd_kpt20',
- id=209,
- color=[64, 64, 128],
- type='',
- swap='ssd_kpt16'),
- 210:
- dict(
- name='ssd_kpt21',
- id=210,
- color=[64, 64, 128],
- type='',
- swap='ssd_kpt15'),
- 211:
- dict(
- name='ssd_kpt22',
- id=211,
- color=[64, 64, 128],
- type='',
- swap='ssd_kpt14'),
- 212:
- dict(
- name='ssd_kpt23',
- id=212,
- color=[64, 64, 128],
- type='',
- swap='ssd_kpt13'),
- 213:
- dict(
- name='ssd_kpt24',
- id=213,
- color=[64, 64, 128],
- type='',
- swap='ssd_kpt12'),
- 214:
- dict(
- name='ssd_kpt25',
- id=214,
- color=[64, 64, 128],
- type='',
- swap='ssd_kpt11'),
- 215:
- dict(
- name='ssd_kpt26',
- id=215,
- color=[64, 64, 128],
- type='',
- swap='ssd_kpt10'),
- 216:
- dict(
- name='ssd_kpt27',
- id=216,
- color=[64, 64, 128],
- type='',
- swap='ssd_kpt9'),
- 217:
- dict(
- name='ssd_kpt28',
- id=217,
- color=[64, 64, 128],
- type='',
- swap='ssd_kpt8'),
- 218:
- dict(
- name='ssd_kpt29',
- id=218,
- color=[64, 64, 128],
- type='',
- swap='ssd_kpt7'),
- 219:
- dict(name='lsd_kpt1', id=219, color=[128, 64, 0], type='', swap=''),
- 220:
- dict(
- name='lsd_kpt2',
- id=220,
- color=[128, 64, 0],
- type='',
- swap='lsd_kpt6'),
- 221:
- dict(
- name='lsd_kpt3',
- id=221,
- color=[128, 64, 0],
- type='',
- swap='lsd_kpt5'),
- 222:
- dict(name='lsd_kpt4', id=222, color=[128, 64, 0], type='', swap=''),
- 223:
- dict(
- name='lsd_kpt5',
- id=223,
- color=[128, 64, 0],
- type='',
- swap='lsd_kpt3'),
- 224:
- dict(
- name='lsd_kpt6',
- id=224,
- color=[128, 64, 0],
- type='',
- swap='lsd_kpt2'),
- 225:
- dict(
- name='lsd_kpt7',
- id=225,
- color=[128, 64, 0],
- type='',
- swap='lsd_kpt37'),
- 226:
- dict(
- name='lsd_kpt8',
- id=226,
- color=[128, 64, 0],
- type='',
- swap='lsd_kpt36'),
- 227:
- dict(
- name='lsd_kpt9',
- id=227,
- color=[128, 64, 0],
- type='',
- swap='lsd_kpt35'),
- 228:
- dict(
- name='lsd_kpt10',
- id=228,
- color=[128, 64, 0],
- type='',
- swap='lsd_kpt34'),
- 229:
- dict(
- name='lsd_kpt11',
- id=229,
- color=[128, 64, 0],
- type='',
- swap='lsd_kpt33'),
- 230:
- dict(
- name='lsd_kpt12',
- id=230,
- color=[128, 64, 0],
- type='',
- swap='lsd_kpt32'),
- 231:
- dict(
- name='lsd_kpt13',
- id=231,
- color=[128, 64, 0],
- type='',
- swap='lsd_kpt31'),
- 232:
- dict(
- name='lsd_kpt14',
- id=232,
- color=[128, 64, 0],
- type='',
- swap='lsd_kpt30'),
- 233:
- dict(
- name='lsd_kpt15',
- id=233,
- color=[128, 64, 0],
- type='',
- swap='lsd_kpt29'),
- 234:
- dict(
- name='lsd_kpt16',
- id=234,
- color=[128, 64, 0],
- type='',
- swap='lsd_kpt28'),
- 235:
- dict(
- name='lsd_kpt17',
- id=235,
- color=[128, 64, 0],
- type='',
- swap='lsd_kpt27'),
- 236:
- dict(
- name='lsd_kpt18',
- id=236,
- color=[128, 64, 0],
- type='',
- swap='lsd_kpt26'),
- 237:
- dict(
- name='lsd_kpt19',
- id=237,
- color=[128, 64, 0],
- type='',
- swap='lsd_kpt25'),
- 238:
- dict(
- name='lsd_kpt20',
- id=238,
- color=[128, 64, 0],
- type='',
- swap='lsd_kpt24'),
- 239:
- dict(
- name='lsd_kpt21',
- id=239,
- color=[128, 64, 0],
- type='',
- swap='lsd_kpt23'),
- 240:
- dict(name='lsd_kpt22', id=240, color=[128, 64, 0], type='', swap=''),
- 241:
- dict(
- name='lsd_kpt23',
- id=241,
- color=[128, 64, 0],
- type='',
- swap='lsd_kpt21'),
- 242:
- dict(
- name='lsd_kpt24',
- id=242,
- color=[128, 64, 0],
- type='',
- swap='lsd_kpt20'),
- 243:
- dict(
- name='lsd_kpt25',
- id=243,
- color=[128, 64, 0],
- type='',
- swap='lsd_kpt19'),
- 244:
- dict(
- name='lsd_kpt26',
- id=244,
- color=[128, 64, 0],
- type='',
- swap='lsd_kpt18'),
- 245:
- dict(
- name='lsd_kpt27',
- id=245,
- color=[128, 64, 0],
- type='',
- swap='lsd_kpt17'),
- 246:
- dict(
- name='lsd_kpt28',
- id=246,
- color=[128, 64, 0],
- type='',
- swap='lsd_kpt16'),
- 247:
- dict(
- name='lsd_kpt29',
- id=247,
- color=[128, 64, 0],
- type='',
- swap='lsd_kpt15'),
- 248:
- dict(
- name='lsd_kpt30',
- id=248,
- color=[128, 64, 0],
- type='',
- swap='lsd_kpt14'),
- 249:
- dict(
- name='lsd_kpt31',
- id=249,
- color=[128, 64, 0],
- type='',
- swap='lsd_kpt13'),
- 250:
- dict(
- name='lsd_kpt32',
- id=250,
- color=[128, 64, 0],
- type='',
- swap='lsd_kpt12'),
- 251:
- dict(
- name='lsd_kpt33',
- id=251,
- color=[128, 64, 0],
- type='',
- swap='lsd_kpt11'),
- 252:
- dict(
- name='lsd_kpt34',
- id=252,
- color=[128, 64, 0],
- type='',
- swap='lsd_kpt10'),
- 253:
- dict(
- name='lsd_kpt35',
- id=253,
- color=[128, 64, 0],
- type='',
- swap='lsd_kpt9'),
- 254:
- dict(
- name='lsd_kpt36',
- id=254,
- color=[128, 64, 0],
- type='',
- swap='lsd_kpt8'),
- 255:
- dict(
- name='lsd_kpt37',
- id=255,
- color=[128, 64, 0],
- type='',
- swap='lsd_kpt7'),
- 256:
- dict(name='vd_kpt1', id=256, color=[128, 64, 255], type='', swap=''),
- 257:
- dict(
- name='vd_kpt2',
- id=257,
- color=[128, 64, 255],
- type='',
- swap='vd_kpt6'),
- 258:
- dict(
- name='vd_kpt3',
- id=258,
- color=[128, 64, 255],
- type='',
- swap='vd_kpt5'),
- 259:
- dict(name='vd_kpt4', id=259, color=[128, 64, 255], type='', swap=''),
- 260:
- dict(
- name='vd_kpt5',
- id=260,
- color=[128, 64, 255],
- type='',
- swap='vd_kpt3'),
- 261:
- dict(
- name='vd_kpt6',
- id=261,
- color=[128, 64, 255],
- type='',
- swap='vd_kpt2'),
- 262:
- dict(
- name='vd_kpt7',
- id=262,
- color=[128, 64, 255],
- type='',
- swap='vd_kpt19'),
- 263:
- dict(
- name='vd_kpt8',
- id=263,
- color=[128, 64, 255],
- type='',
- swap='vd_kpt18'),
- 264:
- dict(
- name='vd_kpt9',
- id=264,
- color=[128, 64, 255],
- type='',
- swap='vd_kpt17'),
- 265:
- dict(
- name='vd_kpt10',
- id=265,
- color=[128, 64, 255],
- type='',
- swap='vd_kpt16'),
- 266:
- dict(
- name='vd_kpt11',
- id=266,
- color=[128, 64, 255],
- type='',
- swap='vd_kpt15'),
- 267:
- dict(
- name='vd_kpt12',
- id=267,
- color=[128, 64, 255],
- type='',
- swap='vd_kpt14'),
- 268:
- dict(name='vd_kpt13', id=268, color=[128, 64, 255], type='', swap=''),
- 269:
- dict(
- name='vd_kpt14',
- id=269,
- color=[128, 64, 255],
- type='',
- swap='vd_kpt12'),
- 270:
- dict(
- name='vd_kpt15',
- id=270,
- color=[128, 64, 255],
- type='',
- swap='vd_kpt11'),
- 271:
- dict(
- name='vd_kpt16',
- id=271,
- color=[128, 64, 255],
- type='',
- swap='vd_kpt10'),
- 272:
- dict(
- name='vd_kpt17',
- id=272,
- color=[128, 64, 255],
- type='',
- swap='vd_kpt9'),
- 273:
- dict(
- name='vd_kpt18',
- id=273,
- color=[128, 64, 255],
- type='',
- swap='vd_kpt8'),
- 274:
- dict(
- name='vd_kpt19',
- id=274,
- color=[128, 64, 255],
- type='',
- swap='vd_kpt7'),
- 275:
- dict(name='sd_kpt1', id=275, color=[128, 64, 0], type='', swap=''),
- 276:
- dict(
- name='sd_kpt2',
- id=276,
- color=[128, 64, 0],
- type='',
- swap='sd_kpt6'),
- 277:
- dict(
- name='sd_kpt3',
- id=277,
- color=[128, 64, 0],
- type='',
- swap='sd_kpt5'),
- 278:
- dict(name='sd_kpt4', id=278, color=[128, 64, 0], type='', swap=''),
- 279:
- dict(
- name='sd_kpt5',
- id=279,
- color=[128, 64, 0],
- type='',
- swap='sd_kpt3'),
- 280:
- dict(
- name='sd_kpt6',
- id=280,
- color=[128, 64, 0],
- type='',
- swap='sd_kpt2'),
- 281:
- dict(
- name='sd_kpt7',
- id=281,
- color=[128, 64, 0],
- type='',
- swap='sd_kpt19'),
- 282:
- dict(
- name='sd_kpt8',
- id=282,
- color=[128, 64, 0],
- type='',
- swap='sd_kpt18'),
- 283:
- dict(
- name='sd_kpt9',
- id=283,
- color=[128, 64, 0],
- type='',
- swap='sd_kpt17'),
- 284:
- dict(
- name='sd_kpt10',
- id=284,
- color=[128, 64, 0],
- type='',
- swap='sd_kpt16'),
- 285:
- dict(
- name='sd_kpt11',
- id=285,
- color=[128, 64, 0],
- type='',
- swap='sd_kpt15'),
- 286:
- dict(
- name='sd_kpt12',
- id=286,
- color=[128, 64, 0],
- type='',
- swap='sd_kpt14'),
- 287:
- dict(name='sd_kpt13', id=287, color=[128, 64, 0], type='', swap=''),
- 288:
- dict(
- name='sd_kpt14',
- id=288,
- color=[128, 64, 0],
- type='',
- swap='sd_kpt12'),
- 289:
- dict(
- name='sd_kpt15',
- id=289,
- color=[128, 64, 0],
- type='',
- swap='sd_kpt11'),
- 290:
- dict(
- name='sd_kpt16',
- id=290,
- color=[128, 64, 0],
- type='',
- swap='sd_kpt10'),
- 291:
- dict(
- name='sd_kpt17',
- id=291,
- color=[128, 64, 0],
- type='',
- swap='sd_kpt9'),
- 292:
- dict(
- name='sd_kpt18',
- id=292,
- color=[128, 64, 0],
- type='',
- swap='sd_kpt8'),
- 293:
- dict(
- name='sd_kpt19',
- id=293,
- color=[128, 64, 0],
- type='',
- swap='sd_kpt7')
- }),
- skeleton_info=dict({
- 0:
- dict(link=('sss_kpt1', 'sss_kpt2'), id=0, color=[255, 128, 0]),
- 1:
- dict(link=('sss_kpt2', 'sss_kpt7'), id=1, color=[255, 128, 0]),
- 2:
- dict(link=('sss_kpt7', 'sss_kpt8'), id=2, color=[255, 128, 0]),
- 3:
- dict(link=('sss_kpt8', 'sss_kpt9'), id=3, color=[255, 128, 0]),
- 4:
- dict(link=('sss_kpt9', 'sss_kpt10'), id=4, color=[255, 128, 0]),
- 5:
- dict(link=('sss_kpt10', 'sss_kpt11'), id=5, color=[255, 128, 0]),
- 6:
- dict(link=('sss_kpt11', 'sss_kpt12'), id=6, color=[255, 128, 0]),
- 7:
- dict(link=('sss_kpt12', 'sss_kpt13'), id=7, color=[255, 128, 0]),
- 8:
- dict(link=('sss_kpt13', 'sss_kpt14'), id=8, color=[255, 128, 0]),
- 9:
- dict(link=('sss_kpt14', 'sss_kpt15'), id=9, color=[255, 128, 0]),
- 10:
- dict(link=('sss_kpt15', 'sss_kpt16'), id=10, color=[255, 128, 0]),
- 11:
- dict(link=('sss_kpt16', 'sss_kpt17'), id=11, color=[255, 128, 0]),
- 12:
- dict(link=('sss_kpt17', 'sss_kpt18'), id=12, color=[255, 128, 0]),
- 13:
- dict(link=('sss_kpt18', 'sss_kpt19'), id=13, color=[255, 128, 0]),
- 14:
- dict(link=('sss_kpt19', 'sss_kpt20'), id=14, color=[255, 128, 0]),
- 15:
- dict(link=('sss_kpt20', 'sss_kpt21'), id=15, color=[255, 128, 0]),
- 16:
- dict(link=('sss_kpt21', 'sss_kpt22'), id=16, color=[255, 128, 0]),
- 17:
- dict(link=('sss_kpt22', 'sss_kpt23'), id=17, color=[255, 128, 0]),
- 18:
- dict(link=('sss_kpt23', 'sss_kpt24'), id=18, color=[255, 128, 0]),
- 19:
- dict(link=('sss_kpt24', 'sss_kpt25'), id=19, color=[255, 128, 0]),
- 20:
- dict(link=('sss_kpt25', 'sss_kpt6'), id=20, color=[255, 128, 0]),
- 21:
- dict(link=('sss_kpt6', 'sss_kpt1'), id=21, color=[255, 128, 0]),
- 22:
- dict(link=('sss_kpt2', 'sss_kpt3'), id=22, color=[255, 128, 0]),
- 23:
- dict(link=('sss_kpt3', 'sss_kpt4'), id=23, color=[255, 128, 0]),
- 24:
- dict(link=('sss_kpt4', 'sss_kpt5'), id=24, color=[255, 128, 0]),
- 25:
- dict(link=('sss_kpt5', 'sss_kpt6'), id=25, color=[255, 128, 0]),
- 26:
- dict(link=('lss_kpt1', 'lss_kpt2'), id=26, color=[255, 0, 128]),
- 27:
- dict(link=('lss_kpt2', 'lss_kpt7'), id=27, color=[255, 0, 128]),
- 28:
- dict(link=('lss_kpt7', 'lss_kpt8'), id=28, color=[255, 0, 128]),
- 29:
- dict(link=('lss_kpt8', 'lss_kpt9'), id=29, color=[255, 0, 128]),
- 30:
- dict(link=('lss_kpt9', 'lss_kpt10'), id=30, color=[255, 0, 128]),
- 31:
- dict(link=('lss_kpt10', 'lss_kpt11'), id=31, color=[255, 0, 128]),
- 32:
- dict(link=('lss_kpt11', 'lss_kpt12'), id=32, color=[255, 0, 128]),
- 33:
- dict(link=('lss_kpt12', 'lss_kpt13'), id=33, color=[255, 0, 128]),
- 34:
- dict(link=('lss_kpt13', 'lss_kpt14'), id=34, color=[255, 0, 128]),
- 35:
- dict(link=('lss_kpt14', 'lss_kpt15'), id=35, color=[255, 0, 128]),
- 36:
- dict(link=('lss_kpt15', 'lss_kpt16'), id=36, color=[255, 0, 128]),
- 37:
- dict(link=('lss_kpt16', 'lss_kpt17'), id=37, color=[255, 0, 128]),
- 38:
- dict(link=('lss_kpt17', 'lss_kpt18'), id=38, color=[255, 0, 128]),
- 39:
- dict(link=('lss_kpt18', 'lss_kpt19'), id=39, color=[255, 0, 128]),
- 40:
- dict(link=('lss_kpt19', 'lss_kpt20'), id=40, color=[255, 0, 128]),
- 41:
- dict(link=('lss_kpt20', 'lss_kpt21'), id=41, color=[255, 0, 128]),
- 42:
- dict(link=('lss_kpt21', 'lss_kpt22'), id=42, color=[255, 0, 128]),
- 43:
- dict(link=('lss_kpt22', 'lss_kpt23'), id=43, color=[255, 0, 128]),
- 44:
- dict(link=('lss_kpt23', 'lss_kpt24'), id=44, color=[255, 0, 128]),
- 45:
- dict(link=('lss_kpt24', 'lss_kpt25'), id=45, color=[255, 0, 128]),
- 46:
- dict(link=('lss_kpt25', 'lss_kpt26'), id=46, color=[255, 0, 128]),
- 47:
- dict(link=('lss_kpt26', 'lss_kpt27'), id=47, color=[255, 0, 128]),
- 48:
- dict(link=('lss_kpt27', 'lss_kpt28'), id=48, color=[255, 0, 128]),
- 49:
- dict(link=('lss_kpt28', 'lss_kpt29'), id=49, color=[255, 0, 128]),
- 50:
- dict(link=('lss_kpt29', 'lss_kpt30'), id=50, color=[255, 0, 128]),
- 51:
- dict(link=('lss_kpt30', 'lss_kpt31'), id=51, color=[255, 0, 128]),
- 52:
- dict(link=('lss_kpt31', 'lss_kpt32'), id=52, color=[255, 0, 128]),
- 53:
- dict(link=('lss_kpt32', 'lss_kpt33'), id=53, color=[255, 0, 128]),
- 54:
- dict(link=('lss_kpt33', 'lss_kpt6'), id=54, color=[255, 0, 128]),
- 55:
- dict(link=('lss_kpt6', 'lss_kpt5'), id=55, color=[255, 0, 128]),
- 56:
- dict(link=('lss_kpt5', 'lss_kpt4'), id=56, color=[255, 0, 128]),
- 57:
- dict(link=('lss_kpt4', 'lss_kpt3'), id=57, color=[255, 0, 128]),
- 58:
- dict(link=('lss_kpt3', 'lss_kpt2'), id=58, color=[255, 0, 128]),
- 59:
- dict(link=('lss_kpt6', 'lss_kpt1'), id=59, color=[255, 0, 128]),
- 60:
- dict(link=('sso_kpt1', 'sso_kpt4'), id=60, color=[128, 0, 255]),
- 61:
- dict(link=('sso_kpt4', 'sso_kpt7'), id=61, color=[128, 0, 255]),
- 62:
- dict(link=('sso_kpt7', 'sso_kpt8'), id=62, color=[128, 0, 255]),
- 63:
- dict(link=('sso_kpt8', 'sso_kpt9'), id=63, color=[128, 0, 255]),
- 64:
- dict(link=('sso_kpt9', 'sso_kpt10'), id=64, color=[128, 0, 255]),
- 65:
- dict(link=('sso_kpt10', 'sso_kpt11'), id=65, color=[128, 0, 255]),
- 66:
- dict(link=('sso_kpt11', 'sso_kpt12'), id=66, color=[128, 0, 255]),
- 67:
- dict(link=('sso_kpt12', 'sso_kpt13'), id=67, color=[128, 0, 255]),
- 68:
- dict(link=('sso_kpt13', 'sso_kpt14'), id=68, color=[128, 0, 255]),
- 69:
- dict(link=('sso_kpt14', 'sso_kpt15'), id=69, color=[128, 0, 255]),
- 70:
- dict(link=('sso_kpt15', 'sso_kpt16'), id=70, color=[128, 0, 255]),
- 71:
- dict(link=('sso_kpt16', 'sso_kpt31'), id=71, color=[128, 0, 255]),
- 72:
- dict(link=('sso_kpt31', 'sso_kpt30'), id=72, color=[128, 0, 255]),
- 73:
- dict(link=('sso_kpt30', 'sso_kpt2'), id=73, color=[128, 0, 255]),
- 74:
- dict(link=('sso_kpt2', 'sso_kpt3'), id=74, color=[128, 0, 255]),
- 75:
- dict(link=('sso_kpt3', 'sso_kpt4'), id=75, color=[128, 0, 255]),
- 76:
- dict(link=('sso_kpt1', 'sso_kpt6'), id=76, color=[128, 0, 255]),
- 77:
- dict(link=('sso_kpt6', 'sso_kpt25'), id=77, color=[128, 0, 255]),
- 78:
- dict(link=('sso_kpt25', 'sso_kpt24'), id=78, color=[128, 0, 255]),
- 79:
- dict(link=('sso_kpt24', 'sso_kpt23'), id=79, color=[128, 0, 255]),
- 80:
- dict(link=('sso_kpt23', 'sso_kpt22'), id=80, color=[128, 0, 255]),
- 81:
- dict(link=('sso_kpt22', 'sso_kpt21'), id=81, color=[128, 0, 255]),
- 82:
- dict(link=('sso_kpt21', 'sso_kpt20'), id=82, color=[128, 0, 255]),
- 83:
- dict(link=('sso_kpt20', 'sso_kpt19'), id=83, color=[128, 0, 255]),
- 84:
- dict(link=('sso_kpt19', 'sso_kpt18'), id=84, color=[128, 0, 255]),
- 85:
- dict(link=('sso_kpt18', 'sso_kpt17'), id=85, color=[128, 0, 255]),
- 86:
- dict(link=('sso_kpt17', 'sso_kpt29'), id=86, color=[128, 0, 255]),
- 87:
- dict(link=('sso_kpt29', 'sso_kpt28'), id=87, color=[128, 0, 255]),
- 88:
- dict(link=('sso_kpt28', 'sso_kpt27'), id=88, color=[128, 0, 255]),
- 89:
- dict(link=('sso_kpt27', 'sso_kpt26'), id=89, color=[128, 0, 255]),
- 90:
- dict(link=('sso_kpt26', 'sso_kpt5'), id=90, color=[128, 0, 255]),
- 91:
- dict(link=('sso_kpt5', 'sso_kpt6'), id=91, color=[128, 0, 255]),
- 92:
- dict(link=('lso_kpt1', 'lso_kpt2'), id=92, color=[0, 128, 255]),
- 93:
- dict(link=('lso_kpt2', 'lso_kpt7'), id=93, color=[0, 128, 255]),
- 94:
- dict(link=('lso_kpt7', 'lso_kpt8'), id=94, color=[0, 128, 255]),
- 95:
- dict(link=('lso_kpt8', 'lso_kpt9'), id=95, color=[0, 128, 255]),
- 96:
- dict(link=('lso_kpt9', 'lso_kpt10'), id=96, color=[0, 128, 255]),
- 97:
- dict(link=('lso_kpt10', 'lso_kpt11'), id=97, color=[0, 128, 255]),
- 98:
- dict(link=('lso_kpt11', 'lso_kpt12'), id=98, color=[0, 128, 255]),
- 99:
- dict(link=('lso_kpt12', 'lso_kpt13'), id=99, color=[0, 128, 255]),
- 100:
- dict(link=('lso_kpt13', 'lso_kpt14'), id=100, color=[0, 128, 255]),
- 101:
- dict(link=('lso_kpt14', 'lso_kpt15'), id=101, color=[0, 128, 255]),
- 102:
- dict(link=('lso_kpt15', 'lso_kpt16'), id=102, color=[0, 128, 255]),
- 103:
- dict(link=('lso_kpt16', 'lso_kpt17'), id=103, color=[0, 128, 255]),
- 104:
- dict(link=('lso_kpt17', 'lso_kpt18'), id=104, color=[0, 128, 255]),
- 105:
- dict(link=('lso_kpt18', 'lso_kpt19'), id=105, color=[0, 128, 255]),
- 106:
- dict(link=('lso_kpt19', 'lso_kpt20'), id=106, color=[0, 128, 255]),
- 107:
- dict(link=('lso_kpt20', 'lso_kpt39'), id=107, color=[0, 128, 255]),
- 108:
- dict(link=('lso_kpt39', 'lso_kpt38'), id=108, color=[0, 128, 255]),
- 109:
- dict(link=('lso_kpt38', 'lso_kpt4'), id=109, color=[0, 128, 255]),
- 110:
- dict(link=('lso_kpt4', 'lso_kpt3'), id=110, color=[0, 128, 255]),
- 111:
- dict(link=('lso_kpt3', 'lso_kpt2'), id=111, color=[0, 128, 255]),
- 112:
- dict(link=('lso_kpt1', 'lso_kpt6'), id=112, color=[0, 128, 255]),
- 113:
- dict(link=('lso_kpt6', 'lso_kpt33'), id=113, color=[0, 128, 255]),
- 114:
- dict(link=('lso_kpt33', 'lso_kpt32'), id=114, color=[0, 128, 255]),
- 115:
- dict(link=('lso_kpt32', 'lso_kpt31'), id=115, color=[0, 128, 255]),
- 116:
- dict(link=('lso_kpt31', 'lso_kpt30'), id=116, color=[0, 128, 255]),
- 117:
- dict(link=('lso_kpt30', 'lso_kpt29'), id=117, color=[0, 128, 255]),
- 118:
- dict(link=('lso_kpt29', 'lso_kpt28'), id=118, color=[0, 128, 255]),
- 119:
- dict(link=('lso_kpt28', 'lso_kpt27'), id=119, color=[0, 128, 255]),
- 120:
- dict(link=('lso_kpt27', 'lso_kpt26'), id=120, color=[0, 128, 255]),
- 121:
- dict(link=('lso_kpt26', 'lso_kpt25'), id=121, color=[0, 128, 255]),
- 122:
- dict(link=('lso_kpt25', 'lso_kpt24'), id=122, color=[0, 128, 255]),
- 123:
- dict(link=('lso_kpt24', 'lso_kpt23'), id=123, color=[0, 128, 255]),
- 124:
- dict(link=('lso_kpt23', 'lso_kpt22'), id=124, color=[0, 128, 255]),
- 125:
- dict(link=('lso_kpt22', 'lso_kpt21'), id=125, color=[0, 128, 255]),
- 126:
- dict(link=('lso_kpt21', 'lso_kpt37'), id=126, color=[0, 128, 255]),
- 127:
- dict(link=('lso_kpt37', 'lso_kpt36'), id=127, color=[0, 128, 255]),
- 128:
- dict(link=('lso_kpt36', 'lso_kpt35'), id=128, color=[0, 128, 255]),
- 129:
- dict(link=('lso_kpt35', 'lso_kpt34'), id=129, color=[0, 128, 255]),
- 130:
- dict(link=('lso_kpt34', 'lso_kpt5'), id=130, color=[0, 128, 255]),
- 131:
- dict(link=('lso_kpt5', 'lso_kpt6'), id=131, color=[0, 128, 255]),
- 132:
- dict(link=('vest_kpt1', 'vest_kpt2'), id=132, color=[0, 128, 128]),
- 133:
- dict(link=('vest_kpt2', 'vest_kpt7'), id=133, color=[0, 128, 128]),
- 134:
- dict(link=('vest_kpt7', 'vest_kpt8'), id=134, color=[0, 128, 128]),
- 135:
- dict(link=('vest_kpt8', 'vest_kpt9'), id=135, color=[0, 128, 128]),
- 136:
- dict(link=('vest_kpt9', 'vest_kpt10'), id=136, color=[0, 128, 128]),
- 137:
- dict(link=('vest_kpt10', 'vest_kpt11'), id=137, color=[0, 128, 128]),
- 138:
- dict(link=('vest_kpt11', 'vest_kpt12'), id=138, color=[0, 128, 128]),
- 139:
- dict(link=('vest_kpt12', 'vest_kpt13'), id=139, color=[0, 128, 128]),
- 140:
- dict(link=('vest_kpt13', 'vest_kpt14'), id=140, color=[0, 128, 128]),
- 141:
- dict(link=('vest_kpt14', 'vest_kpt15'), id=141, color=[0, 128, 128]),
- 142:
- dict(link=('vest_kpt15', 'vest_kpt6'), id=142, color=[0, 128, 128]),
- 143:
- dict(link=('vest_kpt6', 'vest_kpt1'), id=143, color=[0, 128, 128]),
- 144:
- dict(link=('vest_kpt2', 'vest_kpt3'), id=144, color=[0, 128, 128]),
- 145:
- dict(link=('vest_kpt3', 'vest_kpt4'), id=145, color=[0, 128, 128]),
- 146:
- dict(link=('vest_kpt4', 'vest_kpt5'), id=146, color=[0, 128, 128]),
- 147:
- dict(link=('vest_kpt5', 'vest_kpt6'), id=147, color=[0, 128, 128]),
- 148:
- dict(link=('sling_kpt1', 'sling_kpt2'), id=148, color=[0, 0, 128]),
- 149:
- dict(link=('sling_kpt2', 'sling_kpt8'), id=149, color=[0, 0, 128]),
- 150:
- dict(link=('sling_kpt8', 'sling_kpt9'), id=150, color=[0, 0, 128]),
- 151:
- dict(link=('sling_kpt9', 'sling_kpt10'), id=151, color=[0, 0, 128]),
- 152:
- dict(link=('sling_kpt10', 'sling_kpt11'), id=152, color=[0, 0, 128]),
- 153:
- dict(link=('sling_kpt11', 'sling_kpt12'), id=153, color=[0, 0, 128]),
- 154:
- dict(link=('sling_kpt12', 'sling_kpt13'), id=154, color=[0, 0, 128]),
- 155:
- dict(link=('sling_kpt13', 'sling_kpt14'), id=155, color=[0, 0, 128]),
- 156:
- dict(link=('sling_kpt14', 'sling_kpt6'), id=156, color=[0, 0, 128]),
- 157:
- dict(link=('sling_kpt2', 'sling_kpt7'), id=157, color=[0, 0, 128]),
- 158:
- dict(link=('sling_kpt6', 'sling_kpt15'), id=158, color=[0, 0, 128]),
- 159:
- dict(link=('sling_kpt2', 'sling_kpt3'), id=159, color=[0, 0, 128]),
- 160:
- dict(link=('sling_kpt3', 'sling_kpt4'), id=160, color=[0, 0, 128]),
- 161:
- dict(link=('sling_kpt4', 'sling_kpt5'), id=161, color=[0, 0, 128]),
- 162:
- dict(link=('sling_kpt5', 'sling_kpt6'), id=162, color=[0, 0, 128]),
- 163:
- dict(link=('sling_kpt1', 'sling_kpt6'), id=163, color=[0, 0, 128]),
- 164:
- dict(
- link=('shorts_kpt1', 'shorts_kpt4'), id=164, color=[128, 128,
- 128]),
- 165:
- dict(
- link=('shorts_kpt4', 'shorts_kpt5'), id=165, color=[128, 128,
- 128]),
- 166:
- dict(
- link=('shorts_kpt5', 'shorts_kpt6'), id=166, color=[128, 128,
- 128]),
- 167:
- dict(
- link=('shorts_kpt6', 'shorts_kpt7'), id=167, color=[128, 128,
- 128]),
- 168:
- dict(
- link=('shorts_kpt7', 'shorts_kpt8'), id=168, color=[128, 128,
- 128]),
- 169:
- dict(
- link=('shorts_kpt8', 'shorts_kpt9'), id=169, color=[128, 128,
- 128]),
- 170:
- dict(
- link=('shorts_kpt9', 'shorts_kpt10'),
- id=170,
- color=[128, 128, 128]),
- 171:
- dict(
- link=('shorts_kpt10', 'shorts_kpt3'),
- id=171,
- color=[128, 128, 128]),
- 172:
- dict(
- link=('shorts_kpt3', 'shorts_kpt2'), id=172, color=[128, 128,
- 128]),
- 173:
- dict(
- link=('shorts_kpt2', 'shorts_kpt1'), id=173, color=[128, 128,
- 128]),
- 174:
- dict(
- link=('trousers_kpt1', 'trousers_kpt4'),
- id=174,
- color=[128, 0, 128]),
- 175:
- dict(
- link=('trousers_kpt4', 'trousers_kpt5'),
- id=175,
- color=[128, 0, 128]),
- 176:
- dict(
- link=('trousers_kpt5', 'trousers_kpt6'),
- id=176,
- color=[128, 0, 128]),
- 177:
- dict(
- link=('trousers_kpt6', 'trousers_kpt7'),
- id=177,
- color=[128, 0, 128]),
- 178:
- dict(
- link=('trousers_kpt7', 'trousers_kpt8'),
- id=178,
- color=[128, 0, 128]),
- 179:
- dict(
- link=('trousers_kpt8', 'trousers_kpt9'),
- id=179,
- color=[128, 0, 128]),
- 180:
- dict(
- link=('trousers_kpt9', 'trousers_kpt10'),
- id=180,
- color=[128, 0, 128]),
- 181:
- dict(
- link=('trousers_kpt10', 'trousers_kpt11'),
- id=181,
- color=[128, 0, 128]),
- 182:
- dict(
- link=('trousers_kpt11', 'trousers_kpt12'),
- id=182,
- color=[128, 0, 128]),
- 183:
- dict(
- link=('trousers_kpt12', 'trousers_kpt13'),
- id=183,
- color=[128, 0, 128]),
- 184:
- dict(
- link=('trousers_kpt13', 'trousers_kpt14'),
- id=184,
- color=[128, 0, 128]),
- 185:
- dict(
- link=('trousers_kpt14', 'trousers_kpt3'),
- id=185,
- color=[128, 0, 128]),
- 186:
- dict(
- link=('trousers_kpt3', 'trousers_kpt2'),
- id=186,
- color=[128, 0, 128]),
- 187:
- dict(
- link=('trousers_kpt2', 'trousers_kpt1'),
- id=187,
- color=[128, 0, 128]),
- 188:
- dict(link=('skirt_kpt1', 'skirt_kpt4'), id=188, color=[64, 128, 128]),
- 189:
- dict(link=('skirt_kpt4', 'skirt_kpt5'), id=189, color=[64, 128, 128]),
- 190:
- dict(link=('skirt_kpt5', 'skirt_kpt6'), id=190, color=[64, 128, 128]),
- 191:
- dict(link=('skirt_kpt6', 'skirt_kpt7'), id=191, color=[64, 128, 128]),
- 192:
- dict(link=('skirt_kpt7', 'skirt_kpt8'), id=192, color=[64, 128, 128]),
- 193:
- dict(link=('skirt_kpt8', 'skirt_kpt3'), id=193, color=[64, 128, 128]),
- 194:
- dict(link=('skirt_kpt3', 'skirt_kpt2'), id=194, color=[64, 128, 128]),
- 195:
- dict(link=('skirt_kpt2', 'skirt_kpt1'), id=195, color=[64, 128, 128]),
- 196:
- dict(link=('ssd_kpt1', 'ssd_kpt2'), id=196, color=[64, 64, 128]),
- 197:
- dict(link=('ssd_kpt2', 'ssd_kpt7'), id=197, color=[64, 64, 128]),
- 198:
- dict(link=('ssd_kpt7', 'ssd_kpt8'), id=198, color=[64, 64, 128]),
- 199:
- dict(link=('ssd_kpt8', 'ssd_kpt9'), id=199, color=[64, 64, 128]),
- 200:
- dict(link=('ssd_kpt9', 'ssd_kpt10'), id=200, color=[64, 64, 128]),
- 201:
- dict(link=('ssd_kpt10', 'ssd_kpt11'), id=201, color=[64, 64, 128]),
- 202:
- dict(link=('ssd_kpt11', 'ssd_kpt12'), id=202, color=[64, 64, 128]),
- 203:
- dict(link=('ssd_kpt12', 'ssd_kpt13'), id=203, color=[64, 64, 128]),
- 204:
- dict(link=('ssd_kpt13', 'ssd_kpt14'), id=204, color=[64, 64, 128]),
- 205:
- dict(link=('ssd_kpt14', 'ssd_kpt15'), id=205, color=[64, 64, 128]),
- 206:
- dict(link=('ssd_kpt15', 'ssd_kpt16'), id=206, color=[64, 64, 128]),
- 207:
- dict(link=('ssd_kpt16', 'ssd_kpt17'), id=207, color=[64, 64, 128]),
- 208:
- dict(link=('ssd_kpt17', 'ssd_kpt18'), id=208, color=[64, 64, 128]),
- 209:
- dict(link=('ssd_kpt18', 'ssd_kpt19'), id=209, color=[64, 64, 128]),
- 210:
- dict(link=('ssd_kpt19', 'ssd_kpt20'), id=210, color=[64, 64, 128]),
- 211:
- dict(link=('ssd_kpt20', 'ssd_kpt21'), id=211, color=[64, 64, 128]),
- 212:
- dict(link=('ssd_kpt21', 'ssd_kpt22'), id=212, color=[64, 64, 128]),
- 213:
- dict(link=('ssd_kpt22', 'ssd_kpt23'), id=213, color=[64, 64, 128]),
- 214:
- dict(link=('ssd_kpt23', 'ssd_kpt24'), id=214, color=[64, 64, 128]),
- 215:
- dict(link=('ssd_kpt24', 'ssd_kpt25'), id=215, color=[64, 64, 128]),
- 216:
- dict(link=('ssd_kpt25', 'ssd_kpt26'), id=216, color=[64, 64, 128]),
- 217:
- dict(link=('ssd_kpt26', 'ssd_kpt27'), id=217, color=[64, 64, 128]),
- 218:
- dict(link=('ssd_kpt27', 'ssd_kpt28'), id=218, color=[64, 64, 128]),
- 219:
- dict(link=('ssd_kpt28', 'ssd_kpt29'), id=219, color=[64, 64, 128]),
- 220:
- dict(link=('ssd_kpt29', 'ssd_kpt6'), id=220, color=[64, 64, 128]),
- 221:
- dict(link=('ssd_kpt6', 'ssd_kpt5'), id=221, color=[64, 64, 128]),
- 222:
- dict(link=('ssd_kpt5', 'ssd_kpt4'), id=222, color=[64, 64, 128]),
- 223:
- dict(link=('ssd_kpt4', 'ssd_kpt3'), id=223, color=[64, 64, 128]),
- 224:
- dict(link=('ssd_kpt3', 'ssd_kpt2'), id=224, color=[64, 64, 128]),
- 225:
- dict(link=('ssd_kpt6', 'ssd_kpt1'), id=225, color=[64, 64, 128]),
- 226:
- dict(link=('lsd_kpt1', 'lsd_kpt2'), id=226, color=[128, 64, 0]),
- 227:
- dict(link=('lsd_kpt2', 'lsd_kpt7'), id=228, color=[128, 64, 0]),
- 228:
- dict(link=('lsd_kpt7', 'lsd_kpt8'), id=228, color=[128, 64, 0]),
- 229:
- dict(link=('lsd_kpt8', 'lsd_kpt9'), id=229, color=[128, 64, 0]),
- 230:
- dict(link=('lsd_kpt9', 'lsd_kpt10'), id=230, color=[128, 64, 0]),
- 231:
- dict(link=('lsd_kpt10', 'lsd_kpt11'), id=231, color=[128, 64, 0]),
- 232:
- dict(link=('lsd_kpt11', 'lsd_kpt12'), id=232, color=[128, 64, 0]),
- 233:
- dict(link=('lsd_kpt12', 'lsd_kpt13'), id=233, color=[128, 64, 0]),
- 234:
- dict(link=('lsd_kpt13', 'lsd_kpt14'), id=234, color=[128, 64, 0]),
- 235:
- dict(link=('lsd_kpt14', 'lsd_kpt15'), id=235, color=[128, 64, 0]),
- 236:
- dict(link=('lsd_kpt15', 'lsd_kpt16'), id=236, color=[128, 64, 0]),
- 237:
- dict(link=('lsd_kpt16', 'lsd_kpt17'), id=237, color=[128, 64, 0]),
- 238:
- dict(link=('lsd_kpt17', 'lsd_kpt18'), id=238, color=[128, 64, 0]),
- 239:
- dict(link=('lsd_kpt18', 'lsd_kpt19'), id=239, color=[128, 64, 0]),
- 240:
- dict(link=('lsd_kpt19', 'lsd_kpt20'), id=240, color=[128, 64, 0]),
- 241:
- dict(link=('lsd_kpt20', 'lsd_kpt21'), id=241, color=[128, 64, 0]),
- 242:
- dict(link=('lsd_kpt21', 'lsd_kpt22'), id=242, color=[128, 64, 0]),
- 243:
- dict(link=('lsd_kpt22', 'lsd_kpt23'), id=243, color=[128, 64, 0]),
- 244:
- dict(link=('lsd_kpt23', 'lsd_kpt24'), id=244, color=[128, 64, 0]),
- 245:
- dict(link=('lsd_kpt24', 'lsd_kpt25'), id=245, color=[128, 64, 0]),
- 246:
- dict(link=('lsd_kpt25', 'lsd_kpt26'), id=246, color=[128, 64, 0]),
- 247:
- dict(link=('lsd_kpt26', 'lsd_kpt27'), id=247, color=[128, 64, 0]),
- 248:
- dict(link=('lsd_kpt27', 'lsd_kpt28'), id=248, color=[128, 64, 0]),
- 249:
- dict(link=('lsd_kpt28', 'lsd_kpt29'), id=249, color=[128, 64, 0]),
- 250:
- dict(link=('lsd_kpt29', 'lsd_kpt30'), id=250, color=[128, 64, 0]),
- 251:
- dict(link=('lsd_kpt30', 'lsd_kpt31'), id=251, color=[128, 64, 0]),
- 252:
- dict(link=('lsd_kpt31', 'lsd_kpt32'), id=252, color=[128, 64, 0]),
- 253:
- dict(link=('lsd_kpt32', 'lsd_kpt33'), id=253, color=[128, 64, 0]),
- 254:
- dict(link=('lsd_kpt33', 'lsd_kpt34'), id=254, color=[128, 64, 0]),
- 255:
- dict(link=('lsd_kpt34', 'lsd_kpt35'), id=255, color=[128, 64, 0]),
- 256:
- dict(link=('lsd_kpt35', 'lsd_kpt36'), id=256, color=[128, 64, 0]),
- 257:
- dict(link=('lsd_kpt36', 'lsd_kpt37'), id=257, color=[128, 64, 0]),
- 258:
- dict(link=('lsd_kpt37', 'lsd_kpt6'), id=258, color=[128, 64, 0]),
- 259:
- dict(link=('lsd_kpt6', 'lsd_kpt5'), id=259, color=[128, 64, 0]),
- 260:
- dict(link=('lsd_kpt5', 'lsd_kpt4'), id=260, color=[128, 64, 0]),
- 261:
- dict(link=('lsd_kpt4', 'lsd_kpt3'), id=261, color=[128, 64, 0]),
- 262:
- dict(link=('lsd_kpt3', 'lsd_kpt2'), id=262, color=[128, 64, 0]),
- 263:
- dict(link=('lsd_kpt6', 'lsd_kpt1'), id=263, color=[128, 64, 0]),
- 264:
- dict(link=('vd_kpt1', 'vd_kpt2'), id=264, color=[128, 64, 255]),
- 265:
- dict(link=('vd_kpt2', 'vd_kpt7'), id=265, color=[128, 64, 255]),
- 266:
- dict(link=('vd_kpt7', 'vd_kpt8'), id=266, color=[128, 64, 255]),
- 267:
- dict(link=('vd_kpt8', 'vd_kpt9'), id=267, color=[128, 64, 255]),
- 268:
- dict(link=('vd_kpt9', 'vd_kpt10'), id=268, color=[128, 64, 255]),
- 269:
- dict(link=('vd_kpt10', 'vd_kpt11'), id=269, color=[128, 64, 255]),
- 270:
- dict(link=('vd_kpt11', 'vd_kpt12'), id=270, color=[128, 64, 255]),
- 271:
- dict(link=('vd_kpt12', 'vd_kpt13'), id=271, color=[128, 64, 255]),
- 272:
- dict(link=('vd_kpt13', 'vd_kpt14'), id=272, color=[128, 64, 255]),
- 273:
- dict(link=('vd_kpt14', 'vd_kpt15'), id=273, color=[128, 64, 255]),
- 274:
- dict(link=('vd_kpt15', 'vd_kpt16'), id=274, color=[128, 64, 255]),
- 275:
- dict(link=('vd_kpt16', 'vd_kpt17'), id=275, color=[128, 64, 255]),
- 276:
- dict(link=('vd_kpt17', 'vd_kpt18'), id=276, color=[128, 64, 255]),
- 277:
- dict(link=('vd_kpt18', 'vd_kpt19'), id=277, color=[128, 64, 255]),
- 278:
- dict(link=('vd_kpt19', 'vd_kpt6'), id=278, color=[128, 64, 255]),
- 279:
- dict(link=('vd_kpt6', 'vd_kpt5'), id=279, color=[128, 64, 255]),
- 280:
- dict(link=('vd_kpt5', 'vd_kpt4'), id=280, color=[128, 64, 255]),
- 281:
- dict(link=('vd_kpt4', 'vd_kpt3'), id=281, color=[128, 64, 255]),
- 282:
- dict(link=('vd_kpt3', 'vd_kpt2'), id=282, color=[128, 64, 255]),
- 283:
- dict(link=('vd_kpt6', 'vd_kpt1'), id=283, color=[128, 64, 255]),
- 284:
- dict(link=('sd_kpt1', 'sd_kpt2'), id=284, color=[128, 64, 0]),
- 285:
- dict(link=('sd_kpt2', 'sd_kpt8'), id=285, color=[128, 64, 0]),
- 286:
- dict(link=('sd_kpt8', 'sd_kpt9'), id=286, color=[128, 64, 0]),
- 287:
- dict(link=('sd_kpt9', 'sd_kpt10'), id=287, color=[128, 64, 0]),
- 288:
- dict(link=('sd_kpt10', 'sd_kpt11'), id=288, color=[128, 64, 0]),
- 289:
- dict(link=('sd_kpt11', 'sd_kpt12'), id=289, color=[128, 64, 0]),
- 290:
- dict(link=('sd_kpt12', 'sd_kpt13'), id=290, color=[128, 64, 0]),
- 291:
- dict(link=('sd_kpt13', 'sd_kpt14'), id=291, color=[128, 64, 0]),
- 292:
- dict(link=('sd_kpt14', 'sd_kpt15'), id=292, color=[128, 64, 0]),
- 293:
- dict(link=('sd_kpt15', 'sd_kpt16'), id=293, color=[128, 64, 0]),
- 294:
- dict(link=('sd_kpt16', 'sd_kpt17'), id=294, color=[128, 64, 0]),
- 295:
- dict(link=('sd_kpt17', 'sd_kpt18'), id=295, color=[128, 64, 0]),
- 296:
- dict(link=('sd_kpt18', 'sd_kpt6'), id=296, color=[128, 64, 0]),
- 297:
- dict(link=('sd_kpt6', 'sd_kpt5'), id=297, color=[128, 64, 0]),
- 298:
- dict(link=('sd_kpt5', 'sd_kpt4'), id=298, color=[128, 64, 0]),
- 299:
- dict(link=('sd_kpt4', 'sd_kpt3'), id=299, color=[128, 64, 0]),
- 300:
- dict(link=('sd_kpt3', 'sd_kpt2'), id=300, color=[128, 64, 0]),
- 301:
- dict(link=('sd_kpt2', 'sd_kpt7'), id=301, color=[128, 64, 0]),
- 302:
- dict(link=('sd_kpt6', 'sd_kpt19'), id=302, color=[128, 64, 0]),
- 303:
- dict(link=('sd_kpt6', 'sd_kpt1'), id=303, color=[128, 64, 0])
- }),
- joint_weights=[
- 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
- 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
- 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
- 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
- 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
- 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
- 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
- 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
- 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
- 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
- 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
- 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
- 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
- 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
- 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
- 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
- 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
- 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
- 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
- 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
- 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0
- ],
- sigmas=[])
-param_scheduler = [
- dict(
- type='LinearLR', begin=0, end=500, start_factor=0.001, by_epoch=False),
- dict(
- type='MultiStepLR',
- begin=0,
- end=120,
- milestones=[80, 100],
- gamma=0.1,
- by_epoch=True)
-]
-optim_wrapper = dict(optimizer=dict(type='Adam', lr=0.0005))
-auto_scale_lr = dict(base_batch_size=512)
-dataset_type = 'DeepFashion2Dataset'
-data_mode = 'topdown'
-data_root = 'data/deepfashion2/'
-codec = dict(
- type='MSRAHeatmap', input_size=(192, 256), heatmap_size=(48, 64), sigma=2)
-train_pipeline = [
- dict(type='LoadImage'),
- dict(type='GetBBoxCenterScale'),
- dict(type='RandomFlip', direction='horizontal'),
- dict(
- type='RandomBBoxTransform',
- shift_prob=0,
- rotate_factor=60,
- scale_factor=(0.75, 1.25)),
- dict(type='TopdownAffine', input_size=(192, 256)),
- dict(
- type='GenerateTarget',
- encoder=dict(
- type='MSRAHeatmap',
- input_size=(192, 256),
- heatmap_size=(48, 64),
- sigma=2)),
- dict(type='PackPoseInputs')
-]
-val_pipeline = [
- dict(type='LoadImage', backend_args=dict(backend='local')),
- dict(type='GetBBoxCenterScale'),
- dict(type='TopdownAffine', input_size=(192, 256)),
- dict(type='PackPoseInputs')
-]
-train_dataloader = dict(
- batch_size=64,
- num_workers=6,
- persistent_workers=True,
- sampler=dict(type='DefaultSampler', shuffle=True),
- dataset=dict(
- type='DeepFashion2Dataset',
- data_root='data/deepfashion2/',
- data_mode='topdown',
- ann_file='train/deepfashion2_vest.json',
- data_prefix=dict(img='train/image/'),
- pipeline=[
- dict(type='LoadImage'),
- dict(type='GetBBoxCenterScale'),
- dict(type='RandomFlip', direction='horizontal'),
- dict(
- type='RandomBBoxTransform',
- shift_prob=0,
- rotate_factor=60,
- scale_factor=(0.75, 1.25)),
- dict(type='TopdownAffine', input_size=(192, 256)),
- dict(
- type='GenerateTarget',
- encoder=dict(
- type='MSRAHeatmap',
- input_size=(192, 256),
- heatmap_size=(48, 64),
- sigma=2)),
- dict(type='PackPoseInputs')
- ]))
-val_dataloader = dict(
- batch_size=32,
- num_workers=6,
- persistent_workers=True,
- drop_last=False,
- sampler=dict(type='DefaultSampler', shuffle=False),
- dataset=dict(
- type='DeepFashion2Dataset',
- data_root='data/deepfashion2/',
- data_mode='topdown',
- ann_file='validation/deepfashion2_vest.json',
- data_prefix=dict(img='validation/image/'),
- test_mode=True,
- pipeline=[
- dict(type='LoadImage', backend_args=dict(backend='local')),
- dict(type='GetBBoxCenterScale'),
- dict(type='TopdownAffine', input_size=(192, 256)),
- dict(type='PackPoseInputs')
- ]))
-test_dataloader = dict(
- batch_size=32,
- num_workers=6,
- persistent_workers=True,
- drop_last=False,
- sampler=dict(type='DefaultSampler', shuffle=False),
- dataset=dict(
- type='DeepFashion2Dataset',
- data_root='data/deepfashion2/',
- data_mode='topdown',
- ann_file='validation/deepfashion2_vest.json',
- data_prefix=dict(img='validation/image/'),
- test_mode=True,
- pipeline=[
- dict(type='LoadImage', backend_args=dict(backend='local')),
- dict(type='GetBBoxCenterScale'),
- dict(type='TopdownAffine', input_size=(192, 256)),
- dict(type='PackPoseInputs')
- ]))
-channel_cfg = dict(
- num_output_channels=294,
- dataset_joints=294,
- dataset_channel=[[
- 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
- 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
- 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
- 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
- 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,
- 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107,
- 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
- 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135,
- 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149,
- 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163,
- 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177,
- 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
- 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205,
- 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219,
- 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233,
- 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247,
- 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261,
- 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275,
- 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289,
- 290, 291, 292, 293
- ]],
- inference_channel=[
- 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
- 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
- 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
- 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
- 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,
- 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107,
- 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
- 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135,
- 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149,
- 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163,
- 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177,
- 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
- 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205,
- 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219,
- 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233,
- 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247,
- 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261,
- 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275,
- 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289,
- 290, 291, 292, 293
- ])
-model = dict(
- type='TopdownPoseEstimator',
- data_preprocessor=dict(
- type='PoseDataPreprocessor',
- mean=[123.675, 116.28, 103.53],
- std=[58.395, 57.12, 57.375],
- bgr_to_rgb=True),
- backbone=dict(
- type='ResNet',
- depth=50,
- init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')),
- head=dict(
- type='HeatmapHead',
- in_channels=2048,
- out_channels=294,
- loss=dict(type='KeypointMSELoss', use_target_weight=True),
- decoder=dict(
- type='MSRAHeatmap',
- input_size=(192, 256),
- heatmap_size=(48, 64),
- sigma=2)),
- test_cfg=dict(flip_test=True, flip_mode='heatmap', shift_heatmap=True))
-val_evaluator = [
- dict(type='PCKAccuracy', thr=0.2),
- dict(type='AUC'),
- dict(type='EPE')
-]
-test_evaluator = [
- dict(type='PCKAccuracy', thr=0.2),
- dict(type='AUC'),
- dict(type='EPE')
-]
-launcher = 'pytorch'
-work_dir = './work_dirs/td_hm_res50_4xb64-120e_deepfashion2_vest_256x192'
diff --git a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/maker/YAMLMake.d.ts b/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/maker/YAMLMake.d.ts
deleted file mode 100644
index e2b225621796992d6002854700331fc5df314b19..0000000000000000000000000000000000000000
--- a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/maker/YAMLMake.d.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-import Builders from './builders/Builders';
-export default YAMLMake;
-
-declare namespace YAMLMake {
- type BuilderType = Builders.BuilderType;
- type BuildersType = { [name: string]: BuilderType }
-}
-
-declare function YAMLMake(
- scene: Phaser.Scene,
- data: Object | string,
- view?: Object | string,
- styles?: Object | string,
- customBuilders?: YAMLMake.BuildersType
-): Phaser.GameObjects.GameObject;
\ No newline at end of file
diff --git a/spaces/AiMimicry/sovits-models/data_utils.py b/spaces/AiMimicry/sovits-models/data_utils.py
deleted file mode 100644
index 7c76fd1c3a45b8304d916161718c7763874f3e35..0000000000000000000000000000000000000000
--- a/spaces/AiMimicry/sovits-models/data_utils.py
+++ /dev/null
@@ -1,155 +0,0 @@
-import time
-import os
-import random
-import numpy as np
-import torch
-import torch.utils.data
-
-import modules.commons as commons
-import utils
-from modules.mel_processing import spectrogram_torch, spec_to_mel_torch
-from utils import load_wav_to_torch, load_filepaths_and_text
-
-# import h5py
-
-
-"""Multi speaker version"""
-
-
-class TextAudioSpeakerLoader(torch.utils.data.Dataset):
- """
- 1) loads audio, speaker_id, text pairs
- 2) normalizes text and converts them to sequences of integers
- 3) computes spectrograms from audio files.
- """
-
- def __init__(self, audiopaths, hparams, all_in_mem: bool = False):
- self.audiopaths = load_filepaths_and_text(audiopaths)
- self.max_wav_value = hparams.data.max_wav_value
- self.sampling_rate = hparams.data.sampling_rate
- self.filter_length = hparams.data.filter_length
- self.hop_length = hparams.data.hop_length
- self.win_length = hparams.data.win_length
- self.sampling_rate = hparams.data.sampling_rate
- self.use_sr = hparams.train.use_sr
- self.spec_len = hparams.train.max_speclen
- self.spk_map = hparams.spk
-
- random.seed(1234)
- random.shuffle(self.audiopaths)
-
- self.all_in_mem = all_in_mem
- if self.all_in_mem:
- self.cache = [self.get_audio(p[0]) for p in self.audiopaths]
-
- def get_audio(self, filename):
- filename = filename.replace("\\", "/")
- audio, sampling_rate = load_wav_to_torch(filename)
- if sampling_rate != self.sampling_rate:
- raise ValueError("{} SR doesn't match target {} SR".format(
- sampling_rate, self.sampling_rate))
- audio_norm = audio / self.max_wav_value
- audio_norm = audio_norm.unsqueeze(0)
- spec_filename = filename.replace(".wav", ".spec.pt")
-
- # Ideally, all data generated after Mar 25 should have .spec.pt
- if os.path.exists(spec_filename):
- spec = torch.load(spec_filename)
- else:
- spec = spectrogram_torch(audio_norm, self.filter_length,
- self.sampling_rate, self.hop_length, self.win_length,
- center=False)
- spec = torch.squeeze(spec, 0)
- torch.save(spec, spec_filename)
-
- spk = filename.split("/")[-2]
- spk = torch.LongTensor([self.spk_map[spk]])
-
- f0 = np.load(filename + ".f0.npy")
- f0, uv = utils.interpolate_f0(f0)
- f0 = torch.FloatTensor(f0)
- uv = torch.FloatTensor(uv)
-
- c = torch.load(filename+ ".soft.pt")
- c = utils.repeat_expand_2d(c.squeeze(0), f0.shape[0])
-
-
- lmin = min(c.size(-1), spec.size(-1))
- assert abs(c.size(-1) - spec.size(-1)) < 3, (c.size(-1), spec.size(-1), f0.shape, filename)
- assert abs(audio_norm.shape[1]-lmin * self.hop_length) < 3 * self.hop_length
- spec, c, f0, uv = spec[:, :lmin], c[:, :lmin], f0[:lmin], uv[:lmin]
- audio_norm = audio_norm[:, :lmin * self.hop_length]
-
- return c, f0, spec, audio_norm, spk, uv
-
- def random_slice(self, c, f0, spec, audio_norm, spk, uv):
- # if spec.shape[1] < 30:
- # print("skip too short audio:", filename)
- # return None
- if spec.shape[1] > 800:
- start = random.randint(0, spec.shape[1]-800)
- end = start + 790
- spec, c, f0, uv = spec[:, start:end], c[:, start:end], f0[start:end], uv[start:end]
- audio_norm = audio_norm[:, start * self.hop_length : end * self.hop_length]
-
- return c, f0, spec, audio_norm, spk, uv
-
- def __getitem__(self, index):
- if self.all_in_mem:
- return self.random_slice(*self.cache[index])
- else:
- return self.random_slice(*self.get_audio(self.audiopaths[index][0]))
-
- def __len__(self):
- return len(self.audiopaths)
-
-
-class TextAudioCollate:
-
- def __call__(self, batch):
- batch = [b for b in batch if b is not None]
-
- input_lengths, ids_sorted_decreasing = torch.sort(
- torch.LongTensor([x[0].shape[1] for x in batch]),
- dim=0, descending=True)
-
- max_c_len = max([x[0].size(1) for x in batch])
- max_wav_len = max([x[3].size(1) for x in batch])
-
- lengths = torch.LongTensor(len(batch))
-
- c_padded = torch.FloatTensor(len(batch), batch[0][0].shape[0], max_c_len)
- f0_padded = torch.FloatTensor(len(batch), max_c_len)
- spec_padded = torch.FloatTensor(len(batch), batch[0][2].shape[0], max_c_len)
- wav_padded = torch.FloatTensor(len(batch), 1, max_wav_len)
- spkids = torch.LongTensor(len(batch), 1)
- uv_padded = torch.FloatTensor(len(batch), max_c_len)
-
- c_padded.zero_()
- spec_padded.zero_()
- f0_padded.zero_()
- wav_padded.zero_()
- uv_padded.zero_()
-
- for i in range(len(ids_sorted_decreasing)):
- row = batch[ids_sorted_decreasing[i]]
-
- c = row[0]
- c_padded[i, :, :c.size(1)] = c
- lengths[i] = c.size(1)
-
- f0 = row[1]
- f0_padded[i, :f0.size(0)] = f0
-
- spec = row[2]
- spec_padded[i, :, :spec.size(1)] = spec
-
- wav = row[3]
- wav_padded[i, :, :wav.size(1)] = wav
-
- spkids[i, 0] = row[4]
-
- uv = row[5]
- uv_padded[i, :uv.size(0)] = uv
-
- return c_padded, f0_padded, spec_padded, wav_padded, spkids, lengths, uv_padded
diff --git a/spaces/Aki004/herta-so-vits/modules/enhancer.py b/spaces/Aki004/herta-so-vits/modules/enhancer.py
deleted file mode 100644
index 37676311f7d8dc4ddc2a5244dedc27b2437e04f5..0000000000000000000000000000000000000000
--- a/spaces/Aki004/herta-so-vits/modules/enhancer.py
+++ /dev/null
@@ -1,105 +0,0 @@
-import numpy as np
-import torch
-import torch.nn.functional as F
-from vdecoder.nsf_hifigan.nvSTFT import STFT
-from vdecoder.nsf_hifigan.models import load_model
-from torchaudio.transforms import Resample
-
-class Enhancer:
- def __init__(self, enhancer_type, enhancer_ckpt, device=None):
- if device is None:
- device = 'cuda' if torch.cuda.is_available() else 'cpu'
- self.device = device
-
- if enhancer_type == 'nsf-hifigan':
- self.enhancer = NsfHifiGAN(enhancer_ckpt, device=self.device)
- else:
- raise ValueError(f" [x] Unknown enhancer: {enhancer_type}")
-
- self.resample_kernel = {}
- self.enhancer_sample_rate = self.enhancer.sample_rate()
- self.enhancer_hop_size = self.enhancer.hop_size()
-
- def enhance(self,
- audio, # 1, T
- sample_rate,
- f0, # 1, n_frames, 1
- hop_size,
- adaptive_key = 0,
- silence_front = 0
- ):
- # enhancer start time
- start_frame = int(silence_front * sample_rate / hop_size)
- real_silence_front = start_frame * hop_size / sample_rate
- audio = audio[:, int(np.round(real_silence_front * sample_rate)) : ]
- f0 = f0[: , start_frame :, :]
-
- # adaptive parameters
- adaptive_factor = 2 ** ( -adaptive_key / 12)
- adaptive_sample_rate = 100 * int(np.round(self.enhancer_sample_rate / adaptive_factor / 100))
- real_factor = self.enhancer_sample_rate / adaptive_sample_rate
-
- # resample the ddsp output
- if sample_rate == adaptive_sample_rate:
- audio_res = audio
- else:
- key_str = str(sample_rate) + str(adaptive_sample_rate)
- if key_str not in self.resample_kernel:
- self.resample_kernel[key_str] = Resample(sample_rate, adaptive_sample_rate, lowpass_filter_width = 128).to(self.device)
- audio_res = self.resample_kernel[key_str](audio)
-
- n_frames = int(audio_res.size(-1) // self.enhancer_hop_size + 1)
-
- # resample f0
- f0_np = f0.squeeze(0).squeeze(-1).cpu().numpy()
- f0_np *= real_factor
- time_org = (hop_size / sample_rate) * np.arange(len(f0_np)) / real_factor
- time_frame = (self.enhancer_hop_size / self.enhancer_sample_rate) * np.arange(n_frames)
- f0_res = np.interp(time_frame, time_org, f0_np, left=f0_np[0], right=f0_np[-1])
- f0_res = torch.from_numpy(f0_res).unsqueeze(0).float().to(self.device) # 1, n_frames
-
- # enhance
- enhanced_audio, enhancer_sample_rate = self.enhancer(audio_res, f0_res)
-
- # resample the enhanced output
- if adaptive_factor != 0:
- key_str = str(adaptive_sample_rate) + str(enhancer_sample_rate)
- if key_str not in self.resample_kernel:
- self.resample_kernel[key_str] = Resample(adaptive_sample_rate, enhancer_sample_rate, lowpass_filter_width = 128).to(self.device)
- enhanced_audio = self.resample_kernel[key_str](enhanced_audio)
-
- # pad the silence frames
- if start_frame > 0:
- enhanced_audio = F.pad(enhanced_audio, (int(np.round(enhancer_sample_rate * real_silence_front)), 0))
-
- return enhanced_audio, enhancer_sample_rate
-
-
-class NsfHifiGAN(torch.nn.Module):
- def __init__(self, model_path, device=None):
- super().__init__()
- if device is None:
- device = 'cuda' if torch.cuda.is_available() else 'cpu'
- self.device = device
- print('| Load HifiGAN: ', model_path)
- self.model, self.h = load_model(model_path, device=self.device)
-
- def sample_rate(self):
- return self.h.sampling_rate
-
- def hop_size(self):
- return self.h.hop_size
-
- def forward(self, audio, f0):
- stft = STFT(
- self.h.sampling_rate,
- self.h.num_mels,
- self.h.n_fft,
- self.h.win_size,
- self.h.hop_size,
- self.h.fmin,
- self.h.fmax)
- with torch.no_grad():
- mel = stft.get_mel(audio)
- enhanced_audio = self.model(mel, f0[:,:mel.size(-1)]).view(-1)
- return enhanced_audio, self.h.sampling_rate
\ No newline at end of file
diff --git a/spaces/Al-Chan/Vits_League_of_Legends_Yuumi_TTS/mel_processing.py b/spaces/Al-Chan/Vits_League_of_Legends_Yuumi_TTS/mel_processing.py
deleted file mode 100644
index 3614150259809983e776d3fed83021decca06a9c..0000000000000000000000000000000000000000
--- a/spaces/Al-Chan/Vits_League_of_Legends_Yuumi_TTS/mel_processing.py
+++ /dev/null
@@ -1,112 +0,0 @@
-import math
-import os
-import random
-import torch
-from torch import nn
-import torch.nn.functional as F
-import torch.utils.data
-import numpy as np
-import librosa
-import librosa.util as librosa_util
-from librosa.util import normalize, pad_center, tiny
-from scipy.signal import get_window
-from scipy.io.wavfile import read
-from librosa.filters import mel as librosa_mel_fn
-
-MAX_WAV_VALUE = 32768.0
-
-
-def dynamic_range_compression_torch(x, C=1, clip_val=1e-5):
- """
- PARAMS
- ------
- C: compression factor
- """
- return torch.log(torch.clamp(x, min=clip_val) * C)
-
-
-def dynamic_range_decompression_torch(x, C=1):
- """
- PARAMS
- ------
- C: compression factor used to compress
- """
- return torch.exp(x) / C
-
-
-def spectral_normalize_torch(magnitudes):
- output = dynamic_range_compression_torch(magnitudes)
- return output
-
-
-def spectral_de_normalize_torch(magnitudes):
- output = dynamic_range_decompression_torch(magnitudes)
- return output
-
-
-mel_basis = {}
-hann_window = {}
-
-
-def spectrogram_torch(y, n_fft, sampling_rate, hop_size, win_size, center=False):
- if torch.min(y) < -1.:
- print('min value is ', torch.min(y))
- if torch.max(y) > 1.:
- print('max value is ', torch.max(y))
-
- global hann_window
- dtype_device = str(y.dtype) + '_' + str(y.device)
- wnsize_dtype_device = str(win_size) + '_' + dtype_device
- if wnsize_dtype_device not in hann_window:
- hann_window[wnsize_dtype_device] = torch.hann_window(win_size).to(dtype=y.dtype, device=y.device)
-
- y = torch.nn.functional.pad(y.unsqueeze(1), (int((n_fft-hop_size)/2), int((n_fft-hop_size)/2)), mode='reflect')
- y = y.squeeze(1)
-
- spec = torch.stft(y, n_fft, hop_length=hop_size, win_length=win_size, window=hann_window[wnsize_dtype_device],
- center=center, pad_mode='reflect', normalized=False, onesided=True, return_complex=False)
-
- spec = torch.sqrt(spec.pow(2).sum(-1) + 1e-6)
- return spec
-
-
-def spec_to_mel_torch(spec, n_fft, num_mels, sampling_rate, fmin, fmax):
- global mel_basis
- dtype_device = str(spec.dtype) + '_' + str(spec.device)
- fmax_dtype_device = str(fmax) + '_' + dtype_device
- if fmax_dtype_device not in mel_basis:
- mel = librosa_mel_fn(sampling_rate, n_fft, num_mels, fmin, fmax)
- mel_basis[fmax_dtype_device] = torch.from_numpy(mel).to(dtype=spec.dtype, device=spec.device)
- spec = torch.matmul(mel_basis[fmax_dtype_device], spec)
- spec = spectral_normalize_torch(spec)
- return spec
-
-
-def mel_spectrogram_torch(y, n_fft, num_mels, sampling_rate, hop_size, win_size, fmin, fmax, center=False):
- if torch.min(y) < -1.:
- print('min value is ', torch.min(y))
- if torch.max(y) > 1.:
- print('max value is ', torch.max(y))
-
- global mel_basis, hann_window
- dtype_device = str(y.dtype) + '_' + str(y.device)
- fmax_dtype_device = str(fmax) + '_' + dtype_device
- wnsize_dtype_device = str(win_size) + '_' + dtype_device
- if fmax_dtype_device not in mel_basis:
- mel = librosa_mel_fn(sampling_rate, n_fft, num_mels, fmin, fmax)
- mel_basis[fmax_dtype_device] = torch.from_numpy(mel).to(dtype=y.dtype, device=y.device)
- if wnsize_dtype_device not in hann_window:
- hann_window[wnsize_dtype_device] = torch.hann_window(win_size).to(dtype=y.dtype, device=y.device)
-
- y = torch.nn.functional.pad(y.unsqueeze(1), (int((n_fft-hop_size)/2), int((n_fft-hop_size)/2)), mode='reflect')
- y = y.squeeze(1)
-
- spec = torch.stft(y.float(), n_fft, hop_length=hop_size, win_length=win_size, window=hann_window[wnsize_dtype_device],
- center=center, pad_mode='reflect', normalized=False, onesided=True, return_complex=False)
-
- spec = torch.sqrt(spec.pow(2).sum(-1) + 1e-6)
-
- spec = torch.matmul(mel_basis[fmax_dtype_device], spec)
- spec = spectral_normalize_torch(spec)
-
- return spec
diff --git a/spaces/Alesmikes/Elvirespeak/README.md b/spaces/Alesmikes/Elvirespeak/README.md
deleted file mode 100644
index 282cf0ea4e4017c353a759079eae33673000ff2e..0000000000000000000000000000000000000000
--- a/spaces/Alesmikes/Elvirespeak/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: QnA
-emoji: 📈
-colorFrom: indigo
-colorTo: yellow
-sdk: gradio
-sdk_version: 3.24.1
-app_file: app.py
-pinned: false
-duplicated_from: GenAIDemo/economic-forecast
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/AlexWang/lama/saicinpainting/training/trainers/default.py b/spaces/AlexWang/lama/saicinpainting/training/trainers/default.py
deleted file mode 100644
index 86c7f0fab42924bfc93a031e851117634c70f593..0000000000000000000000000000000000000000
--- a/spaces/AlexWang/lama/saicinpainting/training/trainers/default.py
+++ /dev/null
@@ -1,175 +0,0 @@
-import logging
-
-import torch
-import torch.nn.functional as F
-from omegaconf import OmegaConf
-
-from saicinpainting.training.data.datasets import make_constant_area_crop_params
-from saicinpainting.training.losses.distance_weighting import make_mask_distance_weighter
-from saicinpainting.training.losses.feature_matching import feature_matching_loss, masked_l1_loss
-from saicinpainting.training.modules.fake_fakes import FakeFakesGenerator
-from saicinpainting.training.trainers.base import BaseInpaintingTrainingModule, make_multiscale_noise
-from saicinpainting.utils import add_prefix_to_keys, get_ramp
-
-LOGGER = logging.getLogger(__name__)
-
-
-def make_constant_area_crop_batch(batch, **kwargs):
- crop_y, crop_x, crop_height, crop_width = make_constant_area_crop_params(img_height=batch['image'].shape[2],
- img_width=batch['image'].shape[3],
- **kwargs)
- batch['image'] = batch['image'][:, :, crop_y : crop_y + crop_height, crop_x : crop_x + crop_width]
- batch['mask'] = batch['mask'][:, :, crop_y: crop_y + crop_height, crop_x: crop_x + crop_width]
- return batch
-
-
-class DefaultInpaintingTrainingModule(BaseInpaintingTrainingModule):
- def __init__(self, *args, concat_mask=True, rescale_scheduler_kwargs=None, image_to_discriminator='predicted_image',
- add_noise_kwargs=None, noise_fill_hole=False, const_area_crop_kwargs=None,
- distance_weighter_kwargs=None, distance_weighted_mask_for_discr=False,
- fake_fakes_proba=0, fake_fakes_generator_kwargs=None,
- **kwargs):
- super().__init__(*args, **kwargs)
- self.concat_mask = concat_mask
- self.rescale_size_getter = get_ramp(**rescale_scheduler_kwargs) if rescale_scheduler_kwargs is not None else None
- self.image_to_discriminator = image_to_discriminator
- self.add_noise_kwargs = add_noise_kwargs
- self.noise_fill_hole = noise_fill_hole
- self.const_area_crop_kwargs = const_area_crop_kwargs
- self.refine_mask_for_losses = make_mask_distance_weighter(**distance_weighter_kwargs) \
- if distance_weighter_kwargs is not None else None
- self.distance_weighted_mask_for_discr = distance_weighted_mask_for_discr
-
- self.fake_fakes_proba = fake_fakes_proba
- if self.fake_fakes_proba > 1e-3:
- self.fake_fakes_gen = FakeFakesGenerator(**(fake_fakes_generator_kwargs or {}))
-
- def forward(self, batch):
- if self.training and self.rescale_size_getter is not None:
- cur_size = self.rescale_size_getter(self.global_step)
- batch['image'] = F.interpolate(batch['image'], size=cur_size, mode='bilinear', align_corners=False)
- batch['mask'] = F.interpolate(batch['mask'], size=cur_size, mode='nearest')
-
- if self.training and self.const_area_crop_kwargs is not None:
- batch = make_constant_area_crop_batch(batch, **self.const_area_crop_kwargs)
-
- img = batch['image']
- mask = batch['mask']
-
- masked_img = img * (1 - mask)
-
- if self.add_noise_kwargs is not None:
- noise = make_multiscale_noise(masked_img, **self.add_noise_kwargs)
- if self.noise_fill_hole:
- masked_img = masked_img + mask * noise[:, :masked_img.shape[1]]
- masked_img = torch.cat([masked_img, noise], dim=1)
-
- if self.concat_mask:
- masked_img = torch.cat([masked_img, mask], dim=1)
-
- batch['predicted_image'] = self.generator(masked_img)
- batch['inpainted'] = mask * batch['predicted_image'] + (1 - mask) * batch['image']
-
- if self.fake_fakes_proba > 1e-3:
- if self.training and torch.rand(1).item() < self.fake_fakes_proba:
- batch['fake_fakes'], batch['fake_fakes_masks'] = self.fake_fakes_gen(img, mask)
- batch['use_fake_fakes'] = True
- else:
- batch['fake_fakes'] = torch.zeros_like(img)
- batch['fake_fakes_masks'] = torch.zeros_like(mask)
- batch['use_fake_fakes'] = False
-
- batch['mask_for_losses'] = self.refine_mask_for_losses(img, batch['predicted_image'], mask) \
- if self.refine_mask_for_losses is not None and self.training \
- else mask
-
- return batch
-
- def generator_loss(self, batch):
- img = batch['image']
- predicted_img = batch[self.image_to_discriminator]
- original_mask = batch['mask']
- supervised_mask = batch['mask_for_losses']
-
- # L1
- l1_value = masked_l1_loss(predicted_img, img, supervised_mask,
- self.config.losses.l1.weight_known,
- self.config.losses.l1.weight_missing)
-
- total_loss = l1_value
- metrics = dict(gen_l1=l1_value)
-
- # vgg-based perceptual loss
- if self.config.losses.perceptual.weight > 0:
- pl_value = self.loss_pl(predicted_img, img, mask=supervised_mask).sum() * self.config.losses.perceptual.weight
- total_loss = total_loss + pl_value
- metrics['gen_pl'] = pl_value
-
- # discriminator
- # adversarial_loss calls backward by itself
- mask_for_discr = supervised_mask if self.distance_weighted_mask_for_discr else original_mask
- self.adversarial_loss.pre_generator_step(real_batch=img, fake_batch=predicted_img,
- generator=self.generator, discriminator=self.discriminator)
- discr_real_pred, discr_real_features = self.discriminator(img)
- discr_fake_pred, discr_fake_features = self.discriminator(predicted_img)
- adv_gen_loss, adv_metrics = self.adversarial_loss.generator_loss(real_batch=img,
- fake_batch=predicted_img,
- discr_real_pred=discr_real_pred,
- discr_fake_pred=discr_fake_pred,
- mask=mask_for_discr)
- total_loss = total_loss + adv_gen_loss
- metrics['gen_adv'] = adv_gen_loss
- metrics.update(add_prefix_to_keys(adv_metrics, 'adv_'))
-
- # feature matching
- if self.config.losses.feature_matching.weight > 0:
- need_mask_in_fm = OmegaConf.to_container(self.config.losses.feature_matching).get('pass_mask', False)
- mask_for_fm = supervised_mask if need_mask_in_fm else None
- fm_value = feature_matching_loss(discr_fake_features, discr_real_features,
- mask=mask_for_fm) * self.config.losses.feature_matching.weight
- total_loss = total_loss + fm_value
- metrics['gen_fm'] = fm_value
-
- if self.loss_resnet_pl is not None:
- resnet_pl_value = self.loss_resnet_pl(predicted_img, img)
- total_loss = total_loss + resnet_pl_value
- metrics['gen_resnet_pl'] = resnet_pl_value
-
- return total_loss, metrics
-
- def discriminator_loss(self, batch):
- total_loss = 0
- metrics = {}
-
- predicted_img = batch[self.image_to_discriminator].detach()
- self.adversarial_loss.pre_discriminator_step(real_batch=batch['image'], fake_batch=predicted_img,
- generator=self.generator, discriminator=self.discriminator)
- discr_real_pred, discr_real_features = self.discriminator(batch['image'])
- discr_fake_pred, discr_fake_features = self.discriminator(predicted_img)
- adv_discr_loss, adv_metrics = self.adversarial_loss.discriminator_loss(real_batch=batch['image'],
- fake_batch=predicted_img,
- discr_real_pred=discr_real_pred,
- discr_fake_pred=discr_fake_pred,
- mask=batch['mask'])
- total_loss = total_loss + adv_discr_loss
- metrics['discr_adv'] = adv_discr_loss
- metrics.update(add_prefix_to_keys(adv_metrics, 'adv_'))
-
-
- if batch.get('use_fake_fakes', False):
- fake_fakes = batch['fake_fakes']
- self.adversarial_loss.pre_discriminator_step(real_batch=batch['image'], fake_batch=fake_fakes,
- generator=self.generator, discriminator=self.discriminator)
- discr_fake_fakes_pred, _ = self.discriminator(fake_fakes)
- fake_fakes_adv_discr_loss, fake_fakes_adv_metrics = self.adversarial_loss.discriminator_loss(
- real_batch=batch['image'],
- fake_batch=fake_fakes,
- discr_real_pred=discr_real_pred,
- discr_fake_pred=discr_fake_fakes_pred,
- mask=batch['mask']
- )
- total_loss = total_loss + fake_fakes_adv_discr_loss
- metrics['discr_adv_fake_fakes'] = fake_fakes_adv_discr_loss
- metrics.update(add_prefix_to_keys(fake_fakes_adv_metrics, 'adv_'))
-
- return total_loss, metrics
diff --git a/spaces/Alycer/VITS-Umamusume-voice-synthesizer/modules.py b/spaces/Alycer/VITS-Umamusume-voice-synthesizer/modules.py
deleted file mode 100644
index f5af1fd9a20dc03707889f360a39bb4b784a6df3..0000000000000000000000000000000000000000
--- a/spaces/Alycer/VITS-Umamusume-voice-synthesizer/modules.py
+++ /dev/null
@@ -1,387 +0,0 @@
-import math
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-from torch.nn import Conv1d
-from torch.nn.utils import weight_norm, remove_weight_norm
-
-import commons
-from commons import init_weights, get_padding
-from transforms import piecewise_rational_quadratic_transform
-
-
-LRELU_SLOPE = 0.1
-
-
-class LayerNorm(nn.Module):
- def __init__(self, channels, eps=1e-5):
- super().__init__()
- self.channels = channels
- self.eps = eps
-
- self.gamma = nn.Parameter(torch.ones(channels))
- self.beta = nn.Parameter(torch.zeros(channels))
-
- def forward(self, x):
- x = x.transpose(1, -1)
- x = F.layer_norm(x, (self.channels,), self.gamma, self.beta, self.eps)
- return x.transpose(1, -1)
-
-
-class ConvReluNorm(nn.Module):
- def __init__(self, in_channels, hidden_channels, out_channels, kernel_size, n_layers, p_dropout):
- super().__init__()
- self.in_channels = in_channels
- self.hidden_channels = hidden_channels
- self.out_channels = out_channels
- self.kernel_size = kernel_size
- self.n_layers = n_layers
- self.p_dropout = p_dropout
- assert n_layers > 1, "Number of layers should be larger than 0."
-
- self.conv_layers = nn.ModuleList()
- self.norm_layers = nn.ModuleList()
- self.conv_layers.append(nn.Conv1d(in_channels, hidden_channels, kernel_size, padding=kernel_size//2))
- self.norm_layers.append(LayerNorm(hidden_channels))
- self.relu_drop = nn.Sequential(
- nn.ReLU(),
- nn.Dropout(p_dropout))
- for _ in range(n_layers-1):
- self.conv_layers.append(nn.Conv1d(hidden_channels, hidden_channels, kernel_size, padding=kernel_size//2))
- self.norm_layers.append(LayerNorm(hidden_channels))
- self.proj = nn.Conv1d(hidden_channels, out_channels, 1)
- self.proj.weight.data.zero_()
- self.proj.bias.data.zero_()
-
- def forward(self, x, x_mask):
- x_org = x
- for i in range(self.n_layers):
- x = self.conv_layers[i](x * x_mask)
- x = self.norm_layers[i](x)
- x = self.relu_drop(x)
- x = x_org + self.proj(x)
- return x * x_mask
-
-
-class DDSConv(nn.Module):
- """
- Dialted and Depth-Separable Convolution
- """
- def __init__(self, channels, kernel_size, n_layers, p_dropout=0.):
- super().__init__()
- self.channels = channels
- self.kernel_size = kernel_size
- self.n_layers = n_layers
- self.p_dropout = p_dropout
-
- self.drop = nn.Dropout(p_dropout)
- self.convs_sep = nn.ModuleList()
- self.convs_1x1 = nn.ModuleList()
- self.norms_1 = nn.ModuleList()
- self.norms_2 = nn.ModuleList()
- for i in range(n_layers):
- dilation = kernel_size ** i
- padding = (kernel_size * dilation - dilation) // 2
- self.convs_sep.append(nn.Conv1d(channels, channels, kernel_size,
- groups=channels, dilation=dilation, padding=padding
- ))
- self.convs_1x1.append(nn.Conv1d(channels, channels, 1))
- self.norms_1.append(LayerNorm(channels))
- self.norms_2.append(LayerNorm(channels))
-
- def forward(self, x, x_mask, g=None):
- if g is not None:
- x = x + g
- for i in range(self.n_layers):
- y = self.convs_sep[i](x * x_mask)
- y = self.norms_1[i](y)
- y = F.gelu(y)
- y = self.convs_1x1[i](y)
- y = self.norms_2[i](y)
- y = F.gelu(y)
- y = self.drop(y)
- x = x + y
- return x * x_mask
-
-
-class WN(torch.nn.Module):
- def __init__(self, hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=0, p_dropout=0):
- super(WN, self).__init__()
- assert(kernel_size % 2 == 1)
- 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.p_dropout = p_dropout
-
- self.in_layers = torch.nn.ModuleList()
- self.res_skip_layers = torch.nn.ModuleList()
- self.drop = nn.Dropout(p_dropout)
-
- if gin_channels != 0:
- cond_layer = torch.nn.Conv1d(gin_channels, 2*hidden_channels*n_layers, 1)
- self.cond_layer = torch.nn.utils.weight_norm(cond_layer, name='weight')
-
- for i in range(n_layers):
- dilation = dilation_rate ** i
- padding = int((kernel_size * dilation - dilation) / 2)
- in_layer = torch.nn.Conv1d(hidden_channels, 2*hidden_channels, kernel_size,
- dilation=dilation, padding=padding)
- in_layer = torch.nn.utils.weight_norm(in_layer, name='weight')
- self.in_layers.append(in_layer)
-
- # last one is not necessary
- if i < n_layers - 1:
- res_skip_channels = 2 * hidden_channels
- else:
- res_skip_channels = hidden_channels
-
- res_skip_layer = torch.nn.Conv1d(hidden_channels, res_skip_channels, 1)
- res_skip_layer = torch.nn.utils.weight_norm(res_skip_layer, name='weight')
- self.res_skip_layers.append(res_skip_layer)
-
- def forward(self, x, x_mask, g=None, **kwargs):
- output = torch.zeros_like(x)
- n_channels_tensor = torch.IntTensor([self.hidden_channels])
-
- if g is not None:
- g = self.cond_layer(g)
-
- for i in range(self.n_layers):
- x_in = self.in_layers[i](x)
- if g is not None:
- cond_offset = i * 2 * self.hidden_channels
- g_l = g[:,cond_offset:cond_offset+2*self.hidden_channels,:]
- else:
- g_l = torch.zeros_like(x_in)
-
- acts = commons.fused_add_tanh_sigmoid_multiply(
- x_in,
- g_l,
- n_channels_tensor)
- acts = self.drop(acts)
-
- res_skip_acts = self.res_skip_layers[i](acts)
- if i < self.n_layers - 1:
- res_acts = res_skip_acts[:,:self.hidden_channels,:]
- x = (x + res_acts) * x_mask
- output = output + res_skip_acts[:,self.hidden_channels:,:]
- else:
- output = output + res_skip_acts
- return output * x_mask
-
- def remove_weight_norm(self):
- if self.gin_channels != 0:
- torch.nn.utils.remove_weight_norm(self.cond_layer)
- for l in self.in_layers:
- torch.nn.utils.remove_weight_norm(l)
- for l in self.res_skip_layers:
- torch.nn.utils.remove_weight_norm(l)
-
-
-class ResBlock1(torch.nn.Module):
- def __init__(self, channels, kernel_size=3, dilation=(1, 3, 5)):
- super(ResBlock1, self).__init__()
- self.convs1 = nn.ModuleList([
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[0],
- padding=get_padding(kernel_size, dilation[0]))),
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[1],
- padding=get_padding(kernel_size, dilation[1]))),
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[2],
- padding=get_padding(kernel_size, dilation[2])))
- ])
- self.convs1.apply(init_weights)
-
- self.convs2 = nn.ModuleList([
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
- padding=get_padding(kernel_size, 1))),
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
- padding=get_padding(kernel_size, 1))),
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
- padding=get_padding(kernel_size, 1)))
- ])
- self.convs2.apply(init_weights)
-
- def forward(self, x, x_mask=None):
- for c1, c2 in zip(self.convs1, self.convs2):
- xt = F.leaky_relu(x, LRELU_SLOPE)
- if x_mask is not None:
- xt = xt * x_mask
- xt = c1(xt)
- xt = F.leaky_relu(xt, LRELU_SLOPE)
- if x_mask is not None:
- xt = xt * x_mask
- xt = c2(xt)
- x = xt + x
- if x_mask is not None:
- x = x * x_mask
- return x
-
- def remove_weight_norm(self):
- for l in self.convs1:
- remove_weight_norm(l)
- for l in self.convs2:
- remove_weight_norm(l)
-
-
-class ResBlock2(torch.nn.Module):
- def __init__(self, channels, kernel_size=3, dilation=(1, 3)):
- super(ResBlock2, self).__init__()
- self.convs = nn.ModuleList([
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[0],
- padding=get_padding(kernel_size, dilation[0]))),
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[1],
- padding=get_padding(kernel_size, dilation[1])))
- ])
- self.convs.apply(init_weights)
-
- def forward(self, x, x_mask=None):
- for c in self.convs:
- xt = F.leaky_relu(x, LRELU_SLOPE)
- if x_mask is not None:
- xt = xt * x_mask
- xt = c(xt)
- x = xt + x
- if x_mask is not None:
- x = x * x_mask
- return x
-
- def remove_weight_norm(self):
- for l in self.convs:
- remove_weight_norm(l)
-
-
-class Log(nn.Module):
- def forward(self, x, x_mask, reverse=False, **kwargs):
- if not reverse:
- y = torch.log(torch.clamp_min(x, 1e-5)) * x_mask
- logdet = torch.sum(-y, [1, 2])
- return y, logdet
- else:
- x = torch.exp(x) * x_mask
- return x
-
-
-class Flip(nn.Module):
- def forward(self, x, *args, reverse=False, **kwargs):
- x = torch.flip(x, [1])
- if not reverse:
- logdet = torch.zeros(x.size(0)).to(dtype=x.dtype, device=x.device)
- return x, logdet
- else:
- return x
-
-
-class ElementwiseAffine(nn.Module):
- def __init__(self, channels):
- super().__init__()
- self.channels = channels
- self.m = nn.Parameter(torch.zeros(channels,1))
- self.logs = nn.Parameter(torch.zeros(channels,1))
-
- def forward(self, x, x_mask, reverse=False, **kwargs):
- if not reverse:
- y = self.m + torch.exp(self.logs) * x
- y = y * x_mask
- logdet = torch.sum(self.logs * x_mask, [1,2])
- return y, logdet
- else:
- x = (x - self.m) * torch.exp(-self.logs) * x_mask
- return x
-
-
-class ResidualCouplingLayer(nn.Module):
- def __init__(self,
- channels,
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- p_dropout=0,
- gin_channels=0,
- mean_only=False):
- assert channels % 2 == 0, "channels should be divisible by 2"
- 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.half_channels = channels // 2
- self.mean_only = mean_only
-
- self.pre = nn.Conv1d(self.half_channels, hidden_channels, 1)
- self.enc = WN(hidden_channels, kernel_size, dilation_rate, n_layers, p_dropout=p_dropout, gin_channels=gin_channels)
- self.post = nn.Conv1d(hidden_channels, self.half_channels * (2 - mean_only), 1)
- self.post.weight.data.zero_()
- self.post.bias.data.zero_()
-
- def forward(self, x, x_mask, g=None, reverse=False):
- x0, x1 = torch.split(x, [self.half_channels]*2, 1)
- h = self.pre(x0) * x_mask
- h = self.enc(h, x_mask, g=g)
- stats = self.post(h) * x_mask
- if not self.mean_only:
- m, logs = torch.split(stats, [self.half_channels]*2, 1)
- else:
- m = stats
- logs = torch.zeros_like(m)
-
- if not reverse:
- x1 = m + x1 * torch.exp(logs) * x_mask
- x = torch.cat([x0, x1], 1)
- logdet = torch.sum(logs, [1,2])
- return x, logdet
- else:
- x1 = (x1 - m) * torch.exp(-logs) * x_mask
- x = torch.cat([x0, x1], 1)
- return x
-
-
-class ConvFlow(nn.Module):
- def __init__(self, in_channels, filter_channels, kernel_size, n_layers, num_bins=10, tail_bound=5.0):
- super().__init__()
- self.in_channels = in_channels
- self.filter_channels = filter_channels
- self.kernel_size = kernel_size
- self.n_layers = n_layers
- self.num_bins = num_bins
- self.tail_bound = tail_bound
- self.half_channels = in_channels // 2
-
- self.pre = nn.Conv1d(self.half_channels, filter_channels, 1)
- self.convs = DDSConv(filter_channels, kernel_size, n_layers, p_dropout=0.)
- self.proj = nn.Conv1d(filter_channels, self.half_channels * (num_bins * 3 - 1), 1)
- self.proj.weight.data.zero_()
- self.proj.bias.data.zero_()
-
- def forward(self, x, x_mask, g=None, reverse=False):
- x0, x1 = torch.split(x, [self.half_channels]*2, 1)
- h = self.pre(x0)
- h = self.convs(h, x_mask, g=g)
- h = self.proj(h) * x_mask
-
- b, c, t = x0.shape
- h = h.reshape(b, c, -1, t).permute(0, 1, 3, 2) # [b, cx?, t] -> [b, c, t, ?]
-
- unnormalized_widths = h[..., :self.num_bins] / math.sqrt(self.filter_channels)
- unnormalized_heights = h[..., self.num_bins:2*self.num_bins] / math.sqrt(self.filter_channels)
- unnormalized_derivatives = h[..., 2 * self.num_bins:]
-
- x1, logabsdet = piecewise_rational_quadratic_transform(x1,
- unnormalized_widths,
- unnormalized_heights,
- unnormalized_derivatives,
- inverse=reverse,
- tails='linear',
- tail_bound=self.tail_bound
- )
-
- x = torch.cat([x0, x1], 1) * x_mask
- logdet = torch.sum(logabsdet * x_mask, [1,2])
- if not reverse:
- return x, logdet
- else:
- return x
diff --git a/spaces/Amrrs/DragGan-Inversion/stylegan_human/training/augment.py b/spaces/Amrrs/DragGan-Inversion/stylegan_human/training/augment.py
deleted file mode 100644
index 8067f4e3fec058c9025edaa7a9a0442afe859ae5..0000000000000000000000000000000000000000
--- a/spaces/Amrrs/DragGan-Inversion/stylegan_human/training/augment.py
+++ /dev/null
@@ -1,562 +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.
-
-"""Augmentation pipeline from the paper
-"Training Generative Adversarial Networks with Limited Data".
-Matches the original implementation by Karras et al. at
-https://github.com/NVlabs/stylegan2-ada/blob/main/training/augment.py"""
-
-import numpy as np
-import scipy.signal
-import torch
-from torch_utils import persistence
-from torch_utils import misc
-from torch_utils.ops import upfirdn2d
-from torch_utils.ops import grid_sample_gradfix
-from torch_utils.ops import conv2d_gradfix
-
-# ----------------------------------------------------------------------------
-# Coefficients of various wavelet decomposition low-pass filters.
-
-wavelets = {
- 'haar': [0.7071067811865476, 0.7071067811865476],
- 'db1': [0.7071067811865476, 0.7071067811865476],
- 'db2': [-0.12940952255092145, 0.22414386804185735, 0.836516303737469, 0.48296291314469025],
- 'db3': [0.035226291882100656, -0.08544127388224149, -0.13501102001039084, 0.4598775021193313, 0.8068915093133388, 0.3326705529509569],
- 'db4': [-0.010597401784997278, 0.032883011666982945, 0.030841381835986965, -0.18703481171888114, -0.02798376941698385, 0.6308807679295904, 0.7148465705525415, 0.23037781330885523],
- 'db5': [0.003335725285001549, -0.012580751999015526, -0.006241490213011705, 0.07757149384006515, -0.03224486958502952, -0.24229488706619015, 0.13842814590110342, 0.7243085284385744, 0.6038292697974729, 0.160102397974125],
- 'db6': [-0.00107730108499558, 0.004777257511010651, 0.0005538422009938016, -0.031582039318031156, 0.02752286553001629, 0.09750160558707936, -0.12976686756709563, -0.22626469396516913, 0.3152503517092432, 0.7511339080215775, 0.4946238903983854, 0.11154074335008017],
- 'db7': [0.0003537138000010399, -0.0018016407039998328, 0.00042957797300470274, 0.012550998556013784, -0.01657454163101562, -0.03802993693503463, 0.0806126091510659, 0.07130921926705004, -0.22403618499416572, -0.14390600392910627, 0.4697822874053586, 0.7291320908465551, 0.39653931948230575, 0.07785205408506236],
- 'db8': [-0.00011747678400228192, 0.0006754494059985568, -0.0003917403729959771, -0.00487035299301066, 0.008746094047015655, 0.013981027917015516, -0.04408825393106472, -0.01736930100202211, 0.128747426620186, 0.00047248457399797254, -0.2840155429624281, -0.015829105256023893, 0.5853546836548691, 0.6756307362980128, 0.3128715909144659, 0.05441584224308161],
- 'sym2': [-0.12940952255092145, 0.22414386804185735, 0.836516303737469, 0.48296291314469025],
- 'sym3': [0.035226291882100656, -0.08544127388224149, -0.13501102001039084, 0.4598775021193313, 0.8068915093133388, 0.3326705529509569],
- 'sym4': [-0.07576571478927333, -0.02963552764599851, 0.49761866763201545, 0.8037387518059161, 0.29785779560527736, -0.09921954357684722, -0.012603967262037833, 0.0322231006040427],
- 'sym5': [0.027333068345077982, 0.029519490925774643, -0.039134249302383094, 0.1993975339773936, 0.7234076904024206, 0.6339789634582119, 0.01660210576452232, -0.17532808990845047, -0.021101834024758855, 0.019538882735286728],
- 'sym6': [0.015404109327027373, 0.0034907120842174702, -0.11799011114819057, -0.048311742585633, 0.4910559419267466, 0.787641141030194, 0.3379294217276218, -0.07263752278646252, -0.021060292512300564, 0.04472490177066578, 0.0017677118642428036, -0.007800708325034148],
- 'sym7': [0.002681814568257878, -0.0010473848886829163, -0.01263630340325193, 0.03051551316596357, 0.0678926935013727, -0.049552834937127255, 0.017441255086855827, 0.5361019170917628, 0.767764317003164, 0.2886296317515146, -0.14004724044296152, -0.10780823770381774, 0.004010244871533663, 0.010268176708511255],
- 'sym8': [-0.0033824159510061256, -0.0005421323317911481, 0.03169508781149298, 0.007607487324917605, -0.1432942383508097, -0.061273359067658524, 0.4813596512583722, 0.7771857517005235, 0.3644418948353314, -0.05194583810770904, -0.027219029917056003, 0.049137179673607506, 0.003808752013890615, -0.01495225833704823, -0.0003029205147213668, 0.0018899503327594609],
-}
-
-# ----------------------------------------------------------------------------
-# Helpers for constructing transformation matrices.
-
-
-def matrix(*rows, device=None):
- assert all(len(row) == len(rows[0]) for row in rows)
- elems = [x for row in rows for x in row]
- ref = [x for x in elems if isinstance(x, torch.Tensor)]
- if len(ref) == 0:
- return misc.constant(np.asarray(rows), device=device)
- assert device is None or device == ref[0].device
- elems = [x if isinstance(x, torch.Tensor) else misc.constant(
- x, shape=ref[0].shape, device=ref[0].device) for x in elems]
- return torch.stack(elems, dim=-1).reshape(ref[0].shape + (len(rows), -1))
-
-
-def translate2d(tx, ty, **kwargs):
- return matrix(
- [1, 0, tx],
- [0, 1, ty],
- [0, 0, 1],
- **kwargs)
-
-
-def translate3d(tx, ty, tz, **kwargs):
- return matrix(
- [1, 0, 0, tx],
- [0, 1, 0, ty],
- [0, 0, 1, tz],
- [0, 0, 0, 1],
- **kwargs)
-
-
-def scale2d(sx, sy, **kwargs):
- return matrix(
- [sx, 0, 0],
- [0, sy, 0],
- [0, 0, 1],
- **kwargs)
-
-
-def scale3d(sx, sy, sz, **kwargs):
- return matrix(
- [sx, 0, 0, 0],
- [0, sy, 0, 0],
- [0, 0, sz, 0],
- [0, 0, 0, 1],
- **kwargs)
-
-
-def rotate2d(theta, **kwargs):
- return matrix(
- [torch.cos(theta), torch.sin(-theta), 0],
- [torch.sin(theta), torch.cos(theta), 0],
- [0, 0, 1],
- **kwargs)
-
-
-def rotate3d(v, theta, **kwargs):
- vx = v[..., 0]
- vy = v[..., 1]
- vz = v[..., 2]
- s = torch.sin(theta)
- c = torch.cos(theta)
- cc = 1 - c
- return matrix(
- [vx*vx*cc+c, vx*vy*cc-vz*s, vx*vz*cc+vy*s, 0],
- [vy*vx*cc+vz*s, vy*vy*cc+c, vy*vz*cc-vx*s, 0],
- [vz*vx*cc-vy*s, vz*vy*cc+vx*s, vz*vz*cc+c, 0],
- [0, 0, 0, 1],
- **kwargs)
-
-
-def translate2d_inv(tx, ty, **kwargs):
- return translate2d(-tx, -ty, **kwargs)
-
-
-def scale2d_inv(sx, sy, **kwargs):
- return scale2d(1 / sx, 1 / sy, **kwargs)
-
-
-def rotate2d_inv(theta, **kwargs):
- return rotate2d(-theta, **kwargs)
-
-# ----------------------------------------------------------------------------
-# Versatile image augmentation pipeline from the paper
-# "Training Generative Adversarial Networks with Limited Data".
-#
-# All augmentations are disabled by default; individual augmentations can
-# be enabled by setting their probability multipliers to 1.
-
-
-@persistence.persistent_class
-class AugmentPipe(torch.nn.Module):
- def __init__(self,
- xflip=0, rotate90=0, xint=0, xint_max=0.125,
- scale=0, rotate=0, aniso=0, xfrac=0, scale_std=0.2, rotate_max=1, aniso_std=0.2, xfrac_std=0.125,
- brightness=0, contrast=0, lumaflip=0, hue=0, saturation=0, brightness_std=0.2, contrast_std=0.5, hue_max=1, saturation_std=1,
- imgfilter=0, imgfilter_bands=[1, 1, 1, 1], imgfilter_std=1,
- noise=0, cutout=0, noise_std=0.1, cutout_size=0.5,
- ):
- super().__init__()
- # Overall multiplier for augmentation probability.
- self.register_buffer('p', torch.ones([]))
-
- # Pixel blitting.
- # Probability multiplier for x-flip.
- self.xflip = float(xflip)
- # Probability multiplier for 90 degree rotations.
- self.rotate90 = float(rotate90)
- # Probability multiplier for integer translation.
- self.xint = float(xint)
- # Range of integer translation, relative to image dimensions.
- self.xint_max = float(xint_max)
-
- # General geometric transformations.
- # Probability multiplier for isotropic scaling.
- self.scale = float(scale)
- # Probability multiplier for arbitrary rotation.
- self.rotate = float(rotate)
- # Probability multiplier for anisotropic scaling.
- self.aniso = float(aniso)
- # Probability multiplier for fractional translation.
- self.xfrac = float(xfrac)
- # Log2 standard deviation of isotropic scaling.
- self.scale_std = float(scale_std)
- # Range of arbitrary rotation, 1 = full circle.
- self.rotate_max = float(rotate_max)
- # Log2 standard deviation of anisotropic scaling.
- self.aniso_std = float(aniso_std)
- # Standard deviation of frational translation, relative to image dimensions.
- self.xfrac_std = float(xfrac_std)
-
- # Color transformations.
- # Probability multiplier for brightness.
- self.brightness = float(brightness)
- # Probability multiplier for contrast.
- self.contrast = float(contrast)
- # Probability multiplier for luma flip.
- self.lumaflip = float(lumaflip)
- # Probability multiplier for hue rotation.
- self.hue = float(hue)
- # Probability multiplier for saturation.
- self.saturation = float(saturation)
- # Standard deviation of brightness.
- self.brightness_std = float(brightness_std)
- # Log2 standard deviation of contrast.
- self.contrast_std = float(contrast_std)
- # Range of hue rotation, 1 = full circle.
- self.hue_max = float(hue_max)
- # Log2 standard deviation of saturation.
- self.saturation_std = float(saturation_std)
-
- # Image-space filtering.
- # Probability multiplier for image-space filtering.
- self.imgfilter = float(imgfilter)
- # Probability multipliers for individual frequency bands.
- self.imgfilter_bands = list(imgfilter_bands)
- # Log2 standard deviation of image-space filter amplification.
- self.imgfilter_std = float(imgfilter_std)
-
- # Image-space corruptions.
- # Probability multiplier for additive RGB noise.
- self.noise = float(noise)
- # Probability multiplier for cutout.
- self.cutout = float(cutout)
- # Standard deviation of additive RGB noise.
- self.noise_std = float(noise_std)
- # Size of the cutout rectangle, relative to image dimensions.
- self.cutout_size = float(cutout_size)
-
- # Setup orthogonal lowpass filter for geometric augmentations.
- self.register_buffer(
- 'Hz_geom', upfirdn2d.setup_filter(wavelets['sym6']))
-
- # Construct filter bank for image-space filtering.
- Hz_lo = np.asarray(wavelets['sym2']) # H(z)
- Hz_hi = Hz_lo * ((-1) ** np.arange(Hz_lo.size)) # H(-z)
- Hz_lo2 = np.convolve(Hz_lo, Hz_lo[::-1]) / 2 # H(z) * H(z^-1) / 2
- Hz_hi2 = np.convolve(Hz_hi, Hz_hi[::-1]) / 2 # H(-z) * H(-z^-1) / 2
- Hz_fbank = np.eye(4, 1) # Bandpass(H(z), b_i)
- for i in range(1, Hz_fbank.shape[0]):
- Hz_fbank = np.dstack([Hz_fbank, np.zeros_like(Hz_fbank)]).reshape(
- Hz_fbank.shape[0], -1)[:, :-1]
- Hz_fbank = scipy.signal.convolve(Hz_fbank, [Hz_lo2])
- Hz_fbank[i, (Hz_fbank.shape[1] - Hz_hi2.size) //
- 2: (Hz_fbank.shape[1] + Hz_hi2.size) // 2] += Hz_hi2
- self.register_buffer('Hz_fbank', torch.as_tensor(
- Hz_fbank, dtype=torch.float32))
-
- def forward(self, images, debug_percentile=None):
- assert isinstance(images, torch.Tensor) and images.ndim == 4
- batch_size, num_channels, height, width = images.shape
- device = images.device
- if debug_percentile is not None:
- debug_percentile = torch.as_tensor(
- debug_percentile, dtype=torch.float32, device=device)
-
- # -------------------------------------
- # Select parameters for pixel blitting.
- # -------------------------------------
-
- # Initialize inverse homogeneous 2D transform: G_inv @ pixel_out ==> pixel_in
- I_3 = torch.eye(3, device=device)
- G_inv = I_3
-
- # Apply x-flip with probability (xflip * strength).
- if self.xflip > 0:
- i = torch.floor(torch.rand([batch_size], device=device) * 2)
- i = torch.where(torch.rand(
- [batch_size], device=device) < self.xflip * self.p, i, torch.zeros_like(i))
- if debug_percentile is not None:
- i = torch.full_like(i, torch.floor(debug_percentile * 2))
- G_inv = G_inv @ scale2d_inv(1 - 2 * i, 1)
-
- # Apply 90 degree rotations with probability (rotate90 * strength).
- if self.rotate90 > 0:
- i = torch.floor(torch.rand([batch_size], device=device) * 4)
- i = torch.where(torch.rand(
- [batch_size], device=device) < self.rotate90 * self.p, i, torch.zeros_like(i))
- if debug_percentile is not None:
- i = torch.full_like(i, torch.floor(debug_percentile * 4))
- G_inv = G_inv @ rotate2d_inv(-np.pi / 2 * i)
-
- # Apply integer translation with probability (xint * strength).
- if self.xint > 0:
- t = (torch.rand([batch_size, 2], device=device)
- * 2 - 1) * self.xint_max
- t = torch.where(torch.rand(
- [batch_size, 1], device=device) < self.xint * self.p, t, torch.zeros_like(t))
- if debug_percentile is not None:
- t = torch.full_like(
- t, (debug_percentile * 2 - 1) * self.xint_max)
- G_inv = G_inv @ translate2d_inv(torch.round(
- t[:, 0] * width), torch.round(t[:, 1] * height))
-
- # --------------------------------------------------------
- # Select parameters for general geometric transformations.
- # --------------------------------------------------------
-
- # Apply isotropic scaling with probability (scale * strength).
- if self.scale > 0:
- s = torch.exp2(torch.randn(
- [batch_size], device=device) * self.scale_std)
- s = torch.where(torch.rand(
- [batch_size], device=device) < self.scale * self.p, s, torch.ones_like(s))
- if debug_percentile is not None:
- s = torch.full_like(s, torch.exp2(torch.erfinv(
- debug_percentile * 2 - 1) * self.scale_std))
- G_inv = G_inv @ scale2d_inv(s, s)
-
- # Apply pre-rotation with probability p_rot.
- # P(pre OR post) = p
- p_rot = 1 - torch.sqrt((1 - self.rotate * self.p).clamp(0, 1))
- if self.rotate > 0:
- theta = (torch.rand([batch_size], device=device)
- * 2 - 1) * np.pi * self.rotate_max
- theta = torch.where(torch.rand(
- [batch_size], device=device) < p_rot, theta, torch.zeros_like(theta))
- if debug_percentile is not None:
- theta = torch.full_like(
- theta, (debug_percentile * 2 - 1) * np.pi * self.rotate_max)
- G_inv = G_inv @ rotate2d_inv(-theta) # Before anisotropic scaling.
-
- # Apply anisotropic scaling with probability (aniso * strength).
- if self.aniso > 0:
- s = torch.exp2(torch.randn(
- [batch_size], device=device) * self.aniso_std)
- s = torch.where(torch.rand(
- [batch_size], device=device) < self.aniso * self.p, s, torch.ones_like(s))
- if debug_percentile is not None:
- s = torch.full_like(s, torch.exp2(torch.erfinv(
- debug_percentile * 2 - 1) * self.aniso_std))
- G_inv = G_inv @ scale2d_inv(s, 1 / s)
-
- # Apply post-rotation with probability p_rot.
- if self.rotate > 0:
- theta = (torch.rand([batch_size], device=device)
- * 2 - 1) * np.pi * self.rotate_max
- theta = torch.where(torch.rand(
- [batch_size], device=device) < p_rot, theta, torch.zeros_like(theta))
- if debug_percentile is not None:
- theta = torch.zeros_like(theta)
- G_inv = G_inv @ rotate2d_inv(-theta) # After anisotropic scaling.
-
- # Apply fractional translation with probability (xfrac * strength).
- if self.xfrac > 0:
- t = torch.randn([batch_size, 2], device=device) * self.xfrac_std
- t = torch.where(torch.rand(
- [batch_size, 1], device=device) < self.xfrac * self.p, t, torch.zeros_like(t))
- if debug_percentile is not None:
- t = torch.full_like(t, torch.erfinv(
- debug_percentile * 2 - 1) * self.xfrac_std)
- G_inv = G_inv @ translate2d_inv(t[:, 0] * width, t[:, 1] * height)
-
- # ----------------------------------
- # Execute geometric transformations.
- # ----------------------------------
-
- # Execute if the transform is not identity.
- if G_inv is not I_3:
-
- # Calculate padding.
- cx = (width - 1) / 2
- cy = (height - 1) / 2
- cp = matrix([-cx, -cy, 1], [cx, -cy, 1], [cx, cy, 1],
- [-cx, cy, 1], device=device) # [idx, xyz]
- cp = G_inv @ cp.t() # [batch, xyz, idx]
- Hz_pad = self.Hz_geom.shape[0] // 4
- margin = cp[:, :2, :].permute(
- 1, 0, 2).flatten(1) # [xy, batch * idx]
- # [x0, y0, x1, y1]
- margin = torch.cat([-margin, margin]).max(dim=1).values
- margin = margin + \
- misc.constant([Hz_pad * 2 - cx, Hz_pad * 2 - cy]
- * 2, device=device)
- margin = margin.max(misc.constant([0, 0] * 2, device=device))
- margin = margin.min(misc.constant(
- [width-1, height-1] * 2, device=device))
- mx0, my0, mx1, my1 = margin.ceil().to(torch.int32)
-
- # Pad image and adjust origin.
- images = torch.nn.functional.pad(
- input=images, pad=[mx0, mx1, my0, my1], mode='reflect')
- G_inv = translate2d((mx0 - mx1) / 2, (my0 - my1) / 2) @ G_inv
-
- # Upsample.
- images = upfirdn2d.upsample2d(x=images, f=self.Hz_geom, up=2)
- G_inv = scale2d(
- 2, 2, device=device) @ G_inv @ scale2d_inv(2, 2, device=device)
- G_inv = translate2d(-0.5, -0.5,
- device=device) @ G_inv @ translate2d_inv(-0.5, -0.5, device=device)
-
- # Execute transformation.
- shape = [batch_size, num_channels,
- (height + Hz_pad * 2) * 2, (width + Hz_pad * 2) * 2]
- G_inv = scale2d(2 / images.shape[3], 2 / images.shape[2], device=device) @ G_inv @ scale2d_inv(
- 2 / shape[3], 2 / shape[2], device=device)
- grid = torch.nn.functional.affine_grid(
- theta=G_inv[:, :2, :], size=shape, align_corners=False)
- images = grid_sample_gradfix.grid_sample(images, grid)
-
- # Downsample and crop.
- images = upfirdn2d.downsample2d(
- x=images, f=self.Hz_geom, down=2, padding=-Hz_pad*2, flip_filter=True)
-
- # --------------------------------------------
- # Select parameters for color transformations.
- # --------------------------------------------
-
- # Initialize homogeneous 3D transformation matrix: C @ color_in ==> color_out
- I_4 = torch.eye(4, device=device)
- C = I_4
-
- # Apply brightness with probability (brightness * strength).
- if self.brightness > 0:
- b = torch.randn([batch_size], device=device) * self.brightness_std
- b = torch.where(torch.rand(
- [batch_size], device=device) < self.brightness * self.p, b, torch.zeros_like(b))
- if debug_percentile is not None:
- b = torch.full_like(b, torch.erfinv(
- debug_percentile * 2 - 1) * self.brightness_std)
- C = translate3d(b, b, b) @ C
-
- # Apply contrast with probability (contrast * strength).
- if self.contrast > 0:
- c = torch.exp2(torch.randn(
- [batch_size], device=device) * self.contrast_std)
- c = torch.where(torch.rand(
- [batch_size], device=device) < self.contrast * self.p, c, torch.ones_like(c))
- if debug_percentile is not None:
- c = torch.full_like(c, torch.exp2(torch.erfinv(
- debug_percentile * 2 - 1) * self.contrast_std))
- C = scale3d(c, c, c) @ C
-
- # Apply luma flip with probability (lumaflip * strength).
- # Luma axis.
- v = misc.constant(np.asarray([1, 1, 1, 0]) / np.sqrt(3), device=device)
- if self.lumaflip > 0:
- i = torch.floor(torch.rand([batch_size, 1, 1], device=device) * 2)
- i = torch.where(torch.rand(
- [batch_size, 1, 1], device=device) < self.lumaflip * self.p, i, torch.zeros_like(i))
- if debug_percentile is not None:
- i = torch.full_like(i, torch.floor(debug_percentile * 2))
- C = (I_4 - 2 * v.ger(v) * i) @ C # Householder reflection.
-
- # Apply hue rotation with probability (hue * strength).
- if self.hue > 0 and num_channels > 1:
- theta = (torch.rand([batch_size], device=device)
- * 2 - 1) * np.pi * self.hue_max
- theta = torch.where(torch.rand(
- [batch_size], device=device) < self.hue * self.p, theta, torch.zeros_like(theta))
- if debug_percentile is not None:
- theta = torch.full_like(
- theta, (debug_percentile * 2 - 1) * np.pi * self.hue_max)
- C = rotate3d(v, theta) @ C # Rotate around v.
-
- # Apply saturation with probability (saturation * strength).
- if self.saturation > 0 and num_channels > 1:
- s = torch.exp2(torch.randn(
- [batch_size, 1, 1], device=device) * self.saturation_std)
- s = torch.where(torch.rand(
- [batch_size, 1, 1], device=device) < self.saturation * self.p, s, torch.ones_like(s))
- if debug_percentile is not None:
- s = torch.full_like(s, torch.exp2(torch.erfinv(
- debug_percentile * 2 - 1) * self.saturation_std))
- C = (v.ger(v) + (I_4 - v.ger(v)) * s) @ C
-
- # ------------------------------
- # Execute color transformations.
- # ------------------------------
-
- # Execute if the transform is not identity.
- if C is not I_4:
- images = images.reshape([batch_size, num_channels, height * width])
- if num_channels == 3:
- images = C[:, :3, :3] @ images + C[:, :3, 3:]
- elif num_channels == 1:
- C = C[:, :3, :].mean(dim=1, keepdims=True)
- images = images * \
- C[:, :, :3].sum(dim=2, keepdims=True) + C[:, :, 3:]
- else:
- raise ValueError(
- 'Image must be RGB (3 channels) or L (1 channel)')
- images = images.reshape([batch_size, num_channels, height, width])
-
- # ----------------------
- # Image-space filtering.
- # ----------------------
-
- if self.imgfilter > 0:
- num_bands = self.Hz_fbank.shape[0]
- assert len(self.imgfilter_bands) == num_bands
- # Expected power spectrum (1/f).
- expected_power = misc.constant(
- np.array([10, 1, 1, 1]) / 13, device=device)
-
- # Apply amplification for each band with probability (imgfilter * strength * band_strength).
- # Global gain vector (identity).
- g = torch.ones([batch_size, num_bands], device=device)
- for i, band_strength in enumerate(self.imgfilter_bands):
- t_i = torch.exp2(torch.randn(
- [batch_size], device=device) * self.imgfilter_std)
- t_i = torch.where(torch.rand(
- [batch_size], device=device) < self.imgfilter * self.p * band_strength, t_i, torch.ones_like(t_i))
- if debug_percentile is not None:
- t_i = torch.full_like(t_i, torch.exp2(torch.erfinv(
- debug_percentile * 2 - 1) * self.imgfilter_std)) if band_strength > 0 else torch.ones_like(t_i)
- # Temporary gain vector.
- t = torch.ones([batch_size, num_bands], device=device)
- # Replace i'th element.
- t[:, i] = t_i
- # Normalize power.
- t = t / (expected_power * t.square()
- ).sum(dim=-1, keepdims=True).sqrt()
- # Accumulate into global gain.
- g = g * t
-
- # Construct combined amplification filter.
- # [batch, tap]
- Hz_prime = g @ self.Hz_fbank
- Hz_prime = Hz_prime.unsqueeze(1).repeat(
- [1, num_channels, 1]) # [batch, channels, tap]
- # [batch * channels, 1, tap]
- Hz_prime = Hz_prime.reshape([batch_size * num_channels, 1, -1])
-
- # Apply filter.
- p = self.Hz_fbank.shape[1] // 2
- images = images.reshape(
- [1, batch_size * num_channels, height, width])
- images = torch.nn.functional.pad(
- input=images, pad=[p, p, p, p], mode='reflect')
- images = conv2d_gradfix.conv2d(
- input=images, weight=Hz_prime.unsqueeze(2), groups=batch_size*num_channels)
- images = conv2d_gradfix.conv2d(
- input=images, weight=Hz_prime.unsqueeze(3), groups=batch_size*num_channels)
- images = images.reshape([batch_size, num_channels, height, width])
-
- # ------------------------
- # Image-space corruptions.
- # ------------------------
-
- # Apply additive RGB noise with probability (noise * strength).
- if self.noise > 0:
- sigma = torch.randn([batch_size, 1, 1, 1],
- device=device).abs() * self.noise_std
- sigma = torch.where(torch.rand(
- [batch_size, 1, 1, 1], device=device) < self.noise * self.p, sigma, torch.zeros_like(sigma))
- if debug_percentile is not None:
- sigma = torch.full_like(sigma, torch.erfinv(
- debug_percentile) * self.noise_std)
- images = images + \
- torch.randn([batch_size, num_channels, height,
- width], device=device) * sigma
-
- # Apply cutout with probability (cutout * strength).
- if self.cutout > 0:
- size = torch.full([batch_size, 2, 1, 1, 1],
- self.cutout_size, device=device)
- size = torch.where(torch.rand(
- [batch_size, 1, 1, 1, 1], device=device) < self.cutout * self.p, size, torch.zeros_like(size))
- center = torch.rand([batch_size, 2, 1, 1, 1], device=device)
- if debug_percentile is not None:
- size = torch.full_like(size, self.cutout_size)
- center = torch.full_like(center, debug_percentile)
- coord_x = torch.arange(width, device=device).reshape([1, 1, 1, -1])
- coord_y = torch.arange(
- height, device=device).reshape([1, 1, -1, 1])
- mask_x = (((coord_x + 0.5) / width -
- center[:, 0]).abs() >= size[:, 0] / 2)
- mask_y = (((coord_y + 0.5) / height -
- center[:, 1]).abs() >= size[:, 1] / 2)
- mask = torch.logical_or(mask_x, mask_y).to(torch.float32)
- images = images * mask
-
- return images
-
-# ----------------------------------------------------------------------------
diff --git a/spaces/An-619/FastSAM/utils/tools.py b/spaces/An-619/FastSAM/utils/tools.py
deleted file mode 100644
index e57f8746f31c910a5940dd027ec588ee59e60f17..0000000000000000000000000000000000000000
--- a/spaces/An-619/FastSAM/utils/tools.py
+++ /dev/null
@@ -1,442 +0,0 @@
-import numpy as np
-from PIL import Image
-import matplotlib.pyplot as plt
-import cv2
-import torch
-import os
-import sys
-import clip
-
-
-def convert_box_xywh_to_xyxy(box):
- if len(box) == 4:
- return [box[0], box[1], box[0] + box[2], box[1] + box[3]]
- else:
- result = []
- for b in box:
- b = convert_box_xywh_to_xyxy(b)
- result.append(b)
- return result
-
-
-def segment_image(image, bbox):
- image_array = np.array(image)
- segmented_image_array = np.zeros_like(image_array)
- x1, y1, x2, y2 = bbox
- segmented_image_array[y1:y2, x1:x2] = image_array[y1:y2, x1:x2]
- segmented_image = Image.fromarray(segmented_image_array)
- black_image = Image.new("RGB", image.size, (255, 255, 255))
- # transparency_mask = np.zeros_like((), dtype=np.uint8)
- transparency_mask = np.zeros(
- (image_array.shape[0], image_array.shape[1]), dtype=np.uint8
- )
- transparency_mask[y1:y2, x1:x2] = 255
- transparency_mask_image = Image.fromarray(transparency_mask, mode="L")
- black_image.paste(segmented_image, mask=transparency_mask_image)
- return black_image
-
-
-def format_results(result, filter=0):
- annotations = []
- n = len(result.masks.data)
- for i in range(n):
- annotation = {}
- mask = result.masks.data[i] == 1.0
-
- if torch.sum(mask) < filter:
- continue
- annotation["id"] = i
- annotation["segmentation"] = mask.cpu().numpy()
- annotation["bbox"] = result.boxes.data[i]
- annotation["score"] = result.boxes.conf[i]
- annotation["area"] = annotation["segmentation"].sum()
- annotations.append(annotation)
- return annotations
-
-
-def filter_masks(annotations): # filter the overlap mask
- annotations.sort(key=lambda x: x["area"], reverse=True)
- to_remove = set()
- for i in range(0, len(annotations)):
- a = annotations[i]
- for j in range(i + 1, len(annotations)):
- b = annotations[j]
- if i != j and j not in to_remove:
- # check if
- if b["area"] < a["area"]:
- if (a["segmentation"] & b["segmentation"]).sum() / b[
- "segmentation"
- ].sum() > 0.8:
- to_remove.add(j)
-
- return [a for i, a in enumerate(annotations) if i not in to_remove], to_remove
-
-
-def get_bbox_from_mask(mask):
- mask = mask.astype(np.uint8)
- contours, hierarchy = cv2.findContours(
- mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
- )
- x1, y1, w, h = cv2.boundingRect(contours[0])
- x2, y2 = x1 + w, y1 + h
- if len(contours) > 1:
- for b in contours:
- x_t, y_t, w_t, h_t = cv2.boundingRect(b)
- # 将多个bbox合并成一个
- x1 = min(x1, x_t)
- y1 = min(y1, y_t)
- x2 = max(x2, x_t + w_t)
- y2 = max(y2, y_t + h_t)
- h = y2 - y1
- w = x2 - x1
- return [x1, y1, x2, y2]
-
-
-def fast_process(
- annotations, args, mask_random_color, bbox=None, points=None, edges=False
-):
- if isinstance(annotations[0], dict):
- annotations = [annotation["segmentation"] for annotation in annotations]
- result_name = os.path.basename(args.img_path)
- image = cv2.imread(args.img_path)
- image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
- original_h = image.shape[0]
- original_w = image.shape[1]
- if sys.platform == "darwin":
- plt.switch_backend("TkAgg")
- plt.figure(figsize=(original_w/100, original_h/100))
- # Add subplot with no margin.
- plt.subplots_adjust(top=1, bottom=0, right=1, left=0, hspace=0, wspace=0)
- plt.margins(0, 0)
- plt.gca().xaxis.set_major_locator(plt.NullLocator())
- plt.gca().yaxis.set_major_locator(plt.NullLocator())
- plt.imshow(image)
- if args.better_quality == True:
- if isinstance(annotations[0], torch.Tensor):
- annotations = np.array(annotations.cpu())
- for i, mask in enumerate(annotations):
- mask = cv2.morphologyEx(
- mask.astype(np.uint8), cv2.MORPH_CLOSE, np.ones((3, 3), np.uint8)
- )
- annotations[i] = cv2.morphologyEx(
- mask.astype(np.uint8), cv2.MORPH_OPEN, np.ones((8, 8), np.uint8)
- )
- if args.device == "cpu":
- annotations = np.array(annotations)
- fast_show_mask(
- annotations,
- plt.gca(),
- random_color=mask_random_color,
- bbox=bbox,
- points=points,
- point_label=args.point_label,
- retinamask=args.retina,
- target_height=original_h,
- target_width=original_w,
- )
- else:
- if isinstance(annotations[0], np.ndarray):
- annotations = torch.from_numpy(annotations)
- fast_show_mask_gpu(
- annotations,
- plt.gca(),
- random_color=args.randomcolor,
- bbox=bbox,
- points=points,
- point_label=args.point_label,
- retinamask=args.retina,
- target_height=original_h,
- target_width=original_w,
- )
- if isinstance(annotations, torch.Tensor):
- annotations = annotations.cpu().numpy()
- if args.withContours == True:
- contour_all = []
- temp = np.zeros((original_h, original_w, 1))
- for i, mask in enumerate(annotations):
- if type(mask) == dict:
- mask = mask["segmentation"]
- annotation = mask.astype(np.uint8)
- if args.retina == False:
- annotation = cv2.resize(
- annotation,
- (original_w, original_h),
- interpolation=cv2.INTER_NEAREST,
- )
- contours, hierarchy = cv2.findContours(
- annotation, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE
- )
- for contour in contours:
- contour_all.append(contour)
- cv2.drawContours(temp, contour_all, -1, (255, 255, 255), 2)
- color = np.array([0 / 255, 0 / 255, 255 / 255, 0.8])
- contour_mask = temp / 255 * color.reshape(1, 1, -1)
- plt.imshow(contour_mask)
-
- save_path = args.output
- if not os.path.exists(save_path):
- os.makedirs(save_path)
- plt.axis("off")
- fig = plt.gcf()
- plt.draw()
-
- try:
- buf = fig.canvas.tostring_rgb()
- except AttributeError:
- fig.canvas.draw()
- buf = fig.canvas.tostring_rgb()
-
- cols, rows = fig.canvas.get_width_height()
- img_array = np.fromstring(buf, dtype=np.uint8).reshape(rows, cols, 3)
- cv2.imwrite(os.path.join(save_path, result_name), cv2.cvtColor(img_array, cv2.COLOR_RGB2BGR))
-
-
-# CPU post process
-def fast_show_mask(
- annotation,
- ax,
- random_color=False,
- bbox=None,
- points=None,
- point_label=None,
- retinamask=True,
- target_height=960,
- target_width=960,
-):
- msak_sum = annotation.shape[0]
- height = annotation.shape[1]
- weight = annotation.shape[2]
- # 将annotation 按照面积 排序
- areas = np.sum(annotation, axis=(1, 2))
- sorted_indices = np.argsort(areas)
- annotation = annotation[sorted_indices]
-
- index = (annotation != 0).argmax(axis=0)
- if random_color == True:
- color = np.random.random((msak_sum, 1, 1, 3))
- else:
- color = np.ones((msak_sum, 1, 1, 3)) * np.array(
- [30 / 255, 144 / 255, 255 / 255]
- )
- transparency = np.ones((msak_sum, 1, 1, 1)) * 0.6
- visual = np.concatenate([color, transparency], axis=-1)
- mask_image = np.expand_dims(annotation, -1) * visual
-
- show = np.zeros((height, weight, 4))
- h_indices, w_indices = np.meshgrid(
- np.arange(height), np.arange(weight), indexing="ij"
- )
- indices = (index[h_indices, w_indices], h_indices, w_indices, slice(None))
- # 使用向量化索引更新show的值
- show[h_indices, w_indices, :] = mask_image[indices]
- if bbox is not None:
- x1, y1, x2, y2 = bbox
- ax.add_patch(
- plt.Rectangle(
- (x1, y1), x2 - x1, y2 - y1, fill=False, edgecolor="b", linewidth=1
- )
- )
- # draw point
- if points is not None:
- plt.scatter(
- [point[0] for i, point in enumerate(points) if point_label[i] == 1],
- [point[1] for i, point in enumerate(points) if point_label[i] == 1],
- s=20,
- c="y",
- )
- plt.scatter(
- [point[0] for i, point in enumerate(points) if point_label[i] == 0],
- [point[1] for i, point in enumerate(points) if point_label[i] == 0],
- s=20,
- c="m",
- )
-
- if retinamask == False:
- show = cv2.resize(
- show, (target_width, target_height), interpolation=cv2.INTER_NEAREST
- )
- ax.imshow(show)
-
-
-def fast_show_mask_gpu(
- annotation,
- ax,
- random_color=False,
- bbox=None,
- points=None,
- point_label=None,
- retinamask=True,
- target_height=960,
- target_width=960,
-):
- msak_sum = annotation.shape[0]
- height = annotation.shape[1]
- weight = annotation.shape[2]
- areas = torch.sum(annotation, dim=(1, 2))
- sorted_indices = torch.argsort(areas, descending=False)
- annotation = annotation[sorted_indices]
- # 找每个位置第一个非零值下标
- index = (annotation != 0).to(torch.long).argmax(dim=0)
- if random_color == True:
- color = torch.rand((msak_sum, 1, 1, 3)).to(annotation.device)
- else:
- color = torch.ones((msak_sum, 1, 1, 3)).to(annotation.device) * torch.tensor(
- [30 / 255, 144 / 255, 255 / 255]
- ).to(annotation.device)
- transparency = torch.ones((msak_sum, 1, 1, 1)).to(annotation.device) * 0.6
- visual = torch.cat([color, transparency], dim=-1)
- mask_image = torch.unsqueeze(annotation, -1) * visual
- # 按index取数，index指每个位置选哪个batch的数，把mask_image转成一个batch的形式
- show = torch.zeros((height, weight, 4)).to(annotation.device)
- h_indices, w_indices = torch.meshgrid(
- torch.arange(height), torch.arange(weight), indexing="ij"
- )
- indices = (index[h_indices, w_indices], h_indices, w_indices, slice(None))
- # 使用向量化索引更新show的值
- show[h_indices, w_indices, :] = mask_image[indices]
- show_cpu = show.cpu().numpy()
- if bbox is not None:
- x1, y1, x2, y2 = bbox
- ax.add_patch(
- plt.Rectangle(
- (x1, y1), x2 - x1, y2 - y1, fill=False, edgecolor="b", linewidth=1
- )
- )
- # draw point
- if points is not None:
- plt.scatter(
- [point[0] for i, point in enumerate(points) if point_label[i] == 1],
- [point[1] for i, point in enumerate(points) if point_label[i] == 1],
- s=20,
- c="y",
- )
- plt.scatter(
- [point[0] for i, point in enumerate(points) if point_label[i] == 0],
- [point[1] for i, point in enumerate(points) if point_label[i] == 0],
- s=20,
- c="m",
- )
- if retinamask == False:
- show_cpu = cv2.resize(
- show_cpu, (target_width, target_height), interpolation=cv2.INTER_NEAREST
- )
- ax.imshow(show_cpu)
-
-
-# clip
-@torch.no_grad()
-def retriev(
- model, preprocess, elements: [Image.Image], search_text: str, device
-):
- preprocessed_images = [preprocess(image).to(device) for image in elements]
- tokenized_text = clip.tokenize([search_text]).to(device)
- stacked_images = torch.stack(preprocessed_images)
- image_features = model.encode_image(stacked_images)
- text_features = model.encode_text(tokenized_text)
- image_features /= image_features.norm(dim=-1, keepdim=True)
- text_features /= text_features.norm(dim=-1, keepdim=True)
- probs = 100.0 * image_features @ text_features.T
- return probs[:, 0].softmax(dim=0)
-
-
-def crop_image(annotations, image_like):
- if isinstance(image_like, str):
- image = Image.open(image_like)
- else:
- image = image_like
- ori_w, ori_h = image.size
- mask_h, mask_w = annotations[0]["segmentation"].shape
- if ori_w != mask_w or ori_h != mask_h:
- image = image.resize((mask_w, mask_h))
- cropped_boxes = []
- cropped_images = []
- not_crop = []
- origin_id = []
- for _, mask in enumerate(annotations):
- if np.sum(mask["segmentation"]) <= 100:
- continue
- origin_id.append(_)
- bbox = get_bbox_from_mask(mask["segmentation"]) # mask 的 bbox
- cropped_boxes.append(segment_image(image, bbox)) # 保存裁剪的图片
- # cropped_boxes.append(segment_image(image,mask["segmentation"]))
- cropped_images.append(bbox) # 保存裁剪的图片的bbox
- return cropped_boxes, cropped_images, not_crop, origin_id, annotations
-
-
-def box_prompt(masks, bbox, target_height, target_width):
- h = masks.shape[1]
- w = masks.shape[2]
- if h != target_height or w != target_width:
- bbox = [
- int(bbox[0] * w / target_width),
- int(bbox[1] * h / target_height),
- int(bbox[2] * w / target_width),
- int(bbox[3] * h / target_height),
- ]
- bbox[0] = round(bbox[0]) if round(bbox[0]) > 0 else 0
- bbox[1] = round(bbox[1]) if round(bbox[1]) > 0 else 0
- bbox[2] = round(bbox[2]) if round(bbox[2]) < w else w
- bbox[3] = round(bbox[3]) if round(bbox[3]) < h else h
-
- # IoUs = torch.zeros(len(masks), dtype=torch.float32)
- bbox_area = (bbox[3] - bbox[1]) * (bbox[2] - bbox[0])
-
- masks_area = torch.sum(masks[:, bbox[1] : bbox[3], bbox[0] : bbox[2]], dim=(1, 2))
- orig_masks_area = torch.sum(masks, dim=(1, 2))
-
- union = bbox_area + orig_masks_area - masks_area
- IoUs = masks_area / union
- max_iou_index = torch.argmax(IoUs)
-
- return masks[max_iou_index].cpu().numpy(), max_iou_index
-
-
-def point_prompt(masks, points, point_label, target_height, target_width): # numpy 处理
- h = masks[0]["segmentation"].shape[0]
- w = masks[0]["segmentation"].shape[1]
- if h != target_height or w != target_width:
- points = [
- [int(point[0] * w / target_width), int(point[1] * h / target_height)]
- for point in points
- ]
- onemask = np.zeros((h, w))
- masks = sorted(masks, key=lambda x: x['area'], reverse=True)
- for i, annotation in enumerate(masks):
- if type(annotation) == dict:
- mask = annotation['segmentation']
- else:
- mask = annotation
- for i, point in enumerate(points):
- if mask[point[1], point[0]] == 1 and point_label[i] == 1:
- onemask[mask] = 1
- if mask[point[1], point[0]] == 1 and point_label[i] == 0:
- onemask[mask] = 0
- onemask = onemask >= 1
- return onemask, 0
-
-
-def text_prompt(annotations, text, img_path, device, wider=False, threshold=0.9):
- cropped_boxes, cropped_images, not_crop, origin_id, annotations_ = crop_image(
- annotations, img_path
- )
- clip_model, preprocess = clip.load("./weights/CLIP_ViT_B_32.pt", device=device)
- scores = retriev(
- clip_model, preprocess, cropped_boxes, text, device=device
- )
- max_idx = scores.argsort()
- max_idx = max_idx[-1]
- max_idx = origin_id[int(max_idx)]
-
- # find the biggest mask which contains the mask with max score
- if wider:
- mask0 = annotations_[max_idx]["segmentation"]
- area0 = np.sum(mask0)
- areas = [(i, np.sum(mask["segmentation"])) for i, mask in enumerate(annotations_) if i in origin_id]
- areas = sorted(areas, key=lambda area: area[1], reverse=True)
- indices = [area[0] for area in areas]
- for index in indices:
- if index == max_idx or np.sum(annotations_[index]["segmentation"] & mask0) / area0 > threshold:
- max_idx = index
- break
-
- return annotations_[max_idx]["segmentation"], max_idx
diff --git a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/tests/pipelines/stable_diffusion/test_stable_diffusion_pix2pix_zero.py b/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/tests/pipelines/stable_diffusion/test_stable_diffusion_pix2pix_zero.py
deleted file mode 100644
index 7d94b9f230d88e878f05f2611af8d34f9a4dcd26..0000000000000000000000000000000000000000
--- a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/tests/pipelines/stable_diffusion/test_stable_diffusion_pix2pix_zero.py
+++ /dev/null
@@ -1,622 +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 tempfile
-import unittest
-
-import numpy as np
-import torch
-from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer
-
-from diffusers import (
- AutoencoderKL,
- DDIMInverseScheduler,
- DDIMScheduler,
- DDPMScheduler,
- EulerAncestralDiscreteScheduler,
- LMSDiscreteScheduler,
- StableDiffusionPix2PixZeroPipeline,
- UNet2DConditionModel,
-)
-from diffusers.image_processor import VaeImageProcessor
-from diffusers.utils import floats_tensor, load_numpy, slow, torch_device
-from diffusers.utils.testing_utils import enable_full_determinism, load_image, load_pt, require_torch_gpu, skip_mps
-
-from ..pipeline_params import (
- TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
- TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
- TEXT_TO_IMAGE_IMAGE_PARAMS,
-)
-from ..test_pipelines_common import (
- PipelineLatentTesterMixin,
- PipelineTesterMixin,
- assert_mean_pixel_difference,
-)
-
-
-enable_full_determinism()
-
-
-@skip_mps
-class StableDiffusionPix2PixZeroPipelineFastTests(PipelineLatentTesterMixin, PipelineTesterMixin, unittest.TestCase):
- pipeline_class = StableDiffusionPix2PixZeroPipeline
- params = TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"image"}
- batch_params = TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
- image_params = TEXT_TO_IMAGE_IMAGE_PARAMS
- image_latents_params = TEXT_TO_IMAGE_IMAGE_PARAMS
-
- @classmethod
- def setUpClass(cls):
- cls.source_embeds = load_pt(
- "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/pix2pix/src_emb_0.pt"
- )
-
- cls.target_embeds = load_pt(
- "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/pix2pix/tgt_emb_0.pt"
- )
-
- def get_dummy_components(self):
- torch.manual_seed(0)
- unet = UNet2DConditionModel(
- block_out_channels=(32, 64),
- layers_per_block=2,
- sample_size=32,
- in_channels=4,
- out_channels=4,
- down_block_types=("DownBlock2D", "CrossAttnDownBlock2D"),
- up_block_types=("CrossAttnUpBlock2D", "UpBlock2D"),
- cross_attention_dim=32,
- )
- scheduler = DDIMScheduler()
- inverse_scheduler = DDIMInverseScheduler()
- torch.manual_seed(0)
- vae = AutoencoderKL(
- block_out_channels=[32, 64],
- in_channels=3,
- out_channels=3,
- down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"],
- up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"],
- latent_channels=4,
- )
- torch.manual_seed(0)
- text_encoder_config = CLIPTextConfig(
- bos_token_id=0,
- eos_token_id=2,
- hidden_size=32,
- intermediate_size=37,
- layer_norm_eps=1e-05,
- num_attention_heads=4,
- num_hidden_layers=5,
- pad_token_id=1,
- vocab_size=1000,
- )
- text_encoder = CLIPTextModel(text_encoder_config)
- tokenizer = CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip")
-
- components = {
- "unet": unet,
- "scheduler": scheduler,
- "vae": vae,
- "text_encoder": text_encoder,
- "tokenizer": tokenizer,
- "safety_checker": None,
- "feature_extractor": None,
- "inverse_scheduler": inverse_scheduler,
- "caption_generator": None,
- "caption_processor": None,
- }
- return components
-
- def get_dummy_inputs(self, device, seed=0):
- generator = torch.manual_seed(seed)
-
- inputs = {
- "prompt": "A painting of a squirrel eating a burger",
- "generator": generator,
- "num_inference_steps": 2,
- "guidance_scale": 6.0,
- "cross_attention_guidance_amount": 0.15,
- "source_embeds": self.source_embeds,
- "target_embeds": self.target_embeds,
- "output_type": "numpy",
- }
- return inputs
-
- def get_dummy_inversion_inputs(self, device, seed=0):
- dummy_image = floats_tensor((2, 3, 32, 32), rng=random.Random(seed)).to(torch_device)
- dummy_image = dummy_image / 2 + 0.5
- generator = torch.manual_seed(seed)
-
- inputs = {
- "prompt": [
- "A painting of a squirrel eating a burger",
- "A painting of a burger eating a squirrel",
- ],
- "image": dummy_image.cpu(),
- "num_inference_steps": 2,
- "guidance_scale": 6.0,
- "generator": generator,
- "output_type": "numpy",
- }
- return inputs
-
- def get_dummy_inversion_inputs_by_type(self, device, seed=0, input_image_type="pt", output_type="np"):
- inputs = self.get_dummy_inversion_inputs(device, seed)
-
- if input_image_type == "pt":
- image = inputs["image"]
- elif input_image_type == "np":
- image = VaeImageProcessor.pt_to_numpy(inputs["image"])
- elif input_image_type == "pil":
- image = VaeImageProcessor.pt_to_numpy(inputs["image"])
- image = VaeImageProcessor.numpy_to_pil(image)
- else:
- raise ValueError(f"unsupported input_image_type {input_image_type}")
-
- inputs["image"] = image
- inputs["output_type"] = output_type
-
- return inputs
-
- def test_save_load_optional_components(self):
- if not hasattr(self.pipeline_class, "_optional_components"):
- return
-
- components = self.get_dummy_components()
- pipe = self.pipeline_class(**components)
- pipe.to(torch_device)
- pipe.set_progress_bar_config(disable=None)
-
- # set all optional components to None and update pipeline config accordingly
- for optional_component in pipe._optional_components:
- setattr(pipe, optional_component, None)
- pipe.register_modules(**{optional_component: None for optional_component in pipe._optional_components})
-
- inputs = self.get_dummy_inputs(torch_device)
- output = pipe(**inputs)[0]
-
- with tempfile.TemporaryDirectory() as tmpdir:
- pipe.save_pretrained(tmpdir)
- pipe_loaded = self.pipeline_class.from_pretrained(tmpdir)
- pipe_loaded.to(torch_device)
- pipe_loaded.set_progress_bar_config(disable=None)
-
- for optional_component in pipe._optional_components:
- self.assertTrue(
- getattr(pipe_loaded, optional_component) is None,
- f"`{optional_component}` did not stay set to None after loading.",
- )
-
- inputs = self.get_dummy_inputs(torch_device)
- output_loaded = pipe_loaded(**inputs)[0]
-
- max_diff = np.abs(output - output_loaded).max()
- self.assertLess(max_diff, 1e-4)
-
- def test_stable_diffusion_pix2pix_zero_inversion(self):
- device = "cpu" # ensure determinism for the device-dependent torch.Generator
- components = self.get_dummy_components()
- sd_pipe = StableDiffusionPix2PixZeroPipeline(**components)
- sd_pipe = sd_pipe.to(device)
- sd_pipe.set_progress_bar_config(disable=None)
-
- inputs = self.get_dummy_inversion_inputs(device)
- inputs["image"] = inputs["image"][:1]
- inputs["prompt"] = inputs["prompt"][:1]
- image = sd_pipe.invert(**inputs).images
- image_slice = image[0, -3:, -3:, -1]
- assert image.shape == (1, 32, 32, 3)
- expected_slice = np.array([0.4823, 0.4783, 0.5638, 0.5201, 0.5247, 0.5644, 0.5029, 0.5404, 0.5062])
-
- assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-3
-
- def test_stable_diffusion_pix2pix_zero_inversion_batch(self):
- device = "cpu" # ensure determinism for the device-dependent torch.Generator
- components = self.get_dummy_components()
- sd_pipe = StableDiffusionPix2PixZeroPipeline(**components)
- sd_pipe = sd_pipe.to(device)
- sd_pipe.set_progress_bar_config(disable=None)
-
- inputs = self.get_dummy_inversion_inputs(device)
- image = sd_pipe.invert(**inputs).images
- image_slice = image[1, -3:, -3:, -1]
- assert image.shape == (2, 32, 32, 3)
- expected_slice = np.array([0.6446, 0.5232, 0.4914, 0.4441, 0.4654, 0.5546, 0.4650, 0.4938, 0.5044])
-
- assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-3
-
- def test_stable_diffusion_pix2pix_zero_default_case(self):
- device = "cpu" # ensure determinism for the device-dependent torch.Generator
- components = self.get_dummy_components()
- sd_pipe = StableDiffusionPix2PixZeroPipeline(**components)
- sd_pipe = sd_pipe.to(device)
- sd_pipe.set_progress_bar_config(disable=None)
-
- inputs = self.get_dummy_inputs(device)
- image = sd_pipe(**inputs).images
- image_slice = image[0, -3:, -3:, -1]
- assert image.shape == (1, 64, 64, 3)
- expected_slice = np.array([0.4863, 0.5053, 0.5033, 0.4007, 0.3571, 0.4768, 0.5176, 0.5277, 0.4940])
-
- assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-3
-
- def test_stable_diffusion_pix2pix_zero_negative_prompt(self):
- device = "cpu" # ensure determinism for the device-dependent torch.Generator
- components = self.get_dummy_components()
- sd_pipe = StableDiffusionPix2PixZeroPipeline(**components)
- sd_pipe = sd_pipe.to(device)
- sd_pipe.set_progress_bar_config(disable=None)
-
- inputs = self.get_dummy_inputs(device)
- negative_prompt = "french fries"
- output = sd_pipe(**inputs, negative_prompt=negative_prompt)
- image = output.images
- image_slice = image[0, -3:, -3:, -1]
-
- assert image.shape == (1, 64, 64, 3)
- expected_slice = np.array([0.5177, 0.5097, 0.5047, 0.4076, 0.3667, 0.4767, 0.5238, 0.5307, 0.4958])
-
- assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-3
-
- def test_stable_diffusion_pix2pix_zero_euler(self):
- device = "cpu" # ensure determinism for the device-dependent torch.Generator
- components = self.get_dummy_components()
- components["scheduler"] = EulerAncestralDiscreteScheduler(
- beta_start=0.00085, beta_end=0.012, beta_schedule="scaled_linear"
- )
- sd_pipe = StableDiffusionPix2PixZeroPipeline(**components)
- sd_pipe = sd_pipe.to(device)
- sd_pipe.set_progress_bar_config(disable=None)
-
- inputs = self.get_dummy_inputs(device)
- image = sd_pipe(**inputs).images
- image_slice = image[0, -3:, -3:, -1]
-
- assert image.shape == (1, 64, 64, 3)
- expected_slice = np.array([0.5421, 0.5525, 0.6085, 0.5279, 0.4658, 0.5317, 0.4418, 0.4815, 0.5132])
-
- assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-3
-
- def test_stable_diffusion_pix2pix_zero_ddpm(self):
- device = "cpu" # ensure determinism for the device-dependent torch.Generator
- components = self.get_dummy_components()
- components["scheduler"] = DDPMScheduler()
- sd_pipe = StableDiffusionPix2PixZeroPipeline(**components)
- sd_pipe = sd_pipe.to(device)
- sd_pipe.set_progress_bar_config(disable=None)
-
- inputs = self.get_dummy_inputs(device)
- image = sd_pipe(**inputs).images
- image_slice = image[0, -3:, -3:, -1]
-
- assert image.shape == (1, 64, 64, 3)
- expected_slice = np.array([0.4861, 0.5053, 0.5038, 0.3994, 0.3562, 0.4768, 0.5172, 0.5280, 0.4938])
-
- assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-3
-
- def test_stable_diffusion_pix2pix_zero_inversion_pt_np_pil_outputs_equivalent(self):
- device = torch_device
- components = self.get_dummy_components()
- sd_pipe = StableDiffusionPix2PixZeroPipeline(**components)
- sd_pipe = sd_pipe.to(device)
- sd_pipe.set_progress_bar_config(disable=None)
-
- output_pt = sd_pipe.invert(**self.get_dummy_inversion_inputs_by_type(device, output_type="pt")).images
- output_np = sd_pipe.invert(**self.get_dummy_inversion_inputs_by_type(device, output_type="np")).images
- output_pil = sd_pipe.invert(**self.get_dummy_inversion_inputs_by_type(device, output_type="pil")).images
-
- max_diff = np.abs(output_pt.cpu().numpy().transpose(0, 2, 3, 1) - output_np).max()
- self.assertLess(max_diff, 1e-4, "`output_type=='pt'` generate different results from `output_type=='np'`")
-
- max_diff = np.abs(np.array(output_pil[0]) - (output_np[0] * 255).round()).max()
- self.assertLess(max_diff, 2.0, "`output_type=='pil'` generate different results from `output_type=='np'`")
-
- def test_stable_diffusion_pix2pix_zero_inversion_pt_np_pil_inputs_equivalent(self):
- device = torch_device
- components = self.get_dummy_components()
- sd_pipe = StableDiffusionPix2PixZeroPipeline(**components)
- sd_pipe = sd_pipe.to(device)
- sd_pipe.set_progress_bar_config(disable=None)
-
- out_input_pt = sd_pipe.invert(**self.get_dummy_inversion_inputs_by_type(device, input_image_type="pt")).images
- out_input_np = sd_pipe.invert(**self.get_dummy_inversion_inputs_by_type(device, input_image_type="np")).images
- out_input_pil = sd_pipe.invert(
- **self.get_dummy_inversion_inputs_by_type(device, input_image_type="pil")
- ).images
-
- max_diff = np.abs(out_input_pt - out_input_np).max()
- self.assertLess(max_diff, 1e-4, "`input_type=='pt'` generate different result from `input_type=='np'`")
-
- assert_mean_pixel_difference(out_input_pil, out_input_np, expected_max_diff=1)
-
- # Non-determinism caused by the scheduler optimizing the latent inputs during inference
- @unittest.skip("non-deterministic pipeline")
- def test_inference_batch_single_identical(self):
- return super().test_inference_batch_single_identical()
-
-
-@slow
-@require_torch_gpu
-class StableDiffusionPix2PixZeroPipelineSlowTests(unittest.TestCase):
- def tearDown(self):
- super().tearDown()
- gc.collect()
- torch.cuda.empty_cache()
-
- @classmethod
- def setUpClass(cls):
- cls.source_embeds = load_pt(
- "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/pix2pix/cat.pt"
- )
-
- cls.target_embeds = load_pt(
- "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/pix2pix/dog.pt"
- )
-
- def get_inputs(self, seed=0):
- generator = torch.manual_seed(seed)
-
- inputs = {
- "prompt": "turn him into a cyborg",
- "generator": generator,
- "num_inference_steps": 3,
- "guidance_scale": 7.5,
- "cross_attention_guidance_amount": 0.15,
- "source_embeds": self.source_embeds,
- "target_embeds": self.target_embeds,
- "output_type": "numpy",
- }
- return inputs
-
- def test_stable_diffusion_pix2pix_zero_default(self):
- pipe = StableDiffusionPix2PixZeroPipeline.from_pretrained(
- "CompVis/stable-diffusion-v1-4", safety_checker=None, torch_dtype=torch.float16
- )
- pipe.scheduler = DDIMScheduler.from_config(pipe.scheduler.config)
- pipe.to(torch_device)
- pipe.set_progress_bar_config(disable=None)
- pipe.enable_attention_slicing()
-
- inputs = self.get_inputs()
- image = pipe(**inputs).images
- image_slice = image[0, -3:, -3:, -1].flatten()
-
- assert image.shape == (1, 512, 512, 3)
- expected_slice = np.array([0.5742, 0.5757, 0.5747, 0.5781, 0.5688, 0.5713, 0.5742, 0.5664, 0.5747])
-
- assert np.abs(expected_slice - image_slice).max() < 5e-2
-
- def test_stable_diffusion_pix2pix_zero_k_lms(self):
- pipe = StableDiffusionPix2PixZeroPipeline.from_pretrained(
- "CompVis/stable-diffusion-v1-4", safety_checker=None, torch_dtype=torch.float16
- )
- pipe.scheduler = LMSDiscreteScheduler.from_config(pipe.scheduler.config)
- pipe.to(torch_device)
- pipe.set_progress_bar_config(disable=None)
- pipe.enable_attention_slicing()
-
- inputs = self.get_inputs()
- image = pipe(**inputs).images
- image_slice = image[0, -3:, -3:, -1].flatten()
-
- assert image.shape == (1, 512, 512, 3)
- expected_slice = np.array([0.6367, 0.5459, 0.5146, 0.5479, 0.4905, 0.4753, 0.4961, 0.4629, 0.4624])
-
- assert np.abs(expected_slice - image_slice).max() < 5e-2
-
- def test_stable_diffusion_pix2pix_zero_intermediate_state(self):
- number_of_steps = 0
-
- def callback_fn(step: int, timestep: int, latents: torch.FloatTensor) -> None:
- callback_fn.has_been_called = True
- nonlocal number_of_steps
- number_of_steps += 1
- if step == 1:
- latents = latents.detach().cpu().numpy()
- assert latents.shape == (1, 4, 64, 64)
- latents_slice = latents[0, -3:, -3:, -1]
- expected_slice = np.array([0.1345, 0.268, 0.1539, 0.0726, 0.0959, 0.2261, -0.2673, 0.0277, -0.2062])
-
- assert np.abs(latents_slice.flatten() - expected_slice).max() < 5e-2
- elif step == 2:
- latents = latents.detach().cpu().numpy()
- assert latents.shape == (1, 4, 64, 64)
- latents_slice = latents[0, -3:, -3:, -1]
- expected_slice = np.array([0.1393, 0.2637, 0.1617, 0.0724, 0.0987, 0.2271, -0.2666, 0.0299, -0.2104])
-
- assert np.abs(latents_slice.flatten() - expected_slice).max() < 5e-2
-
- callback_fn.has_been_called = False
-
- pipe = StableDiffusionPix2PixZeroPipeline.from_pretrained(
- "CompVis/stable-diffusion-v1-4", safety_checker=None, torch_dtype=torch.float16
- )
- pipe.scheduler = DDIMScheduler.from_config(pipe.scheduler.config)
- pipe = pipe.to(torch_device)
- pipe.set_progress_bar_config(disable=None)
- pipe.enable_attention_slicing()
-
- inputs = self.get_inputs()
- pipe(**inputs, callback=callback_fn, callback_steps=1)
- assert callback_fn.has_been_called
- assert number_of_steps == 3
-
- def test_stable_diffusion_pipeline_with_sequential_cpu_offloading(self):
- torch.cuda.empty_cache()
- torch.cuda.reset_max_memory_allocated()
- torch.cuda.reset_peak_memory_stats()
-
- pipe = StableDiffusionPix2PixZeroPipeline.from_pretrained(
- "CompVis/stable-diffusion-v1-4", safety_checker=None, torch_dtype=torch.float16
- )
- pipe.scheduler = DDIMScheduler.from_config(pipe.scheduler.config)
- pipe = pipe.to(torch_device)
- pipe.set_progress_bar_config(disable=None)
- pipe.enable_attention_slicing(1)
- pipe.enable_sequential_cpu_offload()
-
- inputs = self.get_inputs()
- _ = pipe(**inputs)
-
- mem_bytes = torch.cuda.max_memory_allocated()
- # make sure that less than 8.2 GB is allocated
- assert mem_bytes < 8.2 * 10**9
-
-
-@slow
-@require_torch_gpu
-class InversionPipelineSlowTests(unittest.TestCase):
- def tearDown(self):
- super().tearDown()
- gc.collect()
- torch.cuda.empty_cache()
-
- @classmethod
- def setUpClass(cls):
- raw_image = load_image(
- "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/pix2pix/cat_6.png"
- )
-
- raw_image = raw_image.convert("RGB").resize((512, 512))
-
- cls.raw_image = raw_image
-
- def test_stable_diffusion_pix2pix_inversion(self):
- pipe = StableDiffusionPix2PixZeroPipeline.from_pretrained(
- "CompVis/stable-diffusion-v1-4", safety_checker=None, torch_dtype=torch.float16
- )
- pipe.inverse_scheduler = DDIMInverseScheduler.from_config(pipe.scheduler.config)
-
- caption = "a photography of a cat with flowers"
- pipe.scheduler = DDIMScheduler.from_config(pipe.scheduler.config)
- pipe.enable_model_cpu_offload()
- pipe.set_progress_bar_config(disable=None)
-
- generator = torch.manual_seed(0)
- output = pipe.invert(caption, image=self.raw_image, generator=generator, num_inference_steps=10)
- inv_latents = output[0]
-
- image_slice = inv_latents[0, -3:, -3:, -1].flatten()
-
- assert inv_latents.shape == (1, 4, 64, 64)
- expected_slice = np.array([0.8447, -0.0730, 0.7588, -1.2070, -0.4678, 0.1511, -0.8555, 1.1816, -0.7666])
-
- assert np.abs(expected_slice - image_slice.cpu().numpy()).max() < 5e-2
-
- def test_stable_diffusion_2_pix2pix_inversion(self):
- pipe = StableDiffusionPix2PixZeroPipeline.from_pretrained(
- "stabilityai/stable-diffusion-2-1", safety_checker=None, torch_dtype=torch.float16
- )
- pipe.inverse_scheduler = DDIMInverseScheduler.from_config(pipe.scheduler.config)
-
- caption = "a photography of a cat with flowers"
- pipe.scheduler = DDIMScheduler.from_config(pipe.scheduler.config)
- pipe.enable_model_cpu_offload()
- pipe.set_progress_bar_config(disable=None)
-
- generator = torch.manual_seed(0)
- output = pipe.invert(caption, image=self.raw_image, generator=generator, num_inference_steps=10)
- inv_latents = output[0]
-
- image_slice = inv_latents[0, -3:, -3:, -1].flatten()
-
- assert inv_latents.shape == (1, 4, 64, 64)
- expected_slice = np.array([0.8970, -0.1611, 0.4766, -1.1162, -0.5923, 0.1050, -0.9678, 1.0537, -0.6050])
-
- assert np.abs(expected_slice - image_slice.cpu().numpy()).max() < 5e-2
-
- def test_stable_diffusion_pix2pix_full(self):
- # numpy array of https://huggingface.co/datasets/hf-internal-testing/diffusers-images/blob/main/pix2pix/dog.png
- expected_image = load_numpy(
- "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/pix2pix/dog.npy"
- )
-
- pipe = StableDiffusionPix2PixZeroPipeline.from_pretrained(
- "CompVis/stable-diffusion-v1-4", safety_checker=None, torch_dtype=torch.float16
- )
- pipe.inverse_scheduler = DDIMInverseScheduler.from_config(pipe.scheduler.config)
-
- caption = "a photography of a cat with flowers"
- pipe.scheduler = DDIMScheduler.from_config(pipe.scheduler.config)
- pipe.enable_model_cpu_offload()
- pipe.set_progress_bar_config(disable=None)
-
- generator = torch.manual_seed(0)
- output = pipe.invert(caption, image=self.raw_image, generator=generator)
- inv_latents = output[0]
-
- source_prompts = 4 * ["a cat sitting on the street", "a cat playing in the field", "a face of a cat"]
- target_prompts = 4 * ["a dog sitting on the street", "a dog playing in the field", "a face of a dog"]
-
- source_embeds = pipe.get_embeds(source_prompts)
- target_embeds = pipe.get_embeds(target_prompts)
-
- image = pipe(
- caption,
- source_embeds=source_embeds,
- target_embeds=target_embeds,
- num_inference_steps=50,
- cross_attention_guidance_amount=0.15,
- generator=generator,
- latents=inv_latents,
- negative_prompt=caption,
- output_type="np",
- ).images
-
- max_diff = np.abs(expected_image - image).mean()
- assert max_diff < 0.05
-
- def test_stable_diffusion_2_pix2pix_full(self):
- # numpy array of https://huggingface.co/datasets/hf-internal-testing/diffusers-images/blob/main/pix2pix/dog_2.png
- expected_image = load_numpy(
- "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/pix2pix/dog_2.npy"
- )
-
- pipe = StableDiffusionPix2PixZeroPipeline.from_pretrained(
- "stabilityai/stable-diffusion-2-1", safety_checker=None, torch_dtype=torch.float16
- )
- pipe.inverse_scheduler = DDIMInverseScheduler.from_config(pipe.scheduler.config)
-
- caption = "a photography of a cat with flowers"
- pipe.scheduler = DDIMScheduler.from_config(pipe.scheduler.config)
- pipe.enable_model_cpu_offload()
- pipe.set_progress_bar_config(disable=None)
-
- generator = torch.manual_seed(0)
- output = pipe.invert(caption, image=self.raw_image, generator=generator)
- inv_latents = output[0]
-
- source_prompts = 4 * ["a cat sitting on the street", "a cat playing in the field", "a face of a cat"]
- target_prompts = 4 * ["a dog sitting on the street", "a dog playing in the field", "a face of a dog"]
-
- source_embeds = pipe.get_embeds(source_prompts)
- target_embeds = pipe.get_embeds(target_prompts)
-
- image = pipe(
- caption,
- source_embeds=source_embeds,
- target_embeds=target_embeds,
- num_inference_steps=125,
- cross_attention_guidance_amount=0.015,
- generator=generator,
- latents=inv_latents,
- negative_prompt=caption,
- output_type="np",
- ).images
-
- mean_diff = np.abs(expected_image - image).mean()
- assert mean_diff < 0.25
diff --git a/spaces/Andy1621/IAT_enhancement/model/__init__.py b/spaces/Andy1621/IAT_enhancement/model/__init__.py
deleted file mode 100644
index be46bf1d519bdda61e4848f29cfad2545547e46c..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/IAT_enhancement/model/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-from .IAT import IAT
\ No newline at end of file
diff --git a/spaces/Andy1621/uniformer_image_detection/configs/hrnet/htc_hrnetv2p_w18_20e_coco.py b/spaces/Andy1621/uniformer_image_detection/configs/hrnet/htc_hrnetv2p_w18_20e_coco.py
deleted file mode 100644
index 391636ff452471af367ed14be5faa49c0b7e1be6..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_detection/configs/hrnet/htc_hrnetv2p_w18_20e_coco.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = './htc_hrnetv2p_w32_20e_coco.py'
-model = dict(
- pretrained='open-mmlab://msra/hrnetv2_w18',
- backbone=dict(
- extra=dict(
- stage2=dict(num_channels=(18, 36)),
- stage3=dict(num_channels=(18, 36, 72)),
- stage4=dict(num_channels=(18, 36, 72, 144)))),
- neck=dict(type='HRFPN', in_channels=[18, 36, 72, 144], out_channels=256))
diff --git a/spaces/Andy1621/uniformer_image_detection/configs/pisa/pisa_mask_rcnn_r50_fpn_1x_coco.py b/spaces/Andy1621/uniformer_image_detection/configs/pisa/pisa_mask_rcnn_r50_fpn_1x_coco.py
deleted file mode 100644
index 047a293466a20ea90501e3054d7fcfe23fcdcb39..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_detection/configs/pisa/pisa_mask_rcnn_r50_fpn_1x_coco.py
+++ /dev/null
@@ -1,30 +0,0 @@
-_base_ = '../mask_rcnn/mask_rcnn_r50_fpn_1x_coco.py'
-
-model = dict(
- roi_head=dict(
- type='PISARoIHead',
- bbox_head=dict(
- loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0))),
- train_cfg=dict(
- rpn_proposal=dict(
- nms_pre=2000,
- max_per_img=2000,
- nms=dict(type='nms', iou_threshold=0.7),
- min_bbox_size=0),
- rcnn=dict(
- sampler=dict(
- type='ScoreHLRSampler',
- num=512,
- pos_fraction=0.25,
- neg_pos_ub=-1,
- add_gt_as_proposals=True,
- k=0.5,
- bias=0.),
- isr=dict(k=2, bias=0),
- carl=dict(k=1, bias=0.2))),
- test_cfg=dict(
- rpn=dict(
- nms_pre=2000,
- max_per_img=2000,
- nms=dict(type='nms', iou_threshold=0.7),
- min_bbox_size=0)))
diff --git a/spaces/AnishKumbhar/ChatBot/text-generation-webui-main/api-examples/api-example-model.py b/spaces/AnishKumbhar/ChatBot/text-generation-webui-main/api-examples/api-example-model.py
deleted file mode 100644
index 44109d36c222cc1e47215cbe40bf55ff8009b2d1..0000000000000000000000000000000000000000
--- a/spaces/AnishKumbhar/ChatBot/text-generation-webui-main/api-examples/api-example-model.py
+++ /dev/null
@@ -1,176 +0,0 @@
-#!/usr/bin/env python3
-
-import requests
-
-HOST = '0.0.0.0:5000'
-
-
-def generate(prompt, tokens=200):
- request = {'prompt': prompt, 'max_new_tokens': tokens}
- response = requests.post(f'http://{HOST}/api/v1/generate', json=request)
-
- if response.status_code == 200:
- return response.json()['results'][0]['text']
-
-
-def model_api(request):
- response = requests.post(f'http://{HOST}/api/v1/model', json=request)
- return response.json()
-
-
-# print some common settings
-def print_basic_model_info(response):
- basic_settings = ['truncation_length', 'instruction_template']
- print("Model: ", response['result']['model_name'])
- print("Lora(s): ", response['result']['lora_names'])
- for setting in basic_settings:
- print(setting, "=", response['result']['shared.settings'][setting])
-
-
-# model info
-def model_info():
- response = model_api({'action': 'info'})
- print_basic_model_info(response)
-
-
-# simple loader
-def model_load(model_name):
- return model_api({'action': 'load', 'model_name': model_name})
-
-
-# complex loader
-def complex_model_load(model):
-
- def guess_groupsize(model_name):
- if '1024g' in model_name:
- return 1024
- elif '128g' in model_name:
- return 128
- elif '32g' in model_name:
- return 32
- else:
- return -1
-
- req = {
- 'action': 'load',
- 'model_name': model,
- 'args': {
- 'loader': 'AutoGPTQ',
-
- 'bf16': False,
- 'load_in_8bit': False,
- 'groupsize': 0,
- 'wbits': 0,
-
- # llama.cpp
- 'threads': 0,
- 'n_batch': 512,
- 'no_mmap': False,
- 'mlock': False,
- 'cache_capacity': None,
- 'n_gpu_layers': 0,
- 'n_ctx': 2048,
-
- # RWKV
- 'rwkv_strategy': None,
- 'rwkv_cuda_on': False,
-
- # b&b 4-bit
- # 'load_in_4bit': False,
- # 'compute_dtype': 'float16',
- # 'quant_type': 'nf4',
- # 'use_double_quant': False,
-
- # "cpu": false,
- # "auto_devices": false,
- # "gpu_memory": null,
- # "cpu_memory": null,
- # "disk": false,
- # "disk_cache_dir": "cache",
- },
- }
-
- model = model.lower()
-
- if '4bit' in model or 'gptq' in model or 'int4' in model:
- req['args']['wbits'] = 4
- req['args']['groupsize'] = guess_groupsize(model)
- elif '3bit' in model:
- req['args']['wbits'] = 3
- req['args']['groupsize'] = guess_groupsize(model)
- else:
- req['args']['gptq_for_llama'] = False
-
- if '8bit' in model:
- req['args']['load_in_8bit'] = True
- elif '-hf' in model or 'fp16' in model:
- if '7b' in model:
- req['args']['bf16'] = True # for 24GB
- elif '13b' in model:
- req['args']['load_in_8bit'] = True # for 24GB
- elif 'gguf' in model:
- # req['args']['threads'] = 16
- if '7b' in model:
- req['args']['n_gpu_layers'] = 100
- elif '13b' in model:
- req['args']['n_gpu_layers'] = 100
- elif '30b' in model or '33b' in model:
- req['args']['n_gpu_layers'] = 59 # 24GB
- elif '65b' in model:
- req['args']['n_gpu_layers'] = 42 # 24GB
- elif 'rwkv' in model:
- req['args']['rwkv_cuda_on'] = True
- if '14b' in model:
- req['args']['rwkv_strategy'] = 'cuda f16i8' # 24GB
- else:
- req['args']['rwkv_strategy'] = 'cuda f16' # 24GB
-
- return model_api(req)
-
-
-if __name__ == '__main__':
- for model in model_api({'action': 'list'})['result']:
- try:
- resp = complex_model_load(model)
-
- if 'error' in resp:
- print(f"❌ {model} FAIL Error: {resp['error']['message']}")
- continue
- else:
- print_basic_model_info(resp)
-
- ans = generate("0,1,1,2,3,5,8,13,", tokens=2)
-
- if '21' in ans:
- print(f"✅ {model} PASS ({ans})")
- else:
- print(f"❌ {model} FAIL ({ans})")
-
- except Exception as e:
- print(f"❌ {model} FAIL Exception: {repr(e)}")
-
-
-# 0,1,1,2,3,5,8,13, is the fibonacci sequence, the next number is 21.
-# Some results below.
-""" $ ./model-api-example.py
-Model: 4bit_gpt4-x-alpaca-13b-native-4bit-128g-cuda
-Lora(s): []
-truncation_length = 2048
-instruction_template = Alpaca
-✅ 4bit_gpt4-x-alpaca-13b-native-4bit-128g-cuda PASS (21)
-Model: 4bit_WizardLM-13B-Uncensored-4bit-128g
-Lora(s): []
-truncation_length = 2048
-instruction_template = WizardLM
-✅ 4bit_WizardLM-13B-Uncensored-4bit-128g PASS (21)
-Model: Aeala_VicUnlocked-alpaca-30b-4bit
-Lora(s): []
-truncation_length = 2048
-instruction_template = Alpaca
-✅ Aeala_VicUnlocked-alpaca-30b-4bit PASS (21)
-Model: alpaca-30b-4bit
-Lora(s): []
-truncation_length = 2048
-instruction_template = Alpaca
-✅ alpaca-30b-4bit PASS (21)
-"""
diff --git a/spaces/Anni123/AuRoRA/demo_utils.py b/spaces/Anni123/AuRoRA/demo_utils.py
deleted file mode 100644
index 8ac7d2b63156d74d47e5242a7a0ccc69d8209b0b..0000000000000000000000000000000000000000
--- a/spaces/Anni123/AuRoRA/demo_utils.py
+++ /dev/null
@@ -1,35 +0,0 @@
-import os
-import json
-
-def self_construction(datatype):
- demo_dir = "./demo_pool/{datatype}_demo".format(datatype=datatype)
-
- data_dir = "./data_pool/{datatype}".format(datatype=datatype)
- if os.path.exists(demo_dir):
- print(demo_dir)
- if os.path.exists(data_dir):
- with open(data_dir, 'r') as f:
- for line in f.readlines
-
-self_construction('strategyqa')
-
-single_data = {
- 'question': "asfawreg",
- 'datatype': "dfawds",
- 'base_ans': "",
- 'base_cots': "",
- 'adapter_ans': "",
- 'revised_cots': "",
- 'retrieved_knowledge': "",
- 'feedback': ""
- }
-
-data_dir = "./data_pool/{datatype}".format(datatype="test")
-#with open(data_dir, 'a') as f:
-# data_json = json.dumps(single_data)
-# f.write(data_json + "\n")
-
-with open(data_dir, 'r') as f:
- for line in f.readlines():
- data_dict = json.loads(line)
- print(type(data_dict))
\ No newline at end of file
diff --git a/spaces/ArdaSaygan/PollGeneratorApp/utils.py b/spaces/ArdaSaygan/PollGeneratorApp/utils.py
deleted file mode 100644
index 045efd852772091bcdcad9efb6d98cf02dcc6b5c..0000000000000000000000000000000000000000
--- a/spaces/ArdaSaygan/PollGeneratorApp/utils.py
+++ /dev/null
@@ -1,57 +0,0 @@
-
-import openai
-openai.api_key = "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"
-
-class GPTCompletion:
- def __init__(
- self,
- system="You are a helpful AI assistant",
- model="gpt-3.5-turbo",
- temperature=1.0,
- top_p=1.0,
- n=1,
- stream=False,
- stop=None,
- max_tokens=256,
- presence_penalty=0.0,
- frequency_penalty=0.0,
- logit_bias={}
- ):
- self.system = system
- self.model = model
- self.messages = [{"role": "system", "content": f"{self.system}"}]
- self.temperature = temperature
- self.top_p = top_p
- self.n = n
- self.stream = stream
- self.stop = stop
- self.max_tokens = max_tokens
- self.presence_penalty = presence_penalty
- self.frequency_penalty = frequency_penalty
- self.logit_bias = logit_bias
-
-
- def chatComplete(self, chatHistory, newMessage,firstMessage=""):
-
- self.messages.append({"role": "user", "content": f"{firstMessage}"})
- for i in range(len(chatHistory)):
- self.messages.append({"role": "user", "content": f"{chatHistory[i][0]}"})
- self.messages.append({"role": "assistant", "content": f"{chatHistory[i][1]}"})
-
- self.messages.append({"role": "user", "content": f"{newMessage}"})
-
- response = openai.ChatCompletion.create(
- model=self.model,
- messages=self.messages,
- temperature=self.temperature,
- top_p=self.top_p,
- n=self.n,
- stream=self.stream,
- stop=self.stop,
- max_tokens=self.max_tokens,
- presence_penalty=self.presence_penalty,
- frequency_penalty=self.frequency_penalty,
- logit_bias=self.logit_bias
- )
-
- return response["choices"][0].message["content"].strip()
diff --git a/spaces/AriusXi/CodeGenerator/app.py b/spaces/AriusXi/CodeGenerator/app.py
deleted file mode 100644
index 11e6c534d288cd70f251351c75ff9ed19021a58f..0000000000000000000000000000000000000000
--- a/spaces/AriusXi/CodeGenerator/app.py
+++ /dev/null
@@ -1,17 +0,0 @@
-from transformers import AutoTokenizer, AutoModelForCausalLM
-import gradio as grad
-codegen_tkn = AutoTokenizer.from_pretrained("Salesforce/codegen-350M-mono")
-mdl = AutoModelForCausalLM.from_pretrained("Salesforce/codegen-350M-mono")
-
-def codegen(intent):
-# give input as text which reflects intent of the program.
- text = " write a function which takes 2 numbers as input and returns the larger of the two"
- input_ids = codegen_tkn(intent, return_tensors="pt").input_ids
-
- gen_ids = mdl.generate(input_ids, max_length=128)
- response = codegen_tkn.decode(gen_ids[0], skip_special_tokens=True)
- return response
-
-output=grad.Textbox(lines=1, label="Generated Python Code", placeholder="")
-inp=grad.Textbox(lines=1, label="Place your intent here")
-grad.Interface(codegen, inputs=inp, outputs=output).launch()
\ No newline at end of file
diff --git a/spaces/Arnx/MusicGenXvAKN/CHANGELOG.md b/spaces/Arnx/MusicGenXvAKN/CHANGELOG.md
deleted file mode 100644
index 24fc214df236b40efead4b1585b01632d9658e9b..0000000000000000000000000000000000000000
--- a/spaces/Arnx/MusicGenXvAKN/CHANGELOG.md
+++ /dev/null
@@ -1,23 +0,0 @@
-# Changelog
-
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
-
-## [0.0.2a] - TBD
-
-Improved demo, fixed top p (thanks @jnordberg).
-
-Compressor tanh on output to avoid clipping with some style (especially piano).
-Now repeating the conditioning periodically if it is too short.
-
-More options when launching Gradio app locally (thanks @ashleykleynhans).
-
-Testing out PyTorch 2.0 memory efficient attention.
-
-Added extended generation (infinite length) by slowly moving the windows.
-Note that other implementations exist: https://github.com/camenduru/MusicGen-colab.
-
-## [0.0.1] - 2023-06-09
-
-Initial release, with model evaluation only.
diff --git a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/pygments/filters/__init__.py b/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/pygments/filters/__init__.py
deleted file mode 100644
index c302a6c0c53d7efa8767bd55da2a73535bea0cbf..0000000000000000000000000000000000000000
--- a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/pygments/filters/__init__.py
+++ /dev/null
@@ -1,940 +0,0 @@
-"""
- pygments.filters
- ~~~~~~~~~~~~~~~~
-
- Module containing filter lookup functions and default
- filters.
-
- :copyright: Copyright 2006-2022 by the Pygments team, see AUTHORS.
- :license: BSD, see LICENSE for details.
-"""
-
-import re
-
-from pip._vendor.pygments.token import String, Comment, Keyword, Name, Error, Whitespace, \
- string_to_tokentype
-from pip._vendor.pygments.filter import Filter
-from pip._vendor.pygments.util import get_list_opt, get_int_opt, get_bool_opt, \
- get_choice_opt, ClassNotFound, OptionError
-from pip._vendor.pygments.plugin import find_plugin_filters
-
-
-def find_filter_class(filtername):
- """Lookup a filter by name. Return None if not found."""
- if filtername in FILTERS:
- return FILTERS[filtername]
- for name, cls in find_plugin_filters():
- if name == filtername:
- return cls
- return None
-
-
-def get_filter_by_name(filtername, **options):
- """Return an instantiated filter.
-
- Options are passed to the filter initializer if wanted.
- Raise a ClassNotFound if not found.
- """
- cls = find_filter_class(filtername)
- if cls:
- return cls(**options)
- else:
- raise ClassNotFound('filter %r not found' % filtername)
-
-
-def get_all_filters():
- """Return a generator of all filter names."""
- yield from FILTERS
- for name, _ in find_plugin_filters():
- yield name
-
-
-def _replace_special(ttype, value, regex, specialttype,
- replacefunc=lambda x: x):
- last = 0
- for match in regex.finditer(value):
- start, end = match.start(), match.end()
- if start != last:
- yield ttype, value[last:start]
- yield specialttype, replacefunc(value[start:end])
- last = end
- if last != len(value):
- yield ttype, value[last:]
-
-
-class CodeTagFilter(Filter):
- """Highlight special code tags in comments and docstrings.
-
- Options accepted:
-
- `codetags` : list of strings
- A list of strings that are flagged as code tags. The default is to
- highlight ``XXX``, ``TODO``, ``FIXME``, ``BUG`` and ``NOTE``.
-
- .. versionchanged:: 2.13
- Now recognizes ``FIXME`` by default.
- """
-
- def __init__(self, **options):
- Filter.__init__(self, **options)
- tags = get_list_opt(options, 'codetags',
- ['XXX', 'TODO', 'FIXME', 'BUG', 'NOTE'])
- self.tag_re = re.compile(r'\b(%s)\b' % '|'.join([
- re.escape(tag) for tag in tags if tag
- ]))
-
- def filter(self, lexer, stream):
- regex = self.tag_re
- for ttype, value in stream:
- if ttype in String.Doc or \
- ttype in Comment and \
- ttype not in Comment.Preproc:
- yield from _replace_special(ttype, value, regex, Comment.Special)
- else:
- yield ttype, value
-
-
-class SymbolFilter(Filter):
- """Convert mathematical symbols such as \\ in Isabelle
- or \\longrightarrow in LaTeX into Unicode characters.
-
- This is mostly useful for HTML or console output when you want to
- approximate the source rendering you'd see in an IDE.
-
- Options accepted:
-
- `lang` : string
- The symbol language. Must be one of ``'isabelle'`` or
- ``'latex'``. The default is ``'isabelle'``.
- """
-
- latex_symbols = {
- '\\alpha' : '\U000003b1',
- '\\beta' : '\U000003b2',
- '\\gamma' : '\U000003b3',
- '\\delta' : '\U000003b4',
- '\\varepsilon' : '\U000003b5',
- '\\zeta' : '\U000003b6',
- '\\eta' : '\U000003b7',
- '\\vartheta' : '\U000003b8',
- '\\iota' : '\U000003b9',
- '\\kappa' : '\U000003ba',
- '\\lambda' : '\U000003bb',
- '\\mu' : '\U000003bc',
- '\\nu' : '\U000003bd',
- '\\xi' : '\U000003be',
- '\\pi' : '\U000003c0',
- '\\varrho' : '\U000003c1',
- '\\sigma' : '\U000003c3',
- '\\tau' : '\U000003c4',
- '\\upsilon' : '\U000003c5',
- '\\varphi' : '\U000003c6',
- '\\chi' : '\U000003c7',
- '\\psi' : '\U000003c8',
- '\\omega' : '\U000003c9',
- '\\Gamma' : '\U00000393',
- '\\Delta' : '\U00000394',
- '\\Theta' : '\U00000398',
- '\\Lambda' : '\U0000039b',
- '\\Xi' : '\U0000039e',
- '\\Pi' : '\U000003a0',
- '\\Sigma' : '\U000003a3',
- '\\Upsilon' : '\U000003a5',
- '\\Phi' : '\U000003a6',
- '\\Psi' : '\U000003a8',
- '\\Omega' : '\U000003a9',
- '\\leftarrow' : '\U00002190',
- '\\longleftarrow' : '\U000027f5',
- '\\rightarrow' : '\U00002192',
- '\\longrightarrow' : '\U000027f6',
- '\\Leftarrow' : '\U000021d0',
- '\\Longleftarrow' : '\U000027f8',
- '\\Rightarrow' : '\U000021d2',
- '\\Longrightarrow' : '\U000027f9',
- '\\leftrightarrow' : '\U00002194',
- '\\longleftrightarrow' : '\U000027f7',
- '\\Leftrightarrow' : '\U000021d4',
- '\\Longleftrightarrow' : '\U000027fa',
- '\\mapsto' : '\U000021a6',
- '\\longmapsto' : '\U000027fc',
- '\\relbar' : '\U00002500',
- '\\Relbar' : '\U00002550',
- '\\hookleftarrow' : '\U000021a9',
- '\\hookrightarrow' : '\U000021aa',
- '\\leftharpoondown' : '\U000021bd',
- '\\rightharpoondown' : '\U000021c1',
- '\\leftharpoonup' : '\U000021bc',
- '\\rightharpoonup' : '\U000021c0',
- '\\rightleftharpoons' : '\U000021cc',
- '\\leadsto' : '\U0000219d',
- '\\downharpoonleft' : '\U000021c3',
- '\\downharpoonright' : '\U000021c2',
- '\\upharpoonleft' : '\U000021bf',
- '\\upharpoonright' : '\U000021be',
- '\\restriction' : '\U000021be',
- '\\uparrow' : '\U00002191',
- '\\Uparrow' : '\U000021d1',
- '\\downarrow' : '\U00002193',
- '\\Downarrow' : '\U000021d3',
- '\\updownarrow' : '\U00002195',
- '\\Updownarrow' : '\U000021d5',
- '\\langle' : '\U000027e8',
- '\\rangle' : '\U000027e9',
- '\\lceil' : '\U00002308',
- '\\rceil' : '\U00002309',
- '\\lfloor' : '\U0000230a',
- '\\rfloor' : '\U0000230b',
- '\\flqq' : '\U000000ab',
- '\\frqq' : '\U000000bb',
- '\\bot' : '\U000022a5',
- '\\top' : '\U000022a4',
- '\\wedge' : '\U00002227',
- '\\bigwedge' : '\U000022c0',
- '\\vee' : '\U00002228',
- '\\bigvee' : '\U000022c1',
- '\\forall' : '\U00002200',
- '\\exists' : '\U00002203',
- '\\nexists' : '\U00002204',
- '\\neg' : '\U000000ac',
- '\\Box' : '\U000025a1',
- '\\Diamond' : '\U000025c7',
- '\\vdash' : '\U000022a2',
- '\\models' : '\U000022a8',
- '\\dashv' : '\U000022a3',
- '\\surd' : '\U0000221a',
- '\\le' : '\U00002264',
- '\\ge' : '\U00002265',
- '\\ll' : '\U0000226a',
- '\\gg' : '\U0000226b',
- '\\lesssim' : '\U00002272',
- '\\gtrsim' : '\U00002273',
- '\\lessapprox' : '\U00002a85',
- '\\gtrapprox' : '\U00002a86',
- '\\in' : '\U00002208',
- '\\notin' : '\U00002209',
- '\\subset' : '\U00002282',
- '\\supset' : '\U00002283',
- '\\subseteq' : '\U00002286',
- '\\supseteq' : '\U00002287',
- '\\sqsubset' : '\U0000228f',
- '\\sqsupset' : '\U00002290',
- '\\sqsubseteq' : '\U00002291',
- '\\sqsupseteq' : '\U00002292',
- '\\cap' : '\U00002229',
- '\\bigcap' : '\U000022c2',
- '\\cup' : '\U0000222a',
- '\\bigcup' : '\U000022c3',
- '\\sqcup' : '\U00002294',
- '\\bigsqcup' : '\U00002a06',
- '\\sqcap' : '\U00002293',
- '\\Bigsqcap' : '\U00002a05',
- '\\setminus' : '\U00002216',
- '\\propto' : '\U0000221d',
- '\\uplus' : '\U0000228e',
- '\\bigplus' : '\U00002a04',
- '\\sim' : '\U0000223c',
- '\\doteq' : '\U00002250',
- '\\simeq' : '\U00002243',
- '\\approx' : '\U00002248',
- '\\asymp' : '\U0000224d',
- '\\cong' : '\U00002245',
- '\\equiv' : '\U00002261',
- '\\Join' : '\U000022c8',
- '\\bowtie' : '\U00002a1d',
- '\\prec' : '\U0000227a',
- '\\succ' : '\U0000227b',
- '\\preceq' : '\U0000227c',
- '\\succeq' : '\U0000227d',
- '\\parallel' : '\U00002225',
- '\\mid' : '\U000000a6',
- '\\pm' : '\U000000b1',
- '\\mp' : '\U00002213',
- '\\times' : '\U000000d7',
- '\\div' : '\U000000f7',
- '\\cdot' : '\U000022c5',
- '\\star' : '\U000022c6',
- '\\circ' : '\U00002218',
- '\\dagger' : '\U00002020',
- '\\ddagger' : '\U00002021',
- '\\lhd' : '\U000022b2',
- '\\rhd' : '\U000022b3',
- '\\unlhd' : '\U000022b4',
- '\\unrhd' : '\U000022b5',
- '\\triangleleft' : '\U000025c3',
- '\\triangleright' : '\U000025b9',
- '\\triangle' : '\U000025b3',
- '\\triangleq' : '\U0000225c',
- '\\oplus' : '\U00002295',
- '\\bigoplus' : '\U00002a01',
- '\\otimes' : '\U00002297',
- '\\bigotimes' : '\U00002a02',
- '\\odot' : '\U00002299',
- '\\bigodot' : '\U00002a00',
- '\\ominus' : '\U00002296',
- '\\oslash' : '\U00002298',
- '\\dots' : '\U00002026',
- '\\cdots' : '\U000022ef',
- '\\sum' : '\U00002211',
- '\\prod' : '\U0000220f',
- '\\coprod' : '\U00002210',
- '\\infty' : '\U0000221e',
- '\\int' : '\U0000222b',
- '\\oint' : '\U0000222e',
- '\\clubsuit' : '\U00002663',
- '\\diamondsuit' : '\U00002662',
- '\\heartsuit' : '\U00002661',
- '\\spadesuit' : '\U00002660',
- '\\aleph' : '\U00002135',
- '\\emptyset' : '\U00002205',
- '\\nabla' : '\U00002207',
- '\\partial' : '\U00002202',
- '\\flat' : '\U0000266d',
- '\\natural' : '\U0000266e',
- '\\sharp' : '\U0000266f',
- '\\angle' : '\U00002220',
- '\\copyright' : '\U000000a9',
- '\\textregistered' : '\U000000ae',
- '\\textonequarter' : '\U000000bc',
- '\\textonehalf' : '\U000000bd',
- '\\textthreequarters' : '\U000000be',
- '\\textordfeminine' : '\U000000aa',
- '\\textordmasculine' : '\U000000ba',
- '\\euro' : '\U000020ac',
- '\\pounds' : '\U000000a3',
- '\\yen' : '\U000000a5',
- '\\textcent' : '\U000000a2',
- '\\textcurrency' : '\U000000a4',
- '\\textdegree' : '\U000000b0',
- }
-
- isabelle_symbols = {
- '\\' : '\U0001d7ec',
- '\\' : '\U0001d7ed',
- '\\' : '\U0001d7ee',
- '\\' : '\U0001d7ef',
- '\\' : '\U0001d7f0',
- '\\' : '\U0001d7f1',
- '\\' : '\U0001d7f2',
- '\\' : '\U0001d7f3',
- '\\' : '\U0001d7f4',
- '\\' : '\U0001d7f5',
- '\\' : '\U0001d49c',
- '\\' : '\U0000212c',
- '\\' : '\U0001d49e',
- '\\' : '\U0001d49f',
- '\\' : '\U00002130',
- '\\' : '\U00002131',
- '\\' : '\U0001d4a2',
- '\\' : '\U0000210b',
- '\\' : '\U00002110',
- '\\' : '\U0001d4a5',
- '\\' : '\U0001d4a6',
- '\\' : '\U00002112',
- '\\' : '\U00002133',
- '\\' : '\U0001d4a9',
- '\\' : '\U0001d4aa',
- '\\' : '\U0001d4ab',
- '\\' : '\U0001d4ac',
- '\\' : '\U0000211b',
- '\\' : '\U0001d4ae',
- '\\' : '\U0001d4af',
- '\\' : '\U0001d4b0',
- '\\' : '\U0001d4b1',
- '\\' : '\U0001d4b2',
- '\\' : '\U0001d4b3',
- '\\' : '\U0001d4b4',
- '\\' : '\U0001d4b5',
- '\\' : '\U0001d5ba',
- '\\' : '\U0001d5bb',
- '\\' : '\U0001d5bc',
- '\\' : '\U0001d5bd',
- '\\' : '\U0001d5be',
- '\\' : '\U0001d5bf',
- '\\' : '\U0001d5c0',
- '\\' : '\U0001d5c1',
- '\\' : '\U0001d5c2',
- '\\' : '\U0001d5c3',
- '\\' : '\U0001d5c4',
- '\\' : '\U0001d5c5',
- '\\' : '\U0001d5c6',
- '\\' : '\U0001d5c7',
- '\\' : '\U0001d5c8',
- '\\' : '\U0001d5c9',
- '\\' : '\U0001d5ca',
- '\\' : '\U0001d5cb',
- '\\' : '\U0001d5cc',
- '\\' : '\U0001d5cd',
- '\\' : '\U0001d5ce',
- '\\' : '\U0001d5cf',
- '\\' : '\U0001d5d0',
- '\\' : '\U0001d5d1',
- '\\' : '\U0001d5d2',
- '\\' : '\U0001d5d3',
- '\\' : '\U0001d504',
- '\\' : '\U0001d505',
- '\\' : '\U0000212d',
- '\\' : '\U0001d507',
- '\\' : '\U0001d508',
- '\\' : '\U0001d509',
- '\\' : '\U0001d50a',
- '\\' : '\U0000210c',
- '\\' : '\U00002111',
- '\\' : '\U0001d50d',
- '\\' : '\U0001d50e',
- '\\' : '\U0001d50f',
- '\\' : '\U0001d510',
- '\\' : '\U0001d511',
- '\\' : '\U0001d512',
- '\\' : '\U0001d513',
- '\\' : '\U0001d514',
- '\\' : '\U0000211c',
- '\\' : '\U0001d516',
- '\\' : '\U0001d517',
- '\\' : '\U0001d518',
- '\\' : '\U0001d519',
- '\\' : '\U0001d51a',
- '\\' : '\U0001d51b',
- '\\' : '\U0001d51c',
- '\\' : '\U00002128',
- '\\' : '\U0001d51e',
- '\\' : '\U0001d51f',
- '\\' : '\U0001d520',
- '\\' : '\U0001d521',
- '\\' : '\U0001d522',
- '\\' : '\U0001d523',
- '\\' : '\U0001d524',
- '\\' : '\U0001d525',
- '\\' : '\U0001d526',
- '\\' : '\U0001d527',
- '\\' : '\U0001d528',
- '\\' : '\U0001d529',
- '\\' : '\U0001d52a',
- '\\' : '\U0001d52b',
- '\\' : '\U0001d52c',
- '\\' : '\U0001d52d',
- '\\' : '\U0001d52e',
- '\\' : '\U0001d52f',
- '\\' : '\U0001d530',
- '\\' : '\U0001d531',
- '\\' : '\U0001d532',
- '\\' : '\U0001d533',
- '\\' : '\U0001d534',
- '\\' : '\U0001d535',
- '\\' : '\U0001d536',
- '\\' : '\U0001d537',
- '\\' : '\U000003b1',
- '\\' : '\U000003b2',
- '\\' : '\U000003b3',
- '\\' : '\U000003b4',
- '\\' : '\U000003b5',
- '\\' : '\U000003b6',
- '\\' : '\U000003b7',
- '\\' : '\U000003b8',
- '\\' : '\U000003b9',
- '\\' : '\U000003ba',
- '\\' : '\U000003bb',
- '\\' : '\U000003bc',
- '\\' : '\U000003bd',
- '\\' : '\U000003be',
- '\\' : '\U000003c0',
- '\\' : '\U000003c1',
- '\\' : '\U000003c3',
- '\\' : '\U000003c4',
- '\\' : '\U000003c5',
- '\\' : '\U000003c6',
- '\\' : '\U000003c7',
- '\\' : '\U000003c8',
- '\\' : '\U000003c9',
- '\\' : '\U00000393',
- '\\' : '\U00000394',
- '\\' : '\U00000398',
- '\\' : '\U0000039b',
- '\\' : '\U0000039e',
- '\\' : '\U000003a0',
- '\\' : '\U000003a3',
- '\\' : '\U000003a5',
- '\\' : '\U000003a6',
- '\\' : '\U000003a8',
- '\\' : '\U000003a9',
- '\\' : '\U0001d539',
- '\\' : '\U00002102',
- '\\' : '\U00002115',
- '\\' : '\U0000211a',
- '\\' : '\U0000211d',
- '\\' : '\U00002124',
- '\\' : '\U00002190',
- '\\' : '\U000027f5',
- '\\' : '\U00002192',
- '\\' : '\U000027f6',
- '\\' : '\U000021d0',
- '\\' : '\U000027f8',
- '\\' : '\U000021d2',
- '\\' : '\U000027f9',
- '\\' : '\U00002194',
- '\\' : '\U000027f7',
- '\\' : '\U000021d4',
- '\\' : '\U000027fa',
- '\\' : '\U000021a6',
- '\\' : '\U000027fc',
- '\\' : '\U00002500',
- '\\' : '\U00002550',
- '\\' : '\U000021a9',
- '\\' : '\U000021aa',
- '\\' : '\U000021bd',
- '\\' : '\U000021c1',
- '\\' : '\U000021bc',
- '\\' : '\U000021c0',
- '\\' : '\U000021cc',
- '\\' : '\U0000219d',
- '\\' : '\U000021c3',
- '\\' : '\U000021c2',
- '\\' : '\U000021bf',
- '\\' : '\U000021be',
- '\\' : '\U000021be',
- '\\' : '\U00002237',
- '\\' : '\U00002191',
- '\\' : '\U000021d1',
- '\\' : '\U00002193',
- '\\' : '\U000021d3',
- '\\' : '\U00002195',
- '\\' : '\U000021d5',
- '\\' : '\U000027e8',
- '\\' : '\U000027e9',
- '\\' : '\U00002308',
- '\\' : '\U00002309',
- '\\' : '\U0000230a',
- '\\' : '\U0000230b',
- '\\' : '\U00002987',
- '\\' : '\U00002988',
- '\\' : '\U000027e6',
- '\\' : '\U000027e7',
- '\\' : '\U00002983',
- '\\' : '\U00002984',
- '\\' : '\U000000ab',
- '\\' : '\U000000bb',
- '\\' : '\U000022a5',
- '\\' : '\U000022a4',
- '\\' : '\U00002227',
- '\\' : '\U000022c0',
- '\\' : '\U00002228',
- '\\' : '\U000022c1',
- '\\' : '\U00002200',
- '\\' : '\U00002203',
- '\\' : '\U00002204',
- '\\' : '\U000000ac',
- '\\' : '\U000025a1',
- '\\' : '\U000025c7',
- '\\' : '\U000022a2',
- '\\' : '\U000022a8',
- '\\' : '\U000022a9',
- '\\' : '\U000022ab',
- '\\' : '\U000022a3',
- '\\' : '\U0000221a',
- '\\' : '\U00002264',
- '\\' : '\U00002265',
- '\\' : '\U0000226a',
- '\\' : '\U0000226b',
- '\\' : '\U00002272',
- '\\' : '\U00002273',
- '\\' : '\U00002a85',
- '\\' : '\U00002a86',
- '\\' : '\U00002208',
- '\\' : '\U00002209',
- '\\' : '\U00002282',
- '\\' : '\U00002283',
- '\\' : '\U00002286',
- '\\' : '\U00002287',
- '\\' : '\U0000228f',
- '\\