diff --git a/spaces/1gistliPinn/ChatGPT4/Examples/CivilCAD Free LINK Download Full Version.md b/spaces/1gistliPinn/ChatGPT4/Examples/CivilCAD Free LINK Download Full Version.md
deleted file mode 100644
index 97e8c316502a922edefc02c1339a42f48ebb8406..0000000000000000000000000000000000000000
--- a/spaces/1gistliPinn/ChatGPT4/Examples/CivilCAD Free LINK Download Full Version.md
+++ /dev/null
@@ -1,6 +0,0 @@
-
-
-Civil Cad Crack Download Free by Tamergen, released 26 November 2016 Civil Cad Crack Download Free >>> http://shorl.com/jyfifafypuvi ... 1fdad05405
-
-
-
diff --git a/spaces/1gistliPinn/ChatGPT4/Examples/Crack Crysis 2 Pc 64 Bits.md b/spaces/1gistliPinn/ChatGPT4/Examples/Crack Crysis 2 Pc 64 Bits.md
deleted file mode 100644
index 7293c25a45faa564e483751b64d38d9d45129869..0000000000000000000000000000000000000000
--- a/spaces/1gistliPinn/ChatGPT4/Examples/Crack Crysis 2 Pc 64 Bits.md
+++ /dev/null
@@ -1,25 +0,0 @@
-
-
How to Run Crysis 2 on Windows 10 64-bit OS
-
Crysis 2 is a sci-fi first-person shooter game developed by Crytek and released in 2011. It is the sequel to the critically acclaimed Crysis, which was known for its stunning graphics and demanding system requirements. Crysis 2 is set in a post-apocalyptic New York City, where the player has to fight against alien invaders and human enemies using a nanosuit that grants enhanced abilities.
-
Many PC gamers wonder if they can run Crysis 2 on Windows 10 64-bit OS, since the game was originally designed for Windows XP, Vista, and 7. The good news is that Crysis 2 is compatible with Windows 10 64-bit OS, as long as you have the recommended system requirements and install the latest patches and updates. Here are some tips on how to run Crysis 2 on Windows 10 64-bit OS smoothly and enjoyably.
Before you install and run Crysis 2 on Windows 10 64-bit OS, you should check if your PC meets the minimum or recommended system requirements for the game. Here are the official system requirements for Crysis 2:
-
-
Minimum Requirements
Recommended Requirements
-
CPU: Intel Core 2 Duo 2 GHz or AMD Athlon 64 X2 2 GHz
CPU: Intel Core i5-750 or AMD Phenom II X4 3 GHz
-
RAM: 2 GB
RAM: 3 GB
-
GPU: NVIDIA GeForce 8800 GT or ATI Radeon HD 3850 with 512 MB VRAM
GPU: NVIDIA GeForce GTX 260 or ATI Radeon HD 5850 with 1 GB VRAM
-
OS: Windows XP, Vista, or 7 (32-bit)
OS: Windows XP, Vista, or 7 (64-bit)
-
HDD: At least 9 GB of free space
HDD: At least 9 GB of free space
-
DX: DirectX 9.0c
DX: DirectX 11
-
Sound: DirectX compatible sound card
Sound: DirectX compatible sound card
-
Internet: Broadband connection for online multiplayer
Internet: Broadband connection for online multiplayer
-
-
If your PC meets the minimum requirements, you should be able to run Crysis 2 on Windows 10 64-bit OS at low settings and resolution. However, if you want to enjoy the game at higher settings and resolution, you should aim for the recommended requirements or higher. You can use tools like Can You Run It or System Requirements Lab to check your PC's compatibility with Crysis 2.
-
Install the Latest Patches and Updates
-
Another important step to run Crysis 2 on Windows 10 64-bit OS is to install the latest patches and updates for the game. These patches and updates fix various bugs, improve performance, and add new features to the game. The most important patch for Crysis 2 is Patch 1.9, which prepares the game for DirectX 11 features and high-resolution textures[^1^]. You can download Patch 1.9 from the official website of Crysis or from other sources like Steam or Origin.
-
Patch 1.9 also includes two optional downloads: DirectX 11 Ultra Upgrade and High-Resolution Textures[^1^]. These downloads enhance the graphics quality of Crysis
- d5da3c52bf
-
-
\ No newline at end of file
diff --git a/spaces/1gistliPinn/ChatGPT4/Examples/Download Feem Wifi Pro Cracked For Windowsk.md b/spaces/1gistliPinn/ChatGPT4/Examples/Download Feem Wifi Pro Cracked For Windowsk.md
deleted file mode 100644
index 7be3982da29baaa42dfb231b17aed1943fe7acb3..0000000000000000000000000000000000000000
--- a/spaces/1gistliPinn/ChatGPT4/Examples/Download Feem Wifi Pro Cracked For Windowsk.md
+++ /dev/null
@@ -1,6 +0,0 @@
-
-
-Ponyo Full Movie In English 1080p ->>> DOWNLOAD. Transforming into a little ... download feem wifi pro cracked for windowsk · Chudail Story ... 1fdad05405
-
-
-
diff --git a/spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Animal Connect How to Find and Match the Same Animals in Different Scenarios.md b/spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Animal Connect How to Find and Match the Same Animals in Different Scenarios.md
deleted file mode 100644
index 6010a558648894c7abe18a03c29704b8b4165e11..0000000000000000000000000000000000000000
--- a/spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Animal Connect How to Find and Match the Same Animals in Different Scenarios.md
+++ /dev/null
@@ -1,146 +0,0 @@
-
-
How to Connect with Animals: A Guide for Beginners
-
Have you ever wondered what your pet is thinking or feeling? Have you ever wished you could communicate with animals in a deeper and more meaningful way? If so, you are not alone. Many people have a natural curiosity and affinity for animals, and want to learn how to connect with them on a spiritual, emotional, or mental level.
-
Animal communication, also known as interspecies communication, is the ability to communicate with animals using non-verbal methods such as telepathy, intuition, or body language. It is not a supernatural or paranormal phenomenon, but rather a natural and innate skill that anyone can develop with practice and patience.
In this article, we will explore what animal communication is and why it is important, how to prepare yourself for it, how to practice it in different situations, and how to improve your abilities. We will also answer some frequently asked questions about animal communication at the end.
-
What is animal communication and why is it important?
-
Animal communication is the exchange of information and feelings between humans and animals without using words or sounds. It can involve sending and receiving images, emotions, thoughts, sensations, impressions, or intentions through a mental or energetic connection.
-
Animal communication is important for several reasons. First of all, it can help us understand animals better and appreciate their intelligence, personality, and emotions. It can also help us improve our relationship with them by resolving conflicts, addressing behavioral issues, or expressing our love and gratitude.
Secondly, animal communication can benefit both humans and animals in terms of health and well-being. It can help us detect and treat physical or emotional problems in animals before they become serious. It can also help us cope with stress, anxiety, grief, or loneliness by providing comfort and support from our animal friends.
-
Thirdly, animal communication can foster a deeper connection with nature and all living beings. It can help us respect and protect animals and their habitats by raising our awareness of their needs and rights. It can also help us learn from their wisdom and insights by tapping into their unique perspectives and experiences.
-
How to prepare yourself for animal communication
-
The skills and qualities you need to develop
-
To communicate with animals effectively, you need to develop some skills and qualities that will enhance your receptivity and accuracy. Some of these are:
-
-
Empathy: The ability to feel what another being is feeling and understand their point of view.
-
Intuition: The ability to access your inner knowing and trust your gut feelings.
-
Focus: The ability to concentrate on one thing at a time and block out distractions.
-
Calmness: The ability to relax your mind and body and release any tension or negativity.
-
Openness: The ability to be curious and willing to learn from animals without judgment or prejudice.
-
Honesty: The ability to be truthful and authentic with yourself and animals.
-
-
These skills and qualities can be cultivated through various practices such as meditation, mindfulness, yoga, journaling, or self-care. You can also learn from other animal communicators by reading books, taking courses, or joining communities.
-
The tools and techniques you can use
-
There are many tools and techniques that can help you communicate with animals more easily and effectively. Some of these are:
-
-
Photos: You can use photos of animals to establish a connection with them and send or receive messages. You can also use photos of yourself to introduce yourself to animals and share your intentions.
-
Objects: You can use objects that belong to animals or have their scent or energy to connect with them. For example, you can use their toys, collars, blankets, or hair.
-
Pendulums: You can use pendulums to ask yes or no questions to animals and receive answers by observing the movement of the pendulum.
-
Cards: You can use cards such as tarot cards, oracle cards, or animal cards to receive guidance or insights from animals or the spirit world.
-
Crystals: You can use crystals to enhance your intuition, clarity, protection, or healing when communicating with animals. You can also use crystals to send or receive energy to or from animals.
-
-
These tools and techniques are not necessary for animal communication, but they can be helpful for beginners or as a support for your intuition. You can experiment with different tools and techniques and find what works best for you and the animals you communicate with.
-
How to practice animal communication in different situations
-
How to connect with your own pets or domestic animals
-
Connecting with your own pets or domestic animals is a great way to start practicing animal communication. They are usually familiar with you and willing to communicate with you. Here are some steps you can follow to connect with them:
-
-
Set your intention: Before you communicate with your pet, set your intention for the communication. For example, you may want to ask them how they are feeling, what they need, or what they like. You may also want to tell them something important, such as a change in your schedule, a visit to the vet, or a new family member. Be clear and positive about your intention and ask for their permission to communicate.
-
Create a connection: Next, create a connection with your pet by looking into their eyes, touching their body, or holding their photo or object. Breathe deeply and calmly and tune into their energy. Imagine that you are sending them love and gratitude from your heart. You can also say their name mentally or aloud and invite them to communicate with you.
-
Send and receive messages: Then, send and receive messages with your pet using your preferred method of communication. You can use images, emotions, thoughts, sensations, impressions, or intentions. You can also use words or sounds if you feel comfortable. Be open and attentive to what they are sending you and acknowledge their messages. You can also ask them questions or give them feedback. Remember to be respectful and compassionate in your communication.
-
Close the communication: Finally, close the communication by thanking your pet for their time and cooperation. You can also give them a hug, a treat, or a compliment. Then, disconnect from their energy by taking a deep breath and shaking off any excess energy. You can also write down or record your communication for future reference.
-
-
How to connect with wild animals or animals in nature
-
Connecting with wild animals or animals in nature is a more challenging but rewarding form of animal communication. They are usually less familiar with humans and may have different needs and preferences than domestic animals. Here are some steps you can follow to connect with them:
-
-
Select an animal: Before you communicate with a wild animal, select an animal that you feel drawn to or curious about. You can choose an animal that you see in person, in a photo, in a video, or in your imagination. You can also let the animal choose you by being open and receptive to their presence.
-
Set your intention: Next, set your intention for the communication. For example, you may want to learn more about their life, behavior or culture. You may also want to express your admiration, appreciation, or support for them. Be clear and positive about your intention and ask for their permission to communicate.
-
Create a connection: Then, create a connection with the animal by looking at them, sending them a mental image of yourself, or holding their photo or object. Breathe deeply and calmly and tune into their energy. Imagine that you are sending them love and respect from your heart. You can also say their name or species mentally or aloud and invite them to communicate with you.
-
Send and receive messages: Next, send and receive messages with the animal using your preferred method of communication. You can use images, emotions, thoughts, sensations, impressions, or intentions. You can also use words or sounds if you feel comfortable. Be open and attentive to what they are sending you and acknowledge their messages. You can also ask them questions or give them feedback. Remember to be respectful and compassionate in your communication.
-
Close the communication: Finally, close the communication by thanking the animal for their time and cooperation. You can also give them a blessing, a prayer, or a gift. Then, disconnect from their energy by taking a deep breath and shaking off any excess energy. You can also write down or record your communication for future reference.
-
-
How to connect with animals in distress or need
-
Connecting with animals in distress or need is a more sensitive and delicate form of animal communication. They are usually suffering from physical or emotional pain, trauma, fear, or loss. They may also be in danger, captivity, or abuse. Here are some steps you can follow to connect with them:
-
-
Select an animal: Before you communicate with an animal in distress or need, select an animal that you feel compassion for or want to help. You can choose an animal that you see in person, in a photo, in a video, or in your imagination. You can also let the animal choose you by being open and receptive to their call.
-
Set your intention: Next, set your intention for the communication. For example, you may want to offer them comfort, healing, guidance, or assistance. You may also want to listen to their story, understand their situation, or advocate for their rights. Be clear and positive about your intention and ask for their permission to communicate.
-
Create a connection: Then, create a connection with the animal by looking at them, sending them a mental image of yourself, or holding their photo or object. Breathe deeply and calmly and tune into their energy. Imagine that you are sending them love and compassion from your heart. You can also say their name or species mentally or aloud and invite them to communicate with you.
-
Send and receive messages: Next, send and receive messages with the animal using your preferred method of communication. You can use images, emotions, thoughts, sensations, impressions, or intentions. You can also use words or sounds if you feel comfortable. Be open and attentive to what they are sending you and acknowledge their messages. You can also ask them questions or give them feedback. Remember to be respectful and compassionate in your communication.
-
Close the communication: Finally, close the communication by thanking the animal for their time and cooperation. You can also give them a hug, a kiss, or a gesture of support. Then, disconnect from their energy by taking a deep breath and shaking off any excess energy. You can also write down or record your communication for future reference.
-
-
How to improve your animal communication abilities
-
The tips and resources you can follow
-
To improve your animal communication abilities, you need to practice regularly and learn from your experiences. Here are some tips and resources you can follow to enhance your skills:
-
-
Practice with different animals: Try to communicate with different animals of different species, personalities, backgrounds and situations. This will help you expand your knowledge, awareness, and sensitivity to different animal perspectives and needs.
-
Practice with feedback: Try to communicate with animals that can give you feedback on your communication, such as your own pets, animal communicators, or animal shelters. This will help you verify your accuracy, improve your confidence, and correct your mistakes.
-
Practice with fun: Try to communicate with animals that can make you laugh, smile, or enjoy yourself, such as funny, playful, or cute animals. This will help you relax, have fun, and create a positive bond with animals.
-
Read books and blogs: There are many books and blogs that can teach you more about animal communication, such as Animal Speak by Ted Andrews, The Language of Animals by Carol Gurney, or The Animal Communicator's Guide Through Life, Loss and Love by Pea Horsley. You can also read stories and testimonials from other animal communicators and learn from their experiences.
-
Watch videos and podcasts: There are many videos and podcasts that can show you how animal communication works, such as The Animal Communicator by Anna Breytenbach, The Pet Psychic by Sonya Fitzpatrick, or The Animal Intuitive Show by Anne Angelo Webb. You can also watch interviews and demonstrations from other animal communicators and see their techniques.
-
Take courses and workshops: There are many courses and workshops that can help you learn and practice animal communication, such as The Animal Communication Mastery Program by Danielle MacKinnon, The Animal Communication Online Course by James French, or The Animal Communication Workshop by Penelope Smith. You can also join online or offline communities and groups of animal communicators and get support and guidance.
-
-
The common mistakes and pitfalls you can avoid
-
To improve your animal communication abilities, you also need to avoid some common mistakes and pitfalls that can hinder your progress or harm your relationship with animals. Some of these are:
-
-
Expecting too much: Don't expect to communicate with animals perfectly or instantly. Animal communication is a skill that takes time and practice to master. Be patient and gentle with yourself and the animals you communicate with.
-
Doubting yourself: Don't doubt your intuition or abilities. Animal communication is a natural and innate skill that everyone has. Trust your gut feelings and impressions and don't let your logical mind interfere.
-
Imposing yourself: Don't impose your communication on animals without their consent or interest. Animal communication is a mutual exchange that requires respect and cooperation. Always ask for permission before you communicate and respect their choice if they decline or end the communication.
-
Projecting yourself: Don't project your own thoughts, feelings, or beliefs onto animals. Animal communication is a way of understanding animals as they are, not as we want them to be. Be open and curious about their point of view and don't judge or criticize them.
-
Misinterpreting them: Don't misinterpret the messages or signals that animals send you. Animal communication is a complex and subtle process that involves different levels of meaning and context. Be careful not to jump to conclusions or make assumptions based on your own perspective or experience.
-
-
Conclusion and FAQs
-
In conclusion, animal communication is a wonderful way of connecting with animals on a deeper and more meaningful level. It can help us understand them better, improve our relationship with them, benefit our health and well-being, foster a deeper connection with nature, and learn from their wisdom and insights.
-
To communicate with animals effectively, we need to prepare ourselves by developing some skills and qualities, using some tools and techniques, and practicing in different situations. We also need to improve our abilities by following some tips and resources, and avoiding some common mistakes and pitfalls.
-
If you are interested in learning more about animal communication, here are some frequently asked questions and answers that may help you:
-
Q: Can anyone communicate with animals?
-
A: Yes, anyone can communicate with animals, as it is a natural and innate skill that we all have. However, some people may have more natural talent or affinity for it than others, and some people may need more training or practice to develop it.
-
Q: How can I tell if an animal is communicating with me?
-
A: You can tell if an animal is communicating with you by paying attention to your intuition and the signs that they are sending you. Some signs may include eye contact, body language, facial expressions, sounds, or behaviors. You may also receive messages from them in the form of images, emotions, thoughts, sensations, impressions, or intentions in your mind or heart.
-
Q: How can I verify the accuracy of my communication?
-
A: You can verify the accuracy of your communication by asking for feedback from the animal or from other sources. For example, you can ask the animal to confirm or clarify their message by sending you a sign or a signal. You can also ask other people who know the animal well or have access to their information to validate your communication.
-
Q: How can I protect myself from negative or harmful energies when communicating with animals?
-
A: You can protect yourself from negative or harmful energies when communicating with animals by setting boundaries, shielding yourself, and cleansing yourself. For example, you can set boundaries by asking for permission before you communicate and respecting the animal's choice if they decline or end the communication. You can shield yourself by imagining a protective bubble or a white light around you and the animal. You can cleanse yourself by taking a shower, using salt water, burning sage, or meditating after the communication.
-
Q: How can I communicate with animals who have passed away?
-
A: You can communicate with animals who have passed away by using the same methods and techniques as you would with living animals. However, you may need to adjust your frequency and vibration to match theirs, as they are in a different realm or dimension. You may also need to be more patient and respectful, as they may have different rules or preferences than living animals.
-
I hope this article has helped you learn more about animal communication and how to connect with animals. If you have any questions or comments, please feel free to contact me. Thank you for reading and happy communicating!
197e85843d
-
-
\ No newline at end of file
diff --git a/spaces/1phancelerku/anime-remove-background/Download Simcity Buildit Hack APK and Enjoy the Game with No Limits.md b/spaces/1phancelerku/anime-remove-background/Download Simcity Buildit Hack APK and Enjoy the Game with No Limits.md
deleted file mode 100644
index 29ef6d6b1b8c80527ebf051dc81dc1d52b9386a2..0000000000000000000000000000000000000000
--- a/spaces/1phancelerku/anime-remove-background/Download Simcity Buildit Hack APK and Enjoy the Game with No Limits.md
+++ /dev/null
@@ -1,105 +0,0 @@
-
-
How to Download SimCity BuildIt Hack
-
SimCity BuildIt is a popular mobile game that allows you to create and manage your own city. You can build various types of buildings, such as residential zones, factories, shops, parks, landmarks, and more. You can also provide services to your citizens, such as power, water, sewage, waste management, fire, police, health, education, transportation, entertainment, etc. You can also participate in club wars, contests of mayors, event tracks, design challenges, and other activities.
The game is free to play, but it also has some in-game currencies that you can use to speed up your progress or unlock special features. These currencies are simoleons (the basic money), simcash (the premium money), golden keys (used to unlock specializations), platinum keys (used to unlock mayor's pass buildings), neosimoleons (used in omega zones), war simoleons (used in club wars), regional simoleons (used in regions), and design simoleons (used in design challenges).
-
However, earning these currencies can be time-consuming and challenging. You may need to complete various tasks, participate in events, trade with other players, or spend real money to get them. This can make the game frustrating or boring for some players who want to enjoy the game without limitations. That's why some players may want to use a hack or mod apk for SimCity BuildIt.
-
What is SimCity BuildIt Hack?
-
A hack or mod apk is a modified version of the original game that gives you access to unlimited resources or other advantages. For example, a hack or mod apk for SimCity BuildIt may allow you to get unlimited money, golden keys, platinum keys, neosimoleons, war simoleons, regional simoleons, design simoleons, or other resources. It may also allow you to unlock all the buildings, services, specializations, regions, etc. It may also give you other features such as faster production speed, instant upgrade completion, unlimited storage capacity, etc.
-
Using a hack or mod apk for SimCity BuildIt can make the game easier and more fun for you. You can build your dream city without worrying about running out of resources or waiting for long hours. You can also experiment with different designs and layouts without any restrictions. You can also dominate the club wars and contests of mayors with your powerful city.
-
how to get simcity buildit hack tool
-how to install simcity buildit hack apk
-how to use simcity buildit hack and cheats tool
-how to download simcity buildit hack for android
-how to download simcity buildit hack for ios
-how to download simcity buildit hack for pc
-how to download simcity buildit hack no survey
-how to download simcity buildit hack no human verification
-how to download simcity buildit hack without root
-how to download simcity buildit hack without jailbreak
-how to download simcity buildit hack online
-how to download simcity buildit hack offline
-how to download simcity buildit hack 2023
-how to download simcity buildit hack latest version
-how to download simcity buildit hack mod apk
-how to download simcity buildit hack unlimited money
-how to download simcity buildit hack unlimited simcash
-how to download simcity buildit hack unlimited keys
-how to download simcity buildit hack free resources
-how to download simcity buildit hack generator
-how to download simcity buildit hack reddit
-how to download simcity buildit hack youtube
-how to download simcity buildit hack video tutorial
-how to download simcity buildit hack step by step guide
-how to download simcity buildit hack easy method
-how to download simcity buildit hack working 100%
-how to download simcity buildit hack safe and secure
-how to download simcity buildit hack legal and legit
-how to download simcity buildit hack from official website
-how to download simcity buildit hack from trusted source
-how to download simcity buildit hack from apkcombo.com[^3^]
-how to download simcity buildit hack from reddit.com[^1^] [^2^]
-how to download simcity buildit hack from newscientist.com
-how to download simcity buildit hack from the-sun.com[^3^]
-how to download simcity buildit hack from yahoo.com[^1^]
-how to download simcity buildit hack with proof of success
-how to download simcity buildit hack with positive reviews
-how to download simcity buildit hack with customer support
-how to download simcity buildit hack with updates and patches
-how to download simcity buildit hack with bonus features and tips
-how to download simcity buildit hack with no ads and malware
-how to download simcity buildit hack with no errors and bugs
-how to download simcity buildit hack with no password and activation code
-how to download simcity buildit hack with no viruses and spyware
-how to download simcity buildit hack with no risks and bans
-
How to Get Unlimited Money, Golden Keys, and Other Resources
-
If you want
If you want to get unlimited money, golden keys, and other resources in SimCity BuildIt, you will need to download and install a hack or mod apk for the game. Here are the steps you need to follow:
-
-
Find a reliable source for downloading the hack or mod apk. You can search online for websites or forums that offer SimCity BuildIt hacks or mod apks. Make sure to read the reviews and feedback from other users to avoid downloading any viruses or malware.
-
Download the hack or mod apk file to your device. You may need to enable the option to install apps from unknown sources in your device settings. You may also need to disable any antivirus or security software that may interfere with the installation.
-
Install the hack or mod apk file on your device. Follow the instructions on the screen to complete the installation. You may need to grant some permissions to the app to access your device data.
-
Launch the hack or mod apk app and enjoy the game. You should see a menu or a button that allows you to activate the hack or mod features. You can then start playing the game with unlimited resources and other advantages.
-
-
Tips and Tricks for Using SimCity BuildIt Hack
-
Using a hack or mod apk for SimCity BuildIt can be fun and exciting, but it can also be risky and problematic. Here are some tips and tricks for using the hack or mod apk effectively:
-
-
Plan ahead. Before you start building your city, think about what kind of city you want to create. Do you want a modern metropolis, a green eco-city, a futuristic omega city, or a regional city? Choose your buildings, services, specializations, and regions accordingly.
-
Keep your city clean. Even if you have unlimited resources, you still need to provide adequate services to your citizens. Make sure to have enough power, water, sewage, waste management, fire, police, health, education, transportation, entertainment, etc. for your population. Avoid placing polluting buildings near residential zones.
-
Look out for deals. Sometimes, you may get offers from other players or NPCs to buy or sell resources or items. These deals can be beneficial if you want to get rid of excess resources or get some rare items.
-
-
Risks and Drawbacks of Using SimCity BuildIt Hack
-
Using a hack or mod apk for SimCity BuildIt can also have some potential risks and drawbacks. Here are some of them:
-
-
Getting banned. The game developers may detect that you are using a hack or mod apk and ban your account from playing the game. This can result in losing your progress and achievements.
-
Losing progress. The hack or mod apk may not be compatible with the latest version of the game or your device. This can cause the game to crash or freeze, and you may lose your progress or data.
-
Encountering bugs. The hack or mod apk may not work properly or have some errors or glitches. This can affect the gameplay quality and experience.
-
-
How to Play SimCity BuildIt Without Hack
-
If you don't want to use a hack or mod apk for SimCity BuildIt, you can still play the game without them. You can enjoy the game's challenges and rewards by playing it legitimately and fairly. Here are some ways to play SimCity BuildIt without hack:
-
How to Earn Money, Golden Keys, and Other Resources Legally
-
You can earn money, golden keys, and other resources in SimCity BuildIt by completing various tasks, participating in events, and trading with other players. Here are some examples:
-
-
Complete tasks. You can complete tasks given by your advisors, such as building certain types of buildings, providing certain services, collecting taxes, etc. These tasks will reward you with money, golden keys, simcash, etc.
-
Participate in events. You can participate in events such as club wars, contests of mayors, event tracks, design challenges, etc. These events will reward you with money, golden keys, platinum keys, neosimoleons, war simoleons, regional simoleons, design simoleons, etc.
-
Trade with other players. You can trade with other players through the global trade headquarters or through your club chat. You can sell your excess resources or items for money or buy resources or items that you need from other players.
-
-
How to Build the Ultimate City with SimCity BuildIt Tips and Cheats
-
You can build the ultimate city in SimCity BuildIt by following some proven tips and cheats that will help you optimize your city's performance
You can build the ultimate city in SimCity BuildIt by following some proven tips and cheats that will help you optimize your city's performance and appearance. Here are some examples:
-
-
Expand your population. You can expand your population by building more residential zones and upgrading them. You can also increase your population by providing them with parks, landmarks, specializations, etc. A higher population will give you more taxes and happiness.
-
Upgrade your buildings. You can upgrade your buildings by producing and collecting items from your factories and shops. You can also use simcash or golden keys to speed up the upgrade process. Upgrading your buildings will give you more population, money, experience, etc.
-
Unlock specializations. You can unlock specializations by earning golden keys or platinum keys from events or tasks. Specializations are buildings that provide boosts to your population, happiness, or income. Some examples of specializations are education, entertainment, gambling, landmarks, etc.
-
-
Conclusion
-
SimCity BuildIt is a fun and addictive game that lets you create and manage your own city. You can choose to play the game with or without a hack or mod apk. A hack or mod apk can give you unlimited resources and other advantages, but it can also have some risks and drawbacks. Playing the game without a hack or mod apk can be challenging and rewarding, but it can also be frustrating and boring. Ultimately, the choice is yours. You can decide what kind of city you want to build and how you want to play the game.
-
FAQs
-
Here are some frequently asked questions and answers about SimCity BuildIt hack:
-
-
Q: Is SimCity BuildIt hack safe to use? A: SimCity BuildIt hack may not be safe to use, as it may contain viruses or malware that can harm your device or data. It may also be detected by the game developers and result in a ban from playing the game.
-
Q: How do I update SimCity BuildIt hack? A: SimCity BuildIt hack may not be compatible with the latest version of the game or your device. You may need to find a new source for downloading the hack or mod apk, or wait for the hack or mod apk to be updated by its developers.
-
Q: Can I play SimCity BuildIt hack online? A: SimCity BuildIt hack may not work online, as it may require an internet connection to activate the hack or mod features. It may also be detected by the game servers and result in a ban from playing the game.
-
Q: Can I play SimCity BuildIt hack with my friends? A: SimCity BuildIt hack may not allow you to play with your friends, as it may interfere with the multiplayer features of the game. It may also be unfair to other players who are playing the game legitimately.
-
Q: Can I transfer my progress from SimCity BuildIt hack to SimCity BuildIt original? A: SimCity BuildIt hack may not allow you to transfer your progress to SimCity BuildIt original, as it may have different data formats or structures. It may also result in a loss of progress or data.
- 401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/3i2irg/SF-model/README.md b/spaces/3i2irg/SF-model/README.md
deleted file mode 100644
index 068c68ed6e12e38fab043f1859fd3196c80a10c1..0000000000000000000000000000000000000000
--- a/spaces/3i2irg/SF-model/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: SF Model
-emoji: 🐨
-colorFrom: indigo
-colorTo: yellow
-sdk: gradio
-sdk_version: 3.21.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/4Taps/SadTalker/src/face3d/models/arcface_torch/configs/glint360k_r34.py b/spaces/4Taps/SadTalker/src/face3d/models/arcface_torch/configs/glint360k_r34.py
deleted file mode 100644
index fda2701758a839a7161d09c25f0ca3d26033baff..0000000000000000000000000000000000000000
--- a/spaces/4Taps/SadTalker/src/face3d/models/arcface_torch/configs/glint360k_r34.py
+++ /dev/null
@@ -1,26 +0,0 @@
-from easydict import EasyDict as edict
-
-# make training faster
-# our RAM is 256G
-# mount -t tmpfs -o size=140G tmpfs /train_tmp
-
-config = edict()
-config.loss = "cosface"
-config.network = "r34"
-config.resume = False
-config.output = None
-config.embedding_size = 512
-config.sample_rate = 1.0
-config.fp16 = True
-config.momentum = 0.9
-config.weight_decay = 5e-4
-config.batch_size = 128
-config.lr = 0.1 # batch size is 512
-
-config.rec = "/train_tmp/glint360k"
-config.num_classes = 360232
-config.num_image = 17091657
-config.num_epoch = 20
-config.warmup_epoch = -1
-config.decay_epoch = [8, 12, 15, 18]
-config.val_targets = ["lfw", "cfp_fp", "agedb_30"]
diff --git a/spaces/AHzizi/WaifuVoiceGen/models.py b/spaces/AHzizi/WaifuVoiceGen/models.py
deleted file mode 100644
index 8353b867f441de7e4d05aef980e672899c3a8889..0000000000000000000000000000000000000000
--- a/spaces/AHzizi/WaifuVoiceGen/models.py
+++ /dev/null
@@ -1,533 +0,0 @@
-import math
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-import commons
-import modules
-import attentions
-import monotonic_align
-
-from torch.nn import Conv1d, ConvTranspose1d, Conv2d
-from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
-from commons import init_weights, get_padding
-
-
-class StochasticDurationPredictor(nn.Module):
- def __init__(self, in_channels, filter_channels, kernel_size, p_dropout, n_flows=4, gin_channels=0):
- super().__init__()
- filter_channels = in_channels # it needs to be removed from future version.
- self.in_channels = in_channels
- self.filter_channels = filter_channels
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.n_flows = n_flows
- self.gin_channels = gin_channels
-
- self.log_flow = modules.Log()
- self.flows = nn.ModuleList()
- self.flows.append(modules.ElementwiseAffine(2))
- for i in range(n_flows):
- self.flows.append(modules.ConvFlow(2, filter_channels, kernel_size, n_layers=3))
- self.flows.append(modules.Flip())
-
- self.post_pre = nn.Conv1d(1, filter_channels, 1)
- self.post_proj = nn.Conv1d(filter_channels, filter_channels, 1)
- self.post_convs = modules.DDSConv(filter_channels, kernel_size, n_layers=3, p_dropout=p_dropout)
- self.post_flows = nn.ModuleList()
- self.post_flows.append(modules.ElementwiseAffine(2))
- for i in range(4):
- self.post_flows.append(modules.ConvFlow(2, filter_channels, kernel_size, n_layers=3))
- self.post_flows.append(modules.Flip())
-
- self.pre = nn.Conv1d(in_channels, filter_channels, 1)
- self.proj = nn.Conv1d(filter_channels, filter_channels, 1)
- self.convs = modules.DDSConv(filter_channels, kernel_size, n_layers=3, p_dropout=p_dropout)
- if gin_channels != 0:
- self.cond = nn.Conv1d(gin_channels, filter_channels, 1)
-
- def forward(self, x, x_mask, w=None, g=None, reverse=False, noise_scale=1.0):
- x = torch.detach(x)
- x = self.pre(x)
- if g is not None:
- g = torch.detach(g)
- x = x + self.cond(g)
- x = self.convs(x, x_mask)
- x = self.proj(x) * x_mask
-
- if not reverse:
- flows = self.flows
- assert w is not None
-
- logdet_tot_q = 0
- h_w = self.post_pre(w)
- h_w = self.post_convs(h_w, x_mask)
- h_w = self.post_proj(h_w) * x_mask
- e_q = torch.randn(w.size(0), 2, w.size(2)).to(device=x.device, dtype=x.dtype) * x_mask
- z_q = e_q
- for flow in self.post_flows:
- z_q, logdet_q = flow(z_q, x_mask, g=(x + h_w))
- logdet_tot_q += logdet_q
- z_u, z1 = torch.split(z_q, [1, 1], 1)
- u = torch.sigmoid(z_u) * x_mask
- z0 = (w - u) * x_mask
- logdet_tot_q += torch.sum((F.logsigmoid(z_u) + F.logsigmoid(-z_u)) * x_mask, [1,2])
- logq = torch.sum(-0.5 * (math.log(2*math.pi) + (e_q**2)) * x_mask, [1,2]) - logdet_tot_q
-
- logdet_tot = 0
- z0, logdet = self.log_flow(z0, x_mask)
- logdet_tot += logdet
- z = torch.cat([z0, z1], 1)
- for flow in flows:
- z, logdet = flow(z, x_mask, g=x, reverse=reverse)
- logdet_tot = logdet_tot + logdet
- nll = torch.sum(0.5 * (math.log(2*math.pi) + (z**2)) * x_mask, [1,2]) - logdet_tot
- return nll + logq # [b]
- else:
- flows = list(reversed(self.flows))
- flows = flows[:-2] + [flows[-1]] # remove a useless vflow
- z = torch.randn(x.size(0), 2, x.size(2)).to(device=x.device, dtype=x.dtype) * noise_scale
- for flow in flows:
- z = flow(z, x_mask, g=x, reverse=reverse)
- z0, z1 = torch.split(z, [1, 1], 1)
- logw = z0
- return logw
-
-
-class DurationPredictor(nn.Module):
- def __init__(self, in_channels, filter_channels, kernel_size, p_dropout, gin_channels=0):
- super().__init__()
-
- self.in_channels = in_channels
- self.filter_channels = filter_channels
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.gin_channels = gin_channels
-
- self.drop = nn.Dropout(p_dropout)
- self.conv_1 = nn.Conv1d(in_channels, filter_channels, kernel_size, padding=kernel_size//2)
- self.norm_1 = modules.LayerNorm(filter_channels)
- self.conv_2 = nn.Conv1d(filter_channels, filter_channels, kernel_size, padding=kernel_size//2)
- self.norm_2 = modules.LayerNorm(filter_channels)
- self.proj = nn.Conv1d(filter_channels, 1, 1)
-
- if gin_channels != 0:
- self.cond = nn.Conv1d(gin_channels, in_channels, 1)
-
- def forward(self, x, x_mask, g=None):
- x = torch.detach(x)
- if g is not None:
- g = torch.detach(g)
- x = x + self.cond(g)
- x = self.conv_1(x * x_mask)
- x = torch.relu(x)
- x = self.norm_1(x)
- x = self.drop(x)
- x = self.conv_2(x * x_mask)
- x = torch.relu(x)
- x = self.norm_2(x)
- x = self.drop(x)
- x = self.proj(x * x_mask)
- return x * x_mask
-
-
-class TextEncoder(nn.Module):
- def __init__(self,
- n_vocab,
- out_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout):
- super().__init__()
- self.n_vocab = n_vocab
- self.out_channels = out_channels
- self.hidden_channels = hidden_channels
- self.filter_channels = filter_channels
- self.n_heads = n_heads
- self.n_layers = n_layers
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
-
- self.emb = nn.Embedding(n_vocab, hidden_channels)
- nn.init.normal_(self.emb.weight, 0.0, hidden_channels**-0.5)
-
- self.encoder = attentions.Encoder(
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout)
- self.proj= nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
- def forward(self, x, x_lengths):
- x = self.emb(x) * math.sqrt(self.hidden_channels) # [b, t, h]
- x = torch.transpose(x, 1, -1) # [b, h, t]
- x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
-
- x = self.encoder(x * x_mask, x_mask)
- stats = self.proj(x) * x_mask
-
- m, logs = torch.split(stats, self.out_channels, dim=1)
- return x, m, logs, x_mask
-
-
-class ResidualCouplingBlock(nn.Module):
- def __init__(self,
- channels,
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- n_flows=4,
- gin_channels=0):
- super().__init__()
- self.channels = channels
- self.hidden_channels = hidden_channels
- self.kernel_size = kernel_size
- self.dilation_rate = dilation_rate
- self.n_layers = n_layers
- self.n_flows = n_flows
- self.gin_channels = gin_channels
-
- self.flows = nn.ModuleList()
- for i in range(n_flows):
- self.flows.append(modules.ResidualCouplingLayer(channels, hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=gin_channels, mean_only=True))
- self.flows.append(modules.Flip())
-
- def forward(self, x, x_mask, g=None, reverse=False):
- if not reverse:
- for flow in self.flows:
- x, _ = flow(x, x_mask, g=g, reverse=reverse)
- else:
- for flow in reversed(self.flows):
- x = flow(x, x_mask, g=g, reverse=reverse)
- return x
-
-
-class PosteriorEncoder(nn.Module):
- def __init__(self,
- in_channels,
- out_channels,
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- gin_channels=0):
- super().__init__()
- self.in_channels = in_channels
- self.out_channels = out_channels
- self.hidden_channels = hidden_channels
- self.kernel_size = kernel_size
- self.dilation_rate = dilation_rate
- self.n_layers = n_layers
- self.gin_channels = gin_channels
-
- self.pre = nn.Conv1d(in_channels, hidden_channels, 1)
- self.enc = modules.WN(hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=gin_channels)
- self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
- def forward(self, x, x_lengths, g=None):
- x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
- x = self.pre(x) * x_mask
- x = self.enc(x, x_mask, g=g)
- stats = self.proj(x) * x_mask
- m, logs = torch.split(stats, self.out_channels, dim=1)
- z = (m + torch.randn_like(m) * torch.exp(logs)) * x_mask
- return z, m, logs, x_mask
-
-
-class Generator(torch.nn.Module):
- def __init__(self, initial_channel, resblock, resblock_kernel_sizes, resblock_dilation_sizes, upsample_rates, upsample_initial_channel, upsample_kernel_sizes, gin_channels=0):
- super(Generator, self).__init__()
- self.num_kernels = len(resblock_kernel_sizes)
- self.num_upsamples = len(upsample_rates)
- self.conv_pre = Conv1d(initial_channel, upsample_initial_channel, 7, 1, padding=3)
- resblock = modules.ResBlock1 if resblock == '1' else modules.ResBlock2
-
- self.ups = nn.ModuleList()
- for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
- self.ups.append(weight_norm(
- ConvTranspose1d(upsample_initial_channel//(2**i), upsample_initial_channel//(2**(i+1)),
- k, u, padding=(k-u)//2)))
-
- self.resblocks = nn.ModuleList()
- for i in range(len(self.ups)):
- ch = upsample_initial_channel//(2**(i+1))
- for j, (k, d) in enumerate(zip(resblock_kernel_sizes, resblock_dilation_sizes)):
- self.resblocks.append(resblock(ch, k, d))
-
- self.conv_post = Conv1d(ch, 1, 7, 1, padding=3, bias=False)
- self.ups.apply(init_weights)
-
- if gin_channels != 0:
- self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1)
-
- def forward(self, x, g=None):
- x = self.conv_pre(x)
- if g is not None:
- x = x + self.cond(g)
-
- for i in range(self.num_upsamples):
- x = F.leaky_relu(x, modules.LRELU_SLOPE)
- x = self.ups[i](x)
- xs = None
- for j in range(self.num_kernels):
- if xs is None:
- xs = self.resblocks[i*self.num_kernels+j](x)
- else:
- xs += self.resblocks[i*self.num_kernels+j](x)
- x = xs / self.num_kernels
- x = F.leaky_relu(x)
- x = self.conv_post(x)
- x = torch.tanh(x)
-
- return x
-
- def remove_weight_norm(self):
- print('Removing weight norm...')
- for l in self.ups:
- remove_weight_norm(l)
- for l in self.resblocks:
- l.remove_weight_norm()
-
-
-class DiscriminatorP(torch.nn.Module):
- def __init__(self, period, kernel_size=5, stride=3, use_spectral_norm=False):
- super(DiscriminatorP, self).__init__()
- self.period = period
- self.use_spectral_norm = use_spectral_norm
- norm_f = weight_norm if use_spectral_norm == False else spectral_norm
- self.convs = nn.ModuleList([
- norm_f(Conv2d(1, 32, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
- norm_f(Conv2d(32, 128, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
- norm_f(Conv2d(128, 512, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
- norm_f(Conv2d(512, 1024, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
- norm_f(Conv2d(1024, 1024, (kernel_size, 1), 1, padding=(get_padding(kernel_size, 1), 0))),
- ])
- self.conv_post = norm_f(Conv2d(1024, 1, (3, 1), 1, padding=(1, 0)))
-
- def forward(self, x):
- fmap = []
-
- # 1d to 2d
- b, c, t = x.shape
- if t % self.period != 0: # pad first
- n_pad = self.period - (t % self.period)
- x = F.pad(x, (0, n_pad), "reflect")
- t = t + n_pad
- x = x.view(b, c, t // self.period, self.period)
-
- for l in self.convs:
- x = l(x)
- x = F.leaky_relu(x, modules.LRELU_SLOPE)
- fmap.append(x)
- x = self.conv_post(x)
- fmap.append(x)
- x = torch.flatten(x, 1, -1)
-
- return x, fmap
-
-
-class DiscriminatorS(torch.nn.Module):
- def __init__(self, use_spectral_norm=False):
- super(DiscriminatorS, self).__init__()
- norm_f = weight_norm if use_spectral_norm == False else spectral_norm
- self.convs = nn.ModuleList([
- norm_f(Conv1d(1, 16, 15, 1, padding=7)),
- norm_f(Conv1d(16, 64, 41, 4, groups=4, padding=20)),
- norm_f(Conv1d(64, 256, 41, 4, groups=16, padding=20)),
- norm_f(Conv1d(256, 1024, 41, 4, groups=64, padding=20)),
- norm_f(Conv1d(1024, 1024, 41, 4, groups=256, padding=20)),
- norm_f(Conv1d(1024, 1024, 5, 1, padding=2)),
- ])
- self.conv_post = norm_f(Conv1d(1024, 1, 3, 1, padding=1))
-
- def forward(self, x):
- fmap = []
-
- for l in self.convs:
- x = l(x)
- x = F.leaky_relu(x, modules.LRELU_SLOPE)
- fmap.append(x)
- x = self.conv_post(x)
- fmap.append(x)
- x = torch.flatten(x, 1, -1)
-
- return x, fmap
-
-
-class MultiPeriodDiscriminator(torch.nn.Module):
- def __init__(self, use_spectral_norm=False):
- super(MultiPeriodDiscriminator, self).__init__()
- periods = [2,3,5,7,11]
-
- discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
- discs = discs + [DiscriminatorP(i, use_spectral_norm=use_spectral_norm) for i in periods]
- self.discriminators = nn.ModuleList(discs)
-
- def forward(self, y, y_hat):
- y_d_rs = []
- y_d_gs = []
- fmap_rs = []
- fmap_gs = []
- for i, d in enumerate(self.discriminators):
- y_d_r, fmap_r = d(y)
- y_d_g, fmap_g = d(y_hat)
- y_d_rs.append(y_d_r)
- y_d_gs.append(y_d_g)
- fmap_rs.append(fmap_r)
- fmap_gs.append(fmap_g)
-
- return y_d_rs, y_d_gs, fmap_rs, fmap_gs
-
-
-
-class SynthesizerTrn(nn.Module):
- """
- Synthesizer for Training
- """
-
- def __init__(self,
- n_vocab,
- spec_channels,
- segment_size,
- inter_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- resblock,
- resblock_kernel_sizes,
- resblock_dilation_sizes,
- upsample_rates,
- upsample_initial_channel,
- upsample_kernel_sizes,
- n_speakers=0,
- gin_channels=0,
- use_sdp=True,
- **kwargs):
-
- super().__init__()
- self.n_vocab = n_vocab
- self.spec_channels = spec_channels
- self.inter_channels = inter_channels
- self.hidden_channels = hidden_channels
- self.filter_channels = filter_channels
- self.n_heads = n_heads
- self.n_layers = n_layers
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.resblock = resblock
- self.resblock_kernel_sizes = resblock_kernel_sizes
- self.resblock_dilation_sizes = resblock_dilation_sizes
- self.upsample_rates = upsample_rates
- self.upsample_initial_channel = upsample_initial_channel
- self.upsample_kernel_sizes = upsample_kernel_sizes
- self.segment_size = segment_size
- self.n_speakers = n_speakers
- self.gin_channels = gin_channels
-
- self.use_sdp = use_sdp
-
- self.enc_p = TextEncoder(n_vocab,
- inter_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout)
- self.dec = Generator(inter_channels, resblock, resblock_kernel_sizes, resblock_dilation_sizes, upsample_rates, upsample_initial_channel, upsample_kernel_sizes, gin_channels=gin_channels)
- self.enc_q = PosteriorEncoder(spec_channels, inter_channels, hidden_channels, 5, 1, 16, gin_channels=gin_channels)
- self.flow = ResidualCouplingBlock(inter_channels, hidden_channels, 5, 1, 4, gin_channels=gin_channels)
-
- if use_sdp:
- self.dp = StochasticDurationPredictor(hidden_channels, 192, 3, 0.5, 4, gin_channels=gin_channels)
- else:
- self.dp = DurationPredictor(hidden_channels, 256, 3, 0.5, gin_channels=gin_channels)
-
- if n_speakers > 1:
- self.emb_g = nn.Embedding(n_speakers, gin_channels)
-
- def forward(self, x, x_lengths, y, y_lengths, sid=None):
-
- x, m_p, logs_p, x_mask = self.enc_p(x, x_lengths)
- if self.n_speakers > 0:
- g = self.emb_g(sid).unsqueeze(-1) # [b, h, 1]
- else:
- g = None
-
- z, m_q, logs_q, y_mask = self.enc_q(y, y_lengths, g=g)
- z_p = self.flow(z, y_mask, g=g)
-
- with torch.no_grad():
- # negative cross-entropy
- s_p_sq_r = torch.exp(-2 * logs_p) # [b, d, t]
- neg_cent1 = torch.sum(-0.5 * math.log(2 * math.pi) - logs_p, [1], keepdim=True) # [b, 1, t_s]
- neg_cent2 = torch.matmul(-0.5 * (z_p ** 2).transpose(1, 2), s_p_sq_r) # [b, t_t, d] x [b, d, t_s] = [b, t_t, t_s]
- neg_cent3 = torch.matmul(z_p.transpose(1, 2), (m_p * s_p_sq_r)) # [b, t_t, d] x [b, d, t_s] = [b, t_t, t_s]
- neg_cent4 = torch.sum(-0.5 * (m_p ** 2) * s_p_sq_r, [1], keepdim=True) # [b, 1, t_s]
- neg_cent = neg_cent1 + neg_cent2 + neg_cent3 + neg_cent4
-
- attn_mask = torch.unsqueeze(x_mask, 2) * torch.unsqueeze(y_mask, -1)
- attn = monotonic_align.maximum_path(neg_cent, attn_mask.squeeze(1)).unsqueeze(1).detach()
-
- w = attn.sum(2)
- if self.use_sdp:
- l_length = self.dp(x, x_mask, w, g=g)
- l_length = l_length / torch.sum(x_mask)
- else:
- logw_ = torch.log(w + 1e-6) * x_mask
- logw = self.dp(x, x_mask, g=g)
- l_length = torch.sum((logw - logw_)**2, [1,2]) / torch.sum(x_mask) # for averaging
-
- # expand prior
- m_p = torch.matmul(attn.squeeze(1), m_p.transpose(1, 2)).transpose(1, 2)
- logs_p = torch.matmul(attn.squeeze(1), logs_p.transpose(1, 2)).transpose(1, 2)
-
- z_slice, ids_slice = commons.rand_slice_segments(z, y_lengths, self.segment_size)
- o = self.dec(z_slice, g=g)
- return o, l_length, attn, ids_slice, x_mask, y_mask, (z, z_p, m_p, logs_p, m_q, logs_q)
-
- def infer(self, x, x_lengths, sid=None, noise_scale=1, length_scale=1, noise_scale_w=1., max_len=None):
- x, m_p, logs_p, x_mask = self.enc_p(x, x_lengths)
- if self.n_speakers > 0:
- g = self.emb_g(sid).unsqueeze(-1) # [b, h, 1]
- else:
- g = None
-
- if self.use_sdp:
- logw = self.dp(x, x_mask, g=g, reverse=True, noise_scale=noise_scale_w)
- else:
- logw = self.dp(x, x_mask, g=g)
- w = torch.exp(logw) * x_mask * length_scale
- w_ceil = torch.ceil(w)
- y_lengths = torch.clamp_min(torch.sum(w_ceil, [1, 2]), 1).long()
- y_mask = torch.unsqueeze(commons.sequence_mask(y_lengths, None), 1).to(x_mask.dtype)
- attn_mask = torch.unsqueeze(x_mask, 2) * torch.unsqueeze(y_mask, -1)
- attn = commons.generate_path(w_ceil, attn_mask)
-
- m_p = torch.matmul(attn.squeeze(1), m_p.transpose(1, 2)).transpose(1, 2) # [b, t', t], [b, t, d] -> [b, d, t']
- logs_p = torch.matmul(attn.squeeze(1), logs_p.transpose(1, 2)).transpose(1, 2) # [b, t', t], [b, t, d] -> [b, d, t']
-
- z_p = m_p + torch.randn_like(m_p) * torch.exp(logs_p) * noise_scale
- z = self.flow(z_p, y_mask, g=g, reverse=True)
- o = self.dec((z * y_mask)[:,:,:max_len], g=g)
- return o, attn, y_mask, (z, z_p, m_p, logs_p)
-
- def voice_conversion(self, y, y_lengths, sid_src, sid_tgt):
- assert self.n_speakers > 0, "n_speakers have to be larger than 0."
- g_src = self.emb_g(sid_src).unsqueeze(-1)
- g_tgt = self.emb_g(sid_tgt).unsqueeze(-1)
- z, m_q, logs_q, y_mask = self.enc_q(y, y_lengths, g=g_src)
- z_p = self.flow(z, y_mask, g=g_src)
- z_hat = self.flow(z_p, y_mask, g=g_tgt, reverse=True)
- o_hat = self.dec(z_hat * y_mask, g=g_tgt)
- return o_hat, y_mask, (z, z_p, z_hat)
-
diff --git a/spaces/AIConsultant/MusicGen/audiocraft/grids/compression/encodec_audiogen_16khz.py b/spaces/AIConsultant/MusicGen/audiocraft/grids/compression/encodec_audiogen_16khz.py
deleted file mode 100644
index c9b41f684045594bb264cfb7f4f15d1da439382c..0000000000000000000000000000000000000000
--- a/spaces/AIConsultant/MusicGen/audiocraft/grids/compression/encodec_audiogen_16khz.py
+++ /dev/null
@@ -1,29 +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.
-
-"""
-Grid search file, simply list all the exp you want in `explorer`.
-Any new exp added there will be scheduled.
-You can cancel and experiment by commenting its line.
-
-This grid shows how to train the new AudioGen EnCodec model at 16 kHz.
-"""
-
-from ._explorers import CompressionExplorer
-from ...environment import AudioCraftEnvironment
-
-
-@CompressionExplorer
-def explorer(launcher):
- partitions = AudioCraftEnvironment.get_slurm_partitions(['team', 'global'])
- launcher.slurm_(gpus=8, partition=partitions)
- # use configuration for AudioGen's EnCodec model trained on monophonic audio sampled at 16 kHz
- # AudioGen's EnCodec is trained with a total stride of 320 leading to a frame rate of 50 hz
- launcher.bind_(solver='compression/encodec_audiogen_16khz')
- # replace this by the desired sound dataset
- launcher.bind_(dset='internal/sounds_16khz')
- # launch xp
- launcher()
diff --git a/spaces/AIGC-Audio/AudioGPT/NeuralSeq/vocoders/pwg.py b/spaces/AIGC-Audio/AudioGPT/NeuralSeq/vocoders/pwg.py
deleted file mode 100644
index ca9b6891ab2ba5cb413eeca97a41534e5db129d5..0000000000000000000000000000000000000000
--- a/spaces/AIGC-Audio/AudioGPT/NeuralSeq/vocoders/pwg.py
+++ /dev/null
@@ -1,137 +0,0 @@
-import glob
-import re
-import librosa
-import torch
-import yaml
-from sklearn.preprocessing import StandardScaler
-from torch import nn
-from modules.parallel_wavegan.models import ParallelWaveGANGenerator
-from modules.parallel_wavegan.utils import read_hdf5
-from utils.hparams import hparams
-from utils.pitch_utils import f0_to_coarse
-from vocoders.base_vocoder import BaseVocoder, register_vocoder
-import numpy as np
-
-
-def load_pwg_model(config_path, checkpoint_path, stats_path):
- # load config
- with open(config_path) as f:
- config = yaml.load(f, Loader=yaml.Loader)
-
- # setup
- if torch.cuda.is_available():
- device = torch.device("cuda")
- else:
- device = torch.device("cpu")
- model = ParallelWaveGANGenerator(**config["generator_params"])
-
- ckpt_dict = torch.load(checkpoint_path, map_location="cpu")
- if 'state_dict' not in ckpt_dict: # official vocoder
- model.load_state_dict(torch.load(checkpoint_path, map_location="cpu")["model"]["generator"])
- scaler = StandardScaler()
- if config["format"] == "hdf5":
- scaler.mean_ = read_hdf5(stats_path, "mean")
- scaler.scale_ = read_hdf5(stats_path, "scale")
- elif config["format"] == "npy":
- scaler.mean_ = np.load(stats_path)[0]
- scaler.scale_ = np.load(stats_path)[1]
- else:
- raise ValueError("support only hdf5 or npy format.")
- else: # custom PWG vocoder
- fake_task = nn.Module()
- fake_task.model_gen = model
- fake_task.load_state_dict(torch.load(checkpoint_path, map_location="cpu")["state_dict"], strict=False)
- scaler = None
-
- model.remove_weight_norm()
- model = model.eval().to(device)
- print(f"| Loaded model parameters from {checkpoint_path}.")
- print(f"| PWG device: {device}.")
- return model, scaler, config, device
-
-
-@register_vocoder
-class PWG(BaseVocoder):
- def __init__(self):
- if hparams['vocoder_ckpt'] == '': # load LJSpeech PWG pretrained model
- base_dir = 'wavegan_pretrained'
- ckpts = glob.glob(f'{base_dir}/checkpoint-*steps.pkl')
- ckpt = sorted(ckpts, key=
- lambda x: int(re.findall(f'{base_dir}/checkpoint-(\d+)steps.pkl', x)[0]))[-1]
- config_path = f'{base_dir}/config.yaml'
- print('| load PWG: ', ckpt)
- self.model, self.scaler, self.config, self.device = load_pwg_model(
- config_path=config_path,
- checkpoint_path=ckpt,
- stats_path=f'{base_dir}/stats.h5',
- )
- else:
- base_dir = hparams['vocoder_ckpt']
- print(base_dir)
- config_path = f'{base_dir}/config.yaml'
- ckpt = sorted(glob.glob(f'{base_dir}/model_ckpt_steps_*.ckpt'), key=
- lambda x: int(re.findall(f'{base_dir}/model_ckpt_steps_(\d+).ckpt', x)[0]))[-1]
- print('| load PWG: ', ckpt)
- self.scaler = None
- self.model, _, self.config, self.device = load_pwg_model(
- config_path=config_path,
- checkpoint_path=ckpt,
- stats_path=f'{base_dir}/stats.h5',
- )
-
- def spec2wav(self, mel, **kwargs):
- # start generation
- config = self.config
- device = self.device
- pad_size = (config["generator_params"]["aux_context_window"],
- config["generator_params"]["aux_context_window"])
- c = mel
- if self.scaler is not None:
- c = self.scaler.transform(c)
-
- with torch.no_grad():
- z = torch.randn(1, 1, c.shape[0] * config["hop_size"]).to(device)
- c = np.pad(c, (pad_size, (0, 0)), "edge")
- c = torch.FloatTensor(c).unsqueeze(0).transpose(2, 1).to(device)
- p = kwargs.get('f0')
- if p is not None:
- p = f0_to_coarse(p)
- p = np.pad(p, (pad_size,), "edge")
- p = torch.LongTensor(p[None, :]).to(device)
- y = self.model(z, c, p).view(-1)
- wav_out = y.cpu().numpy()
- return wav_out
-
- @staticmethod
- def wav2spec(wav_fn, return_linear=False):
- from data_gen.tts.data_gen_utils import process_utterance
- res = process_utterance(
- wav_fn, fft_size=hparams['fft_size'],
- hop_size=hparams['hop_size'],
- win_length=hparams['win_size'],
- num_mels=hparams['audio_num_mel_bins'],
- fmin=hparams['fmin'],
- fmax=hparams['fmax'],
- sample_rate=hparams['audio_sample_rate'],
- loud_norm=hparams['loud_norm'],
- min_level_db=hparams['min_level_db'],
- return_linear=return_linear, vocoder='pwg', eps=float(hparams.get('wav2spec_eps', 1e-10)))
- if return_linear:
- return res[0], res[1].T, res[2].T # [T, 80], [T, n_fft]
- else:
- return res[0], res[1].T
-
- @staticmethod
- def wav2mfcc(wav_fn):
- fft_size = hparams['fft_size']
- hop_size = hparams['hop_size']
- win_length = hparams['win_size']
- sample_rate = hparams['audio_sample_rate']
- wav, _ = librosa.core.load(wav_fn, sr=sample_rate)
- mfcc = librosa.feature.mfcc(y=wav, sr=sample_rate, n_mfcc=13,
- n_fft=fft_size, hop_length=hop_size,
- win_length=win_length, pad_mode="constant", power=1.0)
- mfcc_delta = librosa.feature.delta(mfcc, order=1)
- mfcc_delta_delta = librosa.feature.delta(mfcc, order=2)
- mfcc = np.concatenate([mfcc, mfcc_delta, mfcc_delta_delta]).T
- return mfcc
diff --git a/spaces/AIGC-Audio/Make_An_Audio/ldm/modules/encoders/open_clap/linear_probe.py b/spaces/AIGC-Audio/Make_An_Audio/ldm/modules/encoders/open_clap/linear_probe.py
deleted file mode 100644
index bb2841dd4e28201db8b5bd4a215e1b8b9a60d25a..0000000000000000000000000000000000000000
--- a/spaces/AIGC-Audio/Make_An_Audio/ldm/modules/encoders/open_clap/linear_probe.py
+++ /dev/null
@@ -1,63 +0,0 @@
-import numpy as np
-import torch.nn.functional as F
-from torch import nn
-from .model import MLPLayers
-
-
-class LinearProbe(nn.Module):
- def __init__(self, model, mlp, freeze, in_ch, out_ch, act=None):
- """
- Args:
- model: nn.Module
- mlp: bool, if True, then use the MLP layer as the linear probe module
- freeze: bool, if Ture, then freeze all the CLAP model's layers when training the linear probe
- in_ch: int, the output channel from CLAP model
- out_ch: int, the output channel from linear probe (class_num)
- act: torch.nn.functional, the activation function before the loss function
- """
- super().__init__()
- in_ch = 512
- self.clap_model = model
- self.clap_model.text_branch = None # to save memory
- self.freeze = freeze
- if mlp:
- self.lp_layer = MLPLayers(units=[in_ch, in_ch * 2, out_ch])
- else:
- self.lp_layer = nn.Linear(in_ch, out_ch)
-
- if self.freeze:
- for param in self.clap_model.parameters():
- param.requires_grad = False
-
- if act == 'None':
- self.act = None
- elif act == 'relu':
- self.act = nn.ReLU()
- elif act == 'elu':
- self.act = nn.ELU()
- elif act == 'prelu':
- self.act = nn.PReLU(num_parameters=in_ch)
- elif act == 'softmax':
- self.act = nn.Softmax(dim=-1)
- elif act == 'sigmoid':
- self.act = nn.Sigmoid()
-
- def forward(self, x, mix_lambda=None, device=None):
- """
- Args:
- x: waveform, torch.tensor [batch, t_samples] / batch of mel_spec and longer list
- mix_lambda: torch.tensor [batch], the mixup lambda
- Returns:
- class_prob: torch.tensor [batch, class_num]
-
- """
- # batchnorm cancel grandient
- if self.freeze:
- self.clap_model.eval()
-
- x = self.clap_model.audio_projection(
- self.clap_model.audio_branch(x, mixup_lambda=mix_lambda, device=device)["embedding"])
- out = self.lp_layer(x)
- if self.act is not None:
- out = self.act(out)
- return out
diff --git a/spaces/ASJMO/freegpt/g4f/README.md b/spaces/ASJMO/freegpt/g4f/README.md
deleted file mode 100644
index c2cbfd69dc169e2cb4f8d24104fb12a52b91688d..0000000000000000000000000000000000000000
--- a/spaces/ASJMO/freegpt/g4f/README.md
+++ /dev/null
@@ -1,5 +0,0 @@
-## 🚀 API G4F
-
-This API is built upon the [gpt4free](https://github.com/xtekky/gpt4free) project.
-
-
diff --git a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/click/Factory.js b/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/click/Factory.js
deleted file mode 100644
index 9158fc1eb1df9be583d2b23d7601d216ecfdde3a..0000000000000000000000000000000000000000
--- a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/click/Factory.js
+++ /dev/null
@@ -1,11 +0,0 @@
-import Click from './Click.js';
-import ObjectFactory from '../ObjectFactory.js';
-import SetValue from '../../../plugins/utils/object/SetValue.js';
-
-ObjectFactory.register('click', function (gameObject, config) {
- return new Click(gameObject, config);
-});
-
-SetValue(window, 'RexPlugins.UI.Click', Click);
-
-export default Click;
\ No newline at end of file
diff --git a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/pinch/Factory.js b/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/pinch/Factory.js
deleted file mode 100644
index 998162fb7f81af546f21611ae619208acfbb7888..0000000000000000000000000000000000000000
--- a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/pinch/Factory.js
+++ /dev/null
@@ -1,11 +0,0 @@
-import Pinch from './Pinch.js';
-import ObjectFactory from '../ObjectFactory.js';
-import SetValue from '../../../plugins/utils/object/SetValue.js';
-
-ObjectFactory.register('pinch', function (config) {
- return new Pinch(this.scene, config);
-});
-
-SetValue(window, 'RexPlugins.UI.Pinch', Pinch);
-
-export default Pinch;
\ No newline at end of file
diff --git a/spaces/AkashKhamkar/QnA-generator/README.md b/spaces/AkashKhamkar/QnA-generator/README.md
deleted file mode 100644
index ffe6a9ed5dab19a60a9f5ae4d2c5a4c4e0a0290a..0000000000000000000000000000000000000000
--- a/spaces/AkashKhamkar/QnA-generator/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: QnA Generator
-emoji: 🌖
-colorFrom: purple
-colorTo: pink
-sdk: streamlit
-sdk_version: 1.10.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/AlekseyKorshuk/model-evaluation/utils.py b/spaces/AlekseyKorshuk/model-evaluation/utils.py
deleted file mode 100644
index 883297bc5e5da63943333921ce29f695371697b6..0000000000000000000000000000000000000000
--- a/spaces/AlekseyKorshuk/model-evaluation/utils.py
+++ /dev/null
@@ -1,34 +0,0 @@
-import itertools
-import random
-
-
-def get_matchmaking(client, models, is_anonymous=True):
- model_a, model_b = random.sample(models, k=2)
- return model_a, model_b
- sheet = client.open("Chat Arena").sheet1
- records = sheet.get_all_records()
- records = [
- {
- col: record.get(col, None)
- for col in ['model_a', 'model_b']
- } for record in records if record["is_anonymous"] == is_anonymous
- ]
-
- combinations = list(itertools.combinations_with_replacement(models, 2))
- combinations = [frozenset(combination) for combination in combinations if len(set(combination)) > 1]
-
- records = [
- frozenset(record.values()) for record in records
- ]
-
- repetitions_count = {combination: 0 for combination in combinations}
-
- for record in records:
- repetitions_count[record] += 1
-
- sorted_repetitions = dict(sorted(repetitions_count.items(), key=lambda item: item[1]))
- less_common = list(sorted_repetitions.keys())[0]
- less_common = list(less_common)
- random.shuffle(less_common)
- model_a, model_b = less_common
- return model_a, model_b
diff --git a/spaces/Alpaca233/SadTalker/src/face3d/models/arcface_torch/run.sh b/spaces/Alpaca233/SadTalker/src/face3d/models/arcface_torch/run.sh
deleted file mode 100644
index 61af4b4950eb11334e55362e3e3c5e2796979a01..0000000000000000000000000000000000000000
--- a/spaces/Alpaca233/SadTalker/src/face3d/models/arcface_torch/run.sh
+++ /dev/null
@@ -1,2 +0,0 @@
-CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 python -m torch.distributed.launch --nproc_per_node=8 --nnodes=1 --node_rank=0 --master_addr="127.0.0.1" --master_port=1234 train.py configs/ms1mv3_r50
-ps -ef | grep "train" | grep -v grep | awk '{print "kill -9 "$2}' | sh
diff --git a/spaces/Amrrs/DragGan-Inversion/viz/__init__.py b/spaces/Amrrs/DragGan-Inversion/viz/__init__.py
deleted file mode 100644
index 939e7c6c8f94c4ea1141885c3c3295fe083b06aa..0000000000000000000000000000000000000000
--- a/spaces/Amrrs/DragGan-Inversion/viz/__init__.py
+++ /dev/null
@@ -1,9 +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.
-
-# empty
diff --git a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/pipelines/latent_diffusion/__init__.py b/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/pipelines/latent_diffusion/__init__.py
deleted file mode 100644
index a6c16f59869520b9409f5cad488a96634a12a2ca..0000000000000000000000000000000000000000
--- a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/pipelines/latent_diffusion/__init__.py
+++ /dev/null
@@ -1,11 +0,0 @@
-from ...utils import OptionalDependencyNotAvailable, is_torch_available, is_transformers_available
-from .pipeline_latent_diffusion_superresolution import LDMSuperResolutionPipeline
-
-
-try:
- if not (is_transformers_available() and is_torch_available()):
- raise OptionalDependencyNotAvailable()
-except OptionalDependencyNotAvailable:
- from ...utils.dummy_torch_and_transformers_objects import ShapEPipeline
-else:
- from .pipeline_latent_diffusion import LDMBertModel, LDMTextToImagePipeline
diff --git a/spaces/Andy1621/uniformer_image_detection/tools/misc/print_config.py b/spaces/Andy1621/uniformer_image_detection/tools/misc/print_config.py
deleted file mode 100644
index 3627f81fed059f2e819dc6544fac103e1a1e6c17..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_detection/tools/misc/print_config.py
+++ /dev/null
@@ -1,54 +0,0 @@
-import argparse
-import warnings
-
-from mmcv import Config, DictAction
-
-
-def parse_args():
- parser = argparse.ArgumentParser(description='Print the whole config')
- parser.add_argument('config', help='config file path')
- parser.add_argument(
- '--options',
- nargs='+',
- action=DictAction,
- help='override some settings in the used config, the key-value pair '
- 'in xxx=yyy format will be merged into config file (deprecate), '
- 'change to --cfg-options instead.')
- parser.add_argument(
- '--cfg-options',
- nargs='+',
- action=DictAction,
- help='override some settings in the used config, the key-value pair '
- 'in xxx=yyy format will be merged into config file. If the value to '
- 'be overwritten is a list, it should be like key="[a,b]" or key=a,b '
- 'It also allows nested list/tuple values, e.g. key="[(a,b),(c,d)]" '
- 'Note that the quotation marks are necessary and that no white space '
- 'is allowed.')
- args = parser.parse_args()
-
- if args.options and args.cfg_options:
- raise ValueError(
- '--options and --cfg-options cannot be both '
- 'specified, --options is deprecated in favor of --cfg-options')
- if args.options:
- warnings.warn('--options is deprecated in favor of --cfg-options')
- args.cfg_options = args.options
-
- return args
-
-
-def main():
- args = parse_args()
-
- cfg = Config.fromfile(args.config)
- if args.cfg_options is not None:
- cfg.merge_from_dict(args.cfg_options)
- # import modules from string list.
- if cfg.get('custom_imports', None):
- from mmcv.utils import import_modules_from_strings
- import_modules_from_strings(**cfg['custom_imports'])
- print(f'Config:\n{cfg.pretty_text}')
-
-
-if __name__ == '__main__':
- main()
diff --git a/spaces/Anonymous-123/ImageNet-Editing/run.sh b/spaces/Anonymous-123/ImageNet-Editing/run.sh
deleted file mode 100644
index 0673ac320cfba747f67682f86ab7b9a7198eb92d..0000000000000000000000000000000000000000
--- a/spaces/Anonymous-123/ImageNet-Editing/run.sh
+++ /dev/null
@@ -1,86 +0,0 @@
-#!/bin/sh
-#****************************************************************#
-# ScriptName: run.sh
-# Author: Anonymous_123
-# Create Date: 2022-09-12 11:55
-# Modify Author: Anonymous_123
-# Modify Date: 2022-09-25 12:02
-# Function:
-#***************************************************************#
-
-# rm -rf results
-# mkdir results
-# rm -rf tmp
-# mkdir tmp
-ls /usr/local/cuda*
-
-# Backgrounds
-bg_scale=$1 #
-bg_detemined=$2 # given the input background
-hard=False
-if [ "$1" != "" ]; then
- if [ $1 > 0 ]; then
- hard=True
- fi
-fi
-
-# Size
-size=$3
-
-# Direction
-angle=$4
-
-# Steps
-tot_steps=100
-step=$5
-skip_step=`expr $tot_steps - $step`
-
-# number of generated image
-num_of_Images=$6
-
-# Background removal
-cd object_removal/TFill/
-python test.py \
---name imagenet \
---img_file ../../tmp/img/ \
---mask_file ../../tmp/mask/ \
---results_dir ../../results \
---model tc \
---coarse_or_refine refine \
---gpu_id 0 \
---no_shuffle \
---batch_size 1 \
---preprocess scale_shortside \
---mask_type 3 \
---load_size 512 \
---attn_G \
---add_noise
-
-cd ../../
-mv results/imagenet/test_latest/img_ref_out/input_0.png results/object_removal.png
-rm -rf results/imagenet/
-
-# Resize
-python resize_obj.py --img_path tmp/img/input.JPEG --mask_path tmp/mask/input.png --scale $size
-
-if [ "$2" != "" ]; then
- bg_path=$bg_detemined
-else
- bg_path="../results/object_removal.png"
-fi
-
-echo "Background path: " echo $bg_path
-echo "Steps: " echo $step
-echo "Object pixel rate: " echo $size
-echo "Object angle: " echo $angle
-
-# Generating
-cd editing_diffusion
-if [ $1 > 0 ]; then
- CUDA_VISIBLE_DEVICES=0 python main.py -p "test.JPEG" -i $bg_path -i2 "../results/img_rescaled.png" --mask "../results/mask_rescaled.png" --output_path "../tmp" --batch_size 1 --skip_timesteps $skip_step --invert_mask --clip_guidance_lambda 0 --classifier_scale 0. --y 0 --final_save_root "../results/" --rotate_obj --angle $angle --background_complex $bg_scale --hard --iterations_num $num_of_Images # --coarse_to_fine #--background_preservation_loss # --vid #--clip_guidance_lambda 0
-else
- CUDA_VISIBLE_DEVICES=0 python main.py -p "test.JPEG" -i $bg_path -i2 "../results/img_rescaled.png" --mask "../results/mask_rescaled.png" --output_path "../tmp" --batch_size 1 --skip_timesteps $skip_step --invert_mask --clip_guidance_lambda 0 --classifier_scale 0. --y 0 --final_save_root "../results/" --rotate_obj --angle $angle --background_complex $bg_scale --iterations_num $num_of_Images # --coarse_to_fine #--background_preservation_loss # --vid #--clip_guidance_lambda 0
-fi
-
-
-
diff --git a/spaces/Arnx/MusicGenXvAKN/audiocraft/quantization/base.py b/spaces/Arnx/MusicGenXvAKN/audiocraft/quantization/base.py
deleted file mode 100644
index 1b16c130d266fbd021d3fc29bb9f98c33dd3c588..0000000000000000000000000000000000000000
--- a/spaces/Arnx/MusicGenXvAKN/audiocraft/quantization/base.py
+++ /dev/null
@@ -1,107 +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.
-
-"""
-Base class for all quantizers.
-"""
-
-from dataclasses import dataclass, field
-import typing as tp
-
-import torch
-from torch import nn
-
-
-@dataclass
-class QuantizedResult:
- x: torch.Tensor
- codes: torch.Tensor
- bandwidth: torch.Tensor # bandwidth in kb/s used, per batch item.
- penalty: tp.Optional[torch.Tensor] = None
- metrics: dict = field(default_factory=dict)
-
-
-class BaseQuantizer(nn.Module):
- """Base class for quantizers.
- """
-
- def forward(self, x: torch.Tensor, frame_rate: int) -> QuantizedResult:
- """
- Given input tensor x, returns first the quantized (or approximately quantized)
- representation along with quantized codes, bandwidth, and any penalty term for the loss.
- Finally, this returns a dict of metrics to update logging etc.
- Frame rate must be passed so that the bandwidth is properly computed.
- """
- raise NotImplementedError()
-
- def encode(self, x: torch.Tensor) -> torch.Tensor:
- """Encode a given input tensor with the specified sample rate at the given bandwidth.
- """
- raise NotImplementedError()
-
- def decode(self, codes: torch.Tensor) -> torch.Tensor:
- """Decode the given codes to the quantized representation.
- """
- raise NotImplementedError()
-
- @property
- def total_codebooks(self):
- """Total number of codebooks.
- """
- raise NotImplementedError()
-
- @property
- def num_codebooks(self):
- """Number of active codebooks.
- """
- raise NotImplementedError()
-
- def set_num_codebooks(self, n: int):
- """Set the number of active codebooks.
- """
- raise NotImplementedError()
-
-
-class DummyQuantizer(BaseQuantizer):
- """Fake quantizer that actually does not perform any quantization.
- """
- def __init__(self):
- super().__init__()
-
- def forward(self, x: torch.Tensor, frame_rate: int):
- q = x.unsqueeze(1)
- return QuantizedResult(x, q, torch.tensor(q.numel() * 32 * frame_rate / 1000 / len(x)).to(x))
-
- def encode(self, x: torch.Tensor) -> torch.Tensor:
- """Encode a given input tensor with the specified sample rate at the given bandwidth.
- In the case of the DummyQuantizer, the codes are actually identical
- to the input and resulting quantized representation as no quantization is done.
- """
- return x.unsqueeze(1)
-
- def decode(self, codes: torch.Tensor) -> torch.Tensor:
- """Decode the given codes to the quantized representation.
- In the case of the DummyQuantizer, the codes are actually identical
- to the input and resulting quantized representation as no quantization is done.
- """
- return codes.squeeze(1)
-
- @property
- def total_codebooks(self):
- """Total number of codebooks.
- """
- return 1
-
- @property
- def num_codebooks(self):
- """Total number of codebooks.
- """
- return self.total_codebooks
-
- def set_num_codebooks(self, n: int):
- """Set the number of active codebooks.
- """
- raise AttributeError("Cannot override the number of codebooks for the dummy quantizer")
diff --git a/spaces/AsakuraMizu/moe-tts/modules.py b/spaces/AsakuraMizu/moe-tts/modules.py
deleted file mode 100644
index 3484f6a1f4c1c06855c37a1ff4e66c58864acb38..0000000000000000000000000000000000000000
--- a/spaces/AsakuraMizu/moe-tts/modules.py
+++ /dev/null
@@ -1,390 +0,0 @@
-import copy
-import math
-import numpy as np
-import scipy
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
-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):
- """
- Dilated 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/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/distro/distro.py b/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/distro/distro.py
deleted file mode 100644
index 89e1868047225bbcdfe04bdc4bea3281bf91bc20..0000000000000000000000000000000000000000
--- a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/distro/distro.py
+++ /dev/null
@@ -1,1399 +0,0 @@
-#!/usr/bin/env python
-# Copyright 2015,2016,2017 Nir Cohen
-#
-# 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.
-
-"""
-The ``distro`` package (``distro`` stands for Linux Distribution) provides
-information about the Linux distribution it runs on, such as a reliable
-machine-readable distro ID, or version information.
-
-It is the recommended replacement for Python's original
-:py:func:`platform.linux_distribution` function, but it provides much more
-functionality. An alternative implementation became necessary because Python
-3.5 deprecated this function, and Python 3.8 removed it altogether. Its
-predecessor function :py:func:`platform.dist` was already deprecated since
-Python 2.6 and removed in Python 3.8. Still, there are many cases in which
-access to OS distribution information is needed. See `Python issue 1322
-`_ for more information.
-"""
-
-import argparse
-import json
-import logging
-import os
-import re
-import shlex
-import subprocess
-import sys
-import warnings
-from typing import (
- Any,
- Callable,
- Dict,
- Iterable,
- Optional,
- Sequence,
- TextIO,
- Tuple,
- Type,
-)
-
-try:
- from typing import TypedDict
-except ImportError:
- # Python 3.7
- TypedDict = dict
-
-__version__ = "1.8.0"
-
-
-class VersionDict(TypedDict):
- major: str
- minor: str
- build_number: str
-
-
-class InfoDict(TypedDict):
- id: str
- version: str
- version_parts: VersionDict
- like: str
- codename: str
-
-
-_UNIXCONFDIR = os.environ.get("UNIXCONFDIR", "/etc")
-_UNIXUSRLIBDIR = os.environ.get("UNIXUSRLIBDIR", "/usr/lib")
-_OS_RELEASE_BASENAME = "os-release"
-
-#: Translation table for normalizing the "ID" attribute defined in os-release
-#: files, for use by the :func:`distro.id` method.
-#:
-#: * Key: Value as defined in the os-release file, translated to lower case,
-#: with blanks translated to underscores.
-#:
-#: * Value: Normalized value.
-NORMALIZED_OS_ID = {
- "ol": "oracle", # Oracle Linux
- "opensuse-leap": "opensuse", # Newer versions of OpenSuSE report as opensuse-leap
-}
-
-#: Translation table for normalizing the "Distributor ID" attribute returned by
-#: the lsb_release command, for use by the :func:`distro.id` method.
-#:
-#: * Key: Value as returned by the lsb_release command, translated to lower
-#: case, with blanks translated to underscores.
-#:
-#: * Value: Normalized value.
-NORMALIZED_LSB_ID = {
- "enterpriseenterpriseas": "oracle", # Oracle Enterprise Linux 4
- "enterpriseenterpriseserver": "oracle", # Oracle Linux 5
- "redhatenterpriseworkstation": "rhel", # RHEL 6, 7 Workstation
- "redhatenterpriseserver": "rhel", # RHEL 6, 7 Server
- "redhatenterprisecomputenode": "rhel", # RHEL 6 ComputeNode
-}
-
-#: Translation table for normalizing the distro ID derived from the file name
-#: of distro release files, for use by the :func:`distro.id` method.
-#:
-#: * Key: Value as derived from the file name of a distro release file,
-#: translated to lower case, with blanks translated to underscores.
-#:
-#: * Value: Normalized value.
-NORMALIZED_DISTRO_ID = {
- "redhat": "rhel", # RHEL 6.x, 7.x
-}
-
-# Pattern for content of distro release file (reversed)
-_DISTRO_RELEASE_CONTENT_REVERSED_PATTERN = re.compile(
- r"(?:[^)]*\)(.*)\()? *(?:STL )?([\d.+\-a-z]*\d) *(?:esaeler *)?(.+)"
-)
-
-# Pattern for base file name of distro release file
-_DISTRO_RELEASE_BASENAME_PATTERN = re.compile(r"(\w+)[-_](release|version)$")
-
-# Base file names to be looked up for if _UNIXCONFDIR is not readable.
-_DISTRO_RELEASE_BASENAMES = [
- "SuSE-release",
- "arch-release",
- "base-release",
- "centos-release",
- "fedora-release",
- "gentoo-release",
- "mageia-release",
- "mandrake-release",
- "mandriva-release",
- "mandrivalinux-release",
- "manjaro-release",
- "oracle-release",
- "redhat-release",
- "rocky-release",
- "sl-release",
- "slackware-version",
-]
-
-# Base file names to be ignored when searching for distro release file
-_DISTRO_RELEASE_IGNORE_BASENAMES = (
- "debian_version",
- "lsb-release",
- "oem-release",
- _OS_RELEASE_BASENAME,
- "system-release",
- "plesk-release",
- "iredmail-release",
-)
-
-
-def linux_distribution(full_distribution_name: bool = True) -> Tuple[str, str, str]:
- """
- .. deprecated:: 1.6.0
-
- :func:`distro.linux_distribution()` is deprecated. It should only be
- used as a compatibility shim with Python's
- :py:func:`platform.linux_distribution()`. Please use :func:`distro.id`,
- :func:`distro.version` and :func:`distro.name` instead.
-
- Return information about the current OS distribution as a tuple
- ``(id_name, version, codename)`` with items as follows:
-
- * ``id_name``: If *full_distribution_name* is false, the result of
- :func:`distro.id`. Otherwise, the result of :func:`distro.name`.
-
- * ``version``: The result of :func:`distro.version`.
-
- * ``codename``: The extra item (usually in parentheses) after the
- os-release version number, or the result of :func:`distro.codename`.
-
- The interface of this function is compatible with the original
- :py:func:`platform.linux_distribution` function, supporting a subset of
- its parameters.
-
- The data it returns may not exactly be the same, because it uses more data
- sources than the original function, and that may lead to different data if
- the OS distribution is not consistent across multiple data sources it
- provides (there are indeed such distributions ...).
-
- Another reason for differences is the fact that the :func:`distro.id`
- method normalizes the distro ID string to a reliable machine-readable value
- for a number of popular OS distributions.
- """
- warnings.warn(
- "distro.linux_distribution() is deprecated. It should only be used as a "
- "compatibility shim with Python's platform.linux_distribution(). Please use "
- "distro.id(), distro.version() and distro.name() instead.",
- DeprecationWarning,
- stacklevel=2,
- )
- return _distro.linux_distribution(full_distribution_name)
-
-
-def id() -> str:
- """
- Return the distro ID of the current distribution, as a
- machine-readable string.
-
- For a number of OS distributions, the returned distro ID value is
- *reliable*, in the sense that it is documented and that it does not change
- across releases of the distribution.
-
- This package maintains the following reliable distro ID values:
-
- ============== =========================================
- Distro ID Distribution
- ============== =========================================
- "ubuntu" Ubuntu
- "debian" Debian
- "rhel" RedHat Enterprise Linux
- "centos" CentOS
- "fedora" Fedora
- "sles" SUSE Linux Enterprise Server
- "opensuse" openSUSE
- "amzn" Amazon Linux
- "arch" Arch Linux
- "buildroot" Buildroot
- "cloudlinux" CloudLinux OS
- "exherbo" Exherbo Linux
- "gentoo" GenToo Linux
- "ibm_powerkvm" IBM PowerKVM
- "kvmibm" KVM for IBM z Systems
- "linuxmint" Linux Mint
- "mageia" Mageia
- "mandriva" Mandriva Linux
- "parallels" Parallels
- "pidora" Pidora
- "raspbian" Raspbian
- "oracle" Oracle Linux (and Oracle Enterprise Linux)
- "scientific" Scientific Linux
- "slackware" Slackware
- "xenserver" XenServer
- "openbsd" OpenBSD
- "netbsd" NetBSD
- "freebsd" FreeBSD
- "midnightbsd" MidnightBSD
- "rocky" Rocky Linux
- "aix" AIX
- "guix" Guix System
- ============== =========================================
-
- If you have a need to get distros for reliable IDs added into this set,
- or if you find that the :func:`distro.id` function returns a different
- distro ID for one of the listed distros, please create an issue in the
- `distro issue tracker`_.
-
- **Lookup hierarchy and transformations:**
-
- First, the ID is obtained from the following sources, in the specified
- order. The first available and non-empty value is used:
-
- * the value of the "ID" attribute of the os-release file,
-
- * the value of the "Distributor ID" attribute returned by the lsb_release
- command,
-
- * the first part of the file name of the distro release file,
-
- The so determined ID value then passes the following transformations,
- before it is returned by this method:
-
- * it is translated to lower case,
-
- * blanks (which should not be there anyway) are translated to underscores,
-
- * a normalization of the ID is performed, based upon
- `normalization tables`_. The purpose of this normalization is to ensure
- that the ID is as reliable as possible, even across incompatible changes
- in the OS distributions. A common reason for an incompatible change is
- the addition of an os-release file, or the addition of the lsb_release
- command, with ID values that differ from what was previously determined
- from the distro release file name.
- """
- return _distro.id()
-
-
-def name(pretty: bool = False) -> str:
- """
- Return the name of the current OS distribution, as a human-readable
- string.
-
- If *pretty* is false, the name is returned without version or codename.
- (e.g. "CentOS Linux")
-
- If *pretty* is true, the version and codename are appended.
- (e.g. "CentOS Linux 7.1.1503 (Core)")
-
- **Lookup hierarchy:**
-
- The name is obtained from the following sources, in the specified order.
- The first available and non-empty value is used:
-
- * If *pretty* is false:
-
- - the value of the "NAME" attribute of the os-release file,
-
- - the value of the "Distributor ID" attribute returned by the lsb_release
- command,
-
- - the value of the "" field of the distro release file.
-
- * If *pretty* is true:
-
- - the value of the "PRETTY_NAME" attribute of the os-release file,
-
- - the value of the "Description" attribute returned by the lsb_release
- command,
-
- - the value of the "" field of the distro release file, appended
- with the value of the pretty version ("" and ""
- fields) of the distro release file, if available.
- """
- return _distro.name(pretty)
-
-
-def version(pretty: bool = False, best: bool = False) -> str:
- """
- Return the version of the current OS distribution, as a human-readable
- string.
-
- If *pretty* is false, the version is returned without codename (e.g.
- "7.0").
-
- If *pretty* is true, the codename in parenthesis is appended, if the
- codename is non-empty (e.g. "7.0 (Maipo)").
-
- Some distributions provide version numbers with different precisions in
- the different sources of distribution information. Examining the different
- sources in a fixed priority order does not always yield the most precise
- version (e.g. for Debian 8.2, or CentOS 7.1).
-
- Some other distributions may not provide this kind of information. In these
- cases, an empty string would be returned. This behavior can be observed
- with rolling releases distributions (e.g. Arch Linux).
-
- The *best* parameter can be used to control the approach for the returned
- version:
-
- If *best* is false, the first non-empty version number in priority order of
- the examined sources is returned.
-
- If *best* is true, the most precise version number out of all examined
- sources is returned.
-
- **Lookup hierarchy:**
-
- In all cases, the version number is obtained from the following sources.
- If *best* is false, this order represents the priority order:
-
- * the value of the "VERSION_ID" attribute of the os-release file,
- * the value of the "Release" attribute returned by the lsb_release
- command,
- * the version number parsed from the "" field of the first line
- of the distro release file,
- * the version number parsed from the "PRETTY_NAME" attribute of the
- os-release file, if it follows the format of the distro release files.
- * the version number parsed from the "Description" attribute returned by
- the lsb_release command, if it follows the format of the distro release
- files.
- """
- return _distro.version(pretty, best)
-
-
-def version_parts(best: bool = False) -> Tuple[str, str, str]:
- """
- Return the version of the current OS distribution as a tuple
- ``(major, minor, build_number)`` with items as follows:
-
- * ``major``: The result of :func:`distro.major_version`.
-
- * ``minor``: The result of :func:`distro.minor_version`.
-
- * ``build_number``: The result of :func:`distro.build_number`.
-
- For a description of the *best* parameter, see the :func:`distro.version`
- method.
- """
- return _distro.version_parts(best)
-
-
-def major_version(best: bool = False) -> str:
- """
- Return the major version of the current OS distribution, as a string,
- if provided.
- Otherwise, the empty string is returned. The major version is the first
- part of the dot-separated version string.
-
- For a description of the *best* parameter, see the :func:`distro.version`
- method.
- """
- return _distro.major_version(best)
-
-
-def minor_version(best: bool = False) -> str:
- """
- Return the minor version of the current OS distribution, as a string,
- if provided.
- Otherwise, the empty string is returned. The minor version is the second
- part of the dot-separated version string.
-
- For a description of the *best* parameter, see the :func:`distro.version`
- method.
- """
- return _distro.minor_version(best)
-
-
-def build_number(best: bool = False) -> str:
- """
- Return the build number of the current OS distribution, as a string,
- if provided.
- Otherwise, the empty string is returned. The build number is the third part
- of the dot-separated version string.
-
- For a description of the *best* parameter, see the :func:`distro.version`
- method.
- """
- return _distro.build_number(best)
-
-
-def like() -> str:
- """
- Return a space-separated list of distro IDs of distributions that are
- closely related to the current OS distribution in regards to packaging
- and programming interfaces, for example distributions the current
- distribution is a derivative from.
-
- **Lookup hierarchy:**
-
- This information item is only provided by the os-release file.
- For details, see the description of the "ID_LIKE" attribute in the
- `os-release man page
- `_.
- """
- return _distro.like()
-
-
-def codename() -> str:
- """
- Return the codename for the release of the current OS distribution,
- as a string.
-
- If the distribution does not have a codename, an empty string is returned.
-
- Note that the returned codename is not always really a codename. For
- example, openSUSE returns "x86_64". This function does not handle such
- cases in any special way and just returns the string it finds, if any.
-
- **Lookup hierarchy:**
-
- * the codename within the "VERSION" attribute of the os-release file, if
- provided,
-
- * the value of the "Codename" attribute returned by the lsb_release
- command,
-
- * the value of the "" field of the distro release file.
- """
- return _distro.codename()
-
-
-def info(pretty: bool = False, best: bool = False) -> InfoDict:
- """
- Return certain machine-readable information items about the current OS
- distribution in a dictionary, as shown in the following example:
-
- .. sourcecode:: python
-
- {
- 'id': 'rhel',
- 'version': '7.0',
- 'version_parts': {
- 'major': '7',
- 'minor': '0',
- 'build_number': ''
- },
- 'like': 'fedora',
- 'codename': 'Maipo'
- }
-
- The dictionary structure and keys are always the same, regardless of which
- information items are available in the underlying data sources. The values
- for the various keys are as follows:
-
- * ``id``: The result of :func:`distro.id`.
-
- * ``version``: The result of :func:`distro.version`.
-
- * ``version_parts -> major``: The result of :func:`distro.major_version`.
-
- * ``version_parts -> minor``: The result of :func:`distro.minor_version`.
-
- * ``version_parts -> build_number``: The result of
- :func:`distro.build_number`.
-
- * ``like``: The result of :func:`distro.like`.
-
- * ``codename``: The result of :func:`distro.codename`.
-
- For a description of the *pretty* and *best* parameters, see the
- :func:`distro.version` method.
- """
- return _distro.info(pretty, best)
-
-
-def os_release_info() -> Dict[str, str]:
- """
- Return a dictionary containing key-value pairs for the information items
- from the os-release file data source of the current OS distribution.
-
- See `os-release file`_ for details about these information items.
- """
- return _distro.os_release_info()
-
-
-def lsb_release_info() -> Dict[str, str]:
- """
- Return a dictionary containing key-value pairs for the information items
- from the lsb_release command data source of the current OS distribution.
-
- See `lsb_release command output`_ for details about these information
- items.
- """
- return _distro.lsb_release_info()
-
-
-def distro_release_info() -> Dict[str, str]:
- """
- Return a dictionary containing key-value pairs for the information items
- from the distro release file data source of the current OS distribution.
-
- See `distro release file`_ for details about these information items.
- """
- return _distro.distro_release_info()
-
-
-def uname_info() -> Dict[str, str]:
- """
- Return a dictionary containing key-value pairs for the information items
- from the distro release file data source of the current OS distribution.
- """
- return _distro.uname_info()
-
-
-def os_release_attr(attribute: str) -> str:
- """
- Return a single named information item from the os-release file data source
- of the current OS distribution.
-
- Parameters:
-
- * ``attribute`` (string): Key of the information item.
-
- Returns:
-
- * (string): Value of the information item, if the item exists.
- The empty string, if the item does not exist.
-
- See `os-release file`_ for details about these information items.
- """
- return _distro.os_release_attr(attribute)
-
-
-def lsb_release_attr(attribute: str) -> str:
- """
- Return a single named information item from the lsb_release command output
- data source of the current OS distribution.
-
- Parameters:
-
- * ``attribute`` (string): Key of the information item.
-
- Returns:
-
- * (string): Value of the information item, if the item exists.
- The empty string, if the item does not exist.
-
- See `lsb_release command output`_ for details about these information
- items.
- """
- return _distro.lsb_release_attr(attribute)
-
-
-def distro_release_attr(attribute: str) -> str:
- """
- Return a single named information item from the distro release file
- data source of the current OS distribution.
-
- Parameters:
-
- * ``attribute`` (string): Key of the information item.
-
- Returns:
-
- * (string): Value of the information item, if the item exists.
- The empty string, if the item does not exist.
-
- See `distro release file`_ for details about these information items.
- """
- return _distro.distro_release_attr(attribute)
-
-
-def uname_attr(attribute: str) -> str:
- """
- Return a single named information item from the distro release file
- data source of the current OS distribution.
-
- Parameters:
-
- * ``attribute`` (string): Key of the information item.
-
- Returns:
-
- * (string): Value of the information item, if the item exists.
- The empty string, if the item does not exist.
- """
- return _distro.uname_attr(attribute)
-
-
-try:
- from functools import cached_property
-except ImportError:
- # Python < 3.8
- class cached_property: # type: ignore
- """A version of @property which caches the value. On access, it calls the
- underlying function and sets the value in `__dict__` so future accesses
- will not re-call the property.
- """
-
- def __init__(self, f: Callable[[Any], Any]) -> None:
- self._fname = f.__name__
- self._f = f
-
- def __get__(self, obj: Any, owner: Type[Any]) -> Any:
- assert obj is not None, f"call {self._fname} on an instance"
- ret = obj.__dict__[self._fname] = self._f(obj)
- return ret
-
-
-class LinuxDistribution:
- """
- Provides information about a OS distribution.
-
- This package creates a private module-global instance of this class with
- default initialization arguments, that is used by the
- `consolidated accessor functions`_ and `single source accessor functions`_.
- By using default initialization arguments, that module-global instance
- returns data about the current OS distribution (i.e. the distro this
- package runs on).
-
- Normally, it is not necessary to create additional instances of this class.
- However, in situations where control is needed over the exact data sources
- that are used, instances of this class can be created with a specific
- distro release file, or a specific os-release file, or without invoking the
- lsb_release command.
- """
-
- def __init__(
- self,
- include_lsb: Optional[bool] = None,
- os_release_file: str = "",
- distro_release_file: str = "",
- include_uname: Optional[bool] = None,
- root_dir: Optional[str] = None,
- include_oslevel: Optional[bool] = None,
- ) -> None:
- """
- The initialization method of this class gathers information from the
- available data sources, and stores that in private instance attributes.
- Subsequent access to the information items uses these private instance
- attributes, so that the data sources are read only once.
-
- Parameters:
-
- * ``include_lsb`` (bool): Controls whether the
- `lsb_release command output`_ is included as a data source.
-
- If the lsb_release command is not available in the program execution
- path, the data source for the lsb_release command will be empty.
-
- * ``os_release_file`` (string): The path name of the
- `os-release file`_ that is to be used as a data source.
-
- An empty string (the default) will cause the default path name to
- be used (see `os-release file`_ for details).
-
- If the specified or defaulted os-release file does not exist, the
- data source for the os-release file will be empty.
-
- * ``distro_release_file`` (string): The path name of the
- `distro release file`_ that is to be used as a data source.
-
- An empty string (the default) will cause a default search algorithm
- to be used (see `distro release file`_ for details).
-
- If the specified distro release file does not exist, or if no default
- distro release file can be found, the data source for the distro
- release file will be empty.
-
- * ``include_uname`` (bool): Controls whether uname command output is
- included as a data source. If the uname command is not available in
- the program execution path the data source for the uname command will
- be empty.
-
- * ``root_dir`` (string): The absolute path to the root directory to use
- to find distro-related information files. Note that ``include_*``
- parameters must not be enabled in combination with ``root_dir``.
-
- * ``include_oslevel`` (bool): Controls whether (AIX) oslevel command
- output is included as a data source. If the oslevel command is not
- available in the program execution path the data source will be
- empty.
-
- Public instance attributes:
-
- * ``os_release_file`` (string): The path name of the
- `os-release file`_ that is actually used as a data source. The
- empty string if no distro release file is used as a data source.
-
- * ``distro_release_file`` (string): The path name of the
- `distro release file`_ that is actually used as a data source. The
- empty string if no distro release file is used as a data source.
-
- * ``include_lsb`` (bool): The result of the ``include_lsb`` parameter.
- This controls whether the lsb information will be loaded.
-
- * ``include_uname`` (bool): The result of the ``include_uname``
- parameter. This controls whether the uname information will
- be loaded.
-
- * ``include_oslevel`` (bool): The result of the ``include_oslevel``
- parameter. This controls whether (AIX) oslevel information will be
- loaded.
-
- * ``root_dir`` (string): The result of the ``root_dir`` parameter.
- The absolute path to the root directory to use to find distro-related
- information files.
-
- Raises:
-
- * :py:exc:`ValueError`: Initialization parameters combination is not
- supported.
-
- * :py:exc:`OSError`: Some I/O issue with an os-release file or distro
- release file.
-
- * :py:exc:`UnicodeError`: A data source has unexpected characters or
- uses an unexpected encoding.
- """
- self.root_dir = root_dir
- self.etc_dir = os.path.join(root_dir, "etc") if root_dir else _UNIXCONFDIR
- self.usr_lib_dir = (
- os.path.join(root_dir, "usr/lib") if root_dir else _UNIXUSRLIBDIR
- )
-
- if os_release_file:
- self.os_release_file = os_release_file
- else:
- etc_dir_os_release_file = os.path.join(self.etc_dir, _OS_RELEASE_BASENAME)
- usr_lib_os_release_file = os.path.join(
- self.usr_lib_dir, _OS_RELEASE_BASENAME
- )
-
- # NOTE: The idea is to respect order **and** have it set
- # at all times for API backwards compatibility.
- if os.path.isfile(etc_dir_os_release_file) or not os.path.isfile(
- usr_lib_os_release_file
- ):
- self.os_release_file = etc_dir_os_release_file
- else:
- self.os_release_file = usr_lib_os_release_file
-
- self.distro_release_file = distro_release_file or "" # updated later
-
- is_root_dir_defined = root_dir is not None
- if is_root_dir_defined and (include_lsb or include_uname or include_oslevel):
- raise ValueError(
- "Including subprocess data sources from specific root_dir is disallowed"
- " to prevent false information"
- )
- self.include_lsb = (
- include_lsb if include_lsb is not None else not is_root_dir_defined
- )
- self.include_uname = (
- include_uname if include_uname is not None else not is_root_dir_defined
- )
- self.include_oslevel = (
- include_oslevel if include_oslevel is not None else not is_root_dir_defined
- )
-
- def __repr__(self) -> str:
- """Return repr of all info"""
- return (
- "LinuxDistribution("
- "os_release_file={self.os_release_file!r}, "
- "distro_release_file={self.distro_release_file!r}, "
- "include_lsb={self.include_lsb!r}, "
- "include_uname={self.include_uname!r}, "
- "include_oslevel={self.include_oslevel!r}, "
- "root_dir={self.root_dir!r}, "
- "_os_release_info={self._os_release_info!r}, "
- "_lsb_release_info={self._lsb_release_info!r}, "
- "_distro_release_info={self._distro_release_info!r}, "
- "_uname_info={self._uname_info!r}, "
- "_oslevel_info={self._oslevel_info!r})".format(self=self)
- )
-
- def linux_distribution(
- self, full_distribution_name: bool = True
- ) -> Tuple[str, str, str]:
- """
- Return information about the OS distribution that is compatible
- with Python's :func:`platform.linux_distribution`, supporting a subset
- of its parameters.
-
- For details, see :func:`distro.linux_distribution`.
- """
- return (
- self.name() if full_distribution_name else self.id(),
- self.version(),
- self._os_release_info.get("release_codename") or self.codename(),
- )
-
- def id(self) -> str:
- """Return the distro ID of the OS distribution, as a string.
-
- For details, see :func:`distro.id`.
- """
-
- def normalize(distro_id: str, table: Dict[str, str]) -> str:
- distro_id = distro_id.lower().replace(" ", "_")
- return table.get(distro_id, distro_id)
-
- distro_id = self.os_release_attr("id")
- if distro_id:
- return normalize(distro_id, NORMALIZED_OS_ID)
-
- distro_id = self.lsb_release_attr("distributor_id")
- if distro_id:
- return normalize(distro_id, NORMALIZED_LSB_ID)
-
- distro_id = self.distro_release_attr("id")
- if distro_id:
- return normalize(distro_id, NORMALIZED_DISTRO_ID)
-
- distro_id = self.uname_attr("id")
- if distro_id:
- return normalize(distro_id, NORMALIZED_DISTRO_ID)
-
- return ""
-
- def name(self, pretty: bool = False) -> str:
- """
- Return the name of the OS distribution, as a string.
-
- For details, see :func:`distro.name`.
- """
- name = (
- self.os_release_attr("name")
- or self.lsb_release_attr("distributor_id")
- or self.distro_release_attr("name")
- or self.uname_attr("name")
- )
- if pretty:
- name = self.os_release_attr("pretty_name") or self.lsb_release_attr(
- "description"
- )
- if not name:
- name = self.distro_release_attr("name") or self.uname_attr("name")
- version = self.version(pretty=True)
- if version:
- name = f"{name} {version}"
- return name or ""
-
- def version(self, pretty: bool = False, best: bool = False) -> str:
- """
- Return the version of the OS distribution, as a string.
-
- For details, see :func:`distro.version`.
- """
- versions = [
- self.os_release_attr("version_id"),
- self.lsb_release_attr("release"),
- self.distro_release_attr("version_id"),
- self._parse_distro_release_content(self.os_release_attr("pretty_name")).get(
- "version_id", ""
- ),
- self._parse_distro_release_content(
- self.lsb_release_attr("description")
- ).get("version_id", ""),
- self.uname_attr("release"),
- ]
- if self.uname_attr("id").startswith("aix"):
- # On AIX platforms, prefer oslevel command output.
- versions.insert(0, self.oslevel_info())
- elif self.id() == "debian" or "debian" in self.like().split():
- # On Debian-like, add debian_version file content to candidates list.
- versions.append(self._debian_version)
- version = ""
- if best:
- # This algorithm uses the last version in priority order that has
- # the best precision. If the versions are not in conflict, that
- # does not matter; otherwise, using the last one instead of the
- # first one might be considered a surprise.
- for v in versions:
- if v.count(".") > version.count(".") or version == "":
- version = v
- else:
- for v in versions:
- if v != "":
- version = v
- break
- if pretty and version and self.codename():
- version = f"{version} ({self.codename()})"
- return version
-
- def version_parts(self, best: bool = False) -> Tuple[str, str, str]:
- """
- Return the version of the OS distribution, as a tuple of version
- numbers.
-
- For details, see :func:`distro.version_parts`.
- """
- version_str = self.version(best=best)
- if version_str:
- version_regex = re.compile(r"(\d+)\.?(\d+)?\.?(\d+)?")
- matches = version_regex.match(version_str)
- if matches:
- major, minor, build_number = matches.groups()
- return major, minor or "", build_number or ""
- return "", "", ""
-
- def major_version(self, best: bool = False) -> str:
- """
- Return the major version number of the current distribution.
-
- For details, see :func:`distro.major_version`.
- """
- return self.version_parts(best)[0]
-
- def minor_version(self, best: bool = False) -> str:
- """
- Return the minor version number of the current distribution.
-
- For details, see :func:`distro.minor_version`.
- """
- return self.version_parts(best)[1]
-
- def build_number(self, best: bool = False) -> str:
- """
- Return the build number of the current distribution.
-
- For details, see :func:`distro.build_number`.
- """
- return self.version_parts(best)[2]
-
- def like(self) -> str:
- """
- Return the IDs of distributions that are like the OS distribution.
-
- For details, see :func:`distro.like`.
- """
- return self.os_release_attr("id_like") or ""
-
- def codename(self) -> str:
- """
- Return the codename of the OS distribution.
-
- For details, see :func:`distro.codename`.
- """
- try:
- # Handle os_release specially since distros might purposefully set
- # this to empty string to have no codename
- return self._os_release_info["codename"]
- except KeyError:
- return (
- self.lsb_release_attr("codename")
- or self.distro_release_attr("codename")
- or ""
- )
-
- def info(self, pretty: bool = False, best: bool = False) -> InfoDict:
- """
- Return certain machine-readable information about the OS
- distribution.
-
- For details, see :func:`distro.info`.
- """
- return dict(
- id=self.id(),
- version=self.version(pretty, best),
- version_parts=dict(
- major=self.major_version(best),
- minor=self.minor_version(best),
- build_number=self.build_number(best),
- ),
- like=self.like(),
- codename=self.codename(),
- )
-
- def os_release_info(self) -> Dict[str, str]:
- """
- Return a dictionary containing key-value pairs for the information
- items from the os-release file data source of the OS distribution.
-
- For details, see :func:`distro.os_release_info`.
- """
- return self._os_release_info
-
- def lsb_release_info(self) -> Dict[str, str]:
- """
- Return a dictionary containing key-value pairs for the information
- items from the lsb_release command data source of the OS
- distribution.
-
- For details, see :func:`distro.lsb_release_info`.
- """
- return self._lsb_release_info
-
- def distro_release_info(self) -> Dict[str, str]:
- """
- Return a dictionary containing key-value pairs for the information
- items from the distro release file data source of the OS
- distribution.
-
- For details, see :func:`distro.distro_release_info`.
- """
- return self._distro_release_info
-
- def uname_info(self) -> Dict[str, str]:
- """
- Return a dictionary containing key-value pairs for the information
- items from the uname command data source of the OS distribution.
-
- For details, see :func:`distro.uname_info`.
- """
- return self._uname_info
-
- def oslevel_info(self) -> str:
- """
- Return AIX' oslevel command output.
- """
- return self._oslevel_info
-
- def os_release_attr(self, attribute: str) -> str:
- """
- Return a single named information item from the os-release file data
- source of the OS distribution.
-
- For details, see :func:`distro.os_release_attr`.
- """
- return self._os_release_info.get(attribute, "")
-
- def lsb_release_attr(self, attribute: str) -> str:
- """
- Return a single named information item from the lsb_release command
- output data source of the OS distribution.
-
- For details, see :func:`distro.lsb_release_attr`.
- """
- return self._lsb_release_info.get(attribute, "")
-
- def distro_release_attr(self, attribute: str) -> str:
- """
- Return a single named information item from the distro release file
- data source of the OS distribution.
-
- For details, see :func:`distro.distro_release_attr`.
- """
- return self._distro_release_info.get(attribute, "")
-
- def uname_attr(self, attribute: str) -> str:
- """
- Return a single named information item from the uname command
- output data source of the OS distribution.
-
- For details, see :func:`distro.uname_attr`.
- """
- return self._uname_info.get(attribute, "")
-
- @cached_property
- def _os_release_info(self) -> Dict[str, str]:
- """
- Get the information items from the specified os-release file.
-
- Returns:
- A dictionary containing all information items.
- """
- if os.path.isfile(self.os_release_file):
- with open(self.os_release_file, encoding="utf-8") as release_file:
- return self._parse_os_release_content(release_file)
- return {}
-
- @staticmethod
- def _parse_os_release_content(lines: TextIO) -> Dict[str, str]:
- """
- Parse the lines of an os-release file.
-
- Parameters:
-
- * lines: Iterable through the lines in the os-release file.
- Each line must be a unicode string or a UTF-8 encoded byte
- string.
-
- Returns:
- A dictionary containing all information items.
- """
- props = {}
- lexer = shlex.shlex(lines, posix=True)
- lexer.whitespace_split = True
-
- tokens = list(lexer)
- for token in tokens:
- # At this point, all shell-like parsing has been done (i.e.
- # comments processed, quotes and backslash escape sequences
- # processed, multi-line values assembled, trailing newlines
- # stripped, etc.), so the tokens are now either:
- # * variable assignments: var=value
- # * commands or their arguments (not allowed in os-release)
- # Ignore any tokens that are not variable assignments
- if "=" in token:
- k, v = token.split("=", 1)
- props[k.lower()] = v
-
- if "version" in props:
- # extract release codename (if any) from version attribute
- match = re.search(r"\((\D+)\)|,\s*(\D+)", props["version"])
- if match:
- release_codename = match.group(1) or match.group(2)
- props["codename"] = props["release_codename"] = release_codename
-
- if "version_codename" in props:
- # os-release added a version_codename field. Use that in
- # preference to anything else Note that some distros purposefully
- # do not have code names. They should be setting
- # version_codename=""
- props["codename"] = props["version_codename"]
- elif "ubuntu_codename" in props:
- # Same as above but a non-standard field name used on older Ubuntus
- props["codename"] = props["ubuntu_codename"]
-
- return props
-
- @cached_property
- def _lsb_release_info(self) -> Dict[str, str]:
- """
- Get the information items from the lsb_release command output.
-
- Returns:
- A dictionary containing all information items.
- """
- if not self.include_lsb:
- return {}
- try:
- cmd = ("lsb_release", "-a")
- stdout = subprocess.check_output(cmd, stderr=subprocess.DEVNULL)
- # Command not found or lsb_release returned error
- except (OSError, subprocess.CalledProcessError):
- return {}
- content = self._to_str(stdout).splitlines()
- return self._parse_lsb_release_content(content)
-
- @staticmethod
- def _parse_lsb_release_content(lines: Iterable[str]) -> Dict[str, str]:
- """
- Parse the output of the lsb_release command.
-
- Parameters:
-
- * lines: Iterable through the lines of the lsb_release output.
- Each line must be a unicode string or a UTF-8 encoded byte
- string.
-
- Returns:
- A dictionary containing all information items.
- """
- props = {}
- for line in lines:
- kv = line.strip("\n").split(":", 1)
- if len(kv) != 2:
- # Ignore lines without colon.
- continue
- k, v = kv
- props.update({k.replace(" ", "_").lower(): v.strip()})
- return props
-
- @cached_property
- def _uname_info(self) -> Dict[str, str]:
- if not self.include_uname:
- return {}
- try:
- cmd = ("uname", "-rs")
- stdout = subprocess.check_output(cmd, stderr=subprocess.DEVNULL)
- except OSError:
- return {}
- content = self._to_str(stdout).splitlines()
- return self._parse_uname_content(content)
-
- @cached_property
- def _oslevel_info(self) -> str:
- if not self.include_oslevel:
- return ""
- try:
- stdout = subprocess.check_output("oslevel", stderr=subprocess.DEVNULL)
- except (OSError, subprocess.CalledProcessError):
- return ""
- return self._to_str(stdout).strip()
-
- @cached_property
- def _debian_version(self) -> str:
- try:
- with open(
- os.path.join(self.etc_dir, "debian_version"), encoding="ascii"
- ) as fp:
- return fp.readline().rstrip()
- except FileNotFoundError:
- return ""
-
- @staticmethod
- def _parse_uname_content(lines: Sequence[str]) -> Dict[str, str]:
- if not lines:
- return {}
- props = {}
- match = re.search(r"^([^\s]+)\s+([\d\.]+)", lines[0].strip())
- if match:
- name, version = match.groups()
-
- # This is to prevent the Linux kernel version from
- # appearing as the 'best' version on otherwise
- # identifiable distributions.
- if name == "Linux":
- return {}
- props["id"] = name.lower()
- props["name"] = name
- props["release"] = version
- return props
-
- @staticmethod
- def _to_str(bytestring: bytes) -> str:
- encoding = sys.getfilesystemencoding()
- return bytestring.decode(encoding)
-
- @cached_property
- def _distro_release_info(self) -> Dict[str, str]:
- """
- Get the information items from the specified distro release file.
-
- Returns:
- A dictionary containing all information items.
- """
- if self.distro_release_file:
- # If it was specified, we use it and parse what we can, even if
- # its file name or content does not match the expected pattern.
- distro_info = self._parse_distro_release_file(self.distro_release_file)
- basename = os.path.basename(self.distro_release_file)
- # The file name pattern for user-specified distro release files
- # is somewhat more tolerant (compared to when searching for the
- # file), because we want to use what was specified as best as
- # possible.
- match = _DISTRO_RELEASE_BASENAME_PATTERN.match(basename)
- else:
- try:
- basenames = [
- basename
- for basename in os.listdir(self.etc_dir)
- if basename not in _DISTRO_RELEASE_IGNORE_BASENAMES
- and os.path.isfile(os.path.join(self.etc_dir, basename))
- ]
- # We sort for repeatability in cases where there are multiple
- # distro specific files; e.g. CentOS, Oracle, Enterprise all
- # containing `redhat-release` on top of their own.
- basenames.sort()
- except OSError:
- # This may occur when /etc is not readable but we can't be
- # sure about the *-release files. Check common entries of
- # /etc for information. If they turn out to not be there the
- # error is handled in `_parse_distro_release_file()`.
- basenames = _DISTRO_RELEASE_BASENAMES
- for basename in basenames:
- match = _DISTRO_RELEASE_BASENAME_PATTERN.match(basename)
- if match is None:
- continue
- filepath = os.path.join(self.etc_dir, basename)
- distro_info = self._parse_distro_release_file(filepath)
- # The name is always present if the pattern matches.
- if "name" not in distro_info:
- continue
- self.distro_release_file = filepath
- break
- else: # the loop didn't "break": no candidate.
- return {}
-
- if match is not None:
- distro_info["id"] = match.group(1)
-
- # CloudLinux < 7: manually enrich info with proper id.
- if "cloudlinux" in distro_info.get("name", "").lower():
- distro_info["id"] = "cloudlinux"
-
- return distro_info
-
- def _parse_distro_release_file(self, filepath: str) -> Dict[str, str]:
- """
- Parse a distro release file.
-
- Parameters:
-
- * filepath: Path name of the distro release file.
-
- Returns:
- A dictionary containing all information items.
- """
- try:
- with open(filepath, encoding="utf-8") as fp:
- # Only parse the first line. For instance, on SLES there
- # are multiple lines. We don't want them...
- return self._parse_distro_release_content(fp.readline())
- except OSError:
- # Ignore not being able to read a specific, seemingly version
- # related file.
- # See https://github.com/python-distro/distro/issues/162
- return {}
-
- @staticmethod
- def _parse_distro_release_content(line: str) -> Dict[str, str]:
- """
- Parse a line from a distro release file.
-
- Parameters:
- * line: Line from the distro release file. Must be a unicode string
- or a UTF-8 encoded byte string.
-
- Returns:
- A dictionary containing all information items.
- """
- matches = _DISTRO_RELEASE_CONTENT_REVERSED_PATTERN.match(line.strip()[::-1])
- distro_info = {}
- if matches:
- # regexp ensures non-None
- distro_info["name"] = matches.group(3)[::-1]
- if matches.group(2):
- distro_info["version_id"] = matches.group(2)[::-1]
- if matches.group(1):
- distro_info["codename"] = matches.group(1)[::-1]
- elif line:
- distro_info["name"] = line.strip()
- return distro_info
-
-
-_distro = LinuxDistribution()
-
-
-def main() -> None:
- logger = logging.getLogger(__name__)
- logger.setLevel(logging.DEBUG)
- logger.addHandler(logging.StreamHandler(sys.stdout))
-
- parser = argparse.ArgumentParser(description="OS distro info tool")
- parser.add_argument(
- "--json", "-j", help="Output in machine readable format", action="store_true"
- )
-
- parser.add_argument(
- "--root-dir",
- "-r",
- type=str,
- dest="root_dir",
- help="Path to the root filesystem directory (defaults to /)",
- )
-
- args = parser.parse_args()
-
- if args.root_dir:
- dist = LinuxDistribution(
- include_lsb=False,
- include_uname=False,
- include_oslevel=False,
- root_dir=args.root_dir,
- )
- else:
- dist = _distro
-
- if args.json:
- logger.info(json.dumps(dist.info(), indent=4, sort_keys=True))
- else:
- logger.info("Name: %s", dist.name(pretty=True))
- distribution_version = dist.version(pretty=True)
- logger.info("Version: %s", distribution_version)
- distribution_codename = dist.codename()
- logger.info("Codename: %s", distribution_codename)
-
-
-if __name__ == "__main__":
- main()
diff --git a/spaces/AtomdffAI/wechatgpt4atom/bot/openai/open_ai_bot.py b/spaces/AtomdffAI/wechatgpt4atom/bot/openai/open_ai_bot.py
deleted file mode 100644
index 76e282f48bfe535fafe55dc6bec96c0c84f1e7fc..0000000000000000000000000000000000000000
--- a/spaces/AtomdffAI/wechatgpt4atom/bot/openai/open_ai_bot.py
+++ /dev/null
@@ -1,166 +0,0 @@
-# encoding:utf-8
-
-from bot.bot import Bot
-from config import conf
-from common.log import logger
-import openai
-import time
-
-user_session = dict()
-
-# OpenAI对话模型API (可用)
-class OpenAIBot(Bot):
- def __init__(self):
- openai.api_key = conf().get('open_ai_api_key')
-
-
- def reply(self, query, context=None):
- # acquire reply content
- if not context or not context.get('type') or context.get('type') == 'TEXT':
- logger.info("[OPEN_AI] query={}".format(query))
- from_user_id = context['from_user_id']
- if query == '#清除记忆':
- Session.clear_session(from_user_id)
- return '记忆已清除'
- elif query == '#清除所有':
- Session.clear_all_session()
- return '所有人记忆已清除'
-
- new_query = Session.build_session_query(query, from_user_id)
- logger.debug("[OPEN_AI] session query={}".format(new_query))
-
- reply_content = self.reply_text(new_query, from_user_id, 0)
- logger.debug("[OPEN_AI] new_query={}, user={}, reply_cont={}".format(new_query, from_user_id, reply_content))
- if reply_content and query:
- Session.save_session(query, reply_content, from_user_id)
- return reply_content
-
- elif context.get('type', None) == 'IMAGE_CREATE':
- return self.create_img(query, 0)
-
- def reply_text(self, query, user_id, retry_count=0):
- try:
- response = openai.Completion.create(
- model="text-davinci-003", # 对话模型的名称
- prompt=query,
- temperature=0.5, # 值在[0,1]之间，越大表示回复越具有不确定性
- max_tokens=1500, # 回复最大的字符数
- top_p=1,
- frequency_penalty=0.5, # [-2,2]之间，该值越大则更倾向于产生不同的内容
- presence_penalty=0.5, # [-2,2]之间，该值越大则更倾向于产生不同的内容
- stop=["\n\n\n"]
- )
- res_content = response.choices[0]['text'].strip().replace('<|endoftext|>', '')
- logger.info("[OPEN_AI] reply={}".format(res_content))
- return res_content
- except openai.error.RateLimitError as e:
- # rate limit exception
- logger.warn(e)
- if retry_count < 1:
- time.sleep(5)
- logger.warn("[OPEN_AI] RateLimit exceed, 第{}次重试".format(retry_count+1))
- return self.reply_text(query, user_id, retry_count+1)
- else:
- return "提问太快啦，请休息一下再问我吧"
- except Exception as e:
- # unknown exception
- logger.exception(e)
- Session.clear_session(user_id)
- return "请再问我一次吧"
-
-
- def create_img(self, query, retry_count=0):
- try:
- logger.info("[OPEN_AI] image_query={}".format(query))
- response = openai.Image.create(
- prompt=query, #图片描述
- n=1, #每次生成图片的数量
- size="1024x1024" #图片大小,可选有 256x256, 512x512, 1024x1024
- )
- image_url = response['data'][0]['url']
- logger.info("[OPEN_AI] image_url={}".format(image_url))
- return image_url
- except openai.error.RateLimitError as e:
- logger.warn(e)
- if retry_count < 1:
- time.sleep(5)
- logger.warn("[OPEN_AI] ImgCreate RateLimit exceed, 第{}次重试".format(retry_count+1))
- return self.reply_text(query, retry_count+1)
- else:
- return "提问太快啦，请休息一下再问我吧"
- except Exception as e:
- logger.exception(e)
- return None
-
-
-class Session(object):
- @staticmethod
- def build_session_query(query, user_id):
- '''
- build query with conversation history
- e.g. Q: xxx
- A: xxx
- Q: xxx
- :param query: query content
- :param user_id: from user id
- :return: query content with conversaction
- '''
- prompt = conf().get("character_desc", "")
- if prompt:
- prompt += "<|endoftext|>\n\n\n"
- session = user_session.get(user_id, None)
- if session:
- for conversation in session:
- prompt += "Q: " + conversation["question"] + "\n\n\nA: " + conversation["answer"] + "<|endoftext|>\n"
- prompt += "Q: " + query + "\nA: "
- return prompt
- else:
- return prompt + "Q: " + query + "\nA: "
-
- @staticmethod
- def save_session(query, answer, user_id):
- max_tokens = conf().get("conversation_max_tokens")
- if not max_tokens:
- # default 3000
- max_tokens = 1000
- conversation = dict()
- conversation["question"] = query
- conversation["answer"] = answer
- session = user_session.get(user_id)
- logger.debug(conversation)
- logger.debug(session)
- if session:
- # append conversation
- session.append(conversation)
- else:
- # create session
- queue = list()
- queue.append(conversation)
- user_session[user_id] = queue
-
- # discard exceed limit conversation
- Session.discard_exceed_conversation(user_session[user_id], max_tokens)
-
-
- @staticmethod
- def discard_exceed_conversation(session, max_tokens):
- count = 0
- count_list = list()
- for i in range(len(session)-1, -1, -1):
- # count tokens of conversation list
- history_conv = session[i]
- count += len(history_conv["question"]) + len(history_conv["answer"])
- count_list.append(count)
-
- for c in count_list:
- if c > max_tokens:
- # pop first conversation
- session.pop(0)
-
- @staticmethod
- def clear_session(user_id):
- user_session[user_id] = []
-
- @staticmethod
- def clear_all_session():
- user_session.clear()
\ No newline at end of file
diff --git a/spaces/BAAI/dreambooth-altdiffusion/README.md b/spaces/BAAI/dreambooth-altdiffusion/README.md
deleted file mode 100644
index 1ffc265b7ed3def471d790a81b7b11875c18758a..0000000000000000000000000000000000000000
--- a/spaces/BAAI/dreambooth-altdiffusion/README.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-title: Dreambooth-Altdiffusion
-emoji: ☁️
-colorFrom: pink
-colorTo: red
-sdk: gradio
-sdk_version: 3.11
-app_file: app.py
-pinned: false
-license: mit
-duplicated_from: multimodalart/dreambooth-training
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/Bart92/RVC_HF/infer/modules/train/train.py b/spaces/Bart92/RVC_HF/infer/modules/train/train.py
deleted file mode 100644
index 550bef391444c9b6c0d8c44ae3a3809b3ade4218..0000000000000000000000000000000000000000
--- a/spaces/Bart92/RVC_HF/infer/modules/train/train.py
+++ /dev/null
@@ -1,723 +0,0 @@
-import os
-import sys
-import logging
-
-logger = logging.getLogger(__name__)
-
-now_dir = os.getcwd()
-sys.path.append(os.path.join(now_dir))
-
-import datetime
-
-from infer.lib.train import utils
-
-hps = utils.get_hparams()
-os.environ["CUDA_VISIBLE_DEVICES"] = hps.gpus.replace("-", ",")
-n_gpus = len(hps.gpus.split("-"))
-from random import randint, shuffle
-
-import torch
-try:
- import intel_extension_for_pytorch as ipex # pylint: disable=import-error, unused-import
- if torch.xpu.is_available():
- from infer.modules.ipex import ipex_init
- from infer.modules.ipex.gradscaler import gradscaler_init
- from torch.xpu.amp import autocast
- GradScaler = gradscaler_init()
- ipex_init()
- else:
- from torch.cuda.amp import GradScaler, autocast
-except Exception:
- from torch.cuda.amp import GradScaler, autocast
-
-torch.backends.cudnn.deterministic = False
-torch.backends.cudnn.benchmark = False
-from time import sleep
-from time import time as ttime
-
-import torch.distributed as dist
-import torch.multiprocessing as mp
-
-from torch.nn import functional as F
-from torch.nn.parallel import DistributedDataParallel as DDP
-from torch.utils.data import DataLoader
-from torch.utils.tensorboard import SummaryWriter
-
-from infer.lib.infer_pack import commons
-from infer.lib.train.data_utils import (
- DistributedBucketSampler,
- TextAudioCollate,
- TextAudioCollateMultiNSFsid,
- TextAudioLoader,
- TextAudioLoaderMultiNSFsid,
-)
-
-if hps.version == "v1":
- from infer.lib.infer_pack.models import MultiPeriodDiscriminator
- from infer.lib.infer_pack.models import SynthesizerTrnMs256NSFsid as RVC_Model_f0
- from infer.lib.infer_pack.models import (
- SynthesizerTrnMs256NSFsid_nono as RVC_Model_nof0,
- )
-else:
- from infer.lib.infer_pack.models import (
- SynthesizerTrnMs768NSFsid as RVC_Model_f0,
- SynthesizerTrnMs768NSFsid_nono as RVC_Model_nof0,
- MultiPeriodDiscriminatorV2 as MultiPeriodDiscriminator,
- )
-
-from infer.lib.train.losses import (
- discriminator_loss,
- feature_loss,
- generator_loss,
- kl_loss,
-)
-from infer.lib.train.mel_processing import mel_spectrogram_torch, spec_to_mel_torch
-from infer.lib.train.process_ckpt import savee
-
-global_step = 0
-import csv
-
-class EpochRecorder:
- def __init__(self):
- self.last_time = ttime()
-
- def record(self):
- now_time = ttime()
- elapsed_time = now_time - self.last_time
- self.last_time = now_time
- elapsed_time_str = str(datetime.timedelta(seconds=elapsed_time))
- current_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
- return f"[{current_time}] | ({elapsed_time_str})"
-
-def reset_stop_flag():
- with open("csvdb/stop.csv", "w+", newline="") as STOPCSVwrite:
- csv_writer = csv.writer(STOPCSVwrite, delimiter=",")
- csv_writer.writerow(["False"])
-
-def create_model(hps, model_f0, model_nof0):
- filter_length_adjusted = hps.data.filter_length // 2 + 1
- segment_size_adjusted = hps.train.segment_size // hps.data.hop_length
- is_half = hps.train.fp16_run
- sr = hps.sample_rate
-
- model = model_f0 if hps.if_f0 == 1 else model_nof0
-
- return model(
- filter_length_adjusted,
- segment_size_adjusted,
- **hps.model,
- is_half=is_half,
- sr=sr
- )
-
-def move_model_to_cuda_if_available(model, rank):
- if torch.cuda.is_available():
- return model.cuda(rank)
- else:
- return model
-
-def create_optimizer(model, hps):
- return torch.optim.AdamW(
- model.parameters(),
- hps.train.learning_rate,
- betas=hps.train.betas,
- eps=hps.train.eps,
- )
-
-def create_ddp_model(model, rank):
- if torch.cuda.is_available():
- return DDP(model, device_ids=[rank])
- else:
- return DDP(model)
-
-def create_dataset(hps, if_f0=True):
- return TextAudioLoaderMultiNSFsid(hps.data.training_files, hps.data) if if_f0 else TextAudioLoader(hps.data.training_files, hps.data)
-
-def create_sampler(dataset, batch_size, n_gpus, rank):
- return DistributedBucketSampler(
- dataset,
- batch_size * n_gpus,
- # [100, 200, 300, 400, 500, 600, 700, 800, 900, 1000, 1200,1400], # 16s
- [100, 200, 300, 400, 500, 600, 700, 800, 900], # 16s
- num_replicas=n_gpus,
- rank=rank,
- shuffle=True,
- )
-
-def set_collate_fn(if_f0=True):
- return TextAudioCollateMultiNSFsid() if if_f0 else TextAudioCollate()
-
-
-def main():
- n_gpus = torch.cuda.device_count()
-
- if torch.cuda.is_available() == False and torch.backends.mps.is_available() == True:
- n_gpus = 1
- if n_gpus < 1:
- # patch to unblock people without gpus. there is probably a better way.
- logger.warn("NO GPU DETECTED: falling back to CPU - this may take a while")
- n_gpus = 1
- os.environ["MASTER_ADDR"] = "localhost"
- os.environ["MASTER_PORT"] = str(randint(20000, 55555))
- children = []
- for i in range(n_gpus):
- subproc = mp.Process(
- target=run,
- args=(
- i,
- n_gpus,
- hps,
- ),
- )
- children.append(subproc)
- subproc.start()
-
- for i in range(n_gpus):
- children[i].join()
-
-
-def run(rank, n_gpus, hps):
- global global_step
- if rank == 0:
- logger = utils.get_logger(hps.model_dir)
- logger.info(hps)
- # utils.check_git_hash(hps.model_dir)
- writer = SummaryWriter(log_dir=hps.model_dir)
- writer_eval = SummaryWriter(log_dir=os.path.join(hps.model_dir, "eval"))
-
- dist.init_process_group(
- backend="gloo", init_method="env://", world_size=n_gpus, rank=rank
- )
- torch.manual_seed(hps.train.seed)
- if torch.cuda.is_available():
- torch.cuda.set_device(rank)
-
- if hps.if_f0 == 1:
- train_dataset = TextAudioLoaderMultiNSFsid(hps.data.training_files, hps.data)
- else:
- train_dataset = TextAudioLoader(hps.data.training_files, hps.data)
- train_sampler = DistributedBucketSampler(
- train_dataset,
- hps.train.batch_size * n_gpus,
- # [100, 200, 300, 400, 500, 600, 700, 800, 900, 1000, 1200,1400], # 16s
- [100, 200, 300, 400, 500, 600, 700, 800, 900], # 16s
- num_replicas=n_gpus,
- rank=rank,
- shuffle=True,
- )
- # It is possible that dataloader's workers are out of shared memory. Please try to raise your shared memory limit.
- # num_workers=8 -> num_workers=4
- if hps.if_f0 == 1:
- collate_fn = TextAudioCollateMultiNSFsid()
- else:
- collate_fn = TextAudioCollate()
- train_loader = DataLoader(
- train_dataset,
- num_workers=4,
- shuffle=False,
- pin_memory=True,
- collate_fn=collate_fn,
- batch_sampler=train_sampler,
- persistent_workers=True,
- prefetch_factor=8,
- )
- if hps.if_f0 == 1:
- net_g = RVC_Model_f0(
- hps.data.filter_length // 2 + 1,
- hps.train.segment_size // hps.data.hop_length,
- **hps.model,
- is_half=hps.train.fp16_run,
- sr=hps.sample_rate,
- )
- else:
- net_g = RVC_Model_nof0(
- hps.data.filter_length // 2 + 1,
- hps.train.segment_size // hps.data.hop_length,
- **hps.model,
- is_half=hps.train.fp16_run,
- )
- if torch.cuda.is_available():
- net_g = net_g.cuda(rank)
- net_d = MultiPeriodDiscriminator(hps.model.use_spectral_norm)
- if torch.cuda.is_available():
- net_d = net_d.cuda(rank)
- optim_g = torch.optim.AdamW(
- net_g.parameters(),
- hps.train.learning_rate,
- betas=hps.train.betas,
- eps=hps.train.eps,
- )
- optim_d = torch.optim.AdamW(
- net_d.parameters(),
- hps.train.learning_rate,
- betas=hps.train.betas,
- eps=hps.train.eps,
- )
- # net_g = DDP(net_g, device_ids=[rank], find_unused_parameters=True)
- # net_d = DDP(net_d, device_ids=[rank], find_unused_parameters=True)
- if hasattr(torch, "xpu") and torch.xpu.is_available():
- pass
- elif torch.cuda.is_available():
- net_g = DDP(net_g, device_ids=[rank])
- net_d = DDP(net_d, device_ids=[rank])
- else:
- net_g = DDP(net_g)
- net_d = DDP(net_d)
-
- try: # 如果能加载自动resume
- _, _, _, epoch_str = utils.load_checkpoint(
- utils.latest_checkpoint_path(hps.model_dir, "D_*.pth"), net_d, optim_d
- ) # D多半加载没事
- if rank == 0:
- logger.info("loaded D")
- # _, _, _, epoch_str = utils.load_checkpoint(utils.latest_checkpoint_path(hps.model_dir, "G_*.pth"), net_g, optim_g,load_opt=0)
- _, _, _, epoch_str = utils.load_checkpoint(
- utils.latest_checkpoint_path(hps.model_dir, "G_*.pth"), net_g, optim_g
- )
- global_step = (epoch_str - 1) * len(train_loader)
- # epoch_str = 1
- # global_step = 0
- except: # 如果首次不能加载，加载pretrain
- # traceback.print_exc()
- epoch_str = 1
- global_step = 0
- if hps.pretrainG != "":
- if rank == 0:
- logger.info("loaded pretrained %s" % (hps.pretrainG))
- if hasattr(net_g, "module"):
- logger.info(
- net_g.module.load_state_dict(
- torch.load(hps.pretrainG, map_location="cpu")["model"]
- )
- ) ##测试不加载优化器
- else:
- logger.info(
- net_g.load_state_dict(
- torch.load(hps.pretrainG, map_location="cpu")["model"]
- )
- ) ##测试不加载优化器
- if hps.pretrainD != "":
- if rank == 0:
- logger.info("loaded pretrained %s" % (hps.pretrainD))
- if hasattr(net_d, "module"):
- logger.info(
- net_d.module.load_state_dict(
- torch.load(hps.pretrainD, map_location="cpu")["model"]
- )
- )
- else:
- logger.info(
- net_d.load_state_dict(
- torch.load(hps.pretrainD, map_location="cpu")["model"]
- )
- )
-
- scheduler_g = torch.optim.lr_scheduler.ExponentialLR(
- optim_g, gamma=hps.train.lr_decay, last_epoch=epoch_str - 2
- )
- scheduler_d = torch.optim.lr_scheduler.ExponentialLR(
- optim_d, gamma=hps.train.lr_decay, last_epoch=epoch_str - 2
- )
-
- scaler = GradScaler(enabled=hps.train.fp16_run)
-
- cache = []
- for epoch in range(epoch_str, hps.train.epochs + 1):
- if rank == 0:
- train_and_evaluate(
- rank,
- epoch,
- hps,
- [net_g, net_d],
- [optim_g, optim_d],
- [scheduler_g, scheduler_d],
- scaler,
- [train_loader, None],
- logger,
- [writer, writer_eval],
- cache,
- )
- else:
- train_and_evaluate(
- rank,
- epoch,
- hps,
- [net_g, net_d],
- [optim_g, optim_d],
- [scheduler_g, scheduler_d],
- scaler,
- [train_loader, None],
- None,
- None,
- cache,
- )
- scheduler_g.step()
- scheduler_d.step()
-
-
-def train_and_evaluate(
- rank, epoch, hps, nets, optims, schedulers, scaler, loaders, logger, writers, cache
-):
- net_g, net_d = nets
- optim_g, optim_d = optims
- train_loader, eval_loader = loaders
- if writers is not None:
- writer, writer_eval = writers
-
- train_loader.batch_sampler.set_epoch(epoch)
- global global_step
-
- net_g.train()
- net_d.train()
-
- # Prepare data iterator
- if hps.if_cache_data_in_gpu == True:
- # Use Cache
- data_iterator = cache
- if cache == []:
- # Make new cache
- for batch_idx, info in enumerate(train_loader):
- # Unpack
- if hps.if_f0 == 1:
- (
- phone,
- phone_lengths,
- pitch,
- pitchf,
- spec,
- spec_lengths,
- wave,
- wave_lengths,
- sid,
- ) = info
- else:
- (
- phone,
- phone_lengths,
- spec,
- spec_lengths,
- wave,
- wave_lengths,
- sid,
- ) = info
- # Load on CUDA
- if torch.cuda.is_available():
- phone = phone.cuda(rank, non_blocking=True)
- phone_lengths = phone_lengths.cuda(rank, non_blocking=True)
- if hps.if_f0 == 1:
- pitch = pitch.cuda(rank, non_blocking=True)
- pitchf = pitchf.cuda(rank, non_blocking=True)
- sid = sid.cuda(rank, non_blocking=True)
- spec = spec.cuda(rank, non_blocking=True)
- spec_lengths = spec_lengths.cuda(rank, non_blocking=True)
- wave = wave.cuda(rank, non_blocking=True)
- wave_lengths = wave_lengths.cuda(rank, non_blocking=True)
- # Cache on list
- if hps.if_f0 == 1:
- cache.append(
- (
- batch_idx,
- (
- phone,
- phone_lengths,
- pitch,
- pitchf,
- spec,
- spec_lengths,
- wave,
- wave_lengths,
- sid,
- ),
- )
- )
- else:
- cache.append(
- (
- batch_idx,
- (
- phone,
- phone_lengths,
- spec,
- spec_lengths,
- wave,
- wave_lengths,
- sid,
- ),
- )
- )
- else:
- # Load shuffled cache
- shuffle(cache)
- else:
- # Loader
- data_iterator = enumerate(train_loader)
-
- # Run steps
- epoch_recorder = EpochRecorder()
- for batch_idx, info in data_iterator:
- # Data
- ## Unpack
- if hps.if_f0 == 1:
- (
- phone,
- phone_lengths,
- pitch,
- pitchf,
- spec,
- spec_lengths,
- wave,
- wave_lengths,
- sid,
- ) = info
- else:
- phone, phone_lengths, spec, spec_lengths, wave, wave_lengths, sid = info
- ## Load on CUDA
- if (hps.if_cache_data_in_gpu == False) and torch.cuda.is_available():
- phone = phone.cuda(rank, non_blocking=True)
- phone_lengths = phone_lengths.cuda(rank, non_blocking=True)
- if hps.if_f0 == 1:
- pitch = pitch.cuda(rank, non_blocking=True)
- pitchf = pitchf.cuda(rank, non_blocking=True)
- sid = sid.cuda(rank, non_blocking=True)
- spec = spec.cuda(rank, non_blocking=True)
- spec_lengths = spec_lengths.cuda(rank, non_blocking=True)
- wave = wave.cuda(rank, non_blocking=True)
- # wave_lengths = wave_lengths.cuda(rank, non_blocking=True)
-
- # Calculate
- with autocast(enabled=hps.train.fp16_run):
- if hps.if_f0 == 1:
- (
- y_hat,
- ids_slice,
- x_mask,
- z_mask,
- (z, z_p, m_p, logs_p, m_q, logs_q),
- ) = net_g(phone, phone_lengths, pitch, pitchf, spec, spec_lengths, sid)
- else:
- (
- y_hat,
- ids_slice,
- x_mask,
- z_mask,
- (z, z_p, m_p, logs_p, m_q, logs_q),
- ) = net_g(phone, phone_lengths, spec, spec_lengths, sid)
- mel = spec_to_mel_torch(
- spec,
- hps.data.filter_length,
- hps.data.n_mel_channels,
- hps.data.sampling_rate,
- hps.data.mel_fmin,
- hps.data.mel_fmax,
- )
- y_mel = commons.slice_segments(
- mel, ids_slice, hps.train.segment_size // hps.data.hop_length
- )
- with autocast(enabled=False):
- y_hat_mel = mel_spectrogram_torch(
- y_hat.float().squeeze(1),
- hps.data.filter_length,
- hps.data.n_mel_channels,
- hps.data.sampling_rate,
- hps.data.hop_length,
- hps.data.win_length,
- hps.data.mel_fmin,
- hps.data.mel_fmax,
- )
- if hps.train.fp16_run == True:
- y_hat_mel = y_hat_mel.half()
- wave = commons.slice_segments(
- wave, ids_slice * hps.data.hop_length, hps.train.segment_size
- ) # slice
-
- # Discriminator
- y_d_hat_r, y_d_hat_g, _, _ = net_d(wave, y_hat.detach())
- with autocast(enabled=False):
- loss_disc, losses_disc_r, losses_disc_g = discriminator_loss(
- y_d_hat_r, y_d_hat_g
- )
- optim_d.zero_grad()
- scaler.scale(loss_disc).backward()
- scaler.unscale_(optim_d)
- grad_norm_d = commons.clip_grad_value_(net_d.parameters(), None)
- scaler.step(optim_d)
-
- with autocast(enabled=hps.train.fp16_run):
- # Generator
- y_d_hat_r, y_d_hat_g, fmap_r, fmap_g = net_d(wave, y_hat)
- with autocast(enabled=False):
- loss_mel = F.l1_loss(y_mel, y_hat_mel) * hps.train.c_mel
- loss_kl = kl_loss(z_p, logs_q, m_p, logs_p, z_mask) * hps.train.c_kl
- loss_fm = feature_loss(fmap_r, fmap_g)
- loss_gen, losses_gen = generator_loss(y_d_hat_g)
- loss_gen_all = loss_gen + loss_fm + loss_mel + loss_kl
- optim_g.zero_grad()
- scaler.scale(loss_gen_all).backward()
- scaler.unscale_(optim_g)
- grad_norm_g = commons.clip_grad_value_(net_g.parameters(), None)
- scaler.step(optim_g)
- scaler.update()
-
- if rank == 0:
- if global_step % hps.train.log_interval == 0:
- lr = optim_g.param_groups[0]["lr"]
- logger.info(
- "Train Epoch: {} [{:.0f}%]".format(
- epoch, 100.0 * batch_idx / len(train_loader)
- )
- )
- # Amor For Tensorboard display
- if loss_mel > 75:
- loss_mel = 75
- if loss_kl > 9:
- loss_kl = 9
-
- logger.info([global_step, lr])
- logger.info(
- f"loss_disc={loss_disc:.3f}, loss_gen={loss_gen:.3f}, loss_fm={loss_fm:.3f},loss_mel={loss_mel:.3f}, loss_kl={loss_kl:.3f}"
- )
- scalar_dict = {
- "loss/g/total": loss_gen_all,
- "loss/d/total": loss_disc,
- "learning_rate": lr,
- "grad_norm_d": grad_norm_d,
- "grad_norm_g": grad_norm_g,
- }
- scalar_dict.update(
- {
- "loss/g/fm": loss_fm,
- "loss/g/mel": loss_mel,
- "loss/g/kl": loss_kl,
- }
- )
-
- scalar_dict.update(
- {"loss/g/{}".format(i): v for i, v in enumerate(losses_gen)}
- )
- scalar_dict.update(
- {"loss/d_r/{}".format(i): v for i, v in enumerate(losses_disc_r)}
- )
- scalar_dict.update(
- {"loss/d_g/{}".format(i): v for i, v in enumerate(losses_disc_g)}
- )
- image_dict = {
- "slice/mel_org": utils.plot_spectrogram_to_numpy(
- y_mel[0].data.cpu().numpy()
- ),
- "slice/mel_gen": utils.plot_spectrogram_to_numpy(
- y_hat_mel[0].data.cpu().numpy()
- ),
- "all/mel": utils.plot_spectrogram_to_numpy(
- mel[0].data.cpu().numpy()
- ),
- }
- utils.summarize(
- writer=writer,
- global_step=global_step,
- images=image_dict,
- scalars=scalar_dict,
- )
- global_step += 1
- # /Run steps
-
- if epoch % hps.save_every_epoch == 0 and rank == 0:
- if hps.if_latest == 0:
- utils.save_checkpoint(
- net_g,
- optim_g,
- hps.train.learning_rate,
- epoch,
- os.path.join(hps.model_dir, "G_{}.pth".format(global_step)),
- )
- utils.save_checkpoint(
- net_d,
- optim_d,
- hps.train.learning_rate,
- epoch,
- os.path.join(hps.model_dir, "D_{}.pth".format(global_step)),
- )
- else:
- utils.save_checkpoint(
- net_g,
- optim_g,
- hps.train.learning_rate,
- epoch,
- os.path.join(hps.model_dir, "G_{}.pth".format(2333333)),
- )
- utils.save_checkpoint(
- net_d,
- optim_d,
- hps.train.learning_rate,
- epoch,
- os.path.join(hps.model_dir, "D_{}.pth".format(2333333)),
- )
- if rank == 0 and hps.save_every_weights == "1":
- if hasattr(net_g, "module"):
- ckpt = net_g.module.state_dict()
- else:
- ckpt = net_g.state_dict()
- logger.info(
- "saving ckpt %s_e%s:%s"
- % (
- hps.name,
- epoch,
- savee(
- ckpt,
- hps.sample_rate,
- hps.if_f0,
- hps.name + "_e%s_s%s" % (epoch, global_step),
- epoch,
- hps.version,
- hps,
- ),
- )
- )
-
- stopbtn = False
- try:
- with open("csvdb/stop.csv", 'r') as csv_file:
- stopbtn_str = next(csv.reader(csv_file), [None])[0]
- if stopbtn_str is not None: stopbtn = stopbtn_str.lower() == 'true'
- except (ValueError, TypeError, FileNotFoundError, IndexError) as e:
- print(f"Handling exception: {e}")
- stopbtn = False
-
- if stopbtn:
- logger.info("Stop Button was pressed. The program is closed.")
- ckpt = net_g.module.state_dict() if hasattr(net_g, "module") else net_g.state_dict()
- logger.info(
- "saving final ckpt:%s"
- % (
- savee(
- ckpt, hps.sample_rate, hps.if_f0, hps.name, epoch, hps.version, hps
- )
- )
- )
- sleep(1)
- reset_stop_flag()
- os._exit(2333333)
-
- if rank == 0:
- logger.info("====> Epoch: {} {}".format(epoch, epoch_recorder.record()))
- if epoch >= hps.total_epoch and rank == 0:
- logger.info("Training is done. The program is closed.")
-
- if hasattr(net_g, "module"):
- ckpt = net_g.module.state_dict()
- else:
- ckpt = net_g.state_dict()
- logger.info(
- "saving final ckpt:%s"
- % (
- savee(
- ckpt, hps.sample_rate, hps.if_f0, hps.name, epoch, hps.version, hps
- )
- )
- )
- sleep(1)
- os._exit(2333333)
-
-
-if __name__ == "__main__":
- torch.multiprocessing.set_start_method("spawn")
- main()
diff --git a/spaces/Benson/text-generation/Examples/Bowmasters Apk All Characters Unlocked 2022.md b/spaces/Benson/text-generation/Examples/Bowmasters Apk All Characters Unlocked 2022.md
deleted file mode 100644
index cdb99f448ae3714a3cdfc470604af58edab15b50..0000000000000000000000000000000000000000
--- a/spaces/Benson/text-generation/Examples/Bowmasters Apk All Characters Unlocked 2022.md
+++ /dev/null
@@ -1,61 +0,0 @@
-
-
Bowmasters APK all characters unlocked 2022
-
Do you like archery games? Want to try a fun, addictive and action-packed game? Then, you will love Bowmasters, a archery game in which you can choose from more than 60 different characters and compete against other players or artificial intelligence. But what if you want to play with all the characters from the beginning? Or do you want unlimited coins to buy upgrades and customize your experience? In that case, you need to download Bowmasters MOD APK, a modified version of the game that offers you all the unlocked characters and other benefits. In this article, we tell you everything you need to know about Bowmasters and how to download and install its mod apk on your Android device.
-
What is Bowmasters?
-
Bowmasters is a archery game developed by Playgendary, a company known for creating casual and fun games for mobile devices. Bowmasters launched in 2016 and has since accumulated over 100 million downloads on the Google Play Store, where it has a rating of 4.5 stars. The game is also available for iOS and has a web version.
The objective of the game is simple: you must aim and shoot your bow or weapon towards your opponent, trying to hit him in the head or body to reduce his life bar. The game has realistic physics and colorful cartoon graphics that make each shot a fun and bloody experience. In addition, the game has some sound effects and voices that give more humor and personality to the game.
-
More than 60 unique characters to choose from
-
-
Varied and challenging game modes
-
Bowmasters also offers several game modes so you never get bored. You can play against artificial intelligence in the mode du elo, where you can face different opponents and unlock new characters and weapons. You can also play against other players online in multiplayer mode, where you can prove your skill and earn rewards. You can also try the tournament mode, where you must pass several rounds and reach the final. Or if you prefer something more relaxed, you can play target shooting mode, where you must hit different targets with your bow or gun. And if you want something more fun, you can play rubber duck mode, where you must shoot some rubber ducks floating in the water.
-
Why download Bowmasters MOD APK?
-
Bowmasters is a very fun and addictive game, but it also has some drawbacks. For example, to unlock all the characters and weapons, you must play long time or spend real money on integrated purchases. In addition, the game has many ads that can interrupt your fun and consume your mobile data. So if you want to enjoy Bowmasters to the fullest, we recommend that you download Bowmasters MOD APK, a modified version of the game that offers several benefits.
-
Characters unlocked from the beginning
-
One of the most important benefits of Bowmasters MOD APK is that it allows you to play with all the characters from the beginning, without having to unlock them one by one. Thus, you can choose the character that you like best or that best suits your style of play. In addition, you can try all the weapons and special abilities that each character has. This will give you an advantage over your opponents and make the game more varied and fun.
-
Unlimited currencies to buy upgrades
-
-
No annoying ads or integrated purchases
-
Finally, Bowmasters MOD APK frees you from the annoying ads and built-in purchases that the original game has. Thus, you can play without interruptions or distractions, and without spending real money on the game. Plus, you can save your mobile data and battery by not having to watch or download ads. This will make your gaming experience more fluid and enjoyable.
-
-
How to download and install Bowmasters MOD APK?
-
Now that you know what Bowmasters is and why to download its mod apk, we explain how to download it and install it on your Android device. It is very easy and will only take a few minutes. Just follow these steps:
-
Step 1: Download the APK file from a trusted website
-
The first thing to do is to download the Bowmasters MOD APK file from a reliable website. There are many websites that offer these types of files, but not all of them are secure or updated. Therefore, we recommend that you use a website like [APKPure] or [APKMirror], where you can find the latest version of Bowmasters MOD APK with all the unlocked characters and other benefits.
-
Step 2: Enable unknown sources on your device
-
The second thing to do is to enable the option of unknown sources on your Android device. This option allows you to install applications that do not come from the Google Play Store, such as Bowmasters MOD APK. To enable it, you just need to go to your device’s settings, then to security or privacy, and then enable the option of unknown sources or allow installation from unknown sources.
-
Step 3: Install the APK file and open the game
-
-
Conclusion
-
Bowmasters is a very fun and addictive archery game, offering you more than 60 different characters, each with their own bow or weapon, their own special skill and their own personality. In addition, it has several game modes so you never get bored, such as duel mode, multiplayer mode, tournament mode, target shooting mode and rubber duck mode. However, if you want to play with all the characters from the beginning, have unlimited coins to buy upgrades and customize your experience, and get rid of annoying ads and integrated purchases, we recommend that you download Bowmasters MOD APK, a modified version of the game that gives you all these benefits. Just follow the steps we have explained in this article and you can enjoy Bowmasters with all the unlocked characters on your Android device.
-
FAQ
-
Here are some of the most frequently asked questions about Bowmasters and its apk mod:
-
-
-
Question
-
Answer
-
-
-
Is it safe to download Bowmasters MOD APK?
-
Yes, as long as you download it from a reliable website like APKPure or APKMirror, where you can find the latest version of Bowmasters MOD APK with all the unlocked characters and other benefits. These websites check the files they offer and update them constantly.
-
-
-
Do I need to root my device to install Bowmasters MOD APK?
-
No, you don’t need to root your device to install Bowmasters MOD APK. You just need to enable the option of unknown sources on your Android device, as we have explained in this article.
-
-
-
Can I play online with Bowmasters MOD APK?
-
-
-
-
Can I upgrade Bowmasters MOD APK?
-
Yes, you can upgrade Bowmasters MOD APK when a new version is available. However, you should keep in mind that when updating the game you may lose some of the benefits offered by the apk mod, such as unlocked characters or unlimited coins. Therefore, we recommend that you wait for a new version of the apk mod before updating the game.
-
-
-
What other games similar to Bowmasters can I try?
-
If you like Bowmasters, you might also like other similar archery or casual action games, such as Archero, Kick the Buddy, Mr Bullet, Angry Birds 2 or Fruit Ninja.
-
-
64aa2da5cf
-
-
\ No newline at end of file
diff --git a/spaces/CVH-vn1210/make_hair/minigpt4/processors/__init__.py b/spaces/CVH-vn1210/make_hair/minigpt4/processors/__init__.py
deleted file mode 100644
index cfb0908e7603881b41be0228d7f8346f0d00840e..0000000000000000000000000000000000000000
--- a/spaces/CVH-vn1210/make_hair/minigpt4/processors/__init__.py
+++ /dev/null
@@ -1,33 +0,0 @@
-"""
- Copyright (c) 2022, salesforce.com, inc.
- All rights reserved.
- SPDX-License-Identifier: BSD-3-Clause
- For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
-"""
-
-from minigpt4.processors.base_processor import BaseProcessor
-from minigpt4.processors.blip_processors import (
- Blip2ImageTrainProcessor,
- Blip2ImageEvalProcessor,
- BlipCaptionProcessor,
-)
-
-from minigpt4.common.registry import registry
-
-__all__ = [
- "BaseProcessor",
- "Blip2ImageTrainProcessor",
- "Blip2ImageEvalProcessor",
- "BlipCaptionProcessor",
-]
-
-
-def load_processor(name, cfg=None):
- """
- Example
-
- >>> processor = load_processor("alpro_video_train", cfg=None)
- """
- processor = registry.get_processor_class(name).from_config(cfg)
-
- return processor
diff --git a/spaces/CVMX-jaca-tonos/YouTube-Video-Streaming-Spanish-ASR/README.md b/spaces/CVMX-jaca-tonos/YouTube-Video-Streaming-Spanish-ASR/README.md
deleted file mode 100644
index 51cb97c356c0d39e1ce57c3f5b19de83fd1dcd9a..0000000000000000000000000000000000000000
--- a/spaces/CVMX-jaca-tonos/YouTube-Video-Streaming-Spanish-ASR/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: YouTube Video Spanish ASR
-emoji: ⚡
-colorFrom: blue
-colorTo: gray
-sdk: streamlit
-sdk_version: 1.2.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces#reference
diff --git a/spaces/CVPR/LIVE/thrust/thrust/scan.h b/spaces/CVPR/LIVE/thrust/thrust/scan.h
deleted file mode 100644
index 5b79af04895ddab6df64b3080f713ac43e60173b..0000000000000000000000000000000000000000
--- a/spaces/CVPR/LIVE/thrust/thrust/scan.h
+++ /dev/null
@@ -1,1564 +0,0 @@
-/*
- * Copyright 2008-2013 NVIDIA Corporation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-
-/*! \file scan.h
- * \brief Functions for computing prefix sums
- */
-
-#pragma once
-
-#include
-#include
-
-namespace thrust
-{
-
-
-/*! \addtogroup algorithms
- */
-
-
-/*! \addtogroup prefixsums Prefix Sums
- * \ingroup algorithms
- * \{
- */
-
-
-/*! \p inclusive_scan computes an inclusive prefix sum operation. The
- * term 'inclusive' means that each result includes the corresponding
- * input operand in the partial sum. More precisely, *first is
- * assigned to *result and the sum of *first and
- * *(first + 1) is assigned to *(result + 1), and so on.
- * This version of \p inclusive_scan assumes plus as the associative operator.
- * When the input and output sequences are the same, the scan is performed
- * in-place.
-
- * \p inclusive_scan is similar to \c std::partial_sum in the STL. The primary
- * difference between the two functions is that \c std::partial_sum guarantees
- * a serial summation order, while \p inclusive_scan requires associativity of
- * the binary operation to parallelize the prefix sum.
- *
- * The algorithm's execution is parallelized as determined by \p exec.
- *
- * \param exec The execution policy to use for parallelization.
- * \param first The beginning of the input sequence.
- * \param last The end of the input sequence.
- * \param result The beginning of the output sequence.
- * \return The end of the output sequence.
- *
- * \tparam DerivedPolicy The name of the derived execution policy.
- * \tparam InputIterator is a model of Input Iterator
- * and \c InputIterator's \c value_type is convertible to
- * \c OutputIterator's \c value_type.
- * \tparam OutputIterator is a model of Output Iterator,
- * and if \c x and \c y are objects of \c OutputIterator's
- * \c value_type, then x + y is defined. If \c T is
- * \c OutputIterator's \c value_type, then T(0) is
- * defined.
- *
- * \pre \p first may equal \p result but the range [first, last) and the range [result, result + (last - first)) shall not overlap otherwise.
- *
- * The following code snippet demonstrates how to use \p inclusive_scan to compute an in-place
- * prefix sum using the \p thrust::host execution policy for parallelization:
- *
- * \code
- * #include
- * #include
- * ...
- *
- * int data[6] = {1, 0, 2, 2, 1, 3};
- *
- * thrust::inclusive_scan(thrust::host, data, data + 6, data); // in-place scan
- *
- * // data is now {1, 1, 3, 5, 6, 9}
- * \endcode
- *
- * \see http://www.sgi.com/tech/stl/partial_sum.html
- *
- */
-template
-__host__ __device__
- OutputIterator inclusive_scan(const thrust::detail::execution_policy_base &exec,
- InputIterator first,
- InputIterator last,
- OutputIterator result);
-
-
-/*! \p inclusive_scan computes an inclusive prefix sum operation. The
- * term 'inclusive' means that each result includes the corresponding
- * input operand in the partial sum. More precisely, *first is
- * assigned to *result and the sum of *first and
- * *(first + 1) is assigned to *(result + 1), and so on.
- * This version of \p inclusive_scan assumes plus as the associative operator.
- * When the input and output sequences are the same, the scan is performed
- * in-place.
-
- * \p inclusive_scan is similar to \c std::partial_sum in the STL. The primary
- * difference between the two functions is that \c std::partial_sum guarantees
- * a serial summation order, while \p inclusive_scan requires associativity of
- * the binary operation to parallelize the prefix sum.
- *
- * \param first The beginning of the input sequence.
- * \param last The end of the input sequence.
- * \param result The beginning of the output sequence.
- * \return The end of the output sequence.
- *
- * \tparam InputIterator is a model of Input Iterator
- * and \c InputIterator's \c value_type is convertible to
- * \c OutputIterator's \c value_type.
- * \tparam OutputIterator is a model of Output Iterator,
- * and if \c x and \c y are objects of \c OutputIterator's
- * \c value_type, then x + y is defined. If \c T is
- * \c OutputIterator's \c value_type, then T(0) is
- * defined.
- *
- * \pre \p first may equal \p result but the range [first, last) and the range [result, result + (last - first)) shall not overlap otherwise.
- *
- * The following code snippet demonstrates how to use \p inclusive_scan
- *
- * \code
- * #include
- *
- * int data[6] = {1, 0, 2, 2, 1, 3};
- *
- * thrust::inclusive_scan(data, data + 6, data); // in-place scan
- *
- * // data is now {1, 1, 3, 5, 6, 9}
- * \endcode
- *
- * \see http://www.sgi.com/tech/stl/partial_sum.html
- *
- */
-template
- OutputIterator inclusive_scan(InputIterator first,
- InputIterator last,
- OutputIterator result);
-
-
-/*! \p inclusive_scan computes an inclusive prefix sum operation. The
- * term 'inclusive' means that each result includes the corresponding
- * input operand in the partial sum. When the input and output sequences
- * are the same, the scan is performed in-place.
- *
- * \p inclusive_scan is similar to \c std::partial_sum in the STL. The primary
- * difference between the two functions is that \c std::partial_sum guarantees
- * a serial summation order, while \p inclusive_scan requires associativity of
- * the binary operation to parallelize the prefix sum.
- *
- * The algorithm's execution is parallelized as determined by \p exec.
- *
- * \param exec The execution policy to use for parallelization.
- * \param first The beginning of the input sequence.
- * \param last The end of the input sequence.
- * \param result The beginning of the output sequence.
- * \param binary_op The associatve operator used to 'sum' values.
- * \return The end of the output sequence.
- *
- * \tparam DerivedPolicy The name of the derived execution policy.
- * \tparam InputIterator is a model of Input Iterator
- * and \c InputIterator's \c value_type is convertible to
- * \c OutputIterator's \c value_type.
- * \tparam OutputIterator is a model of Output Iterator
- * and \c OutputIterator's \c value_type is convertible to
- * both \c AssociativeOperator's \c first_argument_type and
- * \c second_argument_type.
- * \tparam AssociativeOperator is a model of Binary Function
- * and \c AssociativeOperator's \c result_type is
- * convertible to \c OutputIterator's \c value_type.
- *
- * \pre \p first may equal \p result but the range [first, last) and the range [result, result + (last - first)) shall not overlap otherwise.
- *
- * The following code snippet demonstrates how to use \p inclusive_scan to compute an in-place
- * prefix sum using the \p thrust::host execution policy for parallelization:
- *
- * \code
- * int data[10] = {-5, 0, 2, -3, 2, 4, 0, -1, 2, 8};
- *
- * thrust::maximum binary_op;
- *
- * thrust::inclusive_scan(thrust::host, data, data + 10, data, binary_op); // in-place scan
- *
- * // data is now {-5, 0, 2, 2, 2, 4, 4, 4, 4, 8}
- * \endcode
- *
- * \see http://www.sgi.com/tech/stl/partial_sum.html
- */
-template
-__host__ __device__
- OutputIterator inclusive_scan(const thrust::detail::execution_policy_base &exec,
- InputIterator first,
- InputIterator last,
- OutputIterator result,
- AssociativeOperator binary_op);
-
-
-/*! \p inclusive_scan computes an inclusive prefix sum operation. The
- * term 'inclusive' means that each result includes the corresponding
- * input operand in the partial sum. When the input and output sequences
- * are the same, the scan is performed in-place.
- *
- * \p inclusive_scan is similar to \c std::partial_sum in the STL. The primary
- * difference between the two functions is that \c std::partial_sum guarantees
- * a serial summation order, while \p inclusive_scan requires associativity of
- * the binary operation to parallelize the prefix sum.
- *
- * \param first The beginning of the input sequence.
- * \param last The end of the input sequence.
- * \param result The beginning of the output sequence.
- * \param binary_op The associatve operator used to 'sum' values.
- * \return The end of the output sequence.
- *
- * \tparam InputIterator is a model of Input Iterator
- * and \c InputIterator's \c value_type is convertible to
- * \c OutputIterator's \c value_type.
- * \tparam OutputIterator is a model of Output Iterator
- * and \c OutputIterator's \c value_type is convertible to
- * both \c AssociativeOperator's \c first_argument_type and
- * \c second_argument_type.
- * \tparam AssociativeOperator is a model of Binary Function
- * and \c AssociativeOperator's \c result_type is
- * convertible to \c OutputIterator's \c value_type.
- *
- * \pre \p first may equal \p result but the range [first, last) and the range [result, result + (last - first)) shall not overlap otherwise.
- *
- * The following code snippet demonstrates how to use \p inclusive_scan
- *
- * \code
- * int data[10] = {-5, 0, 2, -3, 2, 4, 0, -1, 2, 8};
- *
- * thrust::maximum binary_op;
- *
- * thrust::inclusive_scan(data, data + 10, data, binary_op); // in-place scan
- *
- * // data is now {-5, 0, 2, 2, 2, 4, 4, 4, 4, 8}
- * \endcode
- *
- * \see http://www.sgi.com/tech/stl/partial_sum.html
- */
-template
- OutputIterator inclusive_scan(InputIterator first,
- InputIterator last,
- OutputIterator result,
- AssociativeOperator binary_op);
-
-
-/*! \p exclusive_scan computes an exclusive prefix sum operation. The
- * term 'exclusive' means that each result does not include the
- * corresponding input operand in the partial sum. More precisely,
- * 0 is assigned to *result and the sum of
- * 0 and *first is assigned to *(result + 1),
- * and so on. This version of \p exclusive_scan assumes plus as the
- * associative operator and \c 0 as the initial value. When the input and
- * output sequences are the same, the scan is performed in-place.
- *
- * The algorithm's execution is parallelized as determined by \p exec.
- *
- * \param exec The execution policy to use for parallelization.
- * \param first The beginning of the input sequence.
- * \param last The end of the input sequence.
- * \param result The beginning of the output sequence.
- * \return The end of the output sequence.
- *
- * \tparam DerivedPolicy The name of the derived execution policy.
- * \tparam InputIterator is a model of Input Iterator
- * and \c InputIterator's \c value_type is convertible to
- * \c OutputIterator's \c value_type.
- * \tparam OutputIterator is a model of Output Iterator,
- * and if \c x and \c y are objects of \c OutputIterator's
- * \c value_type, then x + y is defined. If \c T is
- * \c OutputIterator's \c value_type, then T(0) is
- * defined.
- *
- * \pre \p first may equal \p result but the range [first, last) and the range [result, result + (last - first)) shall not overlap otherwise.
- *
- * The following code snippet demonstrates how to use \p exclusive_scan to compute an in-place
- * prefix sum using the \p thrust::host execution policy for parallelization:
- *
- * \code
- * #include
- * #include
- * ...
- *
- * int data[6] = {1, 0, 2, 2, 1, 3};
- *
- * thrust::exclusive_scan(thrust::host, data, data + 6, data); // in-place scan
- *
- * // data is now {0, 1, 1, 3, 5, 6}
- * \endcode
- *
- * \see http://www.sgi.com/tech/stl/partial_sum.html
- */
-template
-__host__ __device__
- OutputIterator exclusive_scan(const thrust::detail::execution_policy_base &exec,
- InputIterator first,
- InputIterator last,
- OutputIterator result);
-
-
-/*! \p exclusive_scan computes an exclusive prefix sum operation. The
- * term 'exclusive' means that each result does not include the
- * corresponding input operand in the partial sum. More precisely,
- * 0 is assigned to *result and the sum of
- * 0 and *first is assigned to *(result + 1),
- * and so on. This version of \p exclusive_scan assumes plus as the
- * associative operator and \c 0 as the initial value. When the input and
- * output sequences are the same, the scan is performed in-place.
- *
- * \param first The beginning of the input sequence.
- * \param last The end of the input sequence.
- * \param result The beginning of the output sequence.
- * \return The end of the output sequence.
- *
- * \tparam InputIterator is a model of Input Iterator
- * and \c InputIterator's \c value_type is convertible to
- * \c OutputIterator's \c value_type.
- * \tparam OutputIterator is a model of Output Iterator,
- * and if \c x and \c y are objects of \c OutputIterator's
- * \c value_type, then x + y is defined. If \c T is
- * \c OutputIterator's \c value_type, then T(0) is
- * defined.
- *
- * \pre \p first may equal \p result but the range [first, last) and the range [result, result + (last - first)) shall not overlap otherwise.
- *
- * The following code snippet demonstrates how to use \p exclusive_scan
- *
- * \code
- * #include
- *
- * int data[6] = {1, 0, 2, 2, 1, 3};
- *
- * thrust::exclusive_scan(data, data + 6, data); // in-place scan
- *
- * // data is now {0, 1, 1, 3, 5, 6}
- * \endcode
- *
- * \see http://www.sgi.com/tech/stl/partial_sum.html
- */
-template
- OutputIterator exclusive_scan(InputIterator first,
- InputIterator last,
- OutputIterator result);
-
-
-/*! \p exclusive_scan computes an exclusive prefix sum operation. The
- * term 'exclusive' means that each result does not include the
- * corresponding input operand in the partial sum. More precisely,
- * \p init is assigned to *result and the sum of \p init and
- * *first is assigned to *(result + 1), and so on.
- * This version of \p exclusive_scan assumes plus as the associative
- * operator but requires an initial value \p init. When the input and
- * output sequences are the same, the scan is performed in-place.
- *
- * The algorithm's execution is parallelized as determined by \p exec.
- *
- * \param exec The execution policy to use for parallelization.
- * \param first The beginning of the input sequence.
- * \param last The end of the input sequence.
- * \param result The beginning of the output sequence.
- * \param init The initial value.
- * \return The end of the output sequence.
- *
- * \tparam DerivedPolicy The name of the derived execution policy.
- * \tparam InputIterator is a model of Input Iterator
- * and \c InputIterator's \c value_type is convertible to
- * \c OutputIterator's \c value_type.
- * \tparam OutputIterator is a model of Output Iterator,
- * and if \c x and \c y are objects of \c OutputIterator's
- * \c value_type, then x + y is defined.
- * \tparam T is convertible to \c OutputIterator's \c value_type.
- *
- * \pre \p first may equal \p result but the range [first, last) and the range [result, result + (last - first)) shall not overlap otherwise.
- *
- * The following code snippet demonstrates how to use \p exclusive_scan to compute an in-place
- * prefix sum using the \p thrust::host execution policy for parallelization:
- *
- * \code
- * #include
- * #include
- *
- * int data[6] = {1, 0, 2, 2, 1, 3};
- *
- * thrust::exclusive_scan(thrust::host, data, data + 6, data, 4); // in-place scan
- *
- * // data is now {4, 5, 5, 7, 9, 10}
- * \endcode
- *
- * \see http://www.sgi.com/tech/stl/partial_sum.html
- */
-template
-__host__ __device__
- OutputIterator exclusive_scan(const thrust::detail::execution_policy_base &exec,
- InputIterator first,
- InputIterator last,
- OutputIterator result,
- T init);
-
-
-/*! \p exclusive_scan computes an exclusive prefix sum operation. The
- * term 'exclusive' means that each result does not include the
- * corresponding input operand in the partial sum. More precisely,
- * \p init is assigned to *result and the sum of \p init and
- * *first is assigned to *(result + 1), and so on.
- * This version of \p exclusive_scan assumes plus as the associative
- * operator but requires an initial value \p init. When the input and
- * output sequences are the same, the scan is performed in-place.
- *
- * \param first The beginning of the input sequence.
- * \param last The end of the input sequence.
- * \param result The beginning of the output sequence.
- * \param init The initial value.
- * \return The end of the output sequence.
- *
- * \tparam InputIterator is a model of Input Iterator
- * and \c InputIterator's \c value_type is convertible to
- * \c OutputIterator's \c value_type.
- * \tparam OutputIterator is a model of Output Iterator,
- * and if \c x and \c y are objects of \c OutputIterator's
- * \c value_type, then x + y is defined.
- * \tparam T is convertible to \c OutputIterator's \c value_type.
- *
- * \pre \p first may equal \p result but the range [first, last) and the range [result, result + (last - first)) shall not overlap otherwise.
- *
- * The following code snippet demonstrates how to use \p exclusive_scan
- *
- * \code
- * #include
- *
- * int data[6] = {1, 0, 2, 2, 1, 3};
- *
- * thrust::exclusive_scan(data, data + 6, data, 4); // in-place scan
- *
- * // data is now {4, 5, 5, 7, 9, 10}
- * \endcode
- *
- * \see http://www.sgi.com/tech/stl/partial_sum.html
- */
-template
- OutputIterator exclusive_scan(InputIterator first,
- InputIterator last,
- OutputIterator result,
- T init);
-
-
-/*! \p exclusive_scan computes an exclusive prefix sum operation. The
- * term 'exclusive' means that each result does not include the
- * corresponding input operand in the partial sum. More precisely,
- * \p init is assigned to \*result and the value
- * binary_op(init, \*first) is assigned to \*(result + 1),
- * and so on. This version of the function requires both an associative
- * operator and an initial value \p init. When the input and output
- * sequences are the same, the scan is performed in-place.
- *
- * The algorithm's execution is parallelized as determined by \p exec.
- *
- * \param exec The execution policy to use for parallelization.
- * \param first The beginning of the input sequence.
- * \param last The end of the input sequence.
- * \param result The beginning of the output sequence.
- * \param init The initial value.
- * \param binary_op The associatve operator used to 'sum' values.
- * \return The end of the output sequence.
- *
- * \tparam DerivedPolicy The name of the derived execution policy.
- * \tparam InputIterator is a model of Input Iterator
- * and \c InputIterator's \c value_type is convertible to
- * \c OutputIterator's \c value_type.
- * \tparam OutputIterator is a model of Output Iterator
- * and \c OutputIterator's \c value_type is convertible to
- * both \c AssociativeOperator's \c first_argument_type and
- * \c second_argument_type.
- * \tparam T is convertible to \c OutputIterator's \c value_type.
- * \tparam AssociativeOperator is a model of Binary Function
- * and \c AssociativeOperator's \c result_type is
- * convertible to \c OutputIterator's \c value_type.
- *
- * \pre \p first may equal \p result but the range [first, last) and the range [result, result + (last - first)) shall not overlap otherwise.
- *
- * The following code snippet demonstrates how to use \p exclusive_scan to compute an in-place
- * prefix sum using the \p thrust::host execution policy for parallelization:
- *
- * \code
- * #include
- * #include
- * #include
- * ...
- *
- * int data[10] = {-5, 0, 2, -3, 2, 4, 0, -1, 2, 8};
- *
- * thrust::maximum binary_op;
- *
- * thrust::exclusive_scan(thrust::host, data, data + 10, data, 1, binary_op); // in-place scan
- *
- * // data is now {1, 1, 1, 2, 2, 2, 4, 4, 4, 4 }
- * \endcode
- *
- * \see http://www.sgi.com/tech/stl/partial_sum.html
- */
-template
-__host__ __device__
- OutputIterator exclusive_scan(const thrust::detail::execution_policy_base &exec,
- InputIterator first,
- InputIterator last,
- OutputIterator result,
- T init,
- AssociativeOperator binary_op);
-
-
-/*! \p exclusive_scan computes an exclusive prefix sum operation. The
- * term 'exclusive' means that each result does not include the
- * corresponding input operand in the partial sum. More precisely,
- * \p init is assigned to \*result and the value
- * binary_op(init, \*first) is assigned to \*(result + 1),
- * and so on. This version of the function requires both an associative
- * operator and an initial value \p init. When the input and output
- * sequences are the same, the scan is performed in-place.
- *
- * \param first The beginning of the input sequence.
- * \param last The end of the input sequence.
- * \param result The beginning of the output sequence.
- * \param init The initial value.
- * \param binary_op The associatve operator used to 'sum' values.
- * \return The end of the output sequence.
- *
- * \tparam InputIterator is a model of Input Iterator
- * and \c InputIterator's \c value_type is convertible to
- * \c OutputIterator's \c value_type.
- * \tparam OutputIterator is a model of Output Iterator
- * and \c OutputIterator's \c value_type is convertible to
- * both \c AssociativeOperator's \c first_argument_type and
- * \c second_argument_type.
- * \tparam T is convertible to \c OutputIterator's \c value_type.
- * \tparam AssociativeOperator is a model of Binary Function
- * and \c AssociativeOperator's \c result_type is
- * convertible to \c OutputIterator's \c value_type.
- *
- * \pre \p first may equal \p result but the range [first, last) and the range [result, result + (last - first)) shall not overlap otherwise.
- *
- * The following code snippet demonstrates how to use \p exclusive_scan
- *
- * \code
- * #include
- * #include
- *
- * int data[10] = {-5, 0, 2, -3, 2, 4, 0, -1, 2, 8};
- *
- * thrust::maximum binary_op;
- *
- * thrust::exclusive_scan(data, data + 10, data, 1, binary_op); // in-place scan
- *
- * // data is now {1, 1, 1, 2, 2, 2, 4, 4, 4, 4 }
- * \endcode
- *
- * \see http://www.sgi.com/tech/stl/partial_sum.html
- */
-template
- OutputIterator exclusive_scan(InputIterator first,
- InputIterator last,
- OutputIterator result,
- T init,
- AssociativeOperator binary_op);
-
-
-/*! \addtogroup segmentedprefixsums Segmented Prefix Sums
- * \ingroup prefixsums
- * \{
- */
-
-
-/*! \p inclusive_scan_by_key computes an inclusive key-value or 'segmented' prefix
- * sum operation. The term 'inclusive' means that each result includes
- * the corresponding input operand in the partial sum. The term 'segmented'
- * means that the partial sums are broken into distinct segments. In other
- * words, within each segment a separate inclusive scan operation is computed.
- * Refer to the code sample below for example usage.
- *
- * This version of \p inclusive_scan_by_key assumes \c equal_to as the binary
- * predicate used to compare adjacent keys. Specifically, consecutive iterators
- * i and i+1 in the range [first1, last1)
- * belong to the same segment if *i == *(i+1), and belong to
- * different segments otherwise.
- *
- * This version of \p inclusive_scan_by_key assumes \c plus as the associative
- * operator used to perform the prefix sum. When the input and output sequences
- * are the same, the scan is performed in-place.
- *
- * The algorithm's execution is parallelized as determined by \p exec.
- *
- * \param exec The execution policy to use for parallelization.
- * \param first1 The beginning of the key sequence.
- * \param last1 The end of the key sequence.
- * \param first2 The beginning of the input value sequence.
- * \param result The beginning of the output value sequence.
- * \return The end of the output sequence.
- *
- * \tparam DerivedPolicy The name of the derived execution policy.
- * \tparam InputIterator1 is a model of Input Iterator
- * \tparam InputIterator2 is a model of Input Iterator
- * and \c InputIterator2's \c value_type is convertible to \c OutputIterator's \c value_type.
- * \tparam OutputIterator is a model of Output Iterator,
- * and if \c x and \c y are objects of \c OutputIterator's \c value_type, then
- * binary_op(x,y) is defined.
- *
- * \pre \p first1 may equal \p result but the range [first1, last1) and the range [result, result + (last1 - first1)) shall not overlap otherwise.
- * \pre \p first2 may equal \p result but the range [first2, first2 + (last1 - first1) and range [result, result + (last1 - first1)) shall not overlap otherwise.
- *
- * The following code snippet demonstrates how to use \p inclusive_scan_by_key using the \p thrust::host
- * execution policy for parallelization:
- *
- * \code
- * #include
- * #include
- * ...
- *
- * int data[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
- * int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
- *
- * thrust::inclusive_scan_by_key(thrust::host, keys, keys + 10, data, data); // in-place scan
- *
- * // data is now {1, 2, 3, 1, 2, 1, 1, 2, 3, 4};
- * \endcode
- *
- * \see inclusive_scan
- * \see exclusive_scan_by_key
- *
- */
-template
-__host__ __device__
- OutputIterator inclusive_scan_by_key(const thrust::detail::execution_policy_base &exec,
- InputIterator1 first1,
- InputIterator1 last1,
- InputIterator2 first2,
- OutputIterator result);
-
-
-/*! \p inclusive_scan_by_key computes an inclusive key-value or 'segmented' prefix
- * sum operation. The term 'inclusive' means that each result includes
- * the corresponding input operand in the partial sum. The term 'segmented'
- * means that the partial sums are broken into distinct segments. In other
- * words, within each segment a separate inclusive scan operation is computed.
- * Refer to the code sample below for example usage.
- *
- * This version of \p inclusive_scan_by_key assumes \c equal_to as the binary
- * predicate used to compare adjacent keys. Specifically, consecutive iterators
- * i and i+1 in the range [first1, last1)
- * belong to the same segment if *i == *(i+1), and belong to
- * different segments otherwise.
- *
- * This version of \p inclusive_scan_by_key assumes \c plus as the associative
- * operator used to perform the prefix sum. When the input and output sequences
- * are the same, the scan is performed in-place.
- *
- * \param first1 The beginning of the key sequence.
- * \param last1 The end of the key sequence.
- * \param first2 The beginning of the input value sequence.
- * \param result The beginning of the output value sequence.
- * \return The end of the output sequence.
- *
- * \tparam InputIterator1 is a model of Input Iterator
- * \tparam InputIterator2 is a model of Input Iterator
- * and \c InputIterator2's \c value_type is convertible to \c OutputIterator's \c value_type.
- * \tparam OutputIterator is a model of Output Iterator,
- * and if \c x and \c y are objects of \c OutputIterator's \c value_type, then
- * binary_op(x,y) is defined.
- *
- * \pre \p first1 may equal \p result but the range [first1, last1) and the range [result, result + (last1 - first1)) shall not overlap otherwise.
- * \pre \p first2 may equal \p result but the range [first2, first2 + (last1 - first1) and range [result, result + (last1 - first1)) shall not overlap otherwise.
- *
- * The following code snippet demonstrates how to use \p inclusive_scan_by_key
- *
- * \code
- * #include
- *
- * int data[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
- * int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
- *
- * thrust::inclusive_scan_by_key(keys, keys + 10, data, data); // in-place scan
- *
- * // data is now {1, 2, 3, 1, 2, 1, 1, 2, 3, 4};
- * \endcode
- *
- * \see inclusive_scan
- * \see exclusive_scan_by_key
- *
- */
-template
- OutputIterator inclusive_scan_by_key(InputIterator1 first1,
- InputIterator1 last1,
- InputIterator2 first2,
- OutputIterator result);
-
-
-/*! \p inclusive_scan_by_key computes an inclusive key-value or 'segmented' prefix
- * sum operation. The term 'inclusive' means that each result includes
- * the corresponding input operand in the partial sum. The term 'segmented'
- * means that the partial sums are broken into distinct segments. In other
- * words, within each segment a separate inclusive scan operation is computed.
- * Refer to the code sample below for example usage.
- *
- * This version of \p inclusive_scan_by_key uses the binary predicate
- * \c pred to compare adjacent keys. Specifically, consecutive iterators
- * i and i+1 in the range [first1, last1)
- * belong to the same segment if binary_pred(*i, *(i+1)) is true, and belong to
- * different segments otherwise.
- *
- * This version of \p inclusive_scan_by_key assumes \c plus as the associative
- * operator used to perform the prefix sum. When the input and output sequences
- * are the same, the scan is performed in-place.
- *
- * The algorithm's execution is parallelized as determined by \p exec.
- *
- * \param exec The execution policy to use for parallelization.
- * \param first1 The beginning of the key sequence.
- * \param last1 The end of the key sequence.
- * \param first2 The beginning of the input value sequence.
- * \param result The beginning of the output value sequence.
- * \param binary_pred The binary predicate used to determine equality of keys.
- * \return The end of the output sequence.
- *
- * \tparam DerivedPolicy The name of the derived execution policy.
- * \tparam InputIterator1 is a model of Input Iterator
- * \tparam InputIterator2 is a model of Input Iterator
- * and \c InputIterator2's \c value_type is convertible to \c OutputIterator's \c value_type.
- * \tparam OutputIterator is a model of Output Iterator,
- * and if \c x and \c y are objects of \c OutputIterator's \c value_type, then
- * binary_op(x,y) is defined.
- * \tparam BinaryPredicate is a model of Binary Predicate.
- *
- * \pre \p first1 may equal \p result but the range [first1, last1) and the range [result, result + (last1 - first1)) shall not overlap otherwise.
- * \pre \p first2 may equal \p result but the range [first2, first2 + (last1 - first1) and range [result, result + (last1 - first1)) shall not overlap otherwise.
- *
- * The following code snippet demonstrates how to use \p inclusive_scan_by_key using the \p thrust::host
- * execution policy for parallelization:
- *
- * \code
- * #include
- * #include
- * #include
- * ...
- *
- * int data[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
- * int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
- *
- * thrust::equal_to binary_pred;
- *
- * thrust::inclusive_scan_by_key(thrust::host, keys, keys + 10, data, data, binary_pred); // in-place scan
- *
- * // data is now {1, 2, 3, 1, 2, 1, 1, 2, 3, 4};
- * \endcode
- *
- * \see inclusive_scan
- * \see exclusive_scan_by_key
- *
- */
-template
-__host__ __device__
- OutputIterator inclusive_scan_by_key(const thrust::detail::execution_policy_base &exec,
- InputIterator1 first1,
- InputIterator1 last1,
- InputIterator2 first2,
- OutputIterator result,
- BinaryPredicate binary_pred);
-
-
-/*! \p inclusive_scan_by_key computes an inclusive key-value or 'segmented' prefix
- * sum operation. The term 'inclusive' means that each result includes
- * the corresponding input operand in the partial sum. The term 'segmented'
- * means that the partial sums are broken into distinct segments. In other
- * words, within each segment a separate inclusive scan operation is computed.
- * Refer to the code sample below for example usage.
- *
- * This version of \p inclusive_scan_by_key uses the binary predicate
- * \c pred to compare adjacent keys. Specifically, consecutive iterators
- * i and i+1 in the range [first1, last1)
- * belong to the same segment if binary_pred(*i, *(i+1)) is true, and belong to
- * different segments otherwise.
- *
- * This version of \p inclusive_scan_by_key assumes \c plus as the associative
- * operator used to perform the prefix sum. When the input and output sequences
- * are the same, the scan is performed in-place.
- *
- * \param first1 The beginning of the key sequence.
- * \param last1 The end of the key sequence.
- * \param first2 The beginning of the input value sequence.
- * \param result The beginning of the output value sequence.
- * \param binary_pred The binary predicate used to determine equality of keys.
- * \return The end of the output sequence.
- *
- * \tparam InputIterator1 is a model of Input Iterator
- * \tparam InputIterator2 is a model of Input Iterator
- * and \c InputIterator2's \c value_type is convertible to \c OutputIterator's \c value_type.
- * \tparam OutputIterator is a model of Output Iterator,
- * and if \c x and \c y are objects of \c OutputIterator's \c value_type, then
- * binary_op(x,y) is defined.
- * \tparam BinaryPredicate is a model of Binary Predicate.
- *
- * \pre \p first1 may equal \p result but the range [first1, last1) and the range [result, result + (last1 - first1)) shall not overlap otherwise.
- * \pre \p first2 may equal \p result but the range [first2, first2 + (last1 - first1) and range [result, result + (last1 - first1)) shall not overlap otherwise.
- *
- * The following code snippet demonstrates how to use \p inclusive_scan_by_key
- *
- * \code
- * #include
- * #include
- *
- * int data[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
- * int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
- *
- * thrust::equal_to binary_pred;
- *
- * thrust::inclusive_scan_by_key(keys, keys + 10, data, data, binary_pred); // in-place scan
- *
- * // data is now {1, 2, 3, 1, 2, 1, 1, 2, 3, 4};
- * \endcode
- *
- * \see inclusive_scan
- * \see exclusive_scan_by_key
- *
- */
-template
- OutputIterator inclusive_scan_by_key(InputIterator1 first1,
- InputIterator1 last1,
- InputIterator2 first2,
- OutputIterator result,
- BinaryPredicate binary_pred);
-
-
-/*! \p inclusive_scan_by_key computes an inclusive key-value or 'segmented' prefix
- * sum operation. The term 'inclusive' means that each result includes
- * the corresponding input operand in the partial sum. The term 'segmented'
- * means that the partial sums are broken into distinct segments. In other
- * words, within each segment a separate inclusive scan operation is computed.
- * Refer to the code sample below for example usage.
- *
- * This version of \p inclusive_scan_by_key uses the binary predicate
- * \c pred to compare adjacent keys. Specifically, consecutive iterators
- * i and i+1 in the range [first1, last1)
- * belong to the same segment if binary_pred(*i, *(i+1)) is true, and belong to
- * different segments otherwise.
- *
- * This version of \p inclusive_scan_by_key uses the associative operator
- * \c binary_op to perform the prefix sum. When the input and output sequences
- * are the same, the scan is performed in-place.
- *
- * The algorithm's execution is parallelized as determined by \p exec.
- *
- * \param exec The execution policy to use for parallelization.
- * \param first1 The beginning of the key sequence.
- * \param last1 The end of the key sequence.
- * \param first2 The beginning of the input value sequence.
- * \param result The beginning of the output value sequence.
- * \param binary_pred The binary predicate used to determine equality of keys.
- * \param binary_op The associatve operator used to 'sum' values.
- * \return The end of the output sequence.
- *
- * \tparam DerivedPolicy The name of the derived execution policy.
- * \tparam InputIterator1 is a model of Input Iterator
- * \tparam InputIterator2 is a model of Input Iterator
- * and \c InputIterator2's \c value_type is convertible to \c OutputIterator's \c value_type.
- * \tparam OutputIterator is a model of Output Iterator,
- * and if \c x and \c y are objects of \c OutputIterator's \c value_type, then
- * binary_op(x,y) is defined.
- * \tparam BinaryPredicate is a model of Binary Predicate.
- * \tparam AssociativeOperator is a model of Binary Function
- * and \c AssociativeOperator's \c result_type is
- * convertible to \c OutputIterator's \c value_type.
- *
- * \pre \p first1 may equal \p result but the range [first1, last1) and the range [result, result + (last1 - first1)) shall not overlap otherwise.
- * \pre \p first2 may equal \p result but the range [first2, first2 + (last1 - first1) and range [result, result + (last1 - first1)) shall not overlap otherwise.
- *
- * The following code snippet demonstrates how to use \p inclusive_scan_by_key using the \p thrust::host
- * execution policy for parallelization:
- *
- * \code
- * #include
- * #include
- * #include
- * ...
- *
- * int data[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
- * int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
- *
- * thrust::equal_to binary_pred;
- * thrust::plus binary_op;
- *
- * thrust::inclusive_scan_by_key(thrust::host, keys, keys + 10, data, data, binary_pred, binary_op); // in-place scan
- *
- * // data is now {1, 2, 3, 1, 2, 1, 1, 2, 3, 4};
- * \endcode
- *
- * \see inclusive_scan
- * \see exclusive_scan_by_key
- *
- */
-template
-__host__ __device__
- OutputIterator inclusive_scan_by_key(const thrust::detail::execution_policy_base &exec,
- InputIterator1 first1,
- InputIterator1 last1,
- InputIterator2 first2,
- OutputIterator result,
- BinaryPredicate binary_pred,
- AssociativeOperator binary_op);
-
-
-/*! \p inclusive_scan_by_key computes an inclusive key-value or 'segmented' prefix
- * sum operation. The term 'inclusive' means that each result includes
- * the corresponding input operand in the partial sum. The term 'segmented'
- * means that the partial sums are broken into distinct segments. In other
- * words, within each segment a separate inclusive scan operation is computed.
- * Refer to the code sample below for example usage.
- *
- * This version of \p inclusive_scan_by_key uses the binary predicate
- * \c pred to compare adjacent keys. Specifically, consecutive iterators
- * i and i+1 in the range [first1, last1)
- * belong to the same segment if binary_pred(*i, *(i+1)) is true, and belong to
- * different segments otherwise.
- *
- * This version of \p inclusive_scan_by_key uses the associative operator
- * \c binary_op to perform the prefix sum. When the input and output sequences
- * are the same, the scan is performed in-place.
- *
- * \param first1 The beginning of the key sequence.
- * \param last1 The end of the key sequence.
- * \param first2 The beginning of the input value sequence.
- * \param result The beginning of the output value sequence.
- * \param binary_pred The binary predicate used to determine equality of keys.
- * \param binary_op The associatve operator used to 'sum' values.
- * \return The end of the output sequence.
- *
- * \tparam InputIterator1 is a model of Input Iterator
- * \tparam InputIterator2 is a model of Input Iterator
- * and \c InputIterator2's \c value_type is convertible to \c OutputIterator's \c value_type.
- * \tparam OutputIterator is a model of Output Iterator,
- * and if \c x and \c y are objects of \c OutputIterator's \c value_type, then
- * binary_op(x,y) is defined.
- * \tparam BinaryPredicate is a model of Binary Predicate.
- * \tparam AssociativeOperator is a model of Binary Function
- * and \c AssociativeOperator's \c result_type is
- * convertible to \c OutputIterator's \c value_type.
- *
- * \pre \p first1 may equal \p result but the range [first1, last1) and the range [result, result + (last1 - first1)) shall not overlap otherwise.
- * \pre \p first2 may equal \p result but the range [first2, first2 + (last1 - first1) and range [result, result + (last1 - first1)) shall not overlap otherwise.
- *
- * The following code snippet demonstrates how to use \p inclusive_scan_by_key
- *
- * \code
- * #include
- * #include
- *
- * int data[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
- * int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
- *
- * thrust::equal_to binary_pred;
- * thrust::plus binary_op;
- *
- * thrust::inclusive_scan_by_key(keys, keys + 10, data, data, binary_pred, binary_op); // in-place scan
- *
- * // data is now {1, 2, 3, 1, 2, 1, 1, 2, 3, 4};
- * \endcode
- *
- * \see inclusive_scan
- * \see exclusive_scan_by_key
- *
- */
-template
- OutputIterator inclusive_scan_by_key(InputIterator1 first1,
- InputIterator1 last1,
- InputIterator2 first2,
- OutputIterator result,
- BinaryPredicate binary_pred,
- AssociativeOperator binary_op);
-
-
-/*! \p exclusive_scan_by_key computes an exclusive segmented prefix
- *
- * This version of \p exclusive_scan_by_key uses the value \c 0 to
- * initialize the exclusive scan operation.
- *
- * This version of \p exclusive_scan_by_key assumes \c plus as the associative
- * operator used to perform the prefix sum. When the input and output sequences
- * are the same, the scan is performed in-place.
- *
- * This version of \p exclusive_scan_by_key assumes \c equal_to as the binary
- * predicate used to compare adjacent keys. Specifically, consecutive iterators
- * i and i+1 in the range [first1, last1
- * belong to the same segment if *i == *(i+1), and belong to
- * different segments otherwise.
- *
- * Refer to the most general form of \p exclusive_scan_by_key for additional details.
- *
- * The algorithm's execution is parallelized as determined by \p exec.
- *
- * \param exec The execution policy to use for parallelization.
- * \param first1 The beginning of the key sequence.
- * \param last1 The end of the key sequence.
- * \param first2 The beginning of the input value sequence.
- * \param result The beginning of the output value sequence.
- *
- * \pre \p first1 may equal \p result but the range [first1, last1) and the range [result, result + (last1 - first1)) shall not overlap otherwise.
- * \pre \p first2 may equal \p result but the range [first2, first2 + (last1 - first1) and range [result, result + (last1 - first1)) shall not overlap otherwise.
- *
- * The following code snippet demonstrates how to use \p exclusive_scan_by_key using the
- * \p thrust::host execution policy for parallelization:
- *
- * \code
- * #include
- * #include
- * ...
- *
- * int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
- * int vals[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
- *
- * thrust::exclusive_scan_by_key(thrust::host, key, key + 10, vals, vals); // in-place scan
- *
- * // vals is now {0, 1, 2, 0, 1, 0, 0, 1, 2, 3};
- * \endcode
- *
- * \see exclusive_scan
- *
- */
-template
-__host__ __device__
- OutputIterator exclusive_scan_by_key(const thrust::detail::execution_policy_base &exec,
- InputIterator1 first1,
- InputIterator1 last1,
- InputIterator2 first2,
- OutputIterator result);
-
-
-/*! \p exclusive_scan_by_key computes an exclusive segmented prefix
- *
- * This version of \p exclusive_scan_by_key uses the value \c 0 to
- * initialize the exclusive scan operation.
- *
- * This version of \p exclusive_scan_by_key assumes \c plus as the associative
- * operator used to perform the prefix sum. When the input and output sequences
- * are the same, the scan is performed in-place.
- *
- * This version of \p exclusive_scan_by_key assumes \c equal_to as the binary
- * predicate used to compare adjacent keys. Specifically, consecutive iterators
- * i and i+1 in the range [first1, last1
- * belong to the same segment if *i == *(i+1), and belong to
- * different segments otherwise.
- *
- * Refer to the most general form of \p exclusive_scan_by_key for additional details.
- *
- * \param first1 The beginning of the key sequence.
- * \param last1 The end of the key sequence.
- * \param first2 The beginning of the input value sequence.
- * \param result The beginning of the output value sequence.
- *
- * \pre \p first1 may equal \p result but the range [first1, last1) and the range [result, result + (last1 - first1)) shall not overlap otherwise.
- * \pre \p first2 may equal \p result but the range [first2, first2 + (last1 - first1) and range [result, result + (last1 - first1)) shall not overlap otherwise.
- *
- * The following code snippet demonstrates how to use \p exclusive_scan_by_key.
- *
- * \code
- * #include
- *
- * int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
- * int vals[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
- *
- * thrust::exclusive_scan_by_key(key, key + 10, vals, vals); // in-place scan
- *
- * // vals is now {0, 1, 2, 0, 1, 0, 0, 1, 2, 3};
- * \endcode
- *
- * \see exclusive_scan
- *
- */
-template
- OutputIterator exclusive_scan_by_key(InputIterator1 first1,
- InputIterator1 last1,
- InputIterator2 first2,
- OutputIterator result);
-
-
-/*! \p exclusive_scan_by_key computes an exclusive key-value or 'segmented' prefix
- * sum operation. The term 'exclusive' means that each result does not include
- * the corresponding input operand in the partial sum. The term 'segmented'
- * means that the partial sums are broken into distinct segments. In other
- * words, within each segment a separate exclusive scan operation is computed.
- * Refer to the code sample below for example usage.
- *
- * This version of \p exclusive_scan_by_key uses the value \c init to
- * initialize the exclusive scan operation.
- *
- * The algorithm's execution is parallelized as determined by \p exec.
- *
- * \param exec The execution policy to use for parallelization.
- * \param first1 The beginning of the key sequence.
- * \param last1 The end of the key sequence.
- * \param first2 The beginning of the input value sequence.
- * \param result The beginning of the output value sequence.
- * \param init The initial of the exclusive sum value.
- * \return The end of the output sequence.
- *
- * \pre \p first1 may equal \p result but the range [first1, last1) and the range [result, result + (last1 - first1)) shall not overlap otherwise.
- * \pre \p first2 may equal \p result but the range [first2, first2 + (last1 - first1) and range [result, result + (last1 - first1)) shall not overlap otherwise.
- *
- * The following code snippet demonstrates how to use \p exclusive_scan_by_key using the \p
- * thrust::host execution policy for parallelization:
- *
- * \code
- * #include
- * #include
- * #include
- * ...
- *
- * int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
- * int vals[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
- *
- * int init = 5;
- *
- * thrust::exclusive_scan_by_key(thrust::host, key, key + 10, vals, vals, init); // in-place scan
- *
- * // vals is now {5, 6, 7, 5, 6, 5, 5, 6, 7, 8};
- * \endcode
- *
- * \see exclusive_scan
- * \see inclusive_scan_by_key
- *
- */
-template
-__host__ __device__
- OutputIterator exclusive_scan_by_key(const thrust::detail::execution_policy_base &exec,
- InputIterator1 first1,
- InputIterator1 last1,
- InputIterator2 first2,
- OutputIterator result,
- T init);
-
-
-/*! \p exclusive_scan_by_key computes an exclusive key-value or 'segmented' prefix
- * sum operation. The term 'exclusive' means that each result does not include
- * the corresponding input operand in the partial sum. The term 'segmented'
- * means that the partial sums are broken into distinct segments. In other
- * words, within each segment a separate exclusive scan operation is computed.
- * Refer to the code sample below for example usage.
- *
- * This version of \p exclusive_scan_by_key uses the value \c init to
- * initialize the exclusive scan operation.
- *
- * \param first1 The beginning of the key sequence.
- * \param last1 The end of the key sequence.
- * \param first2 The beginning of the input value sequence.
- * \param result The beginning of the output value sequence.
- * \param init The initial of the exclusive sum value.
- * \return The end of the output sequence.
- *
- * \pre \p first1 may equal \p result but the range [first1, last1) and the range [result, result + (last1 - first1)) shall not overlap otherwise.
- * \pre \p first2 may equal \p result but the range [first2, first2 + (last1 - first1) and range [result, result + (last1 - first1)) shall not overlap otherwise.
- *
- * The following code snippet demonstrates how to use \p exclusive_scan_by_key
- *
- * \code
- * #include
- * #include
- *
- * int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
- * int vals[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
- *
- * int init = 5;
- *
- * thrust::exclusive_scan_by_key(key, key + 10, vals, vals, init); // in-place scan
- *
- * // vals is now {5, 6, 7, 5, 6, 5, 5, 6, 7, 8};
- * \endcode
- *
- * \see exclusive_scan
- * \see inclusive_scan_by_key
- *
- */
-template
- OutputIterator exclusive_scan_by_key(InputIterator1 first1,
- InputIterator1 last1,
- InputIterator2 first2,
- OutputIterator result,
- T init);
-
-
-/*! \p exclusive_scan_by_key computes an exclusive key-value or 'segmented' prefix
- * sum operation. The term 'exclusive' means that each result does not include
- * the corresponding input operand in the partial sum. The term 'segmented'
- * means that the partial sums are broken into distinct segments. In other
- * words, within each segment a separate exclusive scan operation is computed.
- * Refer to the code sample below for example usage.
- *
- * This version of \p exclusive_scan_by_key uses the value \c init to
- * initialize the exclusive scan operation.
- *
- * This version of \p exclusive_scan_by_key uses the binary predicate \c binary_pred
- * to compare adjacent keys. Specifically, consecutive iterators i and
- * i+1 in the range [first1, last1) belong to the same segment if
- * binary_pred(*i, *(i+1)) is true, and belong to different segments otherwise.
- *
- * The algorithm's execution is parallelized as determined by \p exec.
- *
- * \param exec The execution policy to use for parallelization.
- * \param first1 The beginning of the key sequence.
- * \param last1 The end of the key sequence.
- * \param first2 The beginning of the input value sequence.
- * \param result The beginning of the output value sequence.
- * \param init The initial of the exclusive sum value.
- * \param binary_pred The binary predicate used to determine equality of keys.
- * \return The end of the output sequence.
- *
- * \pre \p first1 may equal \p result but the range [first1, last1) and the range [result, result + (last1 - first1)) shall not overlap otherwise.
- * \pre \p first2 may equal \p result but the range [first2, first2 + (last1 - first1) and range [result, result + (last1 - first1)) shall not overlap otherwise.
- *
- * The following code snippet demonstrates how to use \p exclusive_scan_by_key using the
- * \p thrust::host execution policy for parallelization:
- *
- * \code
- * #include
- * #include
- * #include
- * ...
- *
- * int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
- * int vals[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
- *
- * int init = 5;
- *
- * thrust::equal_to binary_pred;
- *
- * thrust::exclusive_scan_by_key(thrust::host, key, key + 10, vals, vals, init, binary_pred); // in-place scan
- *
- * // vals is now {5, 6, 7, 5, 6, 5, 5, 6, 7, 8};
- * \endcode
- *
- * \see exclusive_scan
- * \see inclusive_scan_by_key
- *
- */
-template
-__host__ __device__
- OutputIterator exclusive_scan_by_key(const thrust::detail::execution_policy_base &exec,
- InputIterator1 first1,
- InputIterator1 last1,
- InputIterator2 first2,
- OutputIterator result,
- T init,
- BinaryPredicate binary_pred);
-
-
-/*! \p exclusive_scan_by_key computes an exclusive key-value or 'segmented' prefix
- * sum operation. The term 'exclusive' means that each result does not include
- * the corresponding input operand in the partial sum. The term 'segmented'
- * means that the partial sums are broken into distinct segments. In other
- * words, within each segment a separate exclusive scan operation is computed.
- * Refer to the code sample below for example usage.
- *
- * This version of \p exclusive_scan_by_key uses the value \c init to
- * initialize the exclusive scan operation.
- *
- * This version of \p exclusive_scan_by_key uses the binary predicate \c binary_pred
- * to compare adjacent keys. Specifically, consecutive iterators i and
- * i+1 in the range [first1, last1) belong to the same segment if
- * binary_pred(*i, *(i+1)) is true, and belong to different segments otherwise.
- *
- * \param first1 The beginning of the key sequence.
- * \param last1 The end of the key sequence.
- * \param first2 The beginning of the input value sequence.
- * \param result The beginning of the output value sequence.
- * \param init The initial of the exclusive sum value.
- * \param binary_pred The binary predicate used to determine equality of keys.
- * \return The end of the output sequence.
- *
- * \pre \p first1 may equal \p result but the range [first1, last1) and the range [result, result + (last1 - first1)) shall not overlap otherwise.
- * \pre \p first2 may equal \p result but the range [first2, first2 + (last1 - first1) and range [result, result + (last1 - first1)) shall not overlap otherwise.
- *
- * The following code snippet demonstrates how to use \p exclusive_scan_by_key
- *
- * \code
- * #include
- * #include
- *
- * int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
- * int vals[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
- *
- * int init = 5;
- *
- * thrust::equal_to binary_pred;
- *
- * thrust::exclusive_scan_by_key(key, key + 10, vals, vals, init, binary_pred); // in-place scan
- *
- * // vals is now {5, 6, 7, 5, 6, 5, 5, 6, 7, 8};
- * \endcode
- *
- * \see exclusive_scan
- * \see inclusive_scan_by_key
- *
- */
-template
- OutputIterator exclusive_scan_by_key(InputIterator1 first1,
- InputIterator1 last1,
- InputIterator2 first2,
- OutputIterator result,
- T init,
- BinaryPredicate binary_pred);
-
-
-/*! \p exclusive_scan_by_key computes an exclusive key-value or 'segmented' prefix
- * sum operation. The term 'exclusive' means that each result does not include
- * the corresponding input operand in the partial sum. The term 'segmented'
- * means that the partial sums are broken into distinct segments. In other
- * words, within each segment a separate exclusive scan operation is computed.
- * Refer to the code sample below for example usage.
- *
- * This version of \p exclusive_scan_by_key uses the value \c init to
- * initialize the exclusive scan operation.
- *
- * This version of \p exclusive_scan_by_key uses the binary predicate \c binary_pred
- * to compare adjacent keys. Specifically, consecutive iterators i and
- * i+1 in the range [first1, last1) belong to the same segment if
- * binary_pred(*i, *(i+1)) is true, and belong to different segments otherwise.
- *
- * This version of \p exclusive_scan_by_key uses the associative operator
- * \c binary_op to perform the prefix sum. When the input and output sequences
- * are the same, the scan is performed in-place.
- *
- * The algorithm's execution is parallelized as determined by \p exec.
- *
- * \param exec The execution policy to use for parallelization.
- * \param first1 The beginning of the key sequence.
- * \param last1 The end of the key sequence.
- * \param first2 The beginning of the input value sequence.
- * \param result The beginning of the output value sequence.
- * \param init The initial of the exclusive sum value.
- * \param binary_pred The binary predicate used to determine equality of keys.
- * \param binary_op The associatve operator used to 'sum' values.
- * \return The end of the output sequence.
- *
- * \tparam DerivedPolicy The name of the derived execution policy.
- * \tparam InputIterator1 is a model of Input Iterator
- * \tparam InputIterator2 is a model of Input Iterator
- * and \c InputIterator2's \c value_type is convertible to \c OutputIterator's \c value_type.
- * \tparam OutputIterator is a model of Output Iterator,
- * and if \c x and \c y are objects of \c OutputIterator's \c value_type, then
- * binary_op(x,y) is defined.
- * \tparam T is convertible to \c OutputIterator's \c value_type.
- * \tparam BinaryPredicate is a model of Binary Predicate.
- * \tparam AssociativeOperator is a model of Binary Function
- * and \c AssociativeOperator's \c result_type is convertible to \c OutputIterator's \c value_type.
- *
- * \pre \p first1 may equal \p result but the range [first1, last1) and the range [result, result + (last1 - first1)) shall not overlap otherwise.
- * \pre \p first2 may equal \p result but the range [first2, first2 + (last1 - first1) and range [result, result + (last1 - first1)) shall not overlap otherwise.
- *
- * The following code snippet demonstrates how to use \p exclusive_scan_by_key using the
- * \p thrust::host execution policy for parallelization:
- *
- * \code
- * #include
- * #include
- * #include
- * ...
- *
- * int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
- * int vals[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
- *
- * int init = 5;
- *
- * thrust::equal_to binary_pred;
- * thrust::plus binary_op;
- *
- * thrust::exclusive_scan_by_key(thrust::host, key, key + 10, vals, vals, init, binary_pred, binary_op); // in-place scan
- *
- * // vals is now {5, 6, 7, 5, 6, 5, 5, 6, 7, 8};
- * \endcode
- *
- * \see exclusive_scan
- * \see inclusive_scan_by_key
- *
- */
-template
-__host__ __device__
- OutputIterator exclusive_scan_by_key(const thrust::detail::execution_policy_base &exec,
- InputIterator1 first1,
- InputIterator1 last1,
- InputIterator2 first2,
- OutputIterator result,
- T init,
- BinaryPredicate binary_pred,
- AssociativeOperator binary_op);
-
-
-/*! \p exclusive_scan_by_key computes an exclusive key-value or 'segmented' prefix
- * sum operation. The term 'exclusive' means that each result does not include
- * the corresponding input operand in the partial sum. The term 'segmented'
- * means that the partial sums are broken into distinct segments. In other
- * words, within each segment a separate exclusive scan operation is computed.
- * Refer to the code sample below for example usage.
- *
- * This version of \p exclusive_scan_by_key uses the value \c init to
- * initialize the exclusive scan operation.
- *
- * This version of \p exclusive_scan_by_key uses the binary predicate \c binary_pred
- * to compare adjacent keys. Specifically, consecutive iterators i and
- * i+1 in the range [first1, last1) belong to the same segment if
- * binary_pred(*i, *(i+1)) is true, and belong to different segments otherwise.
- *
- * This version of \p exclusive_scan_by_key uses the associative operator
- * \c binary_op to perform the prefix sum. When the input and output sequences
- * are the same, the scan is performed in-place.
- *
- * \param first1 The beginning of the key sequence.
- * \param last1 The end of the key sequence.
- * \param first2 The beginning of the input value sequence.
- * \param result The beginning of the output value sequence.
- * \param init The initial of the exclusive sum value.
- * \param binary_pred The binary predicate used to determine equality of keys.
- * \param binary_op The associatve operator used to 'sum' values.
- * \return The end of the output sequence.
- *
- * \tparam InputIterator1 is a model of Input Iterator
- * \tparam InputIterator2 is a model of Input Iterator
- * and \c InputIterator2's \c value_type is convertible to \c OutputIterator's \c value_type.
- * \tparam OutputIterator is a model of Output Iterator,
- * and if \c x and \c y are objects of \c OutputIterator's \c value_type, then
- * binary_op(x,y) is defined.
- * \tparam T is convertible to \c OutputIterator's \c value_type.
- * \tparam BinaryPredicate is a model of Binary Predicate.
- * \tparam AssociativeOperator is a model of Binary Function
- * and \c AssociativeOperator's \c result_type is convertible to \c OutputIterator's \c value_type.
- *
- * \pre \p first1 may equal \p result but the range [first1, last1) and the range [result, result + (last1 - first1)) shall not overlap otherwise.
- * \pre \p first2 may equal \p result but the range [first2, first2 + (last1 - first1) and range [result, result + (last1 - first1)) shall not overlap otherwise.
- *
- * The following code snippet demonstrates how to use \p exclusive_scan_by_key
- *
- * \code
- * #include
- * #include
- *
- * int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
- * int vals[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
- *
- * int init = 5;
- *
- * thrust::equal_to binary_pred;
- * thrust::plus binary_op;
- *
- * thrust::exclusive_scan_by_key(key, key + 10, vals, vals, init, binary_pred, binary_op); // in-place scan
- *
- * // vals is now {5, 6, 7, 5, 6, 5, 5, 6, 7, 8};
- * \endcode
- *
- * \see exclusive_scan
- * \see inclusive_scan_by_key
- *
- */
-template
- OutputIterator exclusive_scan_by_key(InputIterator1 first1,
- InputIterator1 last1,
- InputIterator2 first2,
- OutputIterator result,
- T init,
- BinaryPredicate binary_pred,
- AssociativeOperator binary_op);
-
-
-/*! \} // end segmentedprefixsums
- */
-
-
-/*! \} // end prefix sums
- */
-
-
-} // end namespace thrust
-
-#include
-
diff --git a/spaces/CVPR/LIVE/thrust/thrust/system/cuda/detail/uninitialized_fill.h b/spaces/CVPR/LIVE/thrust/thrust/system/cuda/detail/uninitialized_fill.h
deleted file mode 100644
index a8f5fa80973dbf4e52fdab3fed18b6517af6fced..0000000000000000000000000000000000000000
--- a/spaces/CVPR/LIVE/thrust/thrust/system/cuda/detail/uninitialized_fill.h
+++ /dev/null
@@ -1,114 +0,0 @@
-/******************************************************************************
- * Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of the NVIDIA CORPORATION nor the
- * names of its contributors may be used to endorse or promote products
- * derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- ******************************************************************************/
-#pragma once
-
-
-#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
-#include
-#include
-#include
-#include
-#include
-
-namespace thrust
-{
-
-namespace cuda_cub {
-
-namespace __uninitialized_fill {
-
- template
- struct functor
- {
- Iterator items;
- T value;
-
- typedef typename iterator_traits::value_type value_type;
-
- THRUST_FUNCTION
- functor(Iterator items_, T const& value_)
- : items(items_), value(value_) {}
-
- template
- void THRUST_DEVICE_FUNCTION operator()(Size idx)
- {
- value_type& out = raw_reference_cast(items[idx]);
-
-#if defined(__CUDA__) && defined(__clang__)
- // XXX unsafe. cuda-clang is seemingly unable to call ::new in device code
- out = value;
-#else
- ::new (static_cast(&out)) value_type(value);
-#endif
- }
- }; // struct functor
-
-} // namespace __uninitialized_copy
-
-template
-Iterator __host__ __device__
-uninitialized_fill_n(execution_policy& policy,
- Iterator first,
- Size count,
- T const& x)
-{
- typedef __uninitialized_fill::functor functor_t;
-
- cuda_cub::parallel_for(policy,
- functor_t(first, x),
- count);
-
- cuda_cub::throw_on_error(
- cuda_cub::synchronize(policy)
- , "uninitialized_fill_n: failed to synchronize"
- );
-
- return first + count;
-}
-
-template
-void __host__ __device__
-uninitialized_fill(execution_policy& policy,
- Iterator first,
- Iterator last,
- T const& x)
-{
- cuda_cub::uninitialized_fill_n(policy,
- first,
- thrust::distance(first, last),
- x);
-}
-
-} // namespace cuda_cub
-
-} // end namespace thrust
-#endif
diff --git a/spaces/CVPR/WALT/mmdet/models/backbones/regnet.py b/spaces/CVPR/WALT/mmdet/models/backbones/regnet.py
deleted file mode 100644
index 91a602a952226cebb5fd0e3e282c6f98ae4fa455..0000000000000000000000000000000000000000
--- a/spaces/CVPR/WALT/mmdet/models/backbones/regnet.py
+++ /dev/null
@@ -1,325 +0,0 @@
-import numpy as np
-import torch.nn as nn
-from mmcv.cnn import build_conv_layer, build_norm_layer
-
-from ..builder import BACKBONES
-from .resnet import ResNet
-from .resnext import Bottleneck
-
-
-@BACKBONES.register_module()
-class RegNet(ResNet):
- """RegNet backbone.
-
- More details can be found in `paper `_ .
-
- Args:
- arch (dict): The parameter of RegNets.
-
- - w0 (int): initial width
- - wa (float): slope of width
- - wm (float): quantization parameter to quantize the width
- - depth (int): depth of the backbone
- - group_w (int): width of group
- - bot_mul (float): bottleneck ratio, i.e. expansion of bottleneck.
- strides (Sequence[int]): Strides of the first block of each stage.
- base_channels (int): Base channels after stem layer.
- in_channels (int): Number of input image channels. Default: 3.
- dilations (Sequence[int]): Dilation of each stage.
- out_indices (Sequence[int]): Output from which stages.
- style (str): `pytorch` or `caffe`. If set to "pytorch", the stride-two
- layer is the 3x3 conv layer, otherwise the stride-two layer is
- the first 1x1 conv layer.
- frozen_stages (int): Stages to be frozen (all param fixed). -1 means
- not freezing any parameters.
- norm_cfg (dict): dictionary to construct and config norm layer.
- norm_eval (bool): Whether to set norm layers to eval mode, namely,
- freeze running stats (mean and var). Note: Effect on Batch Norm
- and its variants only.
- with_cp (bool): Use checkpoint or not. Using checkpoint will save some
- memory while slowing down the training speed.
- zero_init_residual (bool): whether to use zero init for last norm layer
- in resblocks to let them behave as identity.
-
- Example:
- >>> from mmdet.models import RegNet
- >>> import torch
- >>> self = RegNet(
- arch=dict(
- w0=88,
- wa=26.31,
- wm=2.25,
- group_w=48,
- depth=25,
- bot_mul=1.0))
- >>> self.eval()
- >>> inputs = torch.rand(1, 3, 32, 32)
- >>> level_outputs = self.forward(inputs)
- >>> for level_out in level_outputs:
- ... print(tuple(level_out.shape))
- (1, 96, 8, 8)
- (1, 192, 4, 4)
- (1, 432, 2, 2)
- (1, 1008, 1, 1)
- """
- arch_settings = {
- 'regnetx_400mf':
- dict(w0=24, wa=24.48, wm=2.54, group_w=16, depth=22, bot_mul=1.0),
- 'regnetx_800mf':
- dict(w0=56, wa=35.73, wm=2.28, group_w=16, depth=16, bot_mul=1.0),
- 'regnetx_1.6gf':
- dict(w0=80, wa=34.01, wm=2.25, group_w=24, depth=18, bot_mul=1.0),
- 'regnetx_3.2gf':
- dict(w0=88, wa=26.31, wm=2.25, group_w=48, depth=25, bot_mul=1.0),
- 'regnetx_4.0gf':
- dict(w0=96, wa=38.65, wm=2.43, group_w=40, depth=23, bot_mul=1.0),
- 'regnetx_6.4gf':
- dict(w0=184, wa=60.83, wm=2.07, group_w=56, depth=17, bot_mul=1.0),
- 'regnetx_8.0gf':
- dict(w0=80, wa=49.56, wm=2.88, group_w=120, depth=23, bot_mul=1.0),
- 'regnetx_12gf':
- dict(w0=168, wa=73.36, wm=2.37, group_w=112, depth=19, bot_mul=1.0),
- }
-
- def __init__(self,
- arch,
- in_channels=3,
- stem_channels=32,
- base_channels=32,
- strides=(2, 2, 2, 2),
- dilations=(1, 1, 1, 1),
- out_indices=(0, 1, 2, 3),
- style='pytorch',
- deep_stem=False,
- avg_down=False,
- frozen_stages=-1,
- conv_cfg=None,
- norm_cfg=dict(type='BN', requires_grad=True),
- norm_eval=True,
- dcn=None,
- stage_with_dcn=(False, False, False, False),
- plugins=None,
- with_cp=False,
- zero_init_residual=True):
- super(ResNet, self).__init__()
-
- # Generate RegNet parameters first
- if isinstance(arch, str):
- assert arch in self.arch_settings, \
- f'"arch": "{arch}" is not one of the' \
- ' arch_settings'
- arch = self.arch_settings[arch]
- elif not isinstance(arch, dict):
- raise ValueError('Expect "arch" to be either a string '
- f'or a dict, got {type(arch)}')
-
- widths, num_stages = self.generate_regnet(
- arch['w0'],
- arch['wa'],
- arch['wm'],
- arch['depth'],
- )
- # Convert to per stage format
- stage_widths, stage_blocks = self.get_stages_from_blocks(widths)
- # Generate group widths and bot muls
- group_widths = [arch['group_w'] for _ in range(num_stages)]
- self.bottleneck_ratio = [arch['bot_mul'] for _ in range(num_stages)]
- # Adjust the compatibility of stage_widths and group_widths
- stage_widths, group_widths = self.adjust_width_group(
- stage_widths, self.bottleneck_ratio, group_widths)
-
- # Group params by stage
- self.stage_widths = stage_widths
- self.group_widths = group_widths
- self.depth = sum(stage_blocks)
- self.stem_channels = stem_channels
- self.base_channels = base_channels
- self.num_stages = num_stages
- assert num_stages >= 1 and num_stages <= 4
- self.strides = strides
- self.dilations = dilations
- assert len(strides) == len(dilations) == num_stages
- self.out_indices = out_indices
- assert max(out_indices) < num_stages
- self.style = style
- self.deep_stem = deep_stem
- self.avg_down = avg_down
- self.frozen_stages = frozen_stages
- self.conv_cfg = conv_cfg
- self.norm_cfg = norm_cfg
- self.with_cp = with_cp
- self.norm_eval = norm_eval
- self.dcn = dcn
- self.stage_with_dcn = stage_with_dcn
- if dcn is not None:
- assert len(stage_with_dcn) == num_stages
- self.plugins = plugins
- self.zero_init_residual = zero_init_residual
- self.block = Bottleneck
- expansion_bak = self.block.expansion
- self.block.expansion = 1
- self.stage_blocks = stage_blocks[:num_stages]
-
- self._make_stem_layer(in_channels, stem_channels)
-
- self.inplanes = stem_channels
- self.res_layers = []
- for i, num_blocks in enumerate(self.stage_blocks):
- stride = self.strides[i]
- dilation = self.dilations[i]
- group_width = self.group_widths[i]
- width = int(round(self.stage_widths[i] * self.bottleneck_ratio[i]))
- stage_groups = width // group_width
-
- dcn = self.dcn if self.stage_with_dcn[i] else None
- if self.plugins is not None:
- stage_plugins = self.make_stage_plugins(self.plugins, i)
- else:
- stage_plugins = None
-
- res_layer = self.make_res_layer(
- block=self.block,
- inplanes=self.inplanes,
- planes=self.stage_widths[i],
- num_blocks=num_blocks,
- stride=stride,
- dilation=dilation,
- style=self.style,
- avg_down=self.avg_down,
- with_cp=self.with_cp,
- conv_cfg=self.conv_cfg,
- norm_cfg=self.norm_cfg,
- dcn=dcn,
- plugins=stage_plugins,
- groups=stage_groups,
- base_width=group_width,
- base_channels=self.stage_widths[i])
- self.inplanes = self.stage_widths[i]
- layer_name = f'layer{i + 1}'
- self.add_module(layer_name, res_layer)
- self.res_layers.append(layer_name)
-
- self._freeze_stages()
-
- self.feat_dim = stage_widths[-1]
- self.block.expansion = expansion_bak
-
- def _make_stem_layer(self, in_channels, base_channels):
- self.conv1 = build_conv_layer(
- self.conv_cfg,
- in_channels,
- base_channels,
- kernel_size=3,
- stride=2,
- padding=1,
- bias=False)
- self.norm1_name, norm1 = build_norm_layer(
- self.norm_cfg, base_channels, postfix=1)
- self.add_module(self.norm1_name, norm1)
- self.relu = nn.ReLU(inplace=True)
-
- def generate_regnet(self,
- initial_width,
- width_slope,
- width_parameter,
- depth,
- divisor=8):
- """Generates per block width from RegNet parameters.
-
- Args:
- initial_width ([int]): Initial width of the backbone
- width_slope ([float]): Slope of the quantized linear function
- width_parameter ([int]): Parameter used to quantize the width.
- depth ([int]): Depth of the backbone.
- divisor (int, optional): The divisor of channels. Defaults to 8.
-
- Returns:
- list, int: return a list of widths of each stage and the number \
- of stages
- """
- assert width_slope >= 0
- assert initial_width > 0
- assert width_parameter > 1
- assert initial_width % divisor == 0
- widths_cont = np.arange(depth) * width_slope + initial_width
- ks = np.round(
- np.log(widths_cont / initial_width) / np.log(width_parameter))
- widths = initial_width * np.power(width_parameter, ks)
- widths = np.round(np.divide(widths, divisor)) * divisor
- num_stages = len(np.unique(widths))
- widths, widths_cont = widths.astype(int).tolist(), widths_cont.tolist()
- return widths, num_stages
-
- @staticmethod
- def quantize_float(number, divisor):
- """Converts a float to closest non-zero int divisible by divisor.
-
- Args:
- number (int): Original number to be quantized.
- divisor (int): Divisor used to quantize the number.
-
- Returns:
- int: quantized number that is divisible by devisor.
- """
- return int(round(number / divisor) * divisor)
-
- def adjust_width_group(self, widths, bottleneck_ratio, groups):
- """Adjusts the compatibility of widths and groups.
-
- Args:
- widths (list[int]): Width of each stage.
- bottleneck_ratio (float): Bottleneck ratio.
- groups (int): number of groups in each stage
-
- Returns:
- tuple(list): The adjusted widths and groups of each stage.
- """
- bottleneck_width = [
- int(w * b) for w, b in zip(widths, bottleneck_ratio)
- ]
- groups = [min(g, w_bot) for g, w_bot in zip(groups, bottleneck_width)]
- bottleneck_width = [
- self.quantize_float(w_bot, g)
- for w_bot, g in zip(bottleneck_width, groups)
- ]
- widths = [
- int(w_bot / b)
- for w_bot, b in zip(bottleneck_width, bottleneck_ratio)
- ]
- return widths, groups
-
- def get_stages_from_blocks(self, widths):
- """Gets widths/stage_blocks of network at each stage.
-
- Args:
- widths (list[int]): Width in each stage.
-
- Returns:
- tuple(list): width and depth of each stage
- """
- width_diff = [
- width != width_prev
- for width, width_prev in zip(widths + [0], [0] + widths)
- ]
- stage_widths = [
- width for width, diff in zip(widths, width_diff[:-1]) if diff
- ]
- stage_blocks = np.diff([
- depth for depth, diff in zip(range(len(width_diff)), width_diff)
- if diff
- ]).tolist()
- return stage_widths, stage_blocks
-
- def forward(self, x):
- """Forward function."""
- x = self.conv1(x)
- x = self.norm1(x)
- x = self.relu(x)
-
- outs = []
- for i, layer_name in enumerate(self.res_layers):
- res_layer = getattr(self, layer_name)
- x = res_layer(x)
- if i in self.out_indices:
- outs.append(x)
- return tuple(outs)
diff --git a/spaces/CVPR/WALT/mmdet/models/dense_heads/fovea_head.py b/spaces/CVPR/WALT/mmdet/models/dense_heads/fovea_head.py
deleted file mode 100644
index c8ccea787cba3d092284d4a5e209adaf6521c86a..0000000000000000000000000000000000000000
--- a/spaces/CVPR/WALT/mmdet/models/dense_heads/fovea_head.py
+++ /dev/null
@@ -1,341 +0,0 @@
-import torch
-import torch.nn as nn
-from mmcv.cnn import ConvModule, normal_init
-from mmcv.ops import DeformConv2d
-
-from mmdet.core import multi_apply, multiclass_nms
-from ..builder import HEADS
-from .anchor_free_head import AnchorFreeHead
-
-INF = 1e8
-
-
-class FeatureAlign(nn.Module):
-
- def __init__(self,
- in_channels,
- out_channels,
- kernel_size=3,
- deform_groups=4):
- super(FeatureAlign, self).__init__()
- offset_channels = kernel_size * kernel_size * 2
- self.conv_offset = nn.Conv2d(
- 4, deform_groups * offset_channels, 1, bias=False)
- self.conv_adaption = DeformConv2d(
- in_channels,
- out_channels,
- kernel_size=kernel_size,
- padding=(kernel_size - 1) // 2,
- deform_groups=deform_groups)
- self.relu = nn.ReLU(inplace=True)
-
- def init_weights(self):
- normal_init(self.conv_offset, std=0.1)
- normal_init(self.conv_adaption, std=0.01)
-
- def forward(self, x, shape):
- offset = self.conv_offset(shape)
- x = self.relu(self.conv_adaption(x, offset))
- return x
-
-
-@HEADS.register_module()
-class FoveaHead(AnchorFreeHead):
- """FoveaBox: Beyond Anchor-based Object Detector
- https://arxiv.org/abs/1904.03797
- """
-
- def __init__(self,
- num_classes,
- in_channels,
- base_edge_list=(16, 32, 64, 128, 256),
- scale_ranges=((8, 32), (16, 64), (32, 128), (64, 256), (128,
- 512)),
- sigma=0.4,
- with_deform=False,
- deform_groups=4,
- **kwargs):
- self.base_edge_list = base_edge_list
- self.scale_ranges = scale_ranges
- self.sigma = sigma
- self.with_deform = with_deform
- self.deform_groups = deform_groups
- super().__init__(num_classes, in_channels, **kwargs)
-
- def _init_layers(self):
- # box branch
- super()._init_reg_convs()
- self.conv_reg = nn.Conv2d(self.feat_channels, 4, 3, padding=1)
-
- # cls branch
- if not self.with_deform:
- super()._init_cls_convs()
- self.conv_cls = nn.Conv2d(
- self.feat_channels, self.cls_out_channels, 3, padding=1)
- else:
- self.cls_convs = nn.ModuleList()
- self.cls_convs.append(
- ConvModule(
- self.feat_channels, (self.feat_channels * 4),
- 3,
- stride=1,
- padding=1,
- conv_cfg=self.conv_cfg,
- norm_cfg=self.norm_cfg,
- bias=self.norm_cfg is None))
- self.cls_convs.append(
- ConvModule((self.feat_channels * 4), (self.feat_channels * 4),
- 1,
- stride=1,
- padding=0,
- conv_cfg=self.conv_cfg,
- norm_cfg=self.norm_cfg,
- bias=self.norm_cfg is None))
- self.feature_adaption = FeatureAlign(
- self.feat_channels,
- self.feat_channels,
- kernel_size=3,
- deform_groups=self.deform_groups)
- self.conv_cls = nn.Conv2d(
- int(self.feat_channels * 4),
- self.cls_out_channels,
- 3,
- padding=1)
-
- def init_weights(self):
- super().init_weights()
- if self.with_deform:
- self.feature_adaption.init_weights()
-
- def forward_single(self, x):
- cls_feat = x
- reg_feat = x
- for reg_layer in self.reg_convs:
- reg_feat = reg_layer(reg_feat)
- bbox_pred = self.conv_reg(reg_feat)
- if self.with_deform:
- cls_feat = self.feature_adaption(cls_feat, bbox_pred.exp())
- for cls_layer in self.cls_convs:
- cls_feat = cls_layer(cls_feat)
- cls_score = self.conv_cls(cls_feat)
- return cls_score, bbox_pred
-
- def _get_points_single(self, *args, **kwargs):
- y, x = super()._get_points_single(*args, **kwargs)
- return y + 0.5, x + 0.5
-
- def loss(self,
- cls_scores,
- bbox_preds,
- gt_bbox_list,
- gt_label_list,
- img_metas,
- gt_bboxes_ignore=None):
- assert len(cls_scores) == len(bbox_preds)
-
- featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
- points = self.get_points(featmap_sizes, bbox_preds[0].dtype,
- bbox_preds[0].device)
- num_imgs = cls_scores[0].size(0)
- flatten_cls_scores = [
- cls_score.permute(0, 2, 3, 1).reshape(-1, self.cls_out_channels)
- for cls_score in cls_scores
- ]
- flatten_bbox_preds = [
- bbox_pred.permute(0, 2, 3, 1).reshape(-1, 4)
- for bbox_pred in bbox_preds
- ]
- flatten_cls_scores = torch.cat(flatten_cls_scores)
- flatten_bbox_preds = torch.cat(flatten_bbox_preds)
- flatten_labels, flatten_bbox_targets = self.get_targets(
- gt_bbox_list, gt_label_list, featmap_sizes, points)
-
- # FG cat_id: [0, num_classes -1], BG cat_id: num_classes
- pos_inds = ((flatten_labels >= 0)
- & (flatten_labels < self.num_classes)).nonzero().view(-1)
- num_pos = len(pos_inds)
-
- loss_cls = self.loss_cls(
- flatten_cls_scores, flatten_labels, avg_factor=num_pos + num_imgs)
- if num_pos > 0:
- pos_bbox_preds = flatten_bbox_preds[pos_inds]
- pos_bbox_targets = flatten_bbox_targets[pos_inds]
- pos_weights = pos_bbox_targets.new_zeros(
- pos_bbox_targets.size()) + 1.0
- loss_bbox = self.loss_bbox(
- pos_bbox_preds,
- pos_bbox_targets,
- pos_weights,
- avg_factor=num_pos)
- else:
- loss_bbox = torch.tensor(
- 0,
- dtype=flatten_bbox_preds.dtype,
- device=flatten_bbox_preds.device)
- return dict(loss_cls=loss_cls, loss_bbox=loss_bbox)
-
- def get_targets(self, gt_bbox_list, gt_label_list, featmap_sizes, points):
- label_list, bbox_target_list = multi_apply(
- self._get_target_single,
- gt_bbox_list,
- gt_label_list,
- featmap_size_list=featmap_sizes,
- point_list=points)
- flatten_labels = [
- torch.cat([
- labels_level_img.flatten() for labels_level_img in labels_level
- ]) for labels_level in zip(*label_list)
- ]
- flatten_bbox_targets = [
- torch.cat([
- bbox_targets_level_img.reshape(-1, 4)
- for bbox_targets_level_img in bbox_targets_level
- ]) for bbox_targets_level in zip(*bbox_target_list)
- ]
- flatten_labels = torch.cat(flatten_labels)
- flatten_bbox_targets = torch.cat(flatten_bbox_targets)
- return flatten_labels, flatten_bbox_targets
-
- def _get_target_single(self,
- gt_bboxes_raw,
- gt_labels_raw,
- featmap_size_list=None,
- point_list=None):
-
- gt_areas = torch.sqrt((gt_bboxes_raw[:, 2] - gt_bboxes_raw[:, 0]) *
- (gt_bboxes_raw[:, 3] - gt_bboxes_raw[:, 1]))
- label_list = []
- bbox_target_list = []
- # for each pyramid, find the cls and box target
- for base_len, (lower_bound, upper_bound), stride, featmap_size, \
- (y, x) in zip(self.base_edge_list, self.scale_ranges,
- self.strides, featmap_size_list, point_list):
- # FG cat_id: [0, num_classes -1], BG cat_id: num_classes
- labels = gt_labels_raw.new_zeros(featmap_size) + self.num_classes
- bbox_targets = gt_bboxes_raw.new(featmap_size[0], featmap_size[1],
- 4) + 1
- # scale assignment
- hit_indices = ((gt_areas >= lower_bound) &
- (gt_areas <= upper_bound)).nonzero().flatten()
- if len(hit_indices) == 0:
- label_list.append(labels)
- bbox_target_list.append(torch.log(bbox_targets))
- continue
- _, hit_index_order = torch.sort(-gt_areas[hit_indices])
- hit_indices = hit_indices[hit_index_order]
- gt_bboxes = gt_bboxes_raw[hit_indices, :] / stride
- gt_labels = gt_labels_raw[hit_indices]
- half_w = 0.5 * (gt_bboxes[:, 2] - gt_bboxes[:, 0])
- half_h = 0.5 * (gt_bboxes[:, 3] - gt_bboxes[:, 1])
- # valid fovea area: left, right, top, down
- pos_left = torch.ceil(
- gt_bboxes[:, 0] + (1 - self.sigma) * half_w - 0.5).long().\
- clamp(0, featmap_size[1] - 1)
- pos_right = torch.floor(
- gt_bboxes[:, 0] + (1 + self.sigma) * half_w - 0.5).long().\
- clamp(0, featmap_size[1] - 1)
- pos_top = torch.ceil(
- gt_bboxes[:, 1] + (1 - self.sigma) * half_h - 0.5).long().\
- clamp(0, featmap_size[0] - 1)
- pos_down = torch.floor(
- gt_bboxes[:, 1] + (1 + self.sigma) * half_h - 0.5).long().\
- clamp(0, featmap_size[0] - 1)
- for px1, py1, px2, py2, label, (gt_x1, gt_y1, gt_x2, gt_y2) in \
- zip(pos_left, pos_top, pos_right, pos_down, gt_labels,
- gt_bboxes_raw[hit_indices, :]):
- labels[py1:py2 + 1, px1:px2 + 1] = label
- bbox_targets[py1:py2 + 1, px1:px2 + 1, 0] = \
- (stride * x[py1:py2 + 1, px1:px2 + 1] - gt_x1) / base_len
- bbox_targets[py1:py2 + 1, px1:px2 + 1, 1] = \
- (stride * y[py1:py2 + 1, px1:px2 + 1] - gt_y1) / base_len
- bbox_targets[py1:py2 + 1, px1:px2 + 1, 2] = \
- (gt_x2 - stride * x[py1:py2 + 1, px1:px2 + 1]) / base_len
- bbox_targets[py1:py2 + 1, px1:px2 + 1, 3] = \
- (gt_y2 - stride * y[py1:py2 + 1, px1:px2 + 1]) / base_len
- bbox_targets = bbox_targets.clamp(min=1. / 16, max=16.)
- label_list.append(labels)
- bbox_target_list.append(torch.log(bbox_targets))
- return label_list, bbox_target_list
-
- def get_bboxes(self,
- cls_scores,
- bbox_preds,
- img_metas,
- cfg=None,
- rescale=None):
- assert len(cls_scores) == len(bbox_preds)
- num_levels = len(cls_scores)
- featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
- points = self.get_points(
- featmap_sizes,
- bbox_preds[0].dtype,
- bbox_preds[0].device,
- flatten=True)
- result_list = []
- for img_id in range(len(img_metas)):
- cls_score_list = [
- cls_scores[i][img_id].detach() for i in range(num_levels)
- ]
- bbox_pred_list = [
- bbox_preds[i][img_id].detach() for i in range(num_levels)
- ]
- img_shape = img_metas[img_id]['img_shape']
- scale_factor = img_metas[img_id]['scale_factor']
- det_bboxes = self._get_bboxes_single(cls_score_list,
- bbox_pred_list, featmap_sizes,
- points, img_shape,
- scale_factor, cfg, rescale)
- result_list.append(det_bboxes)
- return result_list
-
- def _get_bboxes_single(self,
- cls_scores,
- bbox_preds,
- featmap_sizes,
- point_list,
- img_shape,
- scale_factor,
- cfg,
- rescale=False):
- cfg = self.test_cfg if cfg is None else cfg
- assert len(cls_scores) == len(bbox_preds) == len(point_list)
- det_bboxes = []
- det_scores = []
- for cls_score, bbox_pred, featmap_size, stride, base_len, (y, x) \
- in zip(cls_scores, bbox_preds, featmap_sizes, self.strides,
- self.base_edge_list, point_list):
- assert cls_score.size()[-2:] == bbox_pred.size()[-2:]
- scores = cls_score.permute(1, 2, 0).reshape(
- -1, self.cls_out_channels).sigmoid()
- bbox_pred = bbox_pred.permute(1, 2, 0).reshape(-1, 4).exp()
- nms_pre = cfg.get('nms_pre', -1)
- if (nms_pre > 0) and (scores.shape[0] > nms_pre):
- max_scores, _ = scores.max(dim=1)
- _, topk_inds = max_scores.topk(nms_pre)
- bbox_pred = bbox_pred[topk_inds, :]
- scores = scores[topk_inds, :]
- y = y[topk_inds]
- x = x[topk_inds]
- x1 = (stride * x - base_len * bbox_pred[:, 0]).\
- clamp(min=0, max=img_shape[1] - 1)
- y1 = (stride * y - base_len * bbox_pred[:, 1]).\
- clamp(min=0, max=img_shape[0] - 1)
- x2 = (stride * x + base_len * bbox_pred[:, 2]).\
- clamp(min=0, max=img_shape[1] - 1)
- y2 = (stride * y + base_len * bbox_pred[:, 3]).\
- clamp(min=0, max=img_shape[0] - 1)
- bboxes = torch.stack([x1, y1, x2, y2], -1)
- det_bboxes.append(bboxes)
- det_scores.append(scores)
- det_bboxes = torch.cat(det_bboxes)
- if rescale:
- det_bboxes /= det_bboxes.new_tensor(scale_factor)
- det_scores = torch.cat(det_scores)
- padding = det_scores.new_zeros(det_scores.shape[0], 1)
- # remind that we set FG labels to [0, num_class-1] since mmdet v2.0
- # BG cat_id: num_class
- det_scores = torch.cat([det_scores, padding], dim=1)
- det_bboxes, det_labels = multiclass_nms(det_bboxes, det_scores,
- cfg.score_thr, cfg.nms,
- cfg.max_per_img)
- return det_bboxes, det_labels
diff --git a/spaces/CVPR/WALT/mmdet/utils/profiling.py b/spaces/CVPR/WALT/mmdet/utils/profiling.py
deleted file mode 100644
index 4be9222c37e922329d537f883f5587995e27efc6..0000000000000000000000000000000000000000
--- a/spaces/CVPR/WALT/mmdet/utils/profiling.py
+++ /dev/null
@@ -1,39 +0,0 @@
-import contextlib
-import sys
-import time
-
-import torch
-
-if sys.version_info >= (3, 7):
-
- @contextlib.contextmanager
- def profile_time(trace_name,
- name,
- enabled=True,
- stream=None,
- end_stream=None):
- """Print time spent by CPU and GPU.
-
- Useful as a temporary context manager to find sweet spots of code
- suitable for async implementation.
- """
- if (not enabled) or not torch.cuda.is_available():
- yield
- return
- stream = stream if stream else torch.cuda.current_stream()
- end_stream = end_stream if end_stream else stream
- start = torch.cuda.Event(enable_timing=True)
- end = torch.cuda.Event(enable_timing=True)
- stream.record_event(start)
- try:
- cpu_start = time.monotonic()
- yield
- finally:
- cpu_end = time.monotonic()
- end_stream.record_event(end)
- end.synchronize()
- cpu_time = (cpu_end - cpu_start) * 1000
- gpu_time = start.elapsed_time(end)
- msg = f'{trace_name} {name} cpu_time {cpu_time:.2f} ms '
- msg += f'gpu_time {gpu_time:.2f} ms stream {stream}'
- print(msg, end_stream)
diff --git a/spaces/Caoyunkang/Segment-Any-Anomaly/SAM/scripts/export_onnx_model.py b/spaces/Caoyunkang/Segment-Any-Anomaly/SAM/scripts/export_onnx_model.py
deleted file mode 100644
index 33e11dcc8bd44c3f0c90ffe168773581707d5b40..0000000000000000000000000000000000000000
--- a/spaces/Caoyunkang/Segment-Any-Anomaly/SAM/scripts/export_onnx_model.py
+++ /dev/null
@@ -1,204 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-import torch
-
-from SAM import build_sam, build_sam_vit_b, build_sam_vit_l
-from SAM.utils.onnx import SamOnnxModel
-
-import argparse
-import warnings
-
-try:
- import onnxruntime # type: ignore
-
- onnxruntime_exists = True
-except ImportError:
- onnxruntime_exists = False
-
-parser = argparse.ArgumentParser(
- description="Export the SAM prompt encoder and mask decoder to an ONNX model."
-)
-
-parser.add_argument(
- "--checkpoint", type=str, required=True, help="The path to the SAM model checkpoint."
-)
-
-parser.add_argument(
- "--output", type=str, required=True, help="The filename to save the ONNX model to."
-)
-
-parser.add_argument(
- "--model-type",
- type=str,
- default="default",
- help="In ['default', 'vit_b', 'vit_l']. Which type of SAM model to export.",
-)
-
-parser.add_argument(
- "--return-single-mask",
- action="store_true",
- help=(
- "If true, the exported ONNX model will only return the best mask, "
- "instead of returning multiple masks. For high resolution images "
- "this can improve runtime when upscaling masks is expensive."
- ),
-)
-
-parser.add_argument(
- "--opset",
- type=int,
- default=17,
- help="The ONNX opset version to use. Must be >=11",
-)
-
-parser.add_argument(
- "--quantize-out",
- type=str,
- default=None,
- help=(
- "If set, will quantize the model and save it with this name. "
- "Quantization is performed with quantize_dynamic from onnxruntime.quantization.quantize."
- ),
-)
-
-parser.add_argument(
- "--gelu-approximate",
- action="store_true",
- help=(
- "Replace GELU operations with approximations using tanh. Useful "
- "for some runtimes that have slow or unimplemented erf ops, used in GELU."
- ),
-)
-
-parser.add_argument(
- "--use-stability-score",
- action="store_true",
- help=(
- "Replaces the model's predicted mask quality score with the stability "
- "score calculated on the low resolution masks using an offset of 1.0. "
- ),
-)
-
-parser.add_argument(
- "--return-extra-metrics",
- action="store_true",
- help=(
- "The model will return five results: (masks, scores, stability_scores, "
- "areas, low_res_logits) instead of the usual three. This can be "
- "significantly slower for high resolution outputs."
- ),
-)
-
-
-def run_export(
- model_type: str,
- checkpoint: str,
- output: str,
- opset: int,
- return_single_mask: bool,
- gelu_approximate: bool = False,
- use_stability_score: bool = False,
- return_extra_metrics=False,
-):
- print("Loading model...")
- if model_type == "vit_b":
- sam = build_sam_vit_b(checkpoint)
- elif model_type == "vit_l":
- sam = build_sam_vit_l(checkpoint)
- else:
- sam = build_sam(checkpoint)
-
- onnx_model = SamOnnxModel(
- model=sam,
- return_single_mask=return_single_mask,
- use_stability_score=use_stability_score,
- return_extra_metrics=return_extra_metrics,
- )
-
- if gelu_approximate:
- for n, m in onnx_model.named_modules():
- if isinstance(m, torch.nn.GELU):
- m.approximate = "tanh"
-
- dynamic_axes = {
- "point_coords": {1: "num_points"},
- "point_labels": {1: "num_points"},
- }
-
- embed_dim = sam.prompt_encoder.embed_dim
- embed_size = sam.prompt_encoder.image_embedding_size
- mask_input_size = [4 * x for x in embed_size]
- dummy_inputs = {
- "image_embeddings": torch.randn(1, embed_dim, *embed_size, dtype=torch.float),
- "point_coords": torch.randint(low=0, high=1024, size=(1, 5, 2), dtype=torch.float),
- "point_labels": torch.randint(low=0, high=4, size=(1, 5), dtype=torch.float),
- "mask_input": torch.randn(1, 1, *mask_input_size, dtype=torch.float),
- "has_mask_input": torch.tensor([1], dtype=torch.float),
- "orig_im_size": torch.tensor([1500, 2250], dtype=torch.float),
- }
-
- _ = onnx_model(**dummy_inputs)
-
- output_names = ["masks", "iou_predictions", "low_res_masks"]
-
- with warnings.catch_warnings():
- warnings.filterwarnings("ignore", category=torch.jit.TracerWarning)
- warnings.filterwarnings("ignore", category=UserWarning)
- with open(output, "wb") as f:
- print(f"Exporing onnx model to {output}...")
- torch.onnx.export(
- onnx_model,
- tuple(dummy_inputs.values()),
- f,
- export_params=True,
- verbose=False,
- opset_version=opset,
- do_constant_folding=True,
- input_names=list(dummy_inputs.keys()),
- output_names=output_names,
- dynamic_axes=dynamic_axes,
- )
-
- if onnxruntime_exists:
- ort_inputs = {k: to_numpy(v) for k, v in dummy_inputs.items()}
- ort_session = onnxruntime.InferenceSession(output)
- _ = ort_session.run(None, ort_inputs)
- print("Model has successfully been run with ONNXRuntime.")
-
-
-def to_numpy(tensor):
- return tensor.cpu().numpy()
-
-
-if __name__ == "__main__":
- args = parser.parse_args()
- run_export(
- model_type=args.model_type,
- checkpoint=args.checkpoint,
- output=args.output,
- opset=args.opset,
- return_single_mask=args.return_single_mask,
- gelu_approximate=args.gelu_approximate,
- use_stability_score=args.use_stability_score,
- return_extra_metrics=args.return_extra_metrics,
- )
-
- if args.quantize_out is not None:
- assert onnxruntime_exists, "onnxruntime is required to quantize the model."
- from onnxruntime.quantization import QuantType # type: ignore
- from onnxruntime.quantization.quantize import quantize_dynamic # type: ignore
-
- print(f"Quantizing model and writing to {args.quantize_out}...")
- quantize_dynamic(
- model_input=args.output,
- model_output=args.quantize_out,
- optimize_model=True,
- per_channel=False,
- reduce_range=False,
- weight_type=QuantType.QUInt8,
- )
- print("Done!")
diff --git a/spaces/CofAI/chat.b4/client/css/options.css b/spaces/CofAI/chat.b4/client/css/options.css
deleted file mode 100644
index fb015a54e0a7f7ac521517357d812c994621592e..0000000000000000000000000000000000000000
--- a/spaces/CofAI/chat.b4/client/css/options.css
+++ /dev/null
@@ -1,10 +0,0 @@
-.options-container {
- display: flex;
- flex-wrap: wrap;
-}
-
-@media screen and (max-width: 990px) {
- .options-container {
- justify-content: space-between;
- }
-}
diff --git a/spaces/CofAI/chat/client/css/message.css b/spaces/CofAI/chat/client/css/message.css
deleted file mode 100644
index 64e04147ee4d1e76dda4f39c4f756c9da63e3874..0000000000000000000000000000000000000000
--- a/spaces/CofAI/chat/client/css/message.css
+++ /dev/null
@@ -1,65 +0,0 @@
-.message {
- width: 100%;
- overflow-wrap: break-word;
- display: flex;
- gap: var(--section-gap);
- padding: var(--section-gap);
- padding-bottom: 0;
-}
-
-.message:last-child {
- animation: 0.6s show_message;
-}
-
-@keyframes show_message {
- from {
- transform: translateY(10px);
- opacity: 0;
- }
-}
-
-.message .avatar-container img {
- max-width: 48px;
- max-height: 48px;
- box-shadow: 0.4px 0.5px 0.7px -2px rgba(0, 0, 0, 0.08), 1.1px 1.3px 2px -2px rgba(0, 0, 0, 0.041),
- 2.7px 3px 4.8px -2px rgba(0, 0, 0, 0.029), 9px 10px 16px -2px rgba(0, 0, 0, 0.022);
-}
-
-.message .content {
- display: flex;
- flex-direction: column;
- width: 90%;
- gap: 18px;
-}
-
-.message .content p,
-.message .content li,
-.message .content code {
- font-size: 1rem;
- line-height: 1.3;
-}
-
-@media screen and (max-height: 720px) {
- .message {
- padding: 12px;
- gap: 0;
- }
-
- .message .content {
- margin-left: 8px;
- width: 80%;
- }
-
- .message .avatar-container img {
- max-width: 32px;
- max-height: 32px;
- }
-
- .message .content,
- .message .content p,
- .message .content li,
- .message .content code {
- font-size: 0.875rem;
- line-height: 1.3;
- }
-}
diff --git a/spaces/DEEMOSTECH/ChatAvatar/index.html b/spaces/DEEMOSTECH/ChatAvatar/index.html
deleted file mode 100644
index 26dc8ee7327fd8650b278bdbc29faf8376ab341e..0000000000000000000000000000000000000000
--- a/spaces/DEEMOSTECH/ChatAvatar/index.html
+++ /dev/null
@@ -1 +0,0 @@
-DreamFace
\ No newline at end of file
diff --git a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/misc/configTools.py b/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/misc/configTools.py
deleted file mode 100644
index 38bbada24a19b767756407313d41011db7e1719d..0000000000000000000000000000000000000000
--- a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/misc/configTools.py
+++ /dev/null
@@ -1,348 +0,0 @@
-"""
-Code of the config system; not related to fontTools or fonts in particular.
-
-The options that are specific to fontTools are in :mod:`fontTools.config`.
-
-To create your own config system, you need to create an instance of
-:class:`Options`, and a subclass of :class:`AbstractConfig` with its
-``options`` class variable set to your instance of Options.
-
-"""
-from __future__ import annotations
-
-import logging
-from dataclasses import dataclass
-from typing import (
- Any,
- Callable,
- ClassVar,
- Dict,
- Iterable,
- Mapping,
- MutableMapping,
- Optional,
- Set,
- Union,
-)
-
-
-log = logging.getLogger(__name__)
-
-__all__ = [
- "AbstractConfig",
- "ConfigAlreadyRegisteredError",
- "ConfigError",
- "ConfigUnknownOptionError",
- "ConfigValueParsingError",
- "ConfigValueValidationError",
- "Option",
- "Options",
-]
-
-
-class ConfigError(Exception):
- """Base exception for the config module."""
-
-
-class ConfigAlreadyRegisteredError(ConfigError):
- """Raised when a module tries to register a configuration option that
- already exists.
-
- Should not be raised too much really, only when developing new fontTools
- modules.
- """
-
- def __init__(self, name):
- super().__init__(f"Config option {name} is already registered.")
-
-
-class ConfigValueParsingError(ConfigError):
- """Raised when a configuration value cannot be parsed."""
-
- def __init__(self, name, value):
- super().__init__(
- f"Config option {name}: value cannot be parsed (given {repr(value)})"
- )
-
-
-class ConfigValueValidationError(ConfigError):
- """Raised when a configuration value cannot be validated."""
-
- def __init__(self, name, value):
- super().__init__(
- f"Config option {name}: value is invalid (given {repr(value)})"
- )
-
-
-class ConfigUnknownOptionError(ConfigError):
- """Raised when a configuration option is unknown."""
-
- def __init__(self, option_or_name):
- name = (
- f"'{option_or_name.name}' (id={id(option_or_name)})>"
- if isinstance(option_or_name, Option)
- else f"'{option_or_name}'"
- )
- super().__init__(f"Config option {name} is unknown")
-
-
-# eq=False because Options are unique, not fungible objects
-@dataclass(frozen=True, eq=False)
-class Option:
- name: str
- """Unique name identifying the option (e.g. package.module:MY_OPTION)."""
- help: str
- """Help text for this option."""
- default: Any
- """Default value for this option."""
- parse: Callable[[str], Any]
- """Turn input (e.g. string) into proper type. Only when reading from file."""
- validate: Optional[Callable[[Any], bool]] = None
- """Return true if the given value is an acceptable value."""
-
- @staticmethod
- def parse_optional_bool(v: str) -> Optional[bool]:
- s = str(v).lower()
- if s in {"0", "no", "false"}:
- return False
- if s in {"1", "yes", "true"}:
- return True
- if s in {"auto", "none"}:
- return None
- raise ValueError("invalid optional bool: {v!r}")
-
- @staticmethod
- def validate_optional_bool(v: Any) -> bool:
- return v is None or isinstance(v, bool)
-
-
-class Options(Mapping):
- """Registry of available options for a given config system.
-
- Define new options using the :meth:`register()` method.
-
- Access existing options using the Mapping interface.
- """
-
- __options: Dict[str, Option]
-
- def __init__(self, other: "Options" = None) -> None:
- self.__options = {}
- if other is not None:
- for option in other.values():
- self.register_option(option)
-
- def register(
- self,
- name: str,
- help: str,
- default: Any,
- parse: Callable[[str], Any],
- validate: Optional[Callable[[Any], bool]] = None,
- ) -> Option:
- """Create and register a new option."""
- return self.register_option(Option(name, help, default, parse, validate))
-
- def register_option(self, option: Option) -> Option:
- """Register a new option."""
- name = option.name
- if name in self.__options:
- raise ConfigAlreadyRegisteredError(name)
- self.__options[name] = option
- return option
-
- def is_registered(self, option: Option) -> bool:
- """Return True if the same option object is already registered."""
- return self.__options.get(option.name) is option
-
- def __getitem__(self, key: str) -> Option:
- return self.__options.__getitem__(key)
-
- def __iter__(self) -> Iterator[str]:
- return self.__options.__iter__()
-
- def __len__(self) -> int:
- return self.__options.__len__()
-
- def __repr__(self) -> str:
- return (
- f"{self.__class__.__name__}({{\n"
- + "".join(
- f" {k!r}: Option(default={v.default!r}, ...),\n"
- for k, v in self.__options.items()
- )
- + "})"
- )
-
-
-_USE_GLOBAL_DEFAULT = object()
-
-
-class AbstractConfig(MutableMapping):
- """
- Create a set of config values, optionally pre-filled with values from
- the given dictionary or pre-existing config object.
-
- The class implements the MutableMapping protocol keyed by option name (`str`).
- For convenience its methods accept either Option or str as the key parameter.
-
- .. seealso:: :meth:`set()`
-
- This config class is abstract because it needs its ``options`` class
- var to be set to an instance of :class:`Options` before it can be
- instanciated and used.
-
- .. code:: python
-
- class MyConfig(AbstractConfig):
- options = Options()
-
- MyConfig.register_option( "test:option_name", "This is an option", 0, int, lambda v: isinstance(v, int))
-
- cfg = MyConfig({"test:option_name": 10})
-
- """
-
- options: ClassVar[Options]
-
- @classmethod
- def register_option(
- cls,
- name: str,
- help: str,
- default: Any,
- parse: Callable[[str], Any],
- validate: Optional[Callable[[Any], bool]] = None,
- ) -> Option:
- """Register an available option in this config system."""
- return cls.options.register(
- name, help=help, default=default, parse=parse, validate=validate
- )
-
- _values: Dict[str, Any]
-
- def __init__(
- self,
- values: Union[AbstractConfig, Dict[Union[Option, str], Any]] = {},
- parse_values: bool = False,
- skip_unknown: bool = False,
- ):
- self._values = {}
- values_dict = values._values if isinstance(values, AbstractConfig) else values
- for name, value in values_dict.items():
- self.set(name, value, parse_values, skip_unknown)
-
- def _resolve_option(self, option_or_name: Union[Option, str]) -> Option:
- if isinstance(option_or_name, Option):
- option = option_or_name
- if not self.options.is_registered(option):
- raise ConfigUnknownOptionError(option)
- return option
- elif isinstance(option_or_name, str):
- name = option_or_name
- try:
- return self.options[name]
- except KeyError:
- raise ConfigUnknownOptionError(name)
- else:
- raise TypeError(
- "expected Option or str, found "
- f"{type(option_or_name).__name__}: {option_or_name!r}"
- )
-
- def set(
- self,
- option_or_name: Union[Option, str],
- value: Any,
- parse_values: bool = False,
- skip_unknown: bool = False,
- ):
- """Set the value of an option.
-
- Args:
- * `option_or_name`: an `Option` object or its name (`str`).
- * `value`: the value to be assigned to given option.
- * `parse_values`: parse the configuration value from a string into
- its proper type, as per its `Option` object. The default
- behavior is to raise `ConfigValueValidationError` when the value
- is not of the right type. Useful when reading options from a
- file type that doesn't support as many types as Python.
- * `skip_unknown`: skip unknown configuration options. The default
- behaviour is to raise `ConfigUnknownOptionError`. Useful when
- reading options from a configuration file that has extra entries
- (e.g. for a later version of fontTools)
- """
- try:
- option = self._resolve_option(option_or_name)
- except ConfigUnknownOptionError as e:
- if skip_unknown:
- log.debug(str(e))
- return
- raise
-
- # Can be useful if the values come from a source that doesn't have
- # strict typing (.ini file? Terminal input?)
- if parse_values:
- try:
- value = option.parse(value)
- except Exception as e:
- raise ConfigValueParsingError(option.name, value) from e
-
- if option.validate is not None and not option.validate(value):
- raise ConfigValueValidationError(option.name, value)
-
- self._values[option.name] = value
-
- def get(
- self, option_or_name: Union[Option, str], default: Any = _USE_GLOBAL_DEFAULT
- ) -> Any:
- """
- Get the value of an option. The value which is returned is the first
- provided among:
-
- 1. a user-provided value in the options's ``self._values`` dict
- 2. a caller-provided default value to this method call
- 3. the global default for the option provided in ``fontTools.config``
-
- This is to provide the ability to migrate progressively from config
- options passed as arguments to fontTools APIs to config options read
- from the current TTFont, e.g.
-
- .. code:: python
-
- def fontToolsAPI(font, some_option):
- value = font.cfg.get("someLib.module:SOME_OPTION", some_option)
- # use value
-
- That way, the function will work the same for users of the API that
- still pass the option to the function call, but will favour the new
- config mechanism if the given font specifies a value for that option.
- """
- option = self._resolve_option(option_or_name)
- if option.name in self._values:
- return self._values[option.name]
- if default is not _USE_GLOBAL_DEFAULT:
- return default
- return option.default
-
- def copy(self):
- return self.__class__(self._values)
-
- def __getitem__(self, option_or_name: Union[Option, str]) -> Any:
- return self.get(option_or_name)
-
- def __setitem__(self, option_or_name: Union[Option, str], value: Any) -> None:
- return self.set(option_or_name, value)
-
- def __delitem__(self, option_or_name: Union[Option, str]) -> None:
- option = self._resolve_option(option_or_name)
- del self._values[option.name]
-
- def __iter__(self) -> Iterable[str]:
- return self._values.__iter__()
-
- def __len__(self) -> int:
- return len(self._values)
-
- def __repr__(self) -> str:
- return f"{self.__class__.__name__}({repr(self._values)})"
diff --git a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/gradio/themes/utils/colors.py b/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/gradio/themes/utils/colors.py
deleted file mode 100644
index 6b2d975bdd5245e1cd82bd172ee70a733924d0d8..0000000000000000000000000000000000000000
--- a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/gradio/themes/utils/colors.py
+++ /dev/null
@@ -1,359 +0,0 @@
-from __future__ import annotations
-
-
-class Color:
- all = []
-
- def __init__(
- self,
- c50: str,
- c100: str,
- c200: str,
- c300: str,
- c400: str,
- c500: str,
- c600: str,
- c700: str,
- c800: str,
- c900: str,
- c950: str,
- name: str | None = None,
- ):
- self.c50 = c50
- self.c100 = c100
- self.c200 = c200
- self.c300 = c300
- self.c400 = c400
- self.c500 = c500
- self.c600 = c600
- self.c700 = c700
- self.c800 = c800
- self.c900 = c900
- self.c950 = c950
- self.name = name
- Color.all.append(self)
-
- def expand(self) -> list[str]:
- return [
- self.c50,
- self.c100,
- self.c200,
- self.c300,
- self.c400,
- self.c500,
- self.c600,
- self.c700,
- self.c800,
- self.c900,
- self.c950,
- ]
-
-
-slate = Color(
- name="slate",
- c50="#f8fafc",
- c100="#f1f5f9",
- c200="#e2e8f0",
- c300="#cbd5e1",
- c400="#94a3b8",
- c500="#64748b",
- c600="#475569",
- c700="#334155",
- c800="#1e293b",
- c900="#0f172a",
- c950="#0a0f1e",
-)
-gray = Color(
- name="gray",
- c50="#f9fafb",
- c100="#f3f4f6",
- c200="#e5e7eb",
- c300="#d1d5db",
- c400="#9ca3af",
- c500="#6b7280",
- c600="#4b5563",
- c700="#374151",
- c800="#1f2937",
- c900="#111827",
- c950="#0b0f19",
-)
-zinc = Color(
- name="zinc",
- c50="#fafafa",
- c100="#f4f4f5",
- c200="#e4e4e7",
- c300="#d4d4d8",
- c400="#a1a1aa",
- c500="#71717a",
- c600="#52525b",
- c700="#3f3f46",
- c800="#27272a",
- c900="#18181b",
- c950="#0f0f11",
-)
-neutral = Color(
- name="neutral",
- c50="#fafafa",
- c100="#f5f5f5",
- c200="#e5e5e5",
- c300="#d4d4d4",
- c400="#a3a3a3",
- c500="#737373",
- c600="#525252",
- c700="#404040",
- c800="#262626",
- c900="#171717",
- c950="#0f0f0f",
-)
-stone = Color(
- name="stone",
- c50="#fafaf9",
- c100="#f5f5f4",
- c200="#e7e5e4",
- c300="#d6d3d1",
- c400="#a8a29e",
- c500="#78716c",
- c600="#57534e",
- c700="#44403c",
- c800="#292524",
- c900="#1c1917",
- c950="#0f0e0d",
-)
-red = Color(
- name="red",
- c50="#fef2f2",
- c100="#fee2e2",
- c200="#fecaca",
- c300="#fca5a5",
- c400="#f87171",
- c500="#ef4444",
- c600="#dc2626",
- c700="#b91c1c",
- c800="#991b1b",
- c900="#7f1d1d",
- c950="#6c1e1e",
-)
-orange = Color(
- name="orange",
- c50="#fff7ed",
- c100="#ffedd5",
- c200="#fed7aa",
- c300="#fdba74",
- c400="#fb923c",
- c500="#f97316",
- c600="#ea580c",
- c700="#c2410c",
- c800="#9a3412",
- c900="#7c2d12",
- c950="#6c2e12",
-)
-amber = Color(
- name="amber",
- c50="#fffbeb",
- c100="#fef3c7",
- c200="#fde68a",
- c300="#fcd34d",
- c400="#fbbf24",
- c500="#f59e0b",
- c600="#d97706",
- c700="#b45309",
- c800="#92400e",
- c900="#78350f",
- c950="#6c370f",
-)
-yellow = Color(
- name="yellow",
- c50="#fefce8",
- c100="#fef9c3",
- c200="#fef08a",
- c300="#fde047",
- c400="#facc15",
- c500="#eab308",
- c600="#ca8a04",
- c700="#a16207",
- c800="#854d0e",
- c900="#713f12",
- c950="#653b12",
-)
-lime = Color(
- name="lime",
- c50="#f7fee7",
- c100="#ecfccb",
- c200="#d9f99d",
- c300="#bef264",
- c400="#a3e635",
- c500="#84cc16",
- c600="#65a30d",
- c700="#4d7c0f",
- c800="#3f6212",
- c900="#365314",
- c950="#2f4e14",
-)
-green = Color(
- name="green",
- c50="#f0fdf4",
- c100="#dcfce7",
- c200="#bbf7d0",
- c300="#86efac",
- c400="#4ade80",
- c500="#22c55e",
- c600="#16a34a",
- c700="#15803d",
- c800="#166534",
- c900="#14532d",
- c950="#134e28",
-)
-emerald = Color(
- name="emerald",
- c50="#ecfdf5",
- c100="#d1fae5",
- c200="#a7f3d0",
- c300="#6ee7b7",
- c400="#34d399",
- c500="#10b981",
- c600="#059669",
- c700="#047857",
- c800="#065f46",
- c900="#064e3b",
- c950="#054436",
-)
-teal = Color(
- name="teal",
- c50="#f0fdfa",
- c100="#ccfbf1",
- c200="#99f6e4",
- c300="#5eead4",
- c400="#2dd4bf",
- c500="#14b8a6",
- c600="#0d9488",
- c700="#0f766e",
- c800="#115e59",
- c900="#134e4a",
- c950="#12443e",
-)
-cyan = Color(
- name="cyan",
- c50="#ecfeff",
- c100="#cffafe",
- c200="#a5f3fc",
- c300="#67e8f9",
- c400="#22d3ee",
- c500="#06b6d4",
- c600="#0891b2",
- c700="#0e7490",
- c800="#155e75",
- c900="#164e63",
- c950="#14455c",
-)
-sky = Color(
- name="sky",
- c50="#f0f9ff",
- c100="#e0f2fe",
- c200="#bae6fd",
- c300="#7dd3fc",
- c400="#38bdf8",
- c500="#0ea5e9",
- c600="#0284c7",
- c700="#0369a1",
- c800="#075985",
- c900="#0c4a6e",
- c950="#0b4165",
-)
-blue = Color(
- name="blue",
- c50="#eff6ff",
- c100="#dbeafe",
- c200="#bfdbfe",
- c300="#93c5fd",
- c400="#60a5fa",
- c500="#3b82f6",
- c600="#2563eb",
- c700="#1d4ed8",
- c800="#1e40af",
- c900="#1e3a8a",
- c950="#1d3660",
-)
-indigo = Color(
- name="indigo",
- c50="#eef2ff",
- c100="#e0e7ff",
- c200="#c7d2fe",
- c300="#a5b4fc",
- c400="#818cf8",
- c500="#6366f1",
- c600="#4f46e5",
- c700="#4338ca",
- c800="#3730a3",
- c900="#312e81",
- c950="#2b2c5e",
-)
-violet = Color(
- name="violet",
- c50="#f5f3ff",
- c100="#ede9fe",
- c200="#ddd6fe",
- c300="#c4b5fd",
- c400="#a78bfa",
- c500="#8b5cf6",
- c600="#7c3aed",
- c700="#6d28d9",
- c800="#5b21b6",
- c900="#4c1d95",
- c950="#431d7f",
-)
-purple = Color(
- name="purple",
- c50="#faf5ff",
- c100="#f3e8ff",
- c200="#e9d5ff",
- c300="#d8b4fe",
- c400="#c084fc",
- c500="#a855f7",
- c600="#9333ea",
- c700="#7e22ce",
- c800="#6b21a8",
- c900="#581c87",
- c950="#4c1a73",
-)
-fuchsia = Color(
- name="fuchsia",
- c50="#fdf4ff",
- c100="#fae8ff",
- c200="#f5d0fe",
- c300="#f0abfc",
- c400="#e879f9",
- c500="#d946ef",
- c600="#c026d3",
- c700="#a21caf",
- c800="#86198f",
- c900="#701a75",
- c950="#5e1a66",
-)
-pink = Color(
- name="pink",
- c50="#fdf2f8",
- c100="#fce7f3",
- c200="#fbcfe8",
- c300="#f9a8d4",
- c400="#f472b6",
- c500="#ec4899",
- c600="#db2777",
- c700="#be185d",
- c800="#9d174d",
- c900="#831843",
- c950="#6e1a3d",
-)
-rose = Color(
- name="rose",
- c50="#fff1f2",
- c100="#ffe4e6",
- c200="#fecdd3",
- c300="#fda4af",
- c400="#fb7185",
- c500="#f43f5e",
- c600="#e11d48",
- c700="#be123c",
- c800="#9f1239",
- c900="#881337",
- c950="#771d3a",
-)
diff --git a/spaces/Dabs/wordcloud/README.md b/spaces/Dabs/wordcloud/README.md
deleted file mode 100644
index d1ad05c1a70f0d952d3fc5b601a06461adaf42e4..0000000000000000000000000000000000000000
--- a/spaces/Dabs/wordcloud/README.md
+++ /dev/null
@@ -1,11 +0,0 @@
----
-title: Wordcloud
-emoji: 📈
-colorFrom: purple
-colorTo: blue
-sdk: gradio
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces#reference
diff --git a/spaces/DaleChen/AutoGPT/autogpt/agent/agent_manager.py b/spaces/DaleChen/AutoGPT/autogpt/agent/agent_manager.py
deleted file mode 100644
index 898767a485e50b5e62625a7883edf1b30d5fddf9..0000000000000000000000000000000000000000
--- a/spaces/DaleChen/AutoGPT/autogpt/agent/agent_manager.py
+++ /dev/null
@@ -1,103 +0,0 @@
-"""Agent manager for managing GPT agents"""
-from __future__ import annotations
-
-from typing import Union
-
-from autogpt.config.config import Singleton
-from autogpt.llm_utils import create_chat_completion
-
-
-class AgentManager(metaclass=Singleton):
- """Agent manager for managing GPT agents"""
-
- def __init__(self):
- self.next_key = 0
- self.agents = {} # key, (task, full_message_history, model)
-
- # Create new GPT agent
- # TODO: Centralise use of create_chat_completion() to globally enforce token limit
-
- def create_agent(self, task: str, prompt: str, model: str) -> tuple[int, str]:
- """Create a new agent and return its key
-
- Args:
- task: The task to perform
- prompt: The prompt to use
- model: The model to use
-
- Returns:
- The key of the new agent
- """
- messages = [
- {"role": "user", "content": prompt},
- ]
-
- # Start GPT instance
- agent_reply = create_chat_completion(
- model=model,
- messages=messages,
- )
-
- # Update full message history
- messages.append({"role": "assistant", "content": agent_reply})
-
- key = self.next_key
- # This is done instead of len(agents) to make keys unique even if agents
- # are deleted
- self.next_key += 1
-
- self.agents[key] = (task, messages, model)
-
- return key, agent_reply
-
- def message_agent(self, key: str | int, message: str) -> str:
- """Send a message to an agent and return its response
-
- Args:
- key: The key of the agent to message
- message: The message to send to the agent
-
- Returns:
- The agent's response
- """
- task, messages, model = self.agents[int(key)]
-
- # Add user message to message history before sending to agent
- messages.append({"role": "user", "content": message})
-
- # Start GPT instance
- agent_reply = create_chat_completion(
- model=model,
- messages=messages,
- )
-
- # Update full message history
- messages.append({"role": "assistant", "content": agent_reply})
-
- return agent_reply
-
- def list_agents(self) -> list[tuple[str | int, str]]:
- """Return a list of all agents
-
- Returns:
- A list of tuples of the form (key, task)
- """
-
- # Return a list of agent keys and their tasks
- return [(key, task) for key, (task, _, _) in self.agents.items()]
-
- def delete_agent(self, key: Union[str, int]) -> bool:
- """Delete an agent from the agent manager
-
- Args:
- key: The key of the agent to delete
-
- Returns:
- True if successful, False otherwise
- """
-
- try:
- del self.agents[int(key)]
- return True
- except KeyError:
- return False
diff --git a/spaces/Dana19/animal_classifier/README.md b/spaces/Dana19/animal_classifier/README.md
deleted file mode 100644
index a425a1d90746f5a9dd2b5be1cf2208e15501f220..0000000000000000000000000000000000000000
--- a/spaces/Dana19/animal_classifier/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Animal Classifier
-emoji: 📚
-colorFrom: gray
-colorTo: blue
-sdk: gradio
-sdk_version: 3.4.1
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/DarwinAnim8or/Mistral-Chat/README.md b/spaces/DarwinAnim8or/Mistral-Chat/README.md
deleted file mode 100644
index c63d81174e080bba2742888889eedd9609d2c26d..0000000000000000000000000000000000000000
--- a/spaces/DarwinAnim8or/Mistral-Chat/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Mistral Chat (fast)
-emoji: 😻
-colorFrom: red
-colorTo: yellow
-sdk: gradio
-sdk_version: 3.45.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
\ No newline at end of file
diff --git a/spaces/DemoLou/moe-tts/text/ngu_dialect.py b/spaces/DemoLou/moe-tts/text/ngu_dialect.py
deleted file mode 100644
index 69d0ce6fe5a989843ee059a71ccab793f20f9176..0000000000000000000000000000000000000000
--- a/spaces/DemoLou/moe-tts/text/ngu_dialect.py
+++ /dev/null
@@ -1,30 +0,0 @@
-import re
-import opencc
-
-
-dialects = {'SZ': 'suzhou', 'WX': 'wuxi', 'CZ': 'changzhou', 'HZ': 'hangzhou',
- 'SX': 'shaoxing', 'NB': 'ningbo', 'JJ': 'jingjiang', 'YX': 'yixing',
- 'JD': 'jiading', 'ZR': 'zhenru', 'PH': 'pinghu', 'TX': 'tongxiang',
- 'JS': 'jiashan', 'HN': 'xiashi', 'LP': 'linping', 'XS': 'xiaoshan',
- 'FY': 'fuyang', 'RA': 'ruao', 'CX': 'cixi', 'SM': 'sanmen',
- 'TT': 'tiantai', 'WZ': 'wenzhou', 'SC': 'suichang', 'YB': 'youbu'}
-
-converters = {}
-
-for dialect in dialects.values():
- try:
- converters[dialect] = opencc.OpenCC("chinese_dialect_lexicons/"+dialect)
- except:
- pass
-
-
-def ngu_dialect_to_ipa(text, dialect):
- dialect = dialects[dialect]
- text = converters[dialect].convert(text).replace('-','').replace('$',' ')
- text = re.sub(r'[、；：]', '，', text)
- text = re.sub(r'\s*，\s*', ', ', text)
- text = re.sub(r'\s*。\s*', '. ', text)
- text = re.sub(r'\s*？\s*', '? ', text)
- text = re.sub(r'\s*！\s*', '! ', text)
- text = re.sub(r'\s*$', '', text)
- return text
diff --git a/spaces/DragGan/DragGan-Inversion/stylegan_human/alignment.py b/spaces/DragGan/DragGan-Inversion/stylegan_human/alignment.py
deleted file mode 100644
index 46f58c79061ed8030562300f131f97f04e5ea42f..0000000000000000000000000000000000000000
--- a/spaces/DragGan/DragGan-Inversion/stylegan_human/alignment.py
+++ /dev/null
@@ -1,233 +0,0 @@
-# Copyright (c) SenseTime Research. All rights reserved.
-
-
-import os
-import argparse
-import numpy as np
-import torch
-from torch.utils.data import DataLoader
-from torchvision.transforms import transforms
-from utils.ImagesDataset import ImagesDataset
-
-import cv2
-import time
-import copy
-import imutils
-
-# for openpose body keypoint detector : # (src:https://github.com/Hzzone/pytorch-openpose)
-from openpose.src import util
-from openpose.src.body import Body
-
-# for paddlepaddle human segmentation : #(src: https://github.com/PaddlePaddle/PaddleSeg/blob/release/2.5/contrib/PP-HumanSeg/)
-from PP_HumanSeg.deploy.infer import Predictor as PP_HumenSeg_Predictor
-
-import math
-
-
-def angle_between_points(p0, p1, p2):
- if p0[1] == -1 or p1[1] == -1 or p2[1] == -1:
- return -1
- a = (p1[0]-p0[0])**2 + (p1[1]-p0[1])**2
- b = (p1[0]-p2[0])**2 + (p1[1]-p2[1])**2
- c = (p2[0]-p0[0])**2 + (p2[1]-p0[1])**2
- if a * b == 0:
- return -1
- return math.acos((a+b-c) / math.sqrt(4*a*b)) * 180 / math.pi
-
-
-def crop_img_with_padding(img, keypoints, rect):
- person_xmin, person_xmax, ymin, ymax = rect
- img_h, img_w, _ = img.shape # find body center using keypoints
- middle_shoulder_x = keypoints[1][0]
- middle_hip_x = (keypoints[8][0] + keypoints[11][0]) // 2
- mid_x = (middle_hip_x + middle_shoulder_x) // 2
- mid_y = (ymin + ymax) // 2
- # find which side (l or r) is further than center x, use the further side
- if abs(mid_x-person_xmin) > abs(person_xmax-mid_x): # left further
- xmin = person_xmin
- xmax = mid_x + (mid_x-person_xmin)
- else:
- # may be negtive
- # in this case, the script won't output any image, leave the case like this
- # since we don't want to pad human body
- xmin = mid_x - (person_xmax-mid_x)
- xmax = person_xmax
-
- w = xmax - xmin
- h = ymax - ymin
- # pad rectangle to w:h = 1:2 ## calculate desired border length
- if h / w >= 2: # pad horizontally
- target_w = h // 2
- xmin_prime = int(mid_x - target_w / 2)
- xmax_prime = int(mid_x + target_w / 2)
- if xmin_prime < 0:
- pad_left = abs(xmin_prime) # - xmin
- xmin = 0
- else:
- pad_left = 0
- xmin = xmin_prime
- if xmax_prime > img_w:
- pad_right = xmax_prime - img_w
- xmax = img_w
- else:
- pad_right = 0
- xmax = xmax_prime
-
- cropped_img = img[int(ymin):int(ymax), int(xmin):int(xmax)]
- im_pad = cv2.copyMakeBorder(cropped_img, 0, 0, int(
- pad_left), int(pad_right), cv2.BORDER_REPLICATE)
- else: # pad vertically
- target_h = w * 2
- ymin_prime = mid_y - (target_h / 2)
- ymax_prime = mid_y + (target_h / 2)
- if ymin_prime < 0:
- pad_up = abs(ymin_prime) # - ymin
- ymin = 0
- else:
- pad_up = 0
- ymin = ymin_prime
- if ymax_prime > img_h:
- pad_down = ymax_prime - img_h
- ymax = img_h
- else:
- pad_down = 0
- ymax = ymax_prime
- print(ymin, ymax, xmin, xmax, img.shape)
-
- cropped_img = img[int(ymin):int(ymax), int(xmin):int(xmax)]
- im_pad = cv2.copyMakeBorder(cropped_img, int(pad_up), int(pad_down), 0,
- 0, cv2.BORDER_REPLICATE)
- result = cv2.resize(im_pad, (512, 1024), interpolation=cv2.INTER_AREA)
- return result
-
-
-def run(args):
- os.makedirs(args.output_folder, exist_ok=True)
- dataset = ImagesDataset(
- args.image_folder, transforms.Compose([transforms.ToTensor()]))
- dataloader = DataLoader(dataset, batch_size=1, shuffle=False)
-
- body_estimation = Body('openpose/model/body_pose_model.pth')
-
- total = len(dataloader)
- print('Num of dataloader : ', total)
- os.makedirs(f'{args.output_folder}', exist_ok=True)
- # os.makedirs(f'{args.output_folder}/middle_result', exist_ok=True)
-
- # initialzide HumenSeg
- human_seg_args = {}
- human_seg_args['cfg'] = 'PP_HumanSeg/export_model/deeplabv3p_resnet50_os8_humanseg_512x512_100k_with_softmax/deploy.yaml'
- human_seg_args['input_shape'] = [1024, 512]
- human_seg_args['save_dir'] = args.output_folder
- human_seg_args['soft_predict'] = False
- human_seg_args['use_gpu'] = True
- human_seg_args['test_speed'] = False
- human_seg_args['use_optic_flow'] = False
- human_seg_args['add_argmax'] = True
- human_seg_args = argparse.Namespace(**human_seg_args)
- human_seg = PP_HumenSeg_Predictor(human_seg_args)
-
- from tqdm import tqdm
- for fname, image in tqdm(dataloader):
- # try:
- # tensor to numpy image
- fname = fname[0]
- print(f'Processing \'{fname}\'.')
-
- image = (image.permute(0, 2, 3, 1) * 255).clamp(0, 255)
- image = image.squeeze(0).numpy() # --> tensor to numpy, (H,W,C)
- # avoid super high res img
- if image.shape[0] >= 2000: # height ### for shein image
- ratio = image.shape[0]/1200 # height
- dim = (int(image.shape[1]/ratio), 1200) # (width, height)
- image = cv2.resize(image, dim, interpolation=cv2.INTER_AREA)
- image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
-
- # create segmentation
- # mybg = cv2.imread('mybg.png')
- comb, segmentation, bg, ori_img = human_seg.run(image, None) # mybg)
- # cv2.imwrite('comb.png',comb) # [0,255]
- # cv2.imwrite('alpha.png',segmentation*255) # segmentation [0,1] --> [0.255]
- # cv2.imwrite('bg.png',bg) #[0,255]
- # cv2.imwrite('ori_img.png',ori_img) # [0,255]
-
- masks_np = (segmentation * 255) # .byte().cpu().numpy() #1024,512,1
- mask0_np = masks_np[:, :, 0].astype(np.uint8) # [0, :, :]
- contours = cv2.findContours(
- mask0_np, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
- cnts = imutils.grab_contours(contours)
- c = max(cnts, key=cv2.contourArea)
- extTop = tuple(c[c[:, :, 1].argmin()][0])
- extBot = tuple(c[c[:, :, 1].argmax()][0])
- extBot = list(extBot)
- extTop = list(extTop)
- pad_range = int((extBot[1]-extTop[1])*0.05)
- # seg mask already reaches to the edge
- if (int(extTop[1]) <= 5 and int(extTop[1]) > 0) and (comb.shape[0] > int(extBot[1]) and int(extBot[1]) >= comb.shape[0]-5):
- # pad with pure white, top 100 px, bottom 100 px
- comb = cv2.copyMakeBorder(
- comb, pad_range+5, pad_range+5, 0, 0, cv2.BORDER_CONSTANT, value=[255, 255, 255])
- elif int(extTop[1]) <= 0 or int(extBot[1]) >= comb.shape[0]:
- print('PAD: body out of boundary', fname) # should not happened
- return {}
- else:
- # 105 instead of 100: give some extra space
- comb = cv2.copyMakeBorder(
- comb, pad_range+5, pad_range+5, 0, 0, cv2.BORDER_REPLICATE)
- extBot[1] = extBot[1] + pad_range+5
- extTop[1] = extTop[1] + pad_range+5
-
- extLeft = tuple(c[c[:, :, 0].argmin()][0])
- extRight = tuple(c[c[:, :, 0].argmax()][0])
- extLeft = list(extLeft)
- extRight = list(extRight)
- person_ymin = int(extTop[1])-pad_range # 100
- person_ymax = int(extBot[1])+pad_range # 100 #height
- if person_ymin < 0 or person_ymax > comb.shape[0]: # out of range
- return {}
- person_xmin = int(extLeft[0])
- person_xmax = int(extRight[0])
- rect = [person_xmin, person_xmax, person_ymin, person_ymax]
- # recimg = copy.deepcopy(comb)
- # cv2.rectangle(recimg,(person_xmin,person_ymin),(person_xmax,person_ymax),(0,255,0),2)
- # cv2.imwrite(f'{args.output_folder}/middle_result/{fname}_rec.png',recimg)
-
- # detect keypoints
- keypoints, subset = body_estimation(comb)
- # print(keypoints, subset, len(subset))
- if len(subset) != 1 or (len(subset) == 1 and subset[0][-1] < 15):
- print(
- f'Processing \'{fname}\'. Please import image contains one person only. Also can check segmentation mask. ')
- continue
-
- # canvas = copy.deepcopy(comb)
- # canvas = util.draw_bodypose(canvas, keypoints, subset, show_number=True)
- # cv2.imwrite(f'{args.output_folder}/middle_result/{fname}_keypoints.png',canvas)
-
- comb = crop_img_with_padding(comb, keypoints, rect)
-
- cv2.imwrite(f'{args.output_folder}/{fname}.png', comb)
- print(f' -- Finished processing \'{fname}\'. --')
- # except:
- # print(f'Processing \'{fname}\'. Not satisfied the alignment strategy.')
-
-
-if __name__ == '__main__':
- torch.backends.cudnn.benchmark = True
- torch.backends.cudnn.deterministic = False
-
- t1 = time.time()
- arg_formatter = argparse.ArgumentDefaultsHelpFormatter
- description = 'StyleGAN-Human data process'
- parser = argparse.ArgumentParser(formatter_class=arg_formatter,
- description=description)
- parser.add_argument('--image-folder', type=str, dest='image_folder')
- parser.add_argument('--output-folder',
- dest='output_folder', default='results', type=str)
- # parser.add_argument('--cfg', dest='cfg for segmentation', default='PP_HumanSeg/export_model/ppseg_lite_portrait_398x224_with_softmax/deploy.yaml', type=str)
-
- print('parsing arguments')
- cmd_args = parser.parse_args()
- run(cmd_args)
-
- print('total time elapsed: ', str(time.time() - t1))
diff --git a/spaces/ECCV2022/bytetrack/tutorials/ctracker/mot_online/kalman_filter.py b/spaces/ECCV2022/bytetrack/tutorials/ctracker/mot_online/kalman_filter.py
deleted file mode 100644
index b4c4e9854d8abd2fea75ad6b1fe8cd6846c43680..0000000000000000000000000000000000000000
--- a/spaces/ECCV2022/bytetrack/tutorials/ctracker/mot_online/kalman_filter.py
+++ /dev/null
@@ -1,269 +0,0 @@
-# vim: expandtab:ts=4:sw=4
-import numpy as np
-import scipy.linalg
-
-"""
-Table for the 0.95 quantile of the chi-square distribution with N degrees of
-freedom (contains values for N=1, ..., 9). Taken from MATLAB/Octave's chi2inv
-function and used as Mahalanobis gating threshold.
-"""
-chi2inv95 = {
- 1: 3.8415,
- 2: 5.9915,
- 3: 7.8147,
- 4: 9.4877,
- 5: 11.070,
- 6: 12.592,
- 7: 14.067,
- 8: 15.507,
- 9: 16.919}
-
-
-class KalmanFilter(object):
- """
- A simple Kalman filter for tracking bounding boxes in image space.
-
- The 8-dimensional state space
-
- x, y, a, h, vx, vy, va, vh
-
- contains the bounding box center position (x, y), aspect ratio a, height h,
- and their respective velocities.
-
- Object motion follows a constant velocity model. The bounding box location
- (x, y, a, h) is taken as direct observation of the state space (linear
- observation model).
-
- """
-
- def __init__(self):
- ndim, dt = 4, 1.
-
- # Create Kalman filter model matrices.
- self._motion_mat = np.eye(2 * ndim, 2 * ndim)
- for i in range(ndim):
- self._motion_mat[i, ndim + i] = dt
- self._update_mat = np.eye(ndim, 2 * ndim)
-
- # Motion and observation uncertainty are chosen relative to the current
- # state estimate. These weights control the amount of uncertainty in
- # the model. This is a bit hacky.
- self._std_weight_position = 1. / 20
- self._std_weight_velocity = 1. / 160
-
- def initiate(self, measurement):
- """Create track from unassociated measurement.
-
- Parameters
- ----------
- measurement : ndarray
- Bounding box coordinates (x, y, a, h) with center position (x, y),
- aspect ratio a, and height h.
-
- Returns
- -------
- (ndarray, ndarray)
- Returns the mean vector (8 dimensional) and covariance matrix (8x8
- dimensional) of the new track. Unobserved velocities are initialized
- to 0 mean.
-
- """
- mean_pos = measurement
- mean_vel = np.zeros_like(mean_pos)
- mean = np.r_[mean_pos, mean_vel]
-
- std = [
- 2 * self._std_weight_position * measurement[3],
- 2 * self._std_weight_position * measurement[3],
- 1e-2,
- 2 * self._std_weight_position * measurement[3],
- 10 * self._std_weight_velocity * measurement[3],
- 10 * self._std_weight_velocity * measurement[3],
- 1e-5,
- 10 * self._std_weight_velocity * measurement[3]]
- covariance = np.diag(np.square(std))
- return mean, covariance
-
- def predict(self, mean, covariance):
- """Run Kalman filter prediction step.
-
- Parameters
- ----------
- mean : ndarray
- The 8 dimensional mean vector of the object state at the previous
- time step.
- covariance : ndarray
- The 8x8 dimensional covariance matrix of the object state at the
- previous time step.
-
- Returns
- -------
- (ndarray, ndarray)
- Returns the mean vector and covariance matrix of the predicted
- state. Unobserved velocities are initialized to 0 mean.
-
- """
- std_pos = [
- self._std_weight_position * mean[3],
- self._std_weight_position * mean[3],
- 1e-2,
- self._std_weight_position * mean[3]]
- std_vel = [
- self._std_weight_velocity * mean[3],
- self._std_weight_velocity * mean[3],
- 1e-5,
- self._std_weight_velocity * mean[3]]
- motion_cov = np.diag(np.square(np.r_[std_pos, std_vel]))
-
- #mean = np.dot(self._motion_mat, mean)
- mean = np.dot(mean, self._motion_mat.T)
- covariance = np.linalg.multi_dot((
- self._motion_mat, covariance, self._motion_mat.T)) + motion_cov
-
- return mean, covariance
-
- def project(self, mean, covariance):
- """Project state distribution to measurement space.
-
- Parameters
- ----------
- mean : ndarray
- The state's mean vector (8 dimensional array).
- covariance : ndarray
- The state's covariance matrix (8x8 dimensional).
-
- Returns
- -------
- (ndarray, ndarray)
- Returns the projected mean and covariance matrix of the given state
- estimate.
-
- """
- std = [
- self._std_weight_position * mean[3],
- self._std_weight_position * mean[3],
- 1e-1,
- self._std_weight_position * mean[3]]
- innovation_cov = np.diag(np.square(std))
-
- mean = np.dot(self._update_mat, mean)
- covariance = np.linalg.multi_dot((
- self._update_mat, covariance, self._update_mat.T))
- return mean, covariance + innovation_cov
-
- def multi_predict(self, mean, covariance):
- """Run Kalman filter prediction step (Vectorized version).
- Parameters
- ----------
- mean : ndarray
- The Nx8 dimensional mean matrix of the object states at the previous
- time step.
- covariance : ndarray
- The Nx8x8 dimensional covariance matrics of the object states at the
- previous time step.
- Returns
- -------
- (ndarray, ndarray)
- Returns the mean vector and covariance matrix of the predicted
- state. Unobserved velocities are initialized to 0 mean.
- """
- std_pos = [
- self._std_weight_position * mean[:, 3],
- self._std_weight_position * mean[:, 3],
- 1e-2 * np.ones_like(mean[:, 3]),
- self._std_weight_position * mean[:, 3]]
- std_vel = [
- self._std_weight_velocity * mean[:, 3],
- self._std_weight_velocity * mean[:, 3],
- 1e-5 * np.ones_like(mean[:, 3]),
- self._std_weight_velocity * mean[:, 3]]
- sqr = np.square(np.r_[std_pos, std_vel]).T
-
- motion_cov = []
- for i in range(len(mean)):
- motion_cov.append(np.diag(sqr[i]))
- motion_cov = np.asarray(motion_cov)
-
- mean = np.dot(mean, self._motion_mat.T)
- left = np.dot(self._motion_mat, covariance).transpose((1, 0, 2))
- covariance = np.dot(left, self._motion_mat.T) + motion_cov
-
- return mean, covariance
-
- def update(self, mean, covariance, measurement):
- """Run Kalman filter correction step.
-
- Parameters
- ----------
- mean : ndarray
- The predicted state's mean vector (8 dimensional).
- covariance : ndarray
- The state's covariance matrix (8x8 dimensional).
- measurement : ndarray
- The 4 dimensional measurement vector (x, y, a, h), where (x, y)
- is the center position, a the aspect ratio, and h the height of the
- bounding box.
-
- Returns
- -------
- (ndarray, ndarray)
- Returns the measurement-corrected state distribution.
-
- """
- projected_mean, projected_cov = self.project(mean, covariance)
-
- chol_factor, lower = scipy.linalg.cho_factor(
- projected_cov, lower=True, check_finite=False)
- kalman_gain = scipy.linalg.cho_solve(
- (chol_factor, lower), np.dot(covariance, self._update_mat.T).T,
- check_finite=False).T
- innovation = measurement - projected_mean
-
- new_mean = mean + np.dot(innovation, kalman_gain.T)
- new_covariance = covariance - np.linalg.multi_dot((
- kalman_gain, projected_cov, kalman_gain.T))
- return new_mean, new_covariance
-
- def gating_distance(self, mean, covariance, measurements,
- only_position=False, metric='maha'):
- """Compute gating distance between state distribution and measurements.
- A suitable distance threshold can be obtained from `chi2inv95`. If
- `only_position` is False, the chi-square distribution has 4 degrees of
- freedom, otherwise 2.
- Parameters
- ----------
- mean : ndarray
- Mean vector over the state distribution (8 dimensional).
- covariance : ndarray
- Covariance of the state distribution (8x8 dimensional).
- measurements : ndarray
- An Nx4 dimensional matrix of N measurements, each in
- format (x, y, a, h) where (x, y) is the bounding box center
- position, a the aspect ratio, and h the height.
- only_position : Optional[bool]
- If True, distance computation is done with respect to the bounding
- box center position only.
- Returns
- -------
- ndarray
- Returns an array of length N, where the i-th element contains the
- squared Mahalanobis distance between (mean, covariance) and
- `measurements[i]`.
- """
- mean, covariance = self.project(mean, covariance)
- if only_position:
- mean, covariance = mean[:2], covariance[:2, :2]
- measurements = measurements[:, :2]
-
- d = measurements - mean
- if metric == 'gaussian':
- return np.sum(d * d, axis=1)
- elif metric == 'maha':
- cholesky_factor = np.linalg.cholesky(covariance)
- z = scipy.linalg.solve_triangular(
- cholesky_factor, d.T, lower=True, check_finite=False,
- overwrite_b=True)
- squared_maha = np.sum(z * z, axis=0)
- return squared_maha
- else:
- raise ValueError('invalid distance metric')
diff --git a/spaces/ELam/text_generator/README.md b/spaces/ELam/text_generator/README.md
deleted file mode 100644
index e1dbfc729db442243e11dff3e677e6f46415251f..0000000000000000000000000000000000000000
--- a/spaces/ELam/text_generator/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Text Generator
-emoji: 💻
-colorFrom: purple
-colorTo: blue
-sdk: gradio
-sdk_version: 3.11.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/EuroPython2022/mmocr-demo/configs/_base_/recog_datasets/academic_test.py b/spaces/EuroPython2022/mmocr-demo/configs/_base_/recog_datasets/academic_test.py
deleted file mode 100644
index 888ab3d3be5b40e15596086d4af567bd37f6ec05..0000000000000000000000000000000000000000
--- a/spaces/EuroPython2022/mmocr-demo/configs/_base_/recog_datasets/academic_test.py
+++ /dev/null
@@ -1,57 +0,0 @@
-# Text Recognition Testing set, including:
-# Regular Datasets: IIIT5K, SVT, IC13
-# Irregular Datasets: IC15, SVTP, CT80
-
-test_root = 'data/mixture'
-
-test_img_prefix1 = f'{test_root}/IIIT5K/'
-test_img_prefix2 = f'{test_root}/svt/'
-test_img_prefix3 = f'{test_root}/icdar_2013/'
-test_img_prefix4 = f'{test_root}/icdar_2015/'
-test_img_prefix5 = f'{test_root}/svtp/'
-test_img_prefix6 = f'{test_root}/ct80/'
-
-test_ann_file1 = f'{test_root}/IIIT5K/test_label.txt'
-test_ann_file2 = f'{test_root}/svt/test_label.txt'
-test_ann_file3 = f'{test_root}/icdar_2013/test_label_1015.txt'
-test_ann_file4 = f'{test_root}/icdar_2015/test_label.txt'
-test_ann_file5 = f'{test_root}/svtp/test_label.txt'
-test_ann_file6 = f'{test_root}/ct80/test_label.txt'
-
-test1 = dict(
- type='OCRDataset',
- img_prefix=test_img_prefix1,
- ann_file=test_ann_file1,
- loader=dict(
- type='AnnFileLoader',
- repeat=1,
- file_format='txt',
- parser=dict(
- type='LineStrParser',
- keys=['filename', 'text'],
- keys_idx=[0, 1],
- separator=' ')),
- pipeline=None,
- test_mode=True)
-
-test2 = {key: value for key, value in test1.items()}
-test2['img_prefix'] = test_img_prefix2
-test2['ann_file'] = test_ann_file2
-
-test3 = {key: value for key, value in test1.items()}
-test3['img_prefix'] = test_img_prefix3
-test3['ann_file'] = test_ann_file3
-
-test4 = {key: value for key, value in test1.items()}
-test4['img_prefix'] = test_img_prefix4
-test4['ann_file'] = test_ann_file4
-
-test5 = {key: value for key, value in test1.items()}
-test5['img_prefix'] = test_img_prefix5
-test5['ann_file'] = test_ann_file5
-
-test6 = {key: value for key, value in test1.items()}
-test6['img_prefix'] = test_img_prefix6
-test6['ann_file'] = test_ann_file6
-
-test_list = [test1, test2, test3, test4, test5, test6]
diff --git a/spaces/EuroSciPy2022/arxiv-cards/get_paperinfo_fromurls.py b/spaces/EuroSciPy2022/arxiv-cards/get_paperinfo_fromurls.py
deleted file mode 100644
index a6b390b7aec96f723cf3d80a16102648bd7e8587..0000000000000000000000000000000000000000
--- a/spaces/EuroSciPy2022/arxiv-cards/get_paperinfo_fromurls.py
+++ /dev/null
@@ -1,20 +0,0 @@
-from arxiv_util import arxiv_url_sanitizer
-from arxiv_util import get_paper_info
-
-def get_paperinfo_fromurls(original_url):
- """
- Returns a dictionary of url entered by user
- and corresponding paper info from arxiv.
- """
- url_paperinfo = {}
- url = arxiv_url_sanitizer(original_url.strip())
- # print("Sanitized url = {}".format(url))
- try:
- paper_info = get_paper_info(url)
- except RuntimeError as e:
- print("[SKIP] Error processing : {}, message : {}".format(url, e))
- pass
- url_paperinfo[original_url] = paper_info
-
- return url_paperinfo
-
diff --git a/spaces/Fedev23/Proyecto_edvai/README.md b/spaces/Fedev23/Proyecto_edvai/README.md
deleted file mode 100644
index ae280029f90a4c88292bdc53197681a562020cd8..0000000000000000000000000000000000000000
--- a/spaces/Fedev23/Proyecto_edvai/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Proyecto Edvai
-emoji: 💻
-colorFrom: gray
-colorTo: green
-sdk: gradio
-sdk_version: 3.45.2
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/FrankZxShen/so-vits-svc-models-pcr/modules/attentions.py b/spaces/FrankZxShen/so-vits-svc-models-pcr/modules/attentions.py
deleted file mode 100644
index f9c11ca4a3acb86bf1abc04d9dcfa82a4ed4061f..0000000000000000000000000000000000000000
--- a/spaces/FrankZxShen/so-vits-svc-models-pcr/modules/attentions.py
+++ /dev/null
@@ -1,349 +0,0 @@
-import copy
-import math
-import numpy as np
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-import modules.commons as commons
-import modules.modules as modules
-from modules.modules import LayerNorm
-
-
-class FFT(nn.Module):
- def __init__(self, hidden_channels, filter_channels, n_heads, n_layers=1, kernel_size=1, p_dropout=0.,
- proximal_bias=False, proximal_init=True, **kwargs):
- super().__init__()
- self.hidden_channels = hidden_channels
- self.filter_channels = filter_channels
- self.n_heads = n_heads
- self.n_layers = n_layers
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.proximal_bias = proximal_bias
- self.proximal_init = proximal_init
-
- self.drop = nn.Dropout(p_dropout)
- self.self_attn_layers = nn.ModuleList()
- self.norm_layers_0 = nn.ModuleList()
- self.ffn_layers = nn.ModuleList()
- self.norm_layers_1 = nn.ModuleList()
- for i in range(self.n_layers):
- self.self_attn_layers.append(
- MultiHeadAttention(hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout, proximal_bias=proximal_bias,
- proximal_init=proximal_init))
- self.norm_layers_0.append(LayerNorm(hidden_channels))
- self.ffn_layers.append(
- FFN(hidden_channels, hidden_channels, filter_channels, kernel_size, p_dropout=p_dropout, causal=True))
- self.norm_layers_1.append(LayerNorm(hidden_channels))
-
- def forward(self, x, x_mask):
- """
- x: decoder input
- h: encoder output
- """
- self_attn_mask = commons.subsequent_mask(x_mask.size(2)).to(device=x.device, dtype=x.dtype)
- x = x * x_mask
- for i in range(self.n_layers):
- y = self.self_attn_layers[i](x, x, self_attn_mask)
- y = self.drop(y)
- x = self.norm_layers_0[i](x + y)
-
- y = self.ffn_layers[i](x, x_mask)
- y = self.drop(y)
- x = self.norm_layers_1[i](x + y)
- x = x * x_mask
- return x
-
-
-class Encoder(nn.Module):
- def __init__(self, hidden_channels, filter_channels, n_heads, n_layers, kernel_size=1, p_dropout=0., window_size=4, **kwargs):
- super().__init__()
- self.hidden_channels = hidden_channels
- self.filter_channels = filter_channels
- self.n_heads = n_heads
- self.n_layers = n_layers
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.window_size = window_size
-
- self.drop = nn.Dropout(p_dropout)
- self.attn_layers = nn.ModuleList()
- self.norm_layers_1 = nn.ModuleList()
- self.ffn_layers = nn.ModuleList()
- self.norm_layers_2 = nn.ModuleList()
- for i in range(self.n_layers):
- self.attn_layers.append(MultiHeadAttention(hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout, window_size=window_size))
- self.norm_layers_1.append(LayerNorm(hidden_channels))
- self.ffn_layers.append(FFN(hidden_channels, hidden_channels, filter_channels, kernel_size, p_dropout=p_dropout))
- self.norm_layers_2.append(LayerNorm(hidden_channels))
-
- def forward(self, x, x_mask):
- attn_mask = x_mask.unsqueeze(2) * x_mask.unsqueeze(-1)
- x = x * x_mask
- for i in range(self.n_layers):
- y = self.attn_layers[i](x, x, attn_mask)
- y = self.drop(y)
- x = self.norm_layers_1[i](x + y)
-
- y = self.ffn_layers[i](x, x_mask)
- y = self.drop(y)
- x = self.norm_layers_2[i](x + y)
- x = x * x_mask
- return x
-
-
-class Decoder(nn.Module):
- def __init__(self, hidden_channels, filter_channels, n_heads, n_layers, kernel_size=1, p_dropout=0., proximal_bias=False, proximal_init=True, **kwargs):
- super().__init__()
- self.hidden_channels = hidden_channels
- self.filter_channels = filter_channels
- self.n_heads = n_heads
- self.n_layers = n_layers
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.proximal_bias = proximal_bias
- self.proximal_init = proximal_init
-
- self.drop = nn.Dropout(p_dropout)
- self.self_attn_layers = nn.ModuleList()
- self.norm_layers_0 = nn.ModuleList()
- self.encdec_attn_layers = nn.ModuleList()
- self.norm_layers_1 = nn.ModuleList()
- self.ffn_layers = nn.ModuleList()
- self.norm_layers_2 = nn.ModuleList()
- for i in range(self.n_layers):
- self.self_attn_layers.append(MultiHeadAttention(hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout, proximal_bias=proximal_bias, proximal_init=proximal_init))
- self.norm_layers_0.append(LayerNorm(hidden_channels))
- self.encdec_attn_layers.append(MultiHeadAttention(hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout))
- self.norm_layers_1.append(LayerNorm(hidden_channels))
- self.ffn_layers.append(FFN(hidden_channels, hidden_channels, filter_channels, kernel_size, p_dropout=p_dropout, causal=True))
- self.norm_layers_2.append(LayerNorm(hidden_channels))
-
- def forward(self, x, x_mask, h, h_mask):
- """
- x: decoder input
- h: encoder output
- """
- self_attn_mask = commons.subsequent_mask(x_mask.size(2)).to(device=x.device, dtype=x.dtype)
- encdec_attn_mask = h_mask.unsqueeze(2) * x_mask.unsqueeze(-1)
- x = x * x_mask
- for i in range(self.n_layers):
- y = self.self_attn_layers[i](x, x, self_attn_mask)
- y = self.drop(y)
- x = self.norm_layers_0[i](x + y)
-
- y = self.encdec_attn_layers[i](x, h, encdec_attn_mask)
- y = self.drop(y)
- x = self.norm_layers_1[i](x + y)
-
- y = self.ffn_layers[i](x, x_mask)
- y = self.drop(y)
- x = self.norm_layers_2[i](x + y)
- x = x * x_mask
- return x
-
-
-class MultiHeadAttention(nn.Module):
- def __init__(self, channels, out_channels, n_heads, p_dropout=0., window_size=None, heads_share=True, block_length=None, proximal_bias=False, proximal_init=False):
- super().__init__()
- assert channels % n_heads == 0
-
- self.channels = channels
- self.out_channels = out_channels
- self.n_heads = n_heads
- self.p_dropout = p_dropout
- self.window_size = window_size
- self.heads_share = heads_share
- self.block_length = block_length
- self.proximal_bias = proximal_bias
- self.proximal_init = proximal_init
- self.attn = None
-
- self.k_channels = channels // n_heads
- self.conv_q = nn.Conv1d(channels, channels, 1)
- self.conv_k = nn.Conv1d(channels, channels, 1)
- self.conv_v = nn.Conv1d(channels, channels, 1)
- self.conv_o = nn.Conv1d(channels, out_channels, 1)
- self.drop = nn.Dropout(p_dropout)
-
- if window_size is not None:
- n_heads_rel = 1 if heads_share else n_heads
- rel_stddev = self.k_channels**-0.5
- self.emb_rel_k = nn.Parameter(torch.randn(n_heads_rel, window_size * 2 + 1, self.k_channels) * rel_stddev)
- self.emb_rel_v = nn.Parameter(torch.randn(n_heads_rel, window_size * 2 + 1, self.k_channels) * rel_stddev)
-
- nn.init.xavier_uniform_(self.conv_q.weight)
- nn.init.xavier_uniform_(self.conv_k.weight)
- nn.init.xavier_uniform_(self.conv_v.weight)
- if proximal_init:
- with torch.no_grad():
- self.conv_k.weight.copy_(self.conv_q.weight)
- self.conv_k.bias.copy_(self.conv_q.bias)
-
- def forward(self, x, c, attn_mask=None):
- q = self.conv_q(x)
- k = self.conv_k(c)
- v = self.conv_v(c)
-
- x, self.attn = self.attention(q, k, v, mask=attn_mask)
-
- x = self.conv_o(x)
- return x
-
- def attention(self, query, key, value, mask=None):
- # reshape [b, d, t] -> [b, n_h, t, d_k]
- b, d, t_s, t_t = (*key.size(), query.size(2))
- query = query.view(b, self.n_heads, self.k_channels, t_t).transpose(2, 3)
- key = key.view(b, self.n_heads, self.k_channels, t_s).transpose(2, 3)
- value = value.view(b, self.n_heads, self.k_channels, t_s).transpose(2, 3)
-
- scores = torch.matmul(query / math.sqrt(self.k_channels), key.transpose(-2, -1))
- if self.window_size is not None:
- assert t_s == t_t, "Relative attention is only available for self-attention."
- key_relative_embeddings = self._get_relative_embeddings(self.emb_rel_k, t_s)
- rel_logits = self._matmul_with_relative_keys(query /math.sqrt(self.k_channels), key_relative_embeddings)
- scores_local = self._relative_position_to_absolute_position(rel_logits)
- scores = scores + scores_local
- if self.proximal_bias:
- assert t_s == t_t, "Proximal bias is only available for self-attention."
- scores = scores + self._attention_bias_proximal(t_s).to(device=scores.device, dtype=scores.dtype)
- if mask is not None:
- scores = scores.masked_fill(mask == 0, -1e4)
- if self.block_length is not None:
- assert t_s == t_t, "Local attention is only available for self-attention."
- block_mask = torch.ones_like(scores).triu(-self.block_length).tril(self.block_length)
- scores = scores.masked_fill(block_mask == 0, -1e4)
- p_attn = F.softmax(scores, dim=-1) # [b, n_h, t_t, t_s]
- p_attn = self.drop(p_attn)
- output = torch.matmul(p_attn, value)
- if self.window_size is not None:
- relative_weights = self._absolute_position_to_relative_position(p_attn)
- value_relative_embeddings = self._get_relative_embeddings(self.emb_rel_v, t_s)
- output = output + self._matmul_with_relative_values(relative_weights, value_relative_embeddings)
- output = output.transpose(2, 3).contiguous().view(b, d, t_t) # [b, n_h, t_t, d_k] -> [b, d, t_t]
- return output, p_attn
-
- def _matmul_with_relative_values(self, x, y):
- """
- x: [b, h, l, m]
- y: [h or 1, m, d]
- ret: [b, h, l, d]
- """
- ret = torch.matmul(x, y.unsqueeze(0))
- return ret
-
- def _matmul_with_relative_keys(self, x, y):
- """
- x: [b, h, l, d]
- y: [h or 1, m, d]
- ret: [b, h, l, m]
- """
- ret = torch.matmul(x, y.unsqueeze(0).transpose(-2, -1))
- return ret
-
- def _get_relative_embeddings(self, relative_embeddings, length):
- max_relative_position = 2 * self.window_size + 1
- # Pad first before slice to avoid using cond ops.
- pad_length = max(length - (self.window_size + 1), 0)
- slice_start_position = max((self.window_size + 1) - length, 0)
- slice_end_position = slice_start_position + 2 * length - 1
- if pad_length > 0:
- padded_relative_embeddings = F.pad(
- relative_embeddings,
- commons.convert_pad_shape([[0, 0], [pad_length, pad_length], [0, 0]]))
- else:
- padded_relative_embeddings = relative_embeddings
- used_relative_embeddings = padded_relative_embeddings[:,slice_start_position:slice_end_position]
- return used_relative_embeddings
-
- def _relative_position_to_absolute_position(self, x):
- """
- x: [b, h, l, 2*l-1]
- ret: [b, h, l, l]
- """
- batch, heads, length, _ = x.size()
- # Concat columns of pad to shift from relative to absolute indexing.
- x = F.pad(x, commons.convert_pad_shape([[0,0],[0,0],[0,0],[0,1]]))
-
- # Concat extra elements so to add up to shape (len+1, 2*len-1).
- x_flat = x.view([batch, heads, length * 2 * length])
- x_flat = F.pad(x_flat, commons.convert_pad_shape([[0,0],[0,0],[0,length-1]]))
-
- # Reshape and slice out the padded elements.
- x_final = x_flat.view([batch, heads, length+1, 2*length-1])[:, :, :length, length-1:]
- return x_final
-
- def _absolute_position_to_relative_position(self, x):
- """
- x: [b, h, l, l]
- ret: [b, h, l, 2*l-1]
- """
- batch, heads, length, _ = x.size()
- # padd along column
- x = F.pad(x, commons.convert_pad_shape([[0, 0], [0, 0], [0, 0], [0, length-1]]))
- x_flat = x.view([batch, heads, length**2 + length*(length -1)])
- # add 0's in the beginning that will skew the elements after reshape
- x_flat = F.pad(x_flat, commons.convert_pad_shape([[0, 0], [0, 0], [length, 0]]))
- x_final = x_flat.view([batch, heads, length, 2*length])[:,:,:,1:]
- return x_final
-
- def _attention_bias_proximal(self, length):
- """Bias for self-attention to encourage attention to close positions.
- Args:
- length: an integer scalar.
- Returns:
- a Tensor with shape [1, 1, length, length]
- """
- r = torch.arange(length, dtype=torch.float32)
- diff = torch.unsqueeze(r, 0) - torch.unsqueeze(r, 1)
- return torch.unsqueeze(torch.unsqueeze(-torch.log1p(torch.abs(diff)), 0), 0)
-
-
-class FFN(nn.Module):
- def __init__(self, in_channels, out_channels, filter_channels, kernel_size, p_dropout=0., activation=None, causal=False):
- super().__init__()
- self.in_channels = in_channels
- self.out_channels = out_channels
- self.filter_channels = filter_channels
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.activation = activation
- self.causal = causal
-
- if causal:
- self.padding = self._causal_padding
- else:
- self.padding = self._same_padding
-
- self.conv_1 = nn.Conv1d(in_channels, filter_channels, kernel_size)
- self.conv_2 = nn.Conv1d(filter_channels, out_channels, kernel_size)
- self.drop = nn.Dropout(p_dropout)
-
- def forward(self, x, x_mask):
- x = self.conv_1(self.padding(x * x_mask))
- if self.activation == "gelu":
- x = x * torch.sigmoid(1.702 * x)
- else:
- x = torch.relu(x)
- x = self.drop(x)
- x = self.conv_2(self.padding(x * x_mask))
- return x * x_mask
-
- def _causal_padding(self, x):
- if self.kernel_size == 1:
- return x
- pad_l = self.kernel_size - 1
- pad_r = 0
- padding = [[0, 0], [0, 0], [pad_l, pad_r]]
- x = F.pad(x, commons.convert_pad_shape(padding))
- return x
-
- def _same_padding(self, x):
- if self.kernel_size == 1:
- return x
- pad_l = (self.kernel_size - 1) // 2
- pad_r = self.kernel_size // 2
- padding = [[0, 0], [0, 0], [pad_l, pad_r]]
- x = F.pad(x, commons.convert_pad_shape(padding))
- return x
diff --git a/spaces/FrankZxShen/vits-fast-finetuning-pcr/text/ngu_dialect.py b/spaces/FrankZxShen/vits-fast-finetuning-pcr/text/ngu_dialect.py
deleted file mode 100644
index ce3e12bbf0469426872eed5f681985d3e1be9b26..0000000000000000000000000000000000000000
--- a/spaces/FrankZxShen/vits-fast-finetuning-pcr/text/ngu_dialect.py
+++ /dev/null
@@ -1,30 +0,0 @@
-import re
-import opencc
-
-
-dialects = {'SZ': 'suzhou', 'WX': 'wuxi', 'CZ': 'changzhou', 'HZ': 'hangzhou',
- 'SX': 'shaoxing', 'NB': 'ningbo', 'JJ': 'jingjiang', 'YX': 'yixing',
- 'JD': 'jiading', 'ZR': 'zhenru', 'PH': 'pinghu', 'TX': 'tongxiang',
- 'JS': 'jiashan', 'HN': 'xiashi', 'LP': 'linping', 'XS': 'xiaoshan',
- 'FY': 'fuyang', 'RA': 'ruao', 'CX': 'cixi', 'SM': 'sanmen',
- 'TT': 'tiantai', 'WZ': 'wenzhou', 'SC': 'suichang', 'YB': 'youbu'}
-
-converters = {}
-
-for dialect in dialects.values():
- try:
- converters[dialect] = opencc.OpenCC(dialect)
- except:
- pass
-
-
-def ngu_dialect_to_ipa(text, dialect):
- dialect = dialects[dialect]
- text = converters[dialect].convert(text).replace('-','').replace('$',' ')
- text = re.sub(r'[、；：]', '，', text)
- text = re.sub(r'\s*，\s*', ', ', text)
- text = re.sub(r'\s*。\s*', '. ', text)
- text = re.sub(r'\s*？\s*', '? ', text)
- text = re.sub(r'\s*！\s*', '! ', text)
- text = re.sub(r'\s*$', '', text)
- return text
diff --git a/spaces/Frankapp/bingai/README.md b/spaces/Frankapp/bingai/README.md
deleted file mode 100644
index 0669f78d79e236c82ce10da1a431e04ecef25ed4..0000000000000000000000000000000000000000
--- a/spaces/Frankapp/bingai/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Bingai
-emoji: 📚
-colorFrom: yellow
-colorTo: pink
-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/Gen-Sim/Gen-Sim/misc/__init__.py b/spaces/Gen-Sim/Gen-Sim/misc/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/GitHunter0/100_prisoners_problem_app/functions/module_project_specific_functions.py b/spaces/GitHunter0/100_prisoners_problem_app/functions/module_project_specific_functions.py
deleted file mode 100644
index ba862a52bd44bb732d036248b54573a2c824e076..0000000000000000000000000000000000000000
--- a/spaces/GitHunter0/100_prisoners_problem_app/functions/module_project_specific_functions.py
+++ /dev/null
@@ -1,347 +0,0 @@
-import numpy as np
-
-
-
-#%%% f_streamlit_hide_menu_and_marks
-def f_streamlit_hide_menu_and_marks():
- '''
- # Hide Hamburger Menu and Streamlit logo 'Made with Streamlit'
- '''
- import streamlit as st
-
- hide_menu_footer = """
-
- """
- st.markdown(hide_menu_footer, unsafe_allow_html=True)
-
-
-#%%% f_streamlit_customize_page
-def f_streamlit_customize_page(
- margin_top = "",
- padding_top = "",
- margin_left = "",
- padding_left = ""
-):
-
- import streamlit as st
-
- st_style = f"""
-
- """
- st.markdown(st_style, unsafe_allow_html=True)
-
-
-#%% f_100_prisoners_game_get_random_strategy_probability
-def f_100_prisoners_game_get_random_strategy_probability(
- n_prisoners = 6
-):
-
- "Get the Probability of the Random Strategy for the 100 Prisoners Problem."
-
- # Converges to 0 (zero)
- theoretical_probability = (1/2)**n_prisoners
-
- return 100*theoretical_probability
-#
-#
-# Tests
-if False:
- f_100_prisoners_game_get_random_strategy_probability(2)
- f_100_prisoners_game_get_random_strategy_probability(4)
- f_100_prisoners_game_get_random_strategy_probability(6)
- f_100_prisoners_game_get_random_strategy_probability(100)
- f_100_prisoners_game_get_random_strategy_probability(10000)
-
-
-
-#%% f_100_prisoners_game_get_cf_strategy_probability
-def f_100_prisoners_game_get_cf_strategy_probability(
- n_prisoners = 6
-):
-
- "Get the Probability of the Cycle-Following (Optimal) Strategy for the 100 Prisoners Problem."
-
- import numpy as np
-
- def f_HN(n):
- "Generate n-th Harmonic Number."
- return np.sum(1/np.arange(1,n+1))
-
- # Converges to 0.30685
- theoretical_probability = 1 - (f_HN(n_prisoners) - f_HN(n_prisoners/2))
-
- return 100*theoretical_probability
-#
-#
-# Tests
-if False:
- f_100_prisoners_game_get_cf_strategy_probability(2)
- f_100_prisoners_game_get_cf_strategy_probability(4)
- f_100_prisoners_game_get_cf_strategy_probability(6)
- f_100_prisoners_game_get_cf_strategy_probability(100)
- f_100_prisoners_game_get_cf_strategy_probability(10000)
-
-
-
-
-
-#%% f_100_prisoners_game_simulate_random_strategy
-def f_100_prisoners_game_simulate_random_strategy(
- n_prisoners = 6,
- n_games = 5, # number of samples (games played)
- display_level = [None, "SHORT", "ALL"][0],
- log_path = None
-):
-
- "Random Strategy for the 100 Prisoners Problem."
-
- # 100 prisoners Game problem:
- # https://en.wikipedia.org/wiki/100_prisoners_problem
-
- import numpy as np
- from loguru import logger
- import sys
- import os
-
- if display_level is None:
- level = "CRITICAL"
- if display_level=="SHORT":
- level = "INFO",
- if display_level=="ALL" :
- level = "TRACE"
-
- logger.remove()
-
- if (log_path != None):
-
- try:
- os.remove(log_path)
- except Exception:
- pass
-
- logger.add(log_path, format="{message}", level=level)
- # logger.debug(f"Log Path: {log_path}")
-
- else:
- logger.add(sys.stderr, format="{message}", level=level)
-
- n_prisoners = n_prisoners
- prisoners_numbers = [*range(n_prisoners)] # starts at 0
- n_games = n_games
- max_box_open = round(n_prisoners/2) # round to make it integer
-
- logger.debug("-------------------------------------------------------")
- logger.debug("100 PRISONERS PROBLEM - GAMES SIMULATION")
- logger.debug(f"Random Strategy")
- logger.debug(f"Prisoners: {n_prisoners}")
- logger.debug(f"Games Played (number of simulations): {n_games}")
-
- n_game_success = 0
- for game in range(1, n_games+1):
-
- logger.debug("-------------------------------------------------------")
- logger.debug(f"Game: {game}")
-
- # If you want to get reproducible results
- # np.random.seed(game)
- boxes_numbers = np.random.choice(prisoners_numbers, size=n_prisoners,
- replace=False)
- boxes_dict = {k: v for k, v in enumerate(boxes_numbers)}
- logger.debug(f"{{Box Number: Prisoner Number}} -> {boxes_dict}")
-
- n_prisoner_success = 0
- for prisoner_num in prisoners_numbers:
-
- logger.debug("--")
- logger.debug(f"Prisoner Number: {prisoner_num}")
-
- prisoner_choice_sequence = \
- np.random.choice(boxes_numbers, size=max_box_open,
- replace=False)
-
- logger.debug(f"Prisoner Box Choice Sequence: " + \
- f"{prisoner_choice_sequence}")
-
- box_revealed_sequence = boxes_numbers[prisoner_choice_sequence]
-
- logger.debug(f"Prisoner Revealed Number Sequence: " + \
- f"{box_revealed_sequence}")
-
- success = prisoner_num in box_revealed_sequence
- logger.debug(f"Success: {success}")
-
- if success:
- n_prisoner_success = n_prisoner_success + 1
-
- logger.debug("--")
- logger.debug("Prisoners' Success: " + \
- f"{n_prisoner_success}/{n_prisoners}")
- #
- if n_prisoner_success == n_prisoners:
- n_game_success = n_game_success + 1
-
- logger.debug("\n---------------------------------------------------------")
- logger.info(f"Prisoners: {n_prisoners}")
- logger.info(f"Games Played: {n_games}")
- logger.info(f"Successful Games = {n_game_success}")
- success_rate = round(100*n_game_success/n_games, 1)
- logger.info(
- "Simulated Probability of Winning the Game (Success Rate) = " + \
- f"% {success_rate}"
- )
- logger.debug("---------------------------------------------------------")
-
- return success_rate
-#
-#
-# Test
-if False:
- #
- f_100_prisoners_game_simulate_random_strategy(
- n_prisoners = 4,
- n_games = 5,
- log_path = None,
- display_level = ["ALL", "SHORT", None][0]
- )
- #
- f_100_prisoners_game_simulate_random_strategy(
- n_prisoners = 6,
- n_games = 100,
- log_path = None,
- display_level = None
- )
-
-
-
-
-#%% f_100_prisoners_game_simulate_cf_strategy
-def f_100_prisoners_game_simulate_cf_strategy(
- n_prisoners = 6,
- n_games = 5, # number of samples (games played)
- display_level = [None, "SHORT", "ALL"][0],
- log_path = None
-):
-
- "Cycle-Following (Optimal) Strategy for the 100 Prisoners Problem."
-
- # 100 prisoners Game problem:
- # https://en.wikipedia.org/wiki/100_prisoners_problem
-
- import numpy as np
- from loguru import logger
- import sys
- import os
-
- if display_level is None:
- level = "CRITICAL"
- if display_level=="SHORT":
- level = "INFO",
- if display_level=="ALL" :
- level = "TRACE"
-
- logger.remove()
-
- if (log_path != None):
-
- try:
- os.remove(log_path)
- except Exception:
- pass
-
- logger.add(log_path, format="{message}", level=level)
- # logger.debug(f"Log Path: {log_path}")
-
- else:
- logger.add(sys.stderr, format="{message}", level=level)
-
- n_prisoners = n_prisoners
- prisoners_numbers = [*range(n_prisoners)] # starts at 0
- n_games = n_games
- n_game_success = 0
- max_box_open = n_prisoners/2
-
- logger.debug("-------------------------------------------------------")
- logger.debug("100 PRISONERS PROBLEM - GAMES SIMULATION")
- logger.debug("Cycle-Following (Optimal) Strategy")
- logger.debug(f"Prisoners: {n_prisoners}")
- logger.debug(f"Games Played (number of simulations): {n_games}")
-
- for game in range(1, n_games+1):
-
- logger.debug("-------------------------------------------------------")
- logger.debug(f"Game: {game}")
-
- # If you want to get reproducible results
- # np.random.seed(game)
- boxes_numbers = np.random.choice(prisoners_numbers, size=n_prisoners,
- replace=False)
- boxes_dict = {k: v for k, v in enumerate(boxes_numbers)}
- logger.debug(f"{{Box Number: Prisoner Number}} -> {boxes_dict}")
-
- n_prisoner_success = 0
- for prisoner_num in prisoners_numbers:
- logger.debug("--")
- logger.debug(f"Prisoner Number: {prisoner_num}")
- box_chosen_num = prisoner_num
- n_box_open = 1
- while n_box_open <= max_box_open:
- n_box_open = n_box_open + 1
- box_revealed_num = boxes_numbers[box_chosen_num]
- logger.debug(f"Box Chosen Number: {box_chosen_num}")
- logger.debug(f"Box Revealed Number: {box_revealed_num}")
- success = box_revealed_num == prisoner_num
- if success:
- n_prisoner_success = n_prisoner_success + 1
- logger.debug(f"Success: {success}")
- break
- else:
- box_chosen_num = box_revealed_num
- continue
- else:
- logger.debug(f"Success: {success}")
- logger.debug("--")
- logger.debug("Prisoners' Success: " + \
- f"{n_prisoner_success}/{n_prisoners}")
- #
- if n_prisoner_success == n_prisoners:
- n_game_success = n_game_success + 1
-
- logger.debug("\n---------------------------------------------------------")
- logger.info(f"Prisoners: {n_prisoners}")
- logger.info(f"Games Played: {n_games}")
- logger.info(f"Successful Games = {n_game_success}")
- success_rate = round(100*n_game_success/n_games, 1)
- logger.info(
- "Simulated Probability of Winning the Game (Success Rate) = " + \
- f"% {success_rate}"
- )
- logger.debug("---------------------------------------------------------")
-
- return success_rate
-#
-#
-# Test
-if False:
- f_100_prisoners_game_simulate_cf_strategy(
- n_prisoners = 6,
- n_games = 5,
- log_path = None,
- display_level = "ALL"
- )
-
-
-
-
-#%% _______________________________________________________
-
-
\ No newline at end of file
diff --git a/spaces/Gradio-Blocks/uniformer_image_detection/configs/vfnet/vfnet_r101_fpn_mstrain_2x_coco.py b/spaces/Gradio-Blocks/uniformer_image_detection/configs/vfnet/vfnet_r101_fpn_mstrain_2x_coco.py
deleted file mode 100644
index be7f075fea00a4570d50fd30f1685139b70a8bb6..0000000000000000000000000000000000000000
--- a/spaces/Gradio-Blocks/uniformer_image_detection/configs/vfnet/vfnet_r101_fpn_mstrain_2x_coco.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './vfnet_r50_fpn_mstrain_2x_coco.py'
-model = dict(pretrained='torchvision://resnet101', backbone=dict(depth=101))
diff --git a/spaces/Gradio-Blocks/uniformer_image_detection/mmdet/datasets/deepfashion.py b/spaces/Gradio-Blocks/uniformer_image_detection/mmdet/datasets/deepfashion.py
deleted file mode 100644
index 1125376091f2d4ee6843ae4f2156b3b0453be369..0000000000000000000000000000000000000000
--- a/spaces/Gradio-Blocks/uniformer_image_detection/mmdet/datasets/deepfashion.py
+++ /dev/null
@@ -1,10 +0,0 @@
-from .builder import DATASETS
-from .coco import CocoDataset
-
-
-@DATASETS.register_module()
-class DeepFashionDataset(CocoDataset):
-
- CLASSES = ('top', 'skirt', 'leggings', 'dress', 'outer', 'pants', 'bag',
- 'neckwear', 'headwear', 'eyeglass', 'belt', 'footwear', 'hair',
- 'skin', 'face')
diff --git a/spaces/Gradio-Blocks/uniformer_image_segmentation/configs/fp16/deeplabv3plus_r101-d8_512x1024_80k_fp16_cityscapes.py b/spaces/Gradio-Blocks/uniformer_image_segmentation/configs/fp16/deeplabv3plus_r101-d8_512x1024_80k_fp16_cityscapes.py
deleted file mode 100644
index eaf569d4d76af2e498c039899c01f9960b1158d9..0000000000000000000000000000000000000000
--- a/spaces/Gradio-Blocks/uniformer_image_segmentation/configs/fp16/deeplabv3plus_r101-d8_512x1024_80k_fp16_cityscapes.py
+++ /dev/null
@@ -1,5 +0,0 @@
-_base_ = '../deeplabv3plus/deeplabv3plus_r101-d8_512x1024_80k_cityscapes.py'
-# fp16 settings
-optimizer_config = dict(type='Fp16OptimizerHook', loss_scale=512.)
-# fp16 placeholder
-fp16 = dict()
diff --git a/spaces/Gradio-Blocks/video_nca/app.py b/spaces/Gradio-Blocks/video_nca/app.py
deleted file mode 100644
index d6f8afc0c8743df55959a8b340d2a7b88a0b6792..0000000000000000000000000000000000000000
--- a/spaces/Gradio-Blocks/video_nca/app.py
+++ /dev/null
@@ -1,140 +0,0 @@
-import gradio as gr
-import os, glob
-from functools import partial
-import glob
-import torch
-from torch import nn
-from PIL import Image
-import numpy as np
-
-device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
-
-class RuleCA(nn.Module):
- def __init__(self, hidden_n=6, rule_channels=4, zero_w2=True, device=device):
- super().__init__()
- # The hard-coded filters:
- self.filters = torch.stack([torch.tensor([[0.0,0.0,0.0],[0.0,1.0,0.0],[0.0,0.0,0.0]]),
- torch.tensor([[-1.0,0.0,1.0],[-2.0,0.0,2.0],[-1.0,0.0,1.0]]),
- torch.tensor([[-1.0,0.0,1.0],[-2.0,0.0,2.0],[-1.0,0.0,1.0]]).T,
- torch.tensor([[1.0,2.0,1.0],[2.0,-12,2.0],[1.0,2.0,1.0]])]).to(device)
- self.chn = 4
- self.rule_channels = rule_channels
- self.w1 = nn.Conv2d(4*4+rule_channels, hidden_n, 1).to(device)
- self.relu = nn.ReLU()
- self.w2 = nn.Conv2d(hidden_n, 4, 1, bias=False).to(device)
- if zero_w2:
- self.w2.weight.data.zero_()
- self.device = device
-
- def perchannel_conv(self, x, filters):
- '''filters: [filter_n, h, w]'''
- b, ch, h, w = x.shape
- y = x.reshape(b*ch, 1, h, w)
- y = torch.nn.functional.pad(y, [1, 1, 1, 1], 'circular')
- y = torch.nn.functional.conv2d(y, filters[:,None])
- return y.reshape(b, -1, h, w)
-
- def forward(self, x, rule=0, update_rate=0.5):
- b, ch, xsz, ysz = x.shape
- rule_grid = torch.zeros(b, self.rule_channels, xsz, ysz).to(self.device)
- rule_grid[:,rule] = 1
- y = self.perchannel_conv(x, self.filters) # Apply the filters
- y = torch.cat([y, rule_grid], dim=1)
- y = self.w2(self.relu(self.w1(y))) # pass the result through out 'brain'
- b, c, h, w = y.shape
- update_mask = (torch.rand(b, 1, h, w).to(self.device)+update_rate).floor()
- return x+y*update_mask
-
- def forward_w_rule_grid(self, x, rule_grid, update_rate=0.5):
- y = self.perchannel_conv(x, self.filters) # Apply the filters
- y = torch.cat([y, rule_grid], dim=1)
- y = self.w2(self.relu(self.w1(y))) # pass the result through out 'brain'
- b, c, h, w = y.shape
- update_mask = (torch.rand(b, 1, h, w).to(self.device)+update_rate).floor()
- return x+y*update_mask
-
- def to_rgb(self, x):
- # TODO: rename this to_rgb & explain
- return x[...,:3,:,:]+0.5
-
- def seed(self, n, sz=128):
- """Initializes n 'grids', size sz. In this case all 0s."""
- return torch.zeros(n, self.chn, sz, sz).to(self.device)
-
-def to_frames(video_file):
- os.system('rm -r guide_frames;mkdir guide_frames')
- os.system(f"ffmpeg -i {video_file} guide_frames/%04d.jpg")
-
-def update(preset, enhance, scale2x, video_file):
-
- # Load presets
- ca = RuleCA(hidden_n=32, rule_channels=3)
- ca_fn = ''
- if preset == 'Glowing Crystals':
- ca_fn = 'glowing_crystals.pt'
- elif preset == 'Rainbow Diamonds':
- ca_fn = 'rainbow_diamonds.pt'
- elif preset == 'Dark Diamonds':
- ca_fn = 'dark_diamonds.pt'
- elif preset == 'Dragon Scales':
- ca = RuleCA(hidden_n=16, rule_channels=3)
- ca_fn = 'dragon_scales.pt'
-
- ca.load_state_dict(torch.load(ca_fn, map_location=device))
-
- # Get video frames
- to_frames(video_file)
-
- size=(426, 240)
- vid_size = Image.open(f'guide_frames/0001.jpg').size
- if vid_size[0]>vid_size[1]: # Change < to > if larger side should be capped at 256px
- size = (256, int(256*(vid_size[1]/vid_size[0])))
- else:
- size = (int(256*(vid_size[0]/vid_size[1])), 256)
- if scale2x:
- size = (size[0]*2, size[1]*2)
-
- # Starting grid
- x = torch.zeros(1, 4, size[1], size[0]).to(ca.device)
- os.system("rm -r steps;mkdir steps")
- for i in range(2*len(glob.glob('guide_frames/*.jpg'))-1):
- # load frame
- im = Image.open(f'guide_frames/{i//2+1:04}.jpg').resize(size)
-
- # make rule grid
- rule_grid = torch.tensor(np.array(im)/255).permute(2, 0, 1).unsqueeze(0).to(ca.device)
- if enhance:
- rule_grid = rule_grid * 2 - 0.3 # Add * 2 - 0.3 to 'enhance' an effect
-
- # Apply the updates
- with torch.no_grad():
- x = ca.forward_w_rule_grid(x, rule_grid.float())
- if i%2==0:
- img = ca.to_rgb(x).detach().cpu().clip(0, 1).squeeze().permute(1, 2, 0)
- img = Image.fromarray(np.array(img*255).astype(np.uint8))
- img.save(f'steps/{i//2:05}.jpeg')
-
- # Write output video from saved frames
- os.system("ffmpeg -y -v 0 -framerate 24 -i steps/%05d.jpeg video.mp4")
- return 'video.mp4'
-
-
-demo = gr.Blocks()
-
-with demo:
- gr.Markdown("Choose a preset below, upload a video and then click **Run** to see the output. Read [this report](https://wandb.ai/johnowhitaker/nca/reports/Fun-with-Neural-Cellular-Automata--VmlldzoyMDQ5Mjg0) for background on this project, or check out my [AI art course](https://github.com/johnowhitaker/aiaiart) for an in-depth lesson on Neural Cellular Automata like this.")
- with gr.Row():
- preset = gr.Dropdown(['Glowing Crystals', 'Rainbow Diamonds', 'Dark Diamonds', 'Dragon Scales'], label='Preset')
- with gr.Column():
- enhance = gr.Checkbox(label='Rescale inputs (more extreme results)')
- scale2x = gr.Checkbox(label='Larger output (slower)')
- with gr.Row():
- inp = gr.Video(format='mp4', source='upload', label="Input video (ideally <30s)")
- out = gr.Video(label="Output")
- btn = gr.Button("Run")
- btn.click(fn=update, inputs=[preset, enhance, scale2x, inp], outputs=out)
-
- with gr.Row():
- gr.Markdown("")
-
-demo.launch(enable_queue=True)
\ No newline at end of file
diff --git a/spaces/GrandaddyShmax/AudioCraft_Plus/audiocraft/solvers/compression.py b/spaces/GrandaddyShmax/AudioCraft_Plus/audiocraft/solvers/compression.py
deleted file mode 100644
index b757503472a3bfbf90e1636999e64913848a7474..0000000000000000000000000000000000000000
--- a/spaces/GrandaddyShmax/AudioCraft_Plus/audiocraft/solvers/compression.py
+++ /dev/null
@@ -1,328 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-import logging
-import multiprocessing
-from pathlib import Path
-import typing as tp
-
-import flashy
-import omegaconf
-import torch
-from torch import nn
-
-from . import base, builders
-from .. import models, quantization
-from ..utils import checkpoint
-from ..utils.samples.manager import SampleManager
-from ..utils.utils import get_pool_executor
-
-
-logger = logging.getLogger(__name__)
-
-
-class CompressionSolver(base.StandardSolver):
- """Solver for compression task.
-
- The compression task combines a set of perceptual and objective losses
- to train an EncodecModel (composed of an encoder-decoder and a quantizer)
- to perform high fidelity audio reconstruction.
- """
- def __init__(self, cfg: omegaconf.DictConfig):
- super().__init__(cfg)
- self.rng: torch.Generator # set at each epoch
- self.adv_losses = builders.get_adversarial_losses(self.cfg)
- self.aux_losses = nn.ModuleDict()
- self.info_losses = nn.ModuleDict()
- assert not cfg.fsdp.use, "FSDP not supported by CompressionSolver."
- loss_weights = dict()
- for loss_name, weight in self.cfg.losses.items():
- if loss_name in ['adv', 'feat']:
- for adv_name, _ in self.adv_losses.items():
- loss_weights[f'{loss_name}_{adv_name}'] = weight
- elif weight > 0:
- self.aux_losses[loss_name] = builders.get_loss(loss_name, self.cfg)
- loss_weights[loss_name] = weight
- else:
- self.info_losses[loss_name] = builders.get_loss(loss_name, self.cfg)
- self.balancer = builders.get_balancer(loss_weights, self.cfg.balancer)
- self.register_stateful('adv_losses')
-
- @property
- def best_metric_name(self) -> tp.Optional[str]:
- # best model is the last for the compression model
- return None
-
- def build_model(self):
- """Instantiate model and optimizer."""
- # Model and optimizer
- self.model = models.builders.get_compression_model(self.cfg).to(self.device)
- self.optimizer = builders.get_optimizer(self.model.parameters(), self.cfg.optim)
- self.register_stateful('model', 'optimizer')
- self.register_best_state('model')
- self.register_ema('model')
-
- def build_dataloaders(self):
- """Instantiate audio dataloaders for each stage."""
- self.dataloaders = builders.get_audio_datasets(self.cfg)
-
- def show(self):
- """Show the compression model and employed adversarial loss."""
- self.logger.info(f"Compression model with {self.model.quantizer.total_codebooks} codebooks:")
- self.log_model_summary(self.model)
- self.logger.info("Adversarial loss:")
- self.log_model_summary(self.adv_losses)
- self.logger.info("Auxiliary losses:")
- self.logger.info(self.aux_losses)
- self.logger.info("Info losses:")
- self.logger.info(self.info_losses)
-
- def run_step(self, idx: int, batch: torch.Tensor, metrics: dict):
- """Perform one training or valid step on a given batch."""
- x = batch.to(self.device)
- y = x.clone()
-
- qres = self.model(x)
- assert isinstance(qres, quantization.QuantizedResult)
- y_pred = qres.x
- # Log bandwidth in kb/s
- metrics['bandwidth'] = qres.bandwidth.mean()
-
- if self.is_training:
- d_losses: dict = {}
- if len(self.adv_losses) > 0 and torch.rand(1, generator=self.rng).item() <= 1 / self.cfg.adversarial.every:
- for adv_name, adversary in self.adv_losses.items():
- disc_loss = adversary.train_adv(y_pred, y)
- d_losses[f'd_{adv_name}'] = disc_loss
- metrics['d_loss'] = torch.sum(torch.stack(list(d_losses.values())))
- metrics.update(d_losses)
-
- balanced_losses: dict = {}
- other_losses: dict = {}
-
- # penalty from quantization
- if qres.penalty is not None and qres.penalty.requires_grad:
- other_losses['penalty'] = qres.penalty # penalty term from the quantizer
-
- # adversarial losses
- for adv_name, adversary in self.adv_losses.items():
- adv_loss, feat_loss = adversary(y_pred, y)
- balanced_losses[f'adv_{adv_name}'] = adv_loss
- balanced_losses[f'feat_{adv_name}'] = feat_loss
-
- # auxiliary losses
- for loss_name, criterion in self.aux_losses.items():
- loss = criterion(y_pred, y)
- balanced_losses[loss_name] = loss
-
- # weighted losses
- metrics.update(balanced_losses)
- metrics.update(other_losses)
- metrics.update(qres.metrics)
-
- if self.is_training:
- # backprop losses that are not handled by balancer
- other_loss = torch.tensor(0., device=self.device)
- if 'penalty' in other_losses:
- other_loss += other_losses['penalty']
- if other_loss.requires_grad:
- other_loss.backward(retain_graph=True)
- ratio1 = sum(p.grad.data.norm(p=2).pow(2)
- for p in self.model.parameters() if p.grad is not None)
- assert isinstance(ratio1, torch.Tensor)
- metrics['ratio1'] = ratio1.sqrt()
-
- # balancer losses backward, returns effective training loss
- # with effective weights at the current batch.
- metrics['g_loss'] = self.balancer.backward(balanced_losses, y_pred)
- # add metrics corresponding to weight ratios
- metrics.update(self.balancer.metrics)
- ratio2 = sum(p.grad.data.norm(p=2).pow(2)
- for p in self.model.parameters() if p.grad is not None)
- assert isinstance(ratio2, torch.Tensor)
- metrics['ratio2'] = ratio2.sqrt()
-
- # optim
- flashy.distrib.sync_model(self.model)
- if self.cfg.optim.max_norm:
- torch.nn.utils.clip_grad_norm_(
- self.model.parameters(), self.cfg.optim.max_norm
- )
- self.optimizer.step()
- self.optimizer.zero_grad()
-
- # informative losses only
- info_losses: dict = {}
- with torch.no_grad():
- for loss_name, criterion in self.info_losses.items():
- loss = criterion(y_pred, y)
- info_losses[loss_name] = loss
-
- metrics.update(info_losses)
-
- # aggregated GAN losses: this is useful to report adv and feat across different adversarial loss setups
- adv_losses = [loss for loss_name, loss in metrics.items() if loss_name.startswith('adv')]
- if len(adv_losses) > 0:
- metrics['adv'] = torch.sum(torch.stack(adv_losses))
- feat_losses = [loss for loss_name, loss in metrics.items() if loss_name.startswith('feat')]
- if len(feat_losses) > 0:
- metrics['feat'] = torch.sum(torch.stack(feat_losses))
-
- return metrics
-
- def run_epoch(self):
- # reset random seed at the beginning of the epoch
- self.rng = torch.Generator()
- self.rng.manual_seed(1234 + self.epoch)
- # run epoch
- super().run_epoch()
-
- def evaluate(self):
- """Evaluate stage. Runs audio reconstruction evaluation."""
- self.model.eval()
- evaluate_stage_name = str(self.current_stage)
-
- loader = self.dataloaders['evaluate']
- updates = len(loader)
- lp = self.log_progress(f'{evaluate_stage_name} inference', loader, total=updates, updates=self.log_updates)
- average = flashy.averager()
-
- pendings = []
- ctx = multiprocessing.get_context('spawn')
- with get_pool_executor(self.cfg.evaluate.num_workers, mp_context=ctx) as pool:
- for idx, batch in enumerate(lp):
- x = batch.to(self.device)
- with torch.no_grad():
- qres = self.model(x)
-
- y_pred = qres.x.cpu()
- y = batch.cpu() # should already be on CPU but just in case
- pendings.append(pool.submit(evaluate_audio_reconstruction, y_pred, y, self.cfg))
-
- metrics_lp = self.log_progress(f'{evaluate_stage_name} metrics', pendings, updates=self.log_updates)
- for pending in metrics_lp:
- metrics = pending.result()
- metrics = average(metrics)
-
- metrics = flashy.distrib.average_metrics(metrics, len(loader))
- return metrics
-
- def generate(self):
- """Generate stage."""
- self.model.eval()
- sample_manager = SampleManager(self.xp, map_reference_to_sample_id=True)
- generate_stage_name = str(self.current_stage)
-
- loader = self.dataloaders['generate']
- updates = len(loader)
- lp = self.log_progress(generate_stage_name, loader, total=updates, updates=self.log_updates)
-
- for batch in lp:
- reference, _ = batch
- reference = reference.to(self.device)
- with torch.no_grad():
- qres = self.model(reference)
- assert isinstance(qres, quantization.QuantizedResult)
-
- reference = reference.cpu()
- estimate = qres.x.cpu()
- sample_manager.add_samples(estimate, self.epoch, ground_truth_wavs=reference)
-
- flashy.distrib.barrier()
-
- def load_from_pretrained(self, name: str) -> dict:
- model = models.CompressionModel.get_pretrained(name)
- if isinstance(model, models.DAC):
- raise RuntimeError("Cannot fine tune a DAC model.")
- elif isinstance(model, models.HFEncodecCompressionModel):
- self.logger.warning('Trying to automatically convert a HuggingFace model '
- 'to AudioCraft, this might fail!')
- state = model.model.state_dict()
- new_state = {}
- for k, v in state.items():
- if k.startswith('decoder.layers') and '.conv.' in k and '.block.' not in k:
- # We need to determine if this a convtr or a regular conv.
- layer = int(k.split('.')[2])
- if isinstance(model.model.decoder.layers[layer].conv, torch.nn.ConvTranspose1d):
-
- k = k.replace('.conv.', '.convtr.')
- k = k.replace('encoder.layers.', 'encoder.model.')
- k = k.replace('decoder.layers.', 'decoder.model.')
- k = k.replace('conv.', 'conv.conv.')
- k = k.replace('convtr.', 'convtr.convtr.')
- k = k.replace('quantizer.layers.', 'quantizer.vq.layers.')
- k = k.replace('.codebook.', '._codebook.')
- new_state[k] = v
- state = new_state
- elif isinstance(model, models.EncodecModel):
- state = model.state_dict()
- else:
- raise RuntimeError(f"Cannot fine tune model type {type(model)}.")
- return {
- 'best_state': {'model': state}
- }
-
- @staticmethod
- def model_from_checkpoint(checkpoint_path: tp.Union[Path, str],
- device: tp.Union[torch.device, str] = 'cpu') -> models.CompressionModel:
- """Instantiate a CompressionModel from a given checkpoint path or dora sig.
- This method is a convenient endpoint to load a CompressionModel to use in other solvers.
-
- Args:
- checkpoint_path (Path or str): Path to checkpoint or dora sig from where the checkpoint is resolved.
- This also supports pre-trained models by using a path of the form //pretrained/NAME.
- See `model_from_pretrained` for a list of supported pretrained models.
- use_ema (bool): Use EMA variant of the model instead of the actual model.
- device (torch.device or str): Device on which the model is loaded.
- """
- checkpoint_path = str(checkpoint_path)
- if checkpoint_path.startswith('//pretrained/'):
- name = checkpoint_path.split('/', 3)[-1]
- return models.CompressionModel.get_pretrained(name, device)
- logger = logging.getLogger(__name__)
- logger.info(f"Loading compression model from checkpoint: {checkpoint_path}")
- _checkpoint_path = checkpoint.resolve_checkpoint_path(checkpoint_path, use_fsdp=False)
- assert _checkpoint_path is not None, f"Could not resolve compression model checkpoint path: {checkpoint_path}"
- state = checkpoint.load_checkpoint(_checkpoint_path)
- assert state is not None and 'xp.cfg' in state, f"Could not load compression model from ckpt: {checkpoint_path}"
- cfg = state['xp.cfg']
- cfg.device = device
- compression_model = models.builders.get_compression_model(cfg).to(device)
- assert compression_model.sample_rate == cfg.sample_rate, "Compression model sample rate should match"
-
- assert 'best_state' in state and state['best_state'] != {}
- assert 'exported' not in state, "When loading an exported checkpoint, use the //pretrained/ prefix."
- compression_model.load_state_dict(state['best_state']['model'])
- compression_model.eval()
- logger.info("Compression model loaded!")
- return compression_model
-
- @staticmethod
- def wrapped_model_from_checkpoint(cfg: omegaconf.DictConfig,
- checkpoint_path: tp.Union[Path, str],
- device: tp.Union[torch.device, str] = 'cpu') -> models.CompressionModel:
- """Instantiate a wrapped CompressionModel from a given checkpoint path or dora sig.
-
- Args:
- cfg (omegaconf.DictConfig): Configuration to read from for wrapped mode.
- checkpoint_path (Path or str): Path to checkpoint or dora sig from where the checkpoint is resolved.
- use_ema (bool): Use EMA variant of the model instead of the actual model.
- device (torch.device or str): Device on which the model is loaded.
- """
- compression_model = CompressionSolver.model_from_checkpoint(checkpoint_path, device)
- compression_model = models.builders.get_wrapped_compression_model(compression_model, cfg)
- return compression_model
-
-
-def evaluate_audio_reconstruction(y_pred: torch.Tensor, y: torch.Tensor, cfg: omegaconf.DictConfig) -> dict:
- """Audio reconstruction evaluation method that can be conveniently pickled."""
- metrics = {}
- if cfg.evaluate.metrics.visqol:
- visqol = builders.get_visqol(cfg.metrics.visqol)
- metrics['visqol'] = visqol(y_pred, y, cfg.sample_rate)
- sisnr = builders.get_loss('sisnr', cfg)
- metrics['sisnr'] = sisnr(y_pred, y)
- return metrics
diff --git a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/simultaneous_translation/modules/fixed_pre_decision.py b/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/simultaneous_translation/modules/fixed_pre_decision.py
deleted file mode 100644
index 3991414aed3800f301e4097e819d3064bb549c37..0000000000000000000000000000000000000000
--- a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/simultaneous_translation/modules/fixed_pre_decision.py
+++ /dev/null
@@ -1,190 +0,0 @@
-from functools import partial
-
-import torch
-from torch import Tensor
-import math
-import torch.nn.functional as F
-
-from . import register_monotonic_attention
-from .monotonic_multihead_attention import (
- MonotonicAttention,
- MonotonicInfiniteLookbackAttention,
- WaitKAttention
-)
-from typing import Dict, Optional
-
-
-def fixed_pooling_monotonic_attention(monotonic_attention):
- def create_model(monotonic_attention, klass):
- class FixedStrideMonotonicAttention(monotonic_attention):
- def __init__(self, args):
- self.waitk_lagging = 0
- self.num_heads = 0
- self.noise_mean = 0.0
- self.noise_var = 0.0
- super().__init__(args)
- self.pre_decision_type = args.fixed_pre_decision_type
- self.pre_decision_ratio = args.fixed_pre_decision_ratio
- self.pre_decision_pad_threshold = args.fixed_pre_decision_pad_threshold
- assert self.pre_decision_ratio > 1
-
- if args.fixed_pre_decision_type == "average":
- self.pooling_layer = torch.nn.AvgPool1d(
- kernel_size=self.pre_decision_ratio,
- stride=self.pre_decision_ratio,
- ceil_mode=True,
- )
- elif args.fixed_pre_decision_type == "last":
-
- def last(key):
- if key.size(2) < self.pre_decision_ratio:
- return key
- else:
- k = key[
- :,
- :,
- self.pre_decision_ratio - 1:: self.pre_decision_ratio,
- ].contiguous()
- if key.size(-1) % self.pre_decision_ratio != 0:
- k = torch.cat([k, key[:, :, -1:]], dim=-1).contiguous()
- return k
-
- self.pooling_layer = last
- else:
- raise NotImplementedError
-
- @staticmethod
- def add_args(parser):
- super(
- FixedStrideMonotonicAttention, FixedStrideMonotonicAttention
- ).add_args(parser)
- parser.add_argument(
- "--fixed-pre-decision-ratio",
- type=int,
- required=True,
- help=(
- "Ratio for the fixed pre-decision,"
- "indicating how many encoder steps will start"
- "simultaneous decision making process."
- ),
- )
- parser.add_argument(
- "--fixed-pre-decision-type",
- default="average",
- choices=["average", "last"],
- help="Pooling type",
- )
- parser.add_argument(
- "--fixed-pre-decision-pad-threshold",
- type=float,
- default=0.3,
- help="If a part of the sequence has pad"
- ",the threshold the pooled part is a pad.",
- )
-
- def insert_zeros(self, x):
- bsz_num_heads, tgt_len, src_len = x.size()
- stride = self.pre_decision_ratio
- weight = F.pad(torch.ones(1, 1, 1).to(x), (stride - 1, 0))
- x_upsample = F.conv_transpose1d(
- x.view(-1, src_len).unsqueeze(1),
- weight,
- stride=stride,
- padding=0,
- )
- return x_upsample.squeeze(1).view(bsz_num_heads, tgt_len, -1)
-
- def p_choose(
- self,
- query: Optional[Tensor],
- key: Optional[Tensor],
- key_padding_mask: Optional[Tensor] = None,
- incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None,
- ):
- assert key is not None
- assert query is not None
- src_len = key.size(0)
- tgt_len = query.size(0)
- batch_size = query.size(1)
-
- key_pool = self.pooling_layer(key.transpose(0, 2)).transpose(0, 2)
-
- if key_padding_mask is not None:
- key_padding_mask_pool = (
- self.pooling_layer(key_padding_mask.unsqueeze(0).float())
- .squeeze(0)
- .gt(self.pre_decision_pad_threshold)
- )
- # Make sure at least one element is not pad
- key_padding_mask_pool[:, 0] = 0
- else:
- key_padding_mask_pool = None
-
- if incremental_state is not None:
- # The floor instead of ceil is used for inference
- # But make sure the length key_pool at least 1
- if (
- max(1, math.floor(key.size(0) / self.pre_decision_ratio))
- ) < key_pool.size(0):
- key_pool = key_pool[:-1]
- if key_padding_mask_pool is not None:
- key_padding_mask_pool = key_padding_mask_pool[:-1]
-
- p_choose_pooled = self.p_choose_from_qk(
- query,
- key_pool,
- key_padding_mask_pool,
- incremental_state=incremental_state,
- )
-
- # Upsample, interpolate zeros
- p_choose = self.insert_zeros(p_choose_pooled)
-
- if p_choose.size(-1) < src_len:
- # Append zeros if the upsampled p_choose is shorter than src_len
- p_choose = torch.cat(
- [
- p_choose,
- torch.zeros(
- p_choose.size(0),
- tgt_len,
- src_len - p_choose.size(-1)
- ).to(p_choose)
- ],
- dim=2
- )
- else:
- # can be larger than src_len because we used ceil before
- p_choose = p_choose[:, :, :src_len]
- p_choose[:, :, -1] = p_choose_pooled[:, :, -1]
-
- assert list(p_choose.size()) == [
- batch_size * self.num_heads,
- tgt_len,
- src_len,
- ]
-
- return p_choose
-
- FixedStrideMonotonicAttention.__name__ = klass.__name__
- return FixedStrideMonotonicAttention
-
- return partial(create_model, monotonic_attention)
-
-
-@register_monotonic_attention("waitk_fixed_pre_decision")
-@fixed_pooling_monotonic_attention(WaitKAttention)
-class WaitKAttentionFixedStride:
- pass
-
-
-@register_monotonic_attention("hard_aligned_fixed_pre_decision")
-@fixed_pooling_monotonic_attention(MonotonicAttention)
-class MonotonicAttentionFixedStride:
- pass
-
-
-@register_monotonic_attention("infinite_lookback_fixed_pre_decision")
-@fixed_pooling_monotonic_attention(MonotonicInfiniteLookbackAttention)
-class MonotonicInfiniteLookbackAttentionFixedStride:
- pass
diff --git a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/fairseq/modules/transpose_last.py b/spaces/HarryLee/eCommerceImageCaptioning/fairseq/fairseq/modules/transpose_last.py
deleted file mode 100644
index e578b3ec5097bfac5c976b207ea46bec1d9bd4f5..0000000000000000000000000000000000000000
--- a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/fairseq/modules/transpose_last.py
+++ /dev/null
@@ -1,20 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-"""
-transpose last 2 dimensions of the input
-"""
-
-import torch.nn as nn
-
-
-class TransposeLast(nn.Module):
- def __init__(self, deconstruct_idx=None):
- super().__init__()
- self.deconstruct_idx = deconstruct_idx
-
- def forward(self, x):
- if self.deconstruct_idx is not None:
- x = x[self.deconstruct_idx]
- return x.transpose(-2, -1)
diff --git a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/tests/test_token_block_dataset.py b/spaces/HarryLee/eCommerceImageCaptioning/fairseq/tests/test_token_block_dataset.py
deleted file mode 100644
index c4d7b76dcd55fe7869dbb1fa188f7b36fb639bda..0000000000000000000000000000000000000000
--- a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/tests/test_token_block_dataset.py
+++ /dev/null
@@ -1,92 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import unittest
-
-import tests.utils as test_utils
-import torch
-from fairseq.data import TokenBlockDataset
-
-
-class TestTokenBlockDataset(unittest.TestCase):
- def _build_dataset(self, data, **kwargs):
- sizes = [len(x) for x in data]
- underlying_ds = test_utils.TestDataset(data)
- return TokenBlockDataset(underlying_ds, sizes, **kwargs)
-
- def test_eos_break_mode(self):
- data = [
- torch.tensor([5, 4, 3, 2, 1], dtype=torch.long),
- torch.tensor([1], dtype=torch.long),
- torch.tensor([8, 7, 6, 1], dtype=torch.long),
- ]
- ds = self._build_dataset(data, block_size=None, pad=0, eos=1, break_mode="eos")
- self.assertEqual(ds[0].tolist(), [5, 4, 3, 2, 1])
- self.assertEqual(ds[1].tolist(), [1])
- self.assertEqual(ds[2].tolist(), [8, 7, 6, 1])
-
- data = [
- torch.tensor([5, 4, 3, 2, 1], dtype=torch.long),
- torch.tensor([8, 7, 6, 1], dtype=torch.long),
- torch.tensor([1], dtype=torch.long),
- ]
- ds = self._build_dataset(data, block_size=None, pad=0, eos=1, break_mode="eos")
- self.assertEqual(ds[0].tolist(), [5, 4, 3, 2, 1])
- self.assertEqual(ds[1].tolist(), [8, 7, 6, 1])
- self.assertEqual(ds[2].tolist(), [1])
-
- def test_block_break_mode(self):
- data = [
- torch.tensor([5, 4, 3, 2, 1], dtype=torch.long),
- torch.tensor([8, 7, 6, 1], dtype=torch.long),
- torch.tensor([9, 1], dtype=torch.long),
- ]
- ds = self._build_dataset(data, block_size=3, pad=0, eos=1, break_mode="none")
- self.assertEqual(ds[0].tolist(), [5, 4, 3])
- self.assertEqual(ds[1].tolist(), [2, 1, 8])
- self.assertEqual(ds[2].tolist(), [7, 6, 1])
- self.assertEqual(ds[3].tolist(), [9, 1])
-
- def test_complete_break_mode(self):
- data = [
- torch.tensor([5, 4, 3, 2, 1], dtype=torch.long),
- torch.tensor([8, 7, 6, 1], dtype=torch.long),
- torch.tensor([9, 1], dtype=torch.long),
- ]
- ds = self._build_dataset(
- data, block_size=6, pad=0, eos=1, break_mode="complete"
- )
- self.assertEqual(ds[0].tolist(), [5, 4, 3, 2, 1])
- self.assertEqual(ds[1].tolist(), [8, 7, 6, 1, 9, 1])
-
- data = [
- torch.tensor([4, 3, 2, 1], dtype=torch.long),
- torch.tensor([5, 1], dtype=torch.long),
- torch.tensor([1], dtype=torch.long),
- torch.tensor([6, 1], dtype=torch.long),
- ]
- ds = self._build_dataset(
- data, block_size=3, pad=0, eos=1, break_mode="complete"
- )
- self.assertEqual(ds[0].tolist(), [4, 3, 2, 1])
- self.assertEqual(ds[1].tolist(), [5, 1, 1])
- self.assertEqual(ds[2].tolist(), [6, 1])
-
- def test_4billion_tokens(self):
- """Regression test for numpy type promotion issue https://github.com/numpy/numpy/issues/5745"""
- data = [torch.tensor(list(range(10000)), dtype=torch.long)] * 430000
- ds = self._build_dataset(
- data, block_size=6, pad=0, eos=1, break_mode="complete"
- )
- ds[-1] # __getitem__ works
- start, end = ds.slice_indices[-1]
- assert end > 4294967295 # data must be sufficiently large to overflow uint32
- assert not isinstance(
- end + 1, float
- ) # this would also raise, since np.uint64(1) + 1 => 2.0
-
-
-if __name__ == "__main__":
- unittest.main()
diff --git a/spaces/HenryNavarre/CarlosDrummondAndradeGenerator/app.py b/spaces/HenryNavarre/CarlosDrummondAndradeGenerator/app.py
deleted file mode 100644
index 069bb83f2a598da95226d3e9eb710e9d5597a30f..0000000000000000000000000000000000000000
--- a/spaces/HenryNavarre/CarlosDrummondAndradeGenerator/app.py
+++ /dev/null
@@ -1,60 +0,0 @@
-import tensorflow as tf
-import numpy as np
-import docx2txt
-from tensorflow.keras.preprocessing.sequence import pad_sequences
-from tensorflow.keras.layers import Embedding, LSTM, Dense, Bidirectional
-from tensorflow.keras.preprocessing.text import Tokenizer
-from tensorflow.keras.models import Sequential
-from tensorflow.keras.optimizers import Adam
-import gradio as gr
-import io
-import json
-from tensorflow.keras.preprocessing.text import tokenizer_from_json
-
-
-
-model = tf.keras.models.load_model('my_model.h5')
-with open('tokenizer.json') as f:
- data = json.load(f)
- tokenizer = tokenizer_from_json(data)
-
-max_sequence_len = 58
-def predictor(seed_text):
-# Define total words to predict
- next_words = 10
-
-# Loop until desired length is reached
- for _ in range(next_words):
-
- # Convert the seed text to a token sequence
- token_list = tokenizer.texts_to_sequences([seed_text])[0]
-
- # Pad the sequence
- token_list = pad_sequences([token_list], maxlen=max_sequence_len-1, padding='pre')
-
- # Feed to the model and get the probabilities for each index
- probabilities = model.predict(token_list)
-
- # Get the index with the highest probability
- predicted = np.argmax(probabilities, axis=-1)[0]
-
- # Ignore if index is 0 because that is just the padding.
- if predicted != 0:
-
- # Look up the word associated with the index.
- output_word = tokenizer.index_word[predicted]
-
- # Combine with the seed text
- seed_text += " " + output_word
- return seed_text
-
-# Print the result
-#print(seed_text)
-
-demo = gr.Interface(
- fn=predictor,
- inputs=gr.inputs.Textbox(lines=5, label="Input Text"),
- outputs=gr.outputs.Textbox(label="Generated Text"),
-)
-
-demo.launch()
\ No newline at end of file
diff --git a/spaces/Hina4867/bingo/src/lib/isomorphic/index.ts b/spaces/Hina4867/bingo/src/lib/isomorphic/index.ts
deleted file mode 100644
index 738dc92f74079ab762d584fb7422a8c8c3b61547..0000000000000000000000000000000000000000
--- a/spaces/Hina4867/bingo/src/lib/isomorphic/index.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-'use client'
-
-import Default from './browser'
-
-let exportsModel: any = {}
-
-if (process.browser) {
- Object.assign(exportsModel, require('./browser').default)
-} else {
- Object.assign(exportsModel, require('./node').default)
-}
-
-export default exportsModel! as typeof Default
-
-export const fetch: typeof Default.fetch = exportsModel!.fetch
-export const WebSocket: typeof Default.WebSocket = exportsModel!.WebSocket
-export const debug: typeof Default.debug = exportsModel!.debug
diff --git a/spaces/HugoDzz/super-godot-galaxy/vite.config.ts b/spaces/HugoDzz/super-godot-galaxy/vite.config.ts
deleted file mode 100644
index bbf8c7da43f0080dc6b9fb275f9583b7c17f1506..0000000000000000000000000000000000000000
--- a/spaces/HugoDzz/super-godot-galaxy/vite.config.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-import { sveltekit } from '@sveltejs/kit/vite';
-import { defineConfig } from 'vite';
-
-export default defineConfig({
- plugins: [sveltekit()]
-});
diff --git a/spaces/HugoHE/monitoringObjectDetection/base_cam.py b/spaces/HugoHE/monitoringObjectDetection/base_cam.py
deleted file mode 100644
index 5f603e0a70886b14fb6c65b9f4bab3e659536155..0000000000000000000000000000000000000000
--- a/spaces/HugoHE/monitoringObjectDetection/base_cam.py
+++ /dev/null
@@ -1,223 +0,0 @@
-import numpy as np
-import torch
-import ttach as tta
-from typing import Callable, List, Tuple
-from pytorch_grad_cam.activations_and_gradients import ActivationsAndGradients
-from pytorch_grad_cam.utils.svd_on_activations import get_2d_projection
-from pytorch_grad_cam.utils.image import scale_cam_image
-from pytorch_grad_cam.utils.model_targets import ClassifierOutputTarget
-from pytorch_grad_cam.utils.svd_on_activations import get_2d_projection
-
-# https://arxiv.org/abs/2008.00299
-
-class BaseCAM:
- def __init__(self,
- model: torch.nn.Module,
- target_layers: List[torch.nn.Module],
- use_cuda: bool = False,
- reshape_transform: Callable = None,
- compute_input_gradient: bool = False,
- uses_gradients: bool = True) -> None:
- self.model = model.eval()
- self.target_layers = target_layers
- self.cuda = use_cuda
- if self.cuda:
- self.model = model.cuda()
- self.reshape_transform = reshape_transform
- self.compute_input_gradient = compute_input_gradient
- self.uses_gradients = uses_gradients
- self.activations_and_grads = ActivationsAndGradients(
- self.model, target_layers, reshape_transform)
-
- """ Get a vector of weights for every channel in the target layer.
- Methods that return weights channels,
- will typically need to only implement this function. """
-
- def get_cam_weights(self,
- input_tensor: torch.Tensor,
- target_layers: List[torch.nn.Module],
- targets: List[torch.nn.Module],
- activations: torch.Tensor,
- grads: torch.Tensor) -> np.ndarray:
- raise Exception("Not Implemented")
-
- def get_cam_image(self,
- input_tensor: torch.Tensor,
- target_layer: torch.nn.Module,
- targets: List[torch.nn.Module],
- activations: torch.Tensor,
- grads: torch.Tensor,
- eigen_smooth: bool = False) -> np.ndarray:
-
- weights = self.get_cam_weights(input_tensor,
- target_layer,
- targets,
- activations,
- grads)
- weighted_activations = weights[:, :, None, None] * activations
- if eigen_smooth:
- cam = get_2d_projection(weighted_activations)
- else:
- cam = weighted_activations.sum(axis=1)
- return cam
-
- def forward(self,
- input_tensor: torch.Tensor,
- targets: List[torch.nn.Module],
- eigen_smooth: bool = False) -> np.ndarray:
- if self.cuda:
- input_tensor = input_tensor.cuda()
-
- if self.compute_input_gradient:
- input_tensor = torch.autograd.Variable(input_tensor,
- requires_grad=True)
-
- outputs = self.activations_and_grads(input_tensor)
- if targets is None:
- target_categories = np.argmax(outputs.cpu().data.numpy(), axis=-1)
- targets = [ClassifierOutputTarget(
- category) for category in target_categories]
-
- if self.uses_gradients:
- self.model.zero_grad()
- loss = sum([target(output)
- for target, output in zip(targets, outputs)])
- loss.backward(retain_graph=True)
-
- # In most of the saliency attribution papers, the saliency is
- # computed with a single target layer.
- # Commonly it is the last convolutional layer.
- # Here we support passing a list with multiple target layers.
- # It will compute the saliency image for every image,
- # and then aggregate them (with a default mean aggregation).
- # This gives you more flexibility in case you just want to
- # use all conv layers for example, all Batchnorm layers,
- # or something else.
- cam_per_layer = self.compute_cam_per_layer(input_tensor,
- targets,
- eigen_smooth)
- return self.aggregate_multi_layers(cam_per_layer)
-
- def get_target_width_height(self,
- input_tensor: torch.Tensor) -> Tuple[int, int]:
- width, height = input_tensor.size(-1), input_tensor.size(-2)
- return width, height
-
- def compute_cam_per_layer(
- self,
- input_tensor: torch.Tensor,
- targets: List[torch.nn.Module],
- eigen_smooth: bool) -> np.ndarray:
- activations_list = [a.cpu().data.numpy()
- for a in self.activations_and_grads.activations]
- grads_list = [g.cpu().data.numpy()
- for g in self.activations_and_grads.gradients]
- target_size = self.get_target_width_height(input_tensor[0]["image"])
-
-
- cam_per_target_layer = []
- # Loop over the saliency image from every layer
- for i in range(len(self.target_layers)):
- target_layer = self.target_layers[i]
- layer_activations = None
- layer_grads = None
- if i < len(activations_list):
- layer_activations = activations_list[i]
- if i < len(grads_list):
- layer_grads = grads_list[i]
-
- cam = self.get_cam_image(input_tensor,
- target_layer,
- targets,
- layer_activations,
- layer_grads,
- eigen_smooth)
- cam = np.maximum(cam, 0)
- scaled = scale_cam_image(cam, target_size)
- cam_per_target_layer.append(scaled[:, None, :])
-
- return cam_per_target_layer
-
- def aggregate_multi_layers(
- self,
- cam_per_target_layer: np.ndarray) -> np.ndarray:
- cam_per_target_layer = np.concatenate(cam_per_target_layer, axis=1)
- cam_per_target_layer = np.maximum(cam_per_target_layer, 0)
- result = np.mean(cam_per_target_layer, axis=1)
- return scale_cam_image(result)
-
- def forward_augmentation_smoothing(self,
- input_tensor: torch.Tensor,
- targets: List[torch.nn.Module],
- eigen_smooth: bool = False) -> np.ndarray:
- transforms = tta.Compose(
- [
- tta.HorizontalFlip(),
- tta.Multiply(factors=[0.9, 1, 1.1]),
- ]
- )
- cams = []
- for transform in transforms:
- augmented_tensor = transform.augment_image(input_tensor)
- cam = self.forward(augmented_tensor,
- targets,
- eigen_smooth)
-
- # The ttach library expects a tensor of size BxCxHxW
- cam = cam[:, None, :, :]
- cam = torch.from_numpy(cam)
- cam = transform.deaugment_mask(cam)
-
- # Back to numpy float32, HxW
- cam = cam.numpy()
- cam = cam[:, 0, :, :]
- cams.append(cam)
-
- cam = np.mean(np.float32(cams), axis=0)
- return cam
-
- def __call__(self,
- input_tensor: torch.Tensor,
- targets: List[torch.nn.Module] = None,
- aug_smooth: bool = False,
- eigen_smooth: bool = False) -> np.ndarray:
-
- # Smooth the CAM result with test time augmentation
- if aug_smooth is True:
- return self.forward_augmentation_smoothing(
- input_tensor, targets, eigen_smooth)
-
- return self.forward(input_tensor,
- targets, eigen_smooth)
-
- def __del__(self):
- self.activations_and_grads.release()
-
- def __enter__(self):
- return self
-
- def __exit__(self, exc_type, exc_value, exc_tb):
- self.activations_and_grads.release()
- if isinstance(exc_value, IndexError):
- # Handle IndexError here...
- print(
- f"An exception occurred in CAM with block: {exc_type}. Message: {exc_value}")
- return True
-
-class EigenCAM(BaseCAM):
- def __init__(self, model, target_layers, use_cuda=False,
- reshape_transform=None):
- super(EigenCAM, self).__init__(model,
- target_layers,
- use_cuda,
- reshape_transform,
- uses_gradients=False)
-
- def get_cam_image(self,
- input_tensor,
- target_layer,
- target_category,
- activations,
- grads,
- eigen_smooth):
- return get_2d_projection(activations)
diff --git a/spaces/HuskyTho/EleutherAI-gpt-neo-1.3B/app.py b/spaces/HuskyTho/EleutherAI-gpt-neo-1.3B/app.py
deleted file mode 100644
index 93970092a78890fd2c38659cc3d613ffc079d4f1..0000000000000000000000000000000000000000
--- a/spaces/HuskyTho/EleutherAI-gpt-neo-1.3B/app.py
+++ /dev/null
@@ -1,25 +0,0 @@
-# import gradio as gr
-
-# gr.Interface.load("models/EleutherAI/gpt-neo-1.3B").launch()
-
-# import gradio as gr
-
-# description = "Story generation with GPT"
-# examples = [["An adventurer is approached by a mysterious stranger in the tavern for a new quest."]]
-# demo = gr.Interface.load("models/EleutherAI/gpt-neo-1.3B", description=description, examples=examples)
-# demo.launch()
-
-import gradio as gr
-from transformers import pipeline
-
-generator = pipeline('text-generation', model='EleutherAI/gpt-neo-1.3B')
-examples = [
- ["Then all went silent..."],
-]
-
-def generate(text):
- result=generator(text, min_length=200, max_length=600, num_return_sequences=3)
- return result[0]['generated_text']
-
-gr.Interface(fn=generate, inputs=gr.inputs.Textbox(lines=5, label='input text'), outputs=gr.outputs.Textbox(label='output text'), title='Testing Text Generator', examples=examples).launch()
-
diff --git a/spaces/Intoval/privateChatGPT/locale/extract_locale.py b/spaces/Intoval/privateChatGPT/locale/extract_locale.py
deleted file mode 100644
index 32b0924bd6dffe150cb3e481ddadef836b91b83c..0000000000000000000000000000000000000000
--- a/spaces/Intoval/privateChatGPT/locale/extract_locale.py
+++ /dev/null
@@ -1,26 +0,0 @@
-import os
-import json
-import re
-
-# Define regular expression patterns
-pattern = r'i18n\((\"{3}.*?\"{3}|\".*?\")\)'
-
-# Load the .py file
-with open('ChuanhuChatbot.py', 'r', encoding='utf-8') as f:
- contents = f.read()
-
-# Load the .py files in the modules folder
-for filename in os.listdir("modules"):
- if filename.endswith(".py"):
- with open(os.path.join("modules", filename), "r", encoding="utf-8") as f:
- contents += f.read()
-
-# Matching with regular expressions
-matches = re.findall(pattern, contents, re.DOTALL)
-
-# Convert to key/value pairs
-data = {match.strip('()"'): '' for match in matches}
-
-# Save as a JSON file
-with open('labels.json', 'w', encoding='utf-8') as f:
- json.dump(data, f, ensure_ascii=False, indent=4)
\ No newline at end of file
diff --git a/spaces/Jack003/PixelDayAvatoon/run.py b/spaces/Jack003/PixelDayAvatoon/run.py
deleted file mode 100644
index 553bab1b4e63d80a890983090464c98c75841019..0000000000000000000000000000000000000000
--- a/spaces/Jack003/PixelDayAvatoon/run.py
+++ /dev/null
@@ -1,38 +0,0 @@
-import gradio as gr
-from PIL import Image
-import torch
-
-model2 = torch.hub.load(
- "AK391/animegan2-pytorch:main",
- "generator",
- pretrained=True,
- progress=False
-)
-model1 = torch.hub.load("AK391/animegan2-pytorch:main", "generator", pretrained="face_paint_512_v1")
-face2paint = torch.hub.load(
- 'AK391/animegan2-pytorch:main', 'face2paint',
- size=512,side_by_side=False
-)
-
-def inference(img, ver):
- if ver == 'version 2 (🔺 robustness,🔻 stylization)':
- out = face2paint(model2, img)
- else:
- out = face2paint(model1, img)
- return out
-
-title = "AnimeGANv2"
-description = "Gradio Demo for AnimeGanv2 Face Portrait. To use it, simply upload your image, or click one of the examples to load them. Read more at the links below. Please use a cropped portrait picture for best results similar to the examples below."
-article = "
"
-examples=[['groot.jpeg','version 2 (🔺 robustness,🔻 stylization)'],['gongyoo.jpeg','version 1 (🔺 stylization, 🔻 robustness)']]
-
-demo = gr.Interface(
- fn=inference,
- inputs=[gr.inputs.Image(type="pil"),gr.inputs.Radio(['version 1 (🔺 stylization, 🔻 robustness)','version 2 (🔺 robustness,🔻 stylization)'], type="value", default='version 2 (🔺 robustness,🔻 stylization)', label='version')],
- outputs=gr.outputs.Image(type="pil"),
- title=title,
- description=description,
- article=article,
- examples=examples)
-
-demo.launch()
\ No newline at end of file
diff --git a/spaces/JohnSmith9982/VITS-Umamusume-voice-synthesizer/monotonic_align/setup.py b/spaces/JohnSmith9982/VITS-Umamusume-voice-synthesizer/monotonic_align/setup.py
deleted file mode 100644
index 30c224807a70faa9df9c9eb75f8e80c8c867b16b..0000000000000000000000000000000000000000
--- a/spaces/JohnSmith9982/VITS-Umamusume-voice-synthesizer/monotonic_align/setup.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from distutils.core import setup
-from Cython.Build import cythonize
-import numpy
-
-setup(
- name = 'monotonic_align',
- ext_modules = cythonize("core.pyx"),
- include_dirs=[numpy.get_include()]
-)
diff --git a/spaces/Juno360219/albert-base-v2/style.css b/spaces/Juno360219/albert-base-v2/style.css
deleted file mode 100644
index 114adf441e9032febb46bc056b2a8bb651075f0d..0000000000000000000000000000000000000000
--- a/spaces/Juno360219/albert-base-v2/style.css
+++ /dev/null
@@ -1,28 +0,0 @@
-body {
- padding: 2rem;
- font-family: -apple-system, BlinkMacSystemFont, "Arial", sans-serif;
-}
-
-h1 {
- font-size: 16px;
- margin-top: 0;
-}
-
-p {
- color: rgb(107, 114, 128);
- font-size: 15px;
- margin-bottom: 10px;
- margin-top: 5px;
-}
-
-.card {
- max-width: 620px;
- margin: 0 auto;
- padding: 16px;
- border: 1px solid lightgray;
- border-radius: 16px;
-}
-
-.card p:last-child {
- margin-bottom: 0;
-}
diff --git a/spaces/Kedreamix/YoloGesture/utils/utils_map.py b/spaces/Kedreamix/YoloGesture/utils/utils_map.py
deleted file mode 100644
index 8d9eae9849e63f1b52aa7677dde03a714b9c3749..0000000000000000000000000000000000000000
--- a/spaces/Kedreamix/YoloGesture/utils/utils_map.py
+++ /dev/null
@@ -1,901 +0,0 @@
-import glob
-import json
-import math
-import operator
-import os
-import shutil
-import sys
-
-import cv2
-import matplotlib.pyplot as plt
-import numpy as np
-
-'''
- 0,0 ------> x (width)
- |
- | (Left,Top)
- | *_________
- | | |
- | |
- y |_________|
- (height) *
- (Right,Bottom)
-'''
-
-def log_average_miss_rate(precision, fp_cumsum, num_images):
- """
- log-average miss rate:
- Calculated by averaging miss rates at 9 evenly spaced FPPI points
- between 10e-2 and 10e0, in log-space.
-
- output:
- lamr | log-average miss rate
- mr | miss rate
- fppi | false positives per image
-
- references:
- [1] Dollar, Piotr, et al. "Pedestrian Detection: An Evaluation of the
- State of the Art." Pattern Analysis and Machine Intelligence, IEEE
- Transactions on 34.4 (2012): 743 - 761.
- """
-
- if precision.size == 0:
- lamr = 0
- mr = 1
- fppi = 0
- return lamr, mr, fppi
-
- fppi = fp_cumsum / float(num_images)
- mr = (1 - precision)
-
- fppi_tmp = np.insert(fppi, 0, -1.0)
- mr_tmp = np.insert(mr, 0, 1.0)
-
- ref = np.logspace(-2.0, 0.0, num = 9)
- for i, ref_i in enumerate(ref):
- j = np.where(fppi_tmp <= ref_i)[-1][-1]
- ref[i] = mr_tmp[j]
-
- lamr = math.exp(np.mean(np.log(np.maximum(1e-10, ref))))
-
- return lamr, mr, fppi
-
-"""
- throw error and exit
-"""
-def error(msg):
- print(msg)
- sys.exit(0)
-
-"""
- check if the number is a float between 0.0 and 1.0
-"""
-def is_float_between_0_and_1(value):
- try:
- val = float(value)
- if val > 0.0 and val < 1.0:
- return True
- else:
- return False
- except ValueError:
- return False
-
-"""
- Calculate the AP given the recall and precision array
- 1st) We compute a version of the measured precision/recall curve with
- precision monotonically decreasing
- 2nd) We compute the AP as the area under this curve by numerical integration.
-"""
-def voc_ap(rec, prec):
- """
- --- Official matlab code VOC2012---
- mrec=[0 ; rec ; 1];
- mpre=[0 ; prec ; 0];
- for i=numel(mpre)-1:-1:1
- mpre(i)=max(mpre(i),mpre(i+1));
- end
- i=find(mrec(2:end)~=mrec(1:end-1))+1;
- ap=sum((mrec(i)-mrec(i-1)).*mpre(i));
- """
- rec.insert(0, 0.0) # insert 0.0 at begining of list
- rec.append(1.0) # insert 1.0 at end of list
- mrec = rec[:]
- prec.insert(0, 0.0) # insert 0.0 at begining of list
- prec.append(0.0) # insert 0.0 at end of list
- mpre = prec[:]
- """
- This part makes the precision monotonically decreasing
- (goes from the end to the beginning)
- matlab: for i=numel(mpre)-1:-1:1
- mpre(i)=max(mpre(i),mpre(i+1));
- """
- for i in range(len(mpre)-2, -1, -1):
- mpre[i] = max(mpre[i], mpre[i+1])
- """
- This part creates a list of indexes where the recall changes
- matlab: i=find(mrec(2:end)~=mrec(1:end-1))+1;
- """
- i_list = []
- for i in range(1, len(mrec)):
- if mrec[i] != mrec[i-1]:
- i_list.append(i) # if it was matlab would be i + 1
- """
- The Average Precision (AP) is the area under the curve
- (numerical integration)
- matlab: ap=sum((mrec(i)-mrec(i-1)).*mpre(i));
- """
- ap = 0.0
- for i in i_list:
- ap += ((mrec[i]-mrec[i-1])*mpre[i])
- return ap, mrec, mpre
-
-
-"""
- Convert the lines of a file to a list
-"""
-def file_lines_to_list(path):
- # open txt file lines to a list
- with open(path) as f:
- content = f.readlines()
- # remove whitespace characters like `\n` at the end of each line
- content = [x.strip() for x in content]
- return content
-
-"""
- Draws text in image
-"""
-def draw_text_in_image(img, text, pos, color, line_width):
- font = cv2.FONT_HERSHEY_PLAIN
- fontScale = 1
- lineType = 1
- bottomLeftCornerOfText = pos
- cv2.putText(img, text,
- bottomLeftCornerOfText,
- font,
- fontScale,
- color,
- lineType)
- text_width, _ = cv2.getTextSize(text, font, fontScale, lineType)[0]
- return img, (line_width + text_width)
-
-"""
- Plot - adjust axes
-"""
-def adjust_axes(r, t, fig, axes):
- # get text width for re-scaling
- bb = t.get_window_extent(renderer=r)
- text_width_inches = bb.width / fig.dpi
- # get axis width in inches
- current_fig_width = fig.get_figwidth()
- new_fig_width = current_fig_width + text_width_inches
- propotion = new_fig_width / current_fig_width
- # get axis limit
- x_lim = axes.get_xlim()
- axes.set_xlim([x_lim[0], x_lim[1]*propotion])
-
-"""
- Draw plot using Matplotlib
-"""
-def draw_plot_func(dictionary, n_classes, window_title, plot_title, x_label, output_path, to_show, plot_color, true_p_bar):
- # sort the dictionary by decreasing value, into a list of tuples
- sorted_dic_by_value = sorted(dictionary.items(), key=operator.itemgetter(1))
- # unpacking the list of tuples into two lists
- sorted_keys, sorted_values = zip(*sorted_dic_by_value)
- #
- if true_p_bar != "":
- """
- Special case to draw in:
- - green -> TP: True Positives (object detected and matches ground-truth)
- - red -> FP: False Positives (object detected but does not match ground-truth)
- - orange -> FN: False Negatives (object not detected but present in the ground-truth)
- """
- fp_sorted = []
- tp_sorted = []
- for key in sorted_keys:
- fp_sorted.append(dictionary[key] - true_p_bar[key])
- tp_sorted.append(true_p_bar[key])
- plt.barh(range(n_classes), fp_sorted, align='center', color='crimson', label='False Positive')
- plt.barh(range(n_classes), tp_sorted, align='center', color='forestgreen', label='True Positive', left=fp_sorted)
- # add legend
- plt.legend(loc='lower right')
- """
- Write number on side of bar
- """
- fig = plt.gcf() # gcf - get current figure
- axes = plt.gca()
- r = fig.canvas.get_renderer()
- for i, val in enumerate(sorted_values):
- fp_val = fp_sorted[i]
- tp_val = tp_sorted[i]
- fp_str_val = " " + str(fp_val)
- tp_str_val = fp_str_val + " " + str(tp_val)
- # trick to paint multicolor with offset:
- # first paint everything and then repaint the first number
- t = plt.text(val, i, tp_str_val, color='forestgreen', va='center', fontweight='bold')
- plt.text(val, i, fp_str_val, color='crimson', va='center', fontweight='bold')
- if i == (len(sorted_values)-1): # largest bar
- adjust_axes(r, t, fig, axes)
- else:
- plt.barh(range(n_classes), sorted_values, color=plot_color)
- """
- Write number on side of bar
- """
- fig = plt.gcf() # gcf - get current figure
- axes = plt.gca()
- r = fig.canvas.get_renderer()
- for i, val in enumerate(sorted_values):
- str_val = " " + str(val) # add a space before
- if val < 1.0:
- str_val = " {0:.2f}".format(val)
- t = plt.text(val, i, str_val, color=plot_color, va='center', fontweight='bold')
- # re-set axes to show number inside the figure
- if i == (len(sorted_values)-1): # largest bar
- adjust_axes(r, t, fig, axes)
- # set window title
- fig.canvas.set_window_title(window_title)
- # write classes in y axis
- tick_font_size = 12
- plt.yticks(range(n_classes), sorted_keys, fontsize=tick_font_size)
- """
- Re-scale height accordingly
- """
- init_height = fig.get_figheight()
- # comput the matrix height in points and inches
- dpi = fig.dpi
- height_pt = n_classes * (tick_font_size * 1.4) # 1.4 (some spacing)
- height_in = height_pt / dpi
- # compute the required figure height
- top_margin = 0.15 # in percentage of the figure height
- bottom_margin = 0.05 # in percentage of the figure height
- figure_height = height_in / (1 - top_margin - bottom_margin)
- # set new height
- if figure_height > init_height:
- fig.set_figheight(figure_height)
-
- # set plot title
- plt.title(plot_title, fontsize=14)
- # set axis titles
- # plt.xlabel('classes')
- plt.xlabel(x_label, fontsize='large')
- # adjust size of window
- fig.tight_layout()
- # save the plot
- fig.savefig(output_path)
- # show image
- if to_show:
- plt.show()
- # close the plot
- plt.close()
-
-def get_map(MINOVERLAP, draw_plot, path = './map_out'):
- GT_PATH = os.path.join(path, 'ground-truth')
- DR_PATH = os.path.join(path, 'detection-results')
- IMG_PATH = os.path.join(path, 'images-optional')
- TEMP_FILES_PATH = os.path.join(path, '.temp_files')
- RESULTS_FILES_PATH = os.path.join(path, 'results')
-
- show_animation = True
- if os.path.exists(IMG_PATH):
- for dirpath, dirnames, files in os.walk(IMG_PATH):
- if not files:
- show_animation = False
- else:
- show_animation = False
-
- if not os.path.exists(TEMP_FILES_PATH):
- os.makedirs(TEMP_FILES_PATH)
-
- if os.path.exists(RESULTS_FILES_PATH):
- shutil.rmtree(RESULTS_FILES_PATH)
- if draw_plot:
- os.makedirs(os.path.join(RESULTS_FILES_PATH, "AP"))
- os.makedirs(os.path.join(RESULTS_FILES_PATH, "F1"))
- os.makedirs(os.path.join(RESULTS_FILES_PATH, "Recall"))
- os.makedirs(os.path.join(RESULTS_FILES_PATH, "Precision"))
- if show_animation:
- os.makedirs(os.path.join(RESULTS_FILES_PATH, "images", "detections_one_by_one"))
-
- ground_truth_files_list = glob.glob(GT_PATH + '/*.txt')
- if len(ground_truth_files_list) == 0:
- error("Error: No ground-truth files found!")
- ground_truth_files_list.sort()
- gt_counter_per_class = {}
- counter_images_per_class = {}
-
- for txt_file in ground_truth_files_list:
- file_id = txt_file.split(".txt", 1)[0]
- file_id = os.path.basename(os.path.normpath(file_id))
- temp_path = os.path.join(DR_PATH, (file_id + ".txt"))
- if not os.path.exists(temp_path):
- error_msg = "Error. File not found: {}\n".format(temp_path)
- error(error_msg)
- lines_list = file_lines_to_list(txt_file)
- bounding_boxes = []
- is_difficult = False
- already_seen_classes = []
- for line in lines_list:
- try:
- if "difficult" in line:
- class_name, left, top, right, bottom, _difficult = line.split()
- is_difficult = True
- else:
- class_name, left, top, right, bottom = line.split()
- except:
- if "difficult" in line:
- line_split = line.split()
- _difficult = line_split[-1]
- bottom = line_split[-2]
- right = line_split[-3]
- top = line_split[-4]
- left = line_split[-5]
- class_name = ""
- for name in line_split[:-5]:
- class_name += name + " "
- class_name = class_name[:-1]
- is_difficult = True
- else:
- line_split = line.split()
- bottom = line_split[-1]
- right = line_split[-2]
- top = line_split[-3]
- left = line_split[-4]
- class_name = ""
- for name in line_split[:-4]:
- class_name += name + " "
- class_name = class_name[:-1]
-
- bbox = left + " " + top + " " + right + " " + bottom
- if is_difficult:
- bounding_boxes.append({"class_name":class_name, "bbox":bbox, "used":False, "difficult":True})
- is_difficult = False
- else:
- bounding_boxes.append({"class_name":class_name, "bbox":bbox, "used":False})
- if class_name in gt_counter_per_class:
- gt_counter_per_class[class_name] += 1
- else:
- gt_counter_per_class[class_name] = 1
-
- if class_name not in already_seen_classes:
- if class_name in counter_images_per_class:
- counter_images_per_class[class_name] += 1
- else:
- counter_images_per_class[class_name] = 1
- already_seen_classes.append(class_name)
-
- with open(TEMP_FILES_PATH + "/" + file_id + "_ground_truth.json", 'w') as outfile:
- json.dump(bounding_boxes, outfile)
-
- gt_classes = list(gt_counter_per_class.keys())
- gt_classes = sorted(gt_classes)
- n_classes = len(gt_classes)
-
- dr_files_list = glob.glob(DR_PATH + '/*.txt')
- dr_files_list.sort()
- for class_index, class_name in enumerate(gt_classes):
- bounding_boxes = []
- for txt_file in dr_files_list:
- file_id = txt_file.split(".txt",1)[0]
- file_id = os.path.basename(os.path.normpath(file_id))
- temp_path = os.path.join(GT_PATH, (file_id + ".txt"))
- if class_index == 0:
- if not os.path.exists(temp_path):
- error_msg = "Error. File not found: {}\n".format(temp_path)
- error(error_msg)
- lines = file_lines_to_list(txt_file)
- for line in lines:
- try:
- tmp_class_name, confidence, left, top, right, bottom = line.split()
- except:
- line_split = line.split()
- bottom = line_split[-1]
- right = line_split[-2]
- top = line_split[-3]
- left = line_split[-4]
- confidence = line_split[-5]
- tmp_class_name = ""
- for name in line_split[:-5]:
- tmp_class_name += name + " "
- tmp_class_name = tmp_class_name[:-1]
-
- if tmp_class_name == class_name:
- bbox = left + " " + top + " " + right + " " +bottom
- bounding_boxes.append({"confidence":confidence, "file_id":file_id, "bbox":bbox})
-
- bounding_boxes.sort(key=lambda x:float(x['confidence']), reverse=True)
- with open(TEMP_FILES_PATH + "/" + class_name + "_dr.json", 'w') as outfile:
- json.dump(bounding_boxes, outfile)
-
- sum_AP = 0.0
- ap_dictionary = {}
- lamr_dictionary = {}
- with open(RESULTS_FILES_PATH + "/results.txt", 'w') as results_file:
- results_file.write("# AP and precision/recall per class\n")
- count_true_positives = {}
-
- for class_index, class_name in enumerate(gt_classes):
- count_true_positives[class_name] = 0
- dr_file = TEMP_FILES_PATH + "/" + class_name + "_dr.json"
- dr_data = json.load(open(dr_file))
-
- nd = len(dr_data)
- tp = [0] * nd
- fp = [0] * nd
- score = [0] * nd
- score05_idx = 0
- for idx, detection in enumerate(dr_data):
- file_id = detection["file_id"]
- score[idx] = float(detection["confidence"])
- if score[idx] > 0.5:
- score05_idx = idx
-
- if show_animation:
- ground_truth_img = glob.glob1(IMG_PATH, file_id + ".*")
- if len(ground_truth_img) == 0:
- error("Error. Image not found with id: " + file_id)
- elif len(ground_truth_img) > 1:
- error("Error. Multiple image with id: " + file_id)
- else:
- img = cv2.imread(IMG_PATH + "/" + ground_truth_img[0])
- img_cumulative_path = RESULTS_FILES_PATH + "/images/" + ground_truth_img[0]
- if os.path.isfile(img_cumulative_path):
- img_cumulative = cv2.imread(img_cumulative_path)
- else:
- img_cumulative = img.copy()
- bottom_border = 60
- BLACK = [0, 0, 0]
- img = cv2.copyMakeBorder(img, 0, bottom_border, 0, 0, cv2.BORDER_CONSTANT, value=BLACK)
-
- gt_file = TEMP_FILES_PATH + "/" + file_id + "_ground_truth.json"
- ground_truth_data = json.load(open(gt_file))
- ovmax = -1
- gt_match = -1
- bb = [float(x) for x in detection["bbox"].split()]
- for obj in ground_truth_data:
- if obj["class_name"] == class_name:
- bbgt = [ float(x) for x in obj["bbox"].split() ]
- bi = [max(bb[0],bbgt[0]), max(bb[1],bbgt[1]), min(bb[2],bbgt[2]), min(bb[3],bbgt[3])]
- iw = bi[2] - bi[0] + 1
- ih = bi[3] - bi[1] + 1
- if iw > 0 and ih > 0:
- ua = (bb[2] - bb[0] + 1) * (bb[3] - bb[1] + 1) + (bbgt[2] - bbgt[0]
- + 1) * (bbgt[3] - bbgt[1] + 1) - iw * ih
- ov = iw * ih / ua
- if ov > ovmax:
- ovmax = ov
- gt_match = obj
-
- if show_animation:
- status = "NO MATCH FOUND!"
-
- min_overlap = MINOVERLAP
- if ovmax >= min_overlap:
- if "difficult" not in gt_match:
- if not bool(gt_match["used"]):
- tp[idx] = 1
- gt_match["used"] = True
- count_true_positives[class_name] += 1
- with open(gt_file, 'w') as f:
- f.write(json.dumps(ground_truth_data))
- if show_animation:
- status = "MATCH!"
- else:
- fp[idx] = 1
- if show_animation:
- status = "REPEATED MATCH!"
- else:
- fp[idx] = 1
- if ovmax > 0:
- status = "INSUFFICIENT OVERLAP"
-
- """
- Draw image to show animation
- """
- if show_animation:
- height, widht = img.shape[:2]
- white = (255,255,255)
- light_blue = (255,200,100)
- green = (0,255,0)
- light_red = (30,30,255)
- margin = 10
- # 1nd line
- v_pos = int(height - margin - (bottom_border / 2.0))
- text = "Image: " + ground_truth_img[0] + " "
- img, line_width = draw_text_in_image(img, text, (margin, v_pos), white, 0)
- text = "Class [" + str(class_index) + "/" + str(n_classes) + "]: " + class_name + " "
- img, line_width = draw_text_in_image(img, text, (margin + line_width, v_pos), light_blue, line_width)
- if ovmax != -1:
- color = light_red
- if status == "INSUFFICIENT OVERLAP":
- text = "IoU: {0:.2f}% ".format(ovmax*100) + "< {0:.2f}% ".format(min_overlap*100)
- else:
- text = "IoU: {0:.2f}% ".format(ovmax*100) + ">= {0:.2f}% ".format(min_overlap*100)
- color = green
- img, _ = draw_text_in_image(img, text, (margin + line_width, v_pos), color, line_width)
- # 2nd line
- v_pos += int(bottom_border / 2.0)
- rank_pos = str(idx+1)
- text = "Detection #rank: " + rank_pos + " confidence: {0:.2f}% ".format(float(detection["confidence"])*100)
- img, line_width = draw_text_in_image(img, text, (margin, v_pos), white, 0)
- color = light_red
- if status == "MATCH!":
- color = green
- text = "Result: " + status + " "
- img, line_width = draw_text_in_image(img, text, (margin + line_width, v_pos), color, line_width)
-
- font = cv2.FONT_HERSHEY_SIMPLEX
- if ovmax > 0:
- bbgt = [ int(round(float(x))) for x in gt_match["bbox"].split() ]
- cv2.rectangle(img,(bbgt[0],bbgt[1]),(bbgt[2],bbgt[3]),light_blue,2)
- cv2.rectangle(img_cumulative,(bbgt[0],bbgt[1]),(bbgt[2],bbgt[3]),light_blue,2)
- cv2.putText(img_cumulative, class_name, (bbgt[0],bbgt[1] - 5), font, 0.6, light_blue, 1, cv2.LINE_AA)
- bb = [int(i) for i in bb]
- cv2.rectangle(img,(bb[0],bb[1]),(bb[2],bb[3]),color,2)
- cv2.rectangle(img_cumulative,(bb[0],bb[1]),(bb[2],bb[3]),color,2)
- cv2.putText(img_cumulative, class_name, (bb[0],bb[1] - 5), font, 0.6, color, 1, cv2.LINE_AA)
-
- cv2.imshow("Animation", img)
- cv2.waitKey(20)
- output_img_path = RESULTS_FILES_PATH + "/images/detections_one_by_one/" + class_name + "_detection" + str(idx) + ".jpg"
- cv2.imwrite(output_img_path, img)
- cv2.imwrite(img_cumulative_path, img_cumulative)
-
- cumsum = 0
- for idx, val in enumerate(fp):
- fp[idx] += cumsum
- cumsum += val
-
- cumsum = 0
- for idx, val in enumerate(tp):
- tp[idx] += cumsum
- cumsum += val
-
- rec = tp[:]
- for idx, val in enumerate(tp):
- rec[idx] = float(tp[idx]) / np.maximum(gt_counter_per_class[class_name], 1)
-
- prec = tp[:]
- for idx, val in enumerate(tp):
- prec[idx] = float(tp[idx]) / np.maximum((fp[idx] + tp[idx]), 1)
-
- ap, mrec, mprec = voc_ap(rec[:], prec[:])
- F1 = np.array(rec)*np.array(prec)*2 / np.where((np.array(prec)+np.array(rec))==0, 1, (np.array(prec)+np.array(rec)))
-
- sum_AP += ap
- text = "{0:.2f}%".format(ap*100) + " = " + class_name + " AP " #class_name + " AP = {0:.2f}%".format(ap*100)
-
- if len(prec)>0:
- F1_text = "{0:.2f}".format(F1[score05_idx]) + " = " + class_name + " F1 "
- Recall_text = "{0:.2f}%".format(rec[score05_idx]*100) + " = " + class_name + " Recall "
- Precision_text = "{0:.2f}%".format(prec[score05_idx]*100) + " = " + class_name + " Precision "
- else:
- F1_text = "0.00" + " = " + class_name + " F1 "
- Recall_text = "0.00%" + " = " + class_name + " Recall "
- Precision_text = "0.00%" + " = " + class_name + " Precision "
-
- rounded_prec = [ '%.2f' % elem for elem in prec ]
- rounded_rec = [ '%.2f' % elem for elem in rec ]
- results_file.write(text + "\n Precision: " + str(rounded_prec) + "\n Recall :" + str(rounded_rec) + "\n\n")
- if len(prec)>0:
- print(text + "\t||\tscore_threhold=0.5 : " + "F1=" + "{0:.2f}".format(F1[score05_idx])\
- + " ; Recall=" + "{0:.2f}%".format(rec[score05_idx]*100) + " ; Precision=" + "{0:.2f}%".format(prec[score05_idx]*100))
- else:
- print(text + "\t||\tscore_threhold=0.5 : F1=0.00% ; Recall=0.00% ; Precision=0.00%")
- ap_dictionary[class_name] = ap
-
- n_images = counter_images_per_class[class_name]
- lamr, mr, fppi = log_average_miss_rate(np.array(rec), np.array(fp), n_images)
- lamr_dictionary[class_name] = lamr
-
- if draw_plot:
- plt.plot(rec, prec, '-o')
- area_under_curve_x = mrec[:-1] + [mrec[-2]] + [mrec[-1]]
- area_under_curve_y = mprec[:-1] + [0.0] + [mprec[-1]]
- plt.fill_between(area_under_curve_x, 0, area_under_curve_y, alpha=0.2, edgecolor='r')
-
- fig = plt.gcf()
- fig.canvas.set_window_title('AP ' + class_name)
-
- plt.title('class: ' + text)
- plt.xlabel('Recall')
- plt.ylabel('Precision')
- axes = plt.gca()
- axes.set_xlim([0.0,1.0])
- axes.set_ylim([0.0,1.05])
- fig.savefig(RESULTS_FILES_PATH + "/AP/" + class_name + ".png")
- plt.cla()
-
- plt.plot(score, F1, "-", color='orangered')
- plt.title('class: ' + F1_text + "\nscore_threhold=0.5")
- plt.xlabel('Score_Threhold')
- plt.ylabel('F1')
- axes = plt.gca()
- axes.set_xlim([0.0,1.0])
- axes.set_ylim([0.0,1.05])
- fig.savefig(RESULTS_FILES_PATH + "/F1/" + class_name + ".png")
- plt.cla()
-
- plt.plot(score, rec, "-H", color='gold')
- plt.title('class: ' + Recall_text + "\nscore_threhold=0.5")
- plt.xlabel('Score_Threhold')
- plt.ylabel('Recall')
- axes = plt.gca()
- axes.set_xlim([0.0,1.0])
- axes.set_ylim([0.0,1.05])
- fig.savefig(RESULTS_FILES_PATH + "/Recall/" + class_name + ".png")
- plt.cla()
-
- plt.plot(score, prec, "-s", color='palevioletred')
- plt.title('class: ' + Precision_text + "\nscore_threhold=0.5")
- plt.xlabel('Score_Threhold')
- plt.ylabel('Precision')
- axes = plt.gca()
- axes.set_xlim([0.0,1.0])
- axes.set_ylim([0.0,1.05])
- fig.savefig(RESULTS_FILES_PATH + "/Precision/" + class_name + ".png")
- plt.cla()
-
- if show_animation:
- cv2.destroyAllWindows()
-
- results_file.write("\n# mAP of all classes\n")
- mAP = sum_AP / n_classes
- text = "mAP = {0:.2f}%".format(mAP*100)
- results_file.write(text + "\n")
- print(text)
-
- shutil.rmtree(TEMP_FILES_PATH)
-
- """
- Count total of detection-results
- """
- det_counter_per_class = {}
- for txt_file in dr_files_list:
- lines_list = file_lines_to_list(txt_file)
- for line in lines_list:
- class_name = line.split()[0]
- if class_name in det_counter_per_class:
- det_counter_per_class[class_name] += 1
- else:
- det_counter_per_class[class_name] = 1
- dr_classes = list(det_counter_per_class.keys())
-
- """
- Write number of ground-truth objects per class to results.txt
- """
- with open(RESULTS_FILES_PATH + "/results.txt", 'a') as results_file:
- results_file.write("\n# Number of ground-truth objects per class\n")
- for class_name in sorted(gt_counter_per_class):
- results_file.write(class_name + ": " + str(gt_counter_per_class[class_name]) + "\n")
-
- """
- Finish counting true positives
- """
- for class_name in dr_classes:
- if class_name not in gt_classes:
- count_true_positives[class_name] = 0
-
- """
- Write number of detected objects per class to results.txt
- """
- with open(RESULTS_FILES_PATH + "/results.txt", 'a') as results_file:
- results_file.write("\n# Number of detected objects per class\n")
- for class_name in sorted(dr_classes):
- n_det = det_counter_per_class[class_name]
- text = class_name + ": " + str(n_det)
- text += " (tp:" + str(count_true_positives[class_name]) + ""
- text += ", fp:" + str(n_det - count_true_positives[class_name]) + ")\n"
- results_file.write(text)
-
- """
- Plot the total number of occurences of each class in the ground-truth
- """
- if draw_plot:
- window_title = "ground-truth-info"
- plot_title = "ground-truth\n"
- plot_title += "(" + str(len(ground_truth_files_list)) + " files and " + str(n_classes) + " classes)"
- x_label = "Number of objects per class"
- output_path = RESULTS_FILES_PATH + "/ground-truth-info.png"
- to_show = False
- plot_color = 'forestgreen'
- draw_plot_func(
- gt_counter_per_class,
- n_classes,
- window_title,
- plot_title,
- x_label,
- output_path,
- to_show,
- plot_color,
- '',
- )
-
- # """
- # Plot the total number of occurences of each class in the "detection-results" folder
- # """
- # if draw_plot:
- # window_title = "detection-results-info"
- # # Plot title
- # plot_title = "detection-results\n"
- # plot_title += "(" + str(len(dr_files_list)) + " files and "
- # count_non_zero_values_in_dictionary = sum(int(x) > 0 for x in list(det_counter_per_class.values()))
- # plot_title += str(count_non_zero_values_in_dictionary) + " detected classes)"
- # # end Plot title
- # x_label = "Number of objects per class"
- # output_path = RESULTS_FILES_PATH + "/detection-results-info.png"
- # to_show = False
- # plot_color = 'forestgreen'
- # true_p_bar = count_true_positives
- # draw_plot_func(
- # det_counter_per_class,
- # len(det_counter_per_class),
- # window_title,
- # plot_title,
- # x_label,
- # output_path,
- # to_show,
- # plot_color,
- # true_p_bar
- # )
-
- """
- Draw log-average miss rate plot (Show lamr of all classes in decreasing order)
- """
- if draw_plot:
- window_title = "lamr"
- plot_title = "log-average miss rate"
- x_label = "log-average miss rate"
- output_path = RESULTS_FILES_PATH + "/lamr.png"
- to_show = False
- plot_color = 'royalblue'
- draw_plot_func(
- lamr_dictionary,
- n_classes,
- window_title,
- plot_title,
- x_label,
- output_path,
- to_show,
- plot_color,
- ""
- )
-
- """
- Draw mAP plot (Show AP's of all classes in decreasing order)
- """
- if draw_plot:
- window_title = "mAP"
- plot_title = "mAP = {0:.2f}%".format(mAP*100)
- x_label = "Average Precision"
- output_path = RESULTS_FILES_PATH + "/mAP.png"
- to_show = True
- plot_color = 'royalblue'
- draw_plot_func(
- ap_dictionary,
- n_classes,
- window_title,
- plot_title,
- x_label,
- output_path,
- to_show,
- plot_color,
- ""
- )
-
-def preprocess_gt(gt_path, class_names):
- image_ids = os.listdir(gt_path)
- results = {}
-
- images = []
- bboxes = []
- for i, image_id in enumerate(image_ids):
- lines_list = file_lines_to_list(os.path.join(gt_path, image_id))
- boxes_per_image = []
- image = {}
- image_id = os.path.splitext(image_id)[0]
- image['file_name'] = image_id + '.jpg'
- image['width'] = 1
- image['height'] = 1
- #-----------------------------------------------------------------#
- # 感谢 多学学英语吧 的提醒
- # 解决了'Results do not correspond to current coco set'问题
- #-----------------------------------------------------------------#
- image['id'] = str(image_id)
-
- for line in lines_list:
- difficult = 0
- if "difficult" in line:
- line_split = line.split()
- left, top, right, bottom, _difficult = line_split[-5:]
- class_name = ""
- for name in line_split[:-5]:
- class_name += name + " "
- class_name = class_name[:-1]
- difficult = 1
- else:
- line_split = line.split()
- left, top, right, bottom = line_split[-4:]
- class_name = ""
- for name in line_split[:-4]:
- class_name += name + " "
- class_name = class_name[:-1]
-
- left, top, right, bottom = float(left), float(top), float(right), float(bottom)
- cls_id = class_names.index(class_name) + 1
- bbox = [left, top, right - left, bottom - top, difficult, str(image_id), cls_id, (right - left) * (bottom - top) - 10.0]
- boxes_per_image.append(bbox)
- images.append(image)
- bboxes.extend(boxes_per_image)
- results['images'] = images
-
- categories = []
- for i, cls in enumerate(class_names):
- category = {}
- category['supercategory'] = cls
- category['name'] = cls
- category['id'] = i + 1
- categories.append(category)
- results['categories'] = categories
-
- annotations = []
- for i, box in enumerate(bboxes):
- annotation = {}
- annotation['area'] = box[-1]
- annotation['category_id'] = box[-2]
- annotation['image_id'] = box[-3]
- annotation['iscrowd'] = box[-4]
- annotation['bbox'] = box[:4]
- annotation['id'] = i
- annotations.append(annotation)
- results['annotations'] = annotations
- return results
-
-def preprocess_dr(dr_path, class_names):
- image_ids = os.listdir(dr_path)
- results = []
- for image_id in image_ids:
- lines_list = file_lines_to_list(os.path.join(dr_path, image_id))
- image_id = os.path.splitext(image_id)[0]
- for line in lines_list:
- line_split = line.split()
- confidence, left, top, right, bottom = line_split[-5:]
- class_name = ""
- for name in line_split[:-5]:
- class_name += name + " "
- class_name = class_name[:-1]
- left, top, right, bottom = float(left), float(top), float(right), float(bottom)
- result = {}
- result["image_id"] = str(image_id)
- result["category_id"] = class_names.index(class_name) + 1
- result["bbox"] = [left, top, right - left, bottom - top]
- result["score"] = float(confidence)
- results.append(result)
- return results
-
-def get_coco_map(class_names, path):
- from pycocotools.coco import COCO
- from pycocotools.cocoeval import COCOeval
-
- GT_PATH = os.path.join(path, 'ground-truth')
- DR_PATH = os.path.join(path, 'detection-results')
- COCO_PATH = os.path.join(path, 'coco_eval')
-
- if not os.path.exists(COCO_PATH):
- os.makedirs(COCO_PATH)
-
- GT_JSON_PATH = os.path.join(COCO_PATH, 'instances_gt.json')
- DR_JSON_PATH = os.path.join(COCO_PATH, 'instances_dr.json')
-
- with open(GT_JSON_PATH, "w") as f:
- results_gt = preprocess_gt(GT_PATH, class_names)
- json.dump(results_gt, f, indent=4)
-
- with open(DR_JSON_PATH, "w") as f:
- results_dr = preprocess_dr(DR_PATH, class_names)
- json.dump(results_dr, f, indent=4)
-
- cocoGt = COCO(GT_JSON_PATH)
- cocoDt = cocoGt.loadRes(DR_JSON_PATH)
- cocoEval = COCOeval(cocoGt, cocoDt, 'bbox')
- cocoEval.evaluate()
- cocoEval.accumulate()
- cocoEval.summarize()
diff --git a/spaces/Kevin676/ChatGPT-with-Voice-Cloning-in-Chinese/ppg_extractor/encoder/embedding.py b/spaces/Kevin676/ChatGPT-with-Voice-Cloning-in-Chinese/ppg_extractor/encoder/embedding.py
deleted file mode 100644
index fa3199cf7e3da2ed834d4781b694cf4ccb2a433c..0000000000000000000000000000000000000000
--- a/spaces/Kevin676/ChatGPT-with-Voice-Cloning-in-Chinese/ppg_extractor/encoder/embedding.py
+++ /dev/null
@@ -1,166 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-# Copyright 2019 Shigeki Karita
-# Apache 2.0 (http://www.apache.org/licenses/LICENSE-2.0)
-
-"""Positonal Encoding Module."""
-
-import math
-
-import torch
-
-
-def _pre_hook(
- state_dict,
- prefix,
- local_metadata,
- strict,
- missing_keys,
- unexpected_keys,
- error_msgs,
-):
- """Perform pre-hook in load_state_dict for backward compatibility.
-
- Note:
- We saved self.pe until v.0.5.2 but we have omitted it later.
- Therefore, we remove the item "pe" from `state_dict` for backward compatibility.
-
- """
- k = prefix + "pe"
- if k in state_dict:
- state_dict.pop(k)
-
-
-class PositionalEncoding(torch.nn.Module):
- """Positional encoding.
-
- :param int d_model: embedding dim
- :param float dropout_rate: dropout rate
- :param int max_len: maximum input length
- :param reverse: whether to reverse the input position
-
- """
-
- def __init__(self, d_model, dropout_rate, max_len=5000, reverse=False):
- """Construct an PositionalEncoding object."""
- super(PositionalEncoding, self).__init__()
- self.d_model = d_model
- self.reverse = reverse
- self.xscale = math.sqrt(self.d_model)
- self.dropout = torch.nn.Dropout(p=dropout_rate)
- self.pe = None
- self.extend_pe(torch.tensor(0.0).expand(1, max_len))
- self._register_load_state_dict_pre_hook(_pre_hook)
-
- def extend_pe(self, x):
- """Reset the positional encodings."""
- if self.pe is not None:
- if self.pe.size(1) >= x.size(1):
- if self.pe.dtype != x.dtype or self.pe.device != x.device:
- self.pe = self.pe.to(dtype=x.dtype, device=x.device)
- return
- pe = torch.zeros(x.size(1), self.d_model)
- if self.reverse:
- position = torch.arange(
- x.size(1) - 1, -1, -1.0, dtype=torch.float32
- ).unsqueeze(1)
- else:
- position = torch.arange(0, x.size(1), dtype=torch.float32).unsqueeze(1)
- div_term = torch.exp(
- torch.arange(0, self.d_model, 2, dtype=torch.float32)
- * -(math.log(10000.0) / self.d_model)
- )
- pe[:, 0::2] = torch.sin(position * div_term)
- pe[:, 1::2] = torch.cos(position * div_term)
- pe = pe.unsqueeze(0)
- self.pe = pe.to(device=x.device, dtype=x.dtype)
-
- def forward(self, x: torch.Tensor):
- """Add positional encoding.
-
- Args:
- x (torch.Tensor): Input. Its shape is (batch, time, ...)
-
- Returns:
- torch.Tensor: Encoded tensor. Its shape is (batch, time, ...)
-
- """
- self.extend_pe(x)
- x = x * self.xscale + self.pe[:, : x.size(1)]
- return self.dropout(x)
-
-
-class ScaledPositionalEncoding(PositionalEncoding):
- """Scaled positional encoding module.
-
- See also: Sec. 3.2 https://arxiv.org/pdf/1809.08895.pdf
-
- """
-
- def __init__(self, d_model, dropout_rate, max_len=5000):
- """Initialize class.
-
- :param int d_model: embedding dim
- :param float dropout_rate: dropout rate
- :param int max_len: maximum input length
-
- """
- super().__init__(d_model=d_model, dropout_rate=dropout_rate, max_len=max_len)
- self.alpha = torch.nn.Parameter(torch.tensor(1.0))
-
- def reset_parameters(self):
- """Reset parameters."""
- self.alpha.data = torch.tensor(1.0)
-
- def forward(self, x):
- """Add positional encoding.
-
- Args:
- x (torch.Tensor): Input. Its shape is (batch, time, ...)
-
- Returns:
- torch.Tensor: Encoded tensor. Its shape is (batch, time, ...)
-
- """
- self.extend_pe(x)
- x = x + self.alpha * self.pe[:, : x.size(1)]
- return self.dropout(x)
-
-
-class RelPositionalEncoding(PositionalEncoding):
- """Relitive positional encoding module.
-
- See : Appendix B in https://arxiv.org/abs/1901.02860
-
- :param int d_model: embedding dim
- :param float dropout_rate: dropout rate
- :param int max_len: maximum input length
-
- """
-
- def __init__(self, d_model, dropout_rate, max_len=5000):
- """Initialize class.
-
- :param int d_model: embedding dim
- :param float dropout_rate: dropout rate
- :param int max_len: maximum input length
-
- """
- super().__init__(d_model, dropout_rate, max_len, reverse=True)
-
- def forward(self, x):
- """Compute positional encoding.
-
- Args:
- x (torch.Tensor): Input. Its shape is (batch, time, ...)
-
- Returns:
- torch.Tensor: x. Its shape is (batch, time, ...)
- torch.Tensor: pos_emb. Its shape is (1, time, ...)
-
- """
- self.extend_pe(x)
- x = x * self.xscale
- pos_emb = self.pe[:, : x.size(1)]
- return self.dropout(x), self.dropout(pos_emb)
diff --git a/spaces/Kimata/multimodal_deepfake_detection/models/TMC.py b/spaces/Kimata/multimodal_deepfake_detection/models/TMC.py
deleted file mode 100644
index 09ea4821f7181900aff7d8af18bf0e1323b4e7e2..0000000000000000000000000000000000000000
--- a/spaces/Kimata/multimodal_deepfake_detection/models/TMC.py
+++ /dev/null
@@ -1,156 +0,0 @@
-import torch
-import torch.nn as nn
-from models import image
-import torch.nn.functional as F
-
-
-# loss function
-def KL(alpha, c):
- if torch.cuda.is_available():
- beta = torch.ones((1, c)).cuda()
- else:
- beta = torch.ones((1, c))
- S_alpha = torch.sum(alpha, dim=1, keepdim=True)
- S_beta = torch.sum(beta, dim=1, keepdim=True)
- lnB = torch.lgamma(S_alpha) - torch.sum(torch.lgamma(alpha), dim=1, keepdim=True)
- lnB_uni = torch.sum(torch.lgamma(beta), dim=1, keepdim=True) - torch.lgamma(S_beta)
- dg0 = torch.digamma(S_alpha)
- dg1 = torch.digamma(alpha)
- kl = torch.sum((alpha - beta) * (dg1 - dg0), dim=1, keepdim=True) + lnB + lnB_uni
- return kl
-
-def ce_loss(p, alpha, c, global_step, annealing_step):
- S = torch.sum(alpha, dim=1, keepdim=True)
- E = alpha - 1
- label = p
- A = torch.sum(label * (torch.digamma(S) - torch.digamma(alpha)), dim=1, keepdim=True)
-
- annealing_coef = min(1, global_step / annealing_step)
- alp = E * (1 - label) + 1
- B = annealing_coef * KL(alp, c)
- return torch.mean((A + B))
-
-
-class TMC(nn.Module):
- def __init__(self, args):
- super(TMC, self).__init__()
- self.args = args
- self.rgbenc = image.ImageEncoder(args)
- self.specenc = image.RawNet(args)
-
- spec_last_size = args.img_hidden_sz * 1
- rgb_last_size = args.img_hidden_sz * args.num_image_embeds
- self.spec_depth = nn.ModuleList()
- self.clf_rgb = nn.ModuleList()
-
- for hidden in args.hidden:
- self.spec_depth.append(nn.Linear(spec_last_size, hidden))
- self.spec_depth.append(nn.ReLU())
- self.spec_depth.append(nn.Dropout(args.dropout))
- spec_last_size = hidden
- self.spec_depth.append(nn.Linear(spec_last_size, args.n_classes))
-
- for hidden in args.hidden:
- self.clf_rgb.append(nn.Linear(rgb_last_size, hidden))
- self.clf_rgb.append(nn.ReLU())
- self.clf_rgb.append(nn.Dropout(args.dropout))
- rgb_last_size = hidden
- self.clf_rgb.append(nn.Linear(rgb_last_size, args.n_classes))
-
- def DS_Combin_two(self, alpha1, alpha2):
- # Calculate the merger of two DS evidences
- alpha = dict()
- alpha[0], alpha[1] = alpha1, alpha2
- b, S, E, u = dict(), dict(), dict(), dict()
- for v in range(2):
- S[v] = torch.sum(alpha[v], dim=1, keepdim=True)
- E[v] = alpha[v] - 1
- b[v] = E[v] / (S[v].expand(E[v].shape))
- u[v] = self.args.n_classes / S[v]
-
- # b^0 @ b^(0+1)
- bb = torch.bmm(b[0].view(-1, self.args.n_classes, 1), b[1].view(-1, 1, self.args.n_classes))
- # b^0 * u^1
- uv1_expand = u[1].expand(b[0].shape)
- bu = torch.mul(b[0], uv1_expand)
- # b^1 * u^0
- uv_expand = u[0].expand(b[0].shape)
- ub = torch.mul(b[1], uv_expand)
- # calculate K
- bb_sum = torch.sum(bb, dim=(1, 2), out=None)
- bb_diag = torch.diagonal(bb, dim1=-2, dim2=-1).sum(-1)
- # bb_diag1 = torch.diag(torch.mm(b[v], torch.transpose(b[v+1], 0, 1)))
- K = bb_sum - bb_diag
-
- # calculate b^a
- b_a = (torch.mul(b[0], b[1]) + bu + ub) / ((1 - K).view(-1, 1).expand(b[0].shape))
- # calculate u^a
- u_a = torch.mul(u[0], u[1]) / ((1 - K).view(-1, 1).expand(u[0].shape))
- # test = torch.sum(b_a, dim = 1, keepdim = True) + u_a #Verify programming errors
-
- # calculate new S
- S_a = self.args.n_classes / u_a
- # calculate new e_k
- e_a = torch.mul(b_a, S_a.expand(b_a.shape))
- alpha_a = e_a + 1
- return alpha_a
-
- def forward(self, rgb, spec):
- spec = self.specenc(spec)
- spec = torch.flatten(spec, start_dim=1)
-
- rgb = self.rgbenc(rgb)
- rgb = torch.flatten(rgb, start_dim=1)
-
- spec_out = spec
-
- for layer in self.spec_depth:
- spec_out = layer(spec_out)
-
- rgb_out = rgb
-
- for layer in self.clf_rgb:
- rgb_out = layer(rgb_out)
-
- spec_evidence, rgb_evidence = F.softplus(spec_out), F.softplus(rgb_out)
- spec_alpha, rgb_alpha = spec_evidence+1, rgb_evidence+1
- spec_rgb_alpha = self.DS_Combin_two(spec_alpha, rgb_alpha)
- return spec_alpha, rgb_alpha, spec_rgb_alpha
-
-
-class ETMC(TMC):
- def __init__(self, args):
- super(ETMC, self).__init__(args)
- last_size = args.img_hidden_sz * args.num_image_embeds + args.img_hidden_sz * args.num_image_embeds
- self.clf = nn.ModuleList()
- for hidden in args.hidden:
- self.clf.append(nn.Linear(last_size, hidden))
- self.clf.append(nn.ReLU())
- self.clf.append(nn.Dropout(args.dropout))
- last_size = hidden
- self.clf.append(nn.Linear(last_size, args.n_classes))
-
- def forward(self, rgb, spec):
- spec = self.specenc(spec)
- spec = torch.flatten(spec, start_dim=1)
-
- rgb = self.rgbenc(rgb)
- rgb = torch.flatten(rgb, start_dim=1)
-
- spec_out = spec
- for layer in self.spec_depth:
- spec_out = layer(spec_out)
-
- rgb_out = rgb
- for layer in self.clf_rgb:
- rgb_out = layer(rgb_out)
-
- pseudo_out = torch.cat([rgb, spec], -1)
- for layer in self.clf:
- pseudo_out = layer(pseudo_out)
-
- depth_evidence, rgb_evidence, pseudo_evidence = F.softplus(spec_out), F.softplus(rgb_out), F.softplus(pseudo_out)
- depth_alpha, rgb_alpha, pseudo_alpha = depth_evidence+1, rgb_evidence+1, pseudo_evidence+1
- depth_rgb_alpha = self.DS_Combin_two(self.DS_Combin_two(depth_alpha, rgb_alpha), pseudo_alpha)
- return depth_alpha, rgb_alpha, pseudo_alpha, depth_rgb_alpha
-
diff --git a/spaces/KonradSzafer/HF-QA-Demo/data/get_hf_repositories_urls.py b/spaces/KonradSzafer/HF-QA-Demo/data/get_hf_repositories_urls.py
deleted file mode 100644
index 50d0b677044c5a5f6028363ed983fc304afd85f2..0000000000000000000000000000000000000000
--- a/spaces/KonradSzafer/HF-QA-Demo/data/get_hf_repositories_urls.py
+++ /dev/null
@@ -1,49 +0,0 @@
-import json
-import argparse
-import requests
-from typing import List
-
-
-def get_repositories_names(token: str, min_stars: int) -> List[str]:
- repos_per_page = 100
- repo_names = []
- i = 0
- while True:
- url = \
- f'https://api.github.com/orgs/huggingface/repos?' \
- f'per_page={repos_per_page}&page={i}'
- headers = {'Authorization': f'token {token}'}
- response = requests.get(url, headers=headers)
- if response.status_code == 200:
- repos = json.loads(response.content)
- repo_names += [
- repo['full_name'] for repo in repos
- if repo['stargazers_count'] >= min_stars
- ]
- if len(repos) < repos_per_page:
- break
- i += 1
- else:
- return 'Error: '+str(response.status_code)
- return list(set(repo_names))
-
-
-def save_repositories_urls(repositories_names: List[str], output_filename: str):
- urls = [f'https://github.com/{repo_name}' for repo_name in repositories_names]
- data = {'urls': urls}
- with open(output_filename, 'w') as f:
- json.dump(data, f, indent=4)
-
-
-if __name__ == '__main__':
- parser = argparse.ArgumentParser()
- parser.add_argument('--token', type=str)
- parser.add_argument('--stars', type=str)
- args = parser.parse_args()
- repositories = get_repositories_names(token=args.token, min_stars=int(args.stars))
- repositories += [
- 'huggingface/hf-endpoints-documentation',
- 'gradio-app/gradio'
- ]
- print(f'Found {len(repositories)} repositories with at least {args.stars} stars')
- save_repositories_urls(repositories, 'datasets/hf_repositories_urls_scraped.json')
diff --git a/spaces/KyanChen/RSPrompter/mmdet/datasets/base_det_dataset.py b/spaces/KyanChen/RSPrompter/mmdet/datasets/base_det_dataset.py
deleted file mode 100644
index cbc6bad46f9880ce62dafac911cba1698466ffe7..0000000000000000000000000000000000000000
--- a/spaces/KyanChen/RSPrompter/mmdet/datasets/base_det_dataset.py
+++ /dev/null
@@ -1,120 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import os.path as osp
-from typing import List, Optional
-
-from mmengine.dataset import BaseDataset
-from mmengine.fileio import load
-from mmengine.utils import is_abs
-
-from ..registry import DATASETS
-
-
-@DATASETS.register_module()
-class BaseDetDataset(BaseDataset):
- """Base dataset for detection.
-
- Args:
- proposal_file (str, optional): Proposals file path. Defaults to None.
- file_client_args (dict): Arguments to instantiate the
- corresponding backend in mmdet <= 3.0.0rc6. Defaults to None.
- backend_args (dict, optional): Arguments to instantiate the
- corresponding backend. Defaults to None.
- """
-
- def __init__(self,
- *args,
- seg_map_suffix: str = '.png',
- proposal_file: Optional[str] = None,
- file_client_args: dict = None,
- backend_args: dict = None,
- **kwargs) -> None:
- self.seg_map_suffix = seg_map_suffix
- self.proposal_file = proposal_file
- self.backend_args = backend_args
- if file_client_args is not None:
- raise RuntimeError(
- 'The `file_client_args` is deprecated, '
- 'please use `backend_args` instead, please refer to'
- 'https://github.com/open-mmlab/mmdetection/blob/main/configs/_base_/datasets/coco_detection.py' # noqa: E501
- )
- super().__init__(*args, **kwargs)
-
- def full_init(self) -> None:
- """Load annotation file and set ``BaseDataset._fully_initialized`` to
- True.
-
- If ``lazy_init=False``, ``full_init`` will be called during the
- instantiation and ``self._fully_initialized`` will be set to True. If
- ``obj._fully_initialized=False``, the class method decorated by
- ``force_full_init`` will call ``full_init`` automatically.
-
- Several steps to initialize annotation:
-
- - load_data_list: Load annotations from annotation file.
- - load_proposals: Load proposals from proposal file, if
- `self.proposal_file` is not None.
- - filter data information: Filter annotations according to
- filter_cfg.
- - slice_data: Slice dataset according to ``self._indices``
- - serialize_data: Serialize ``self.data_list`` if
- ``self.serialize_data`` is True.
- """
- if self._fully_initialized:
- return
- # load data information
- self.data_list = self.load_data_list()
- # get proposals from file
- if self.proposal_file is not None:
- self.load_proposals()
- # filter illegal data, such as data that has no annotations.
- self.data_list = self.filter_data()
-
- # Get subset data according to indices.
- if self._indices is not None:
- self.data_list = self._get_unserialized_subset(self._indices)
-
- # serialize data_list
- if self.serialize_data:
- self.data_bytes, self.data_address = self._serialize_data()
-
- self._fully_initialized = True
-
- def load_proposals(self) -> None:
- """Load proposals from proposals file.
-
- The `proposals_list` should be a dict[img_path: proposals]
- with the same length as `data_list`. And the `proposals` should be
- a `dict` or :obj:`InstanceData` usually contains following keys.
-
- - bboxes (np.ndarry): Has a shape (num_instances, 4),
- the last dimension 4 arrange as (x1, y1, x2, y2).
- - scores (np.ndarry): Classification scores, has a shape
- (num_instance, ).
- """
- # TODO: Add Unit Test after fully support Dump-Proposal Metric
- if not is_abs(self.proposal_file):
- self.proposal_file = osp.join(self.data_root, self.proposal_file)
- proposals_list = load(
- self.proposal_file, backend_args=self.backend_args)
- assert len(self.data_list) == len(proposals_list)
- for data_info in self.data_list:
- img_path = data_info['img_path']
- # `file_name` is the key to obtain the proposals from the
- # `proposals_list`.
- file_name = osp.join(
- osp.split(osp.split(img_path)[0])[-1],
- osp.split(img_path)[-1])
- proposals = proposals_list[file_name]
- data_info['proposals'] = proposals
-
- def get_cat_ids(self, idx: int) -> List[int]:
- """Get COCO category ids by index.
-
- Args:
- idx (int): Index of data.
-
- Returns:
- List[int]: All categories in the image of specified index.
- """
- instances = self.get_data_info(idx)['instances']
- return [instance['bbox_label'] for instance in instances]
diff --git a/spaces/KyanChen/RSPrompter/mmdet/models/dense_heads/yolact_head.py b/spaces/KyanChen/RSPrompter/mmdet/models/dense_heads/yolact_head.py
deleted file mode 100644
index 2e2d60225dd708868bed2797fad34c2b6e4a5fd1..0000000000000000000000000000000000000000
--- a/spaces/KyanChen/RSPrompter/mmdet/models/dense_heads/yolact_head.py
+++ /dev/null
@@ -1,1193 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import copy
-from typing import List, Optional
-
-import numpy as np
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from mmcv.cnn import ConvModule
-from mmengine.model import BaseModule, ModuleList
-from mmengine.structures import InstanceData
-from torch import Tensor
-
-from mmdet.registry import MODELS
-from mmdet.utils import (ConfigType, InstanceList, OptConfigType,
- OptInstanceList, OptMultiConfig)
-from ..layers import fast_nms
-from ..utils import images_to_levels, multi_apply, select_single_mlvl
-from ..utils.misc import empty_instances
-from .anchor_head import AnchorHead
-from .base_mask_head import BaseMaskHead
-
-
-@MODELS.register_module()
-class YOLACTHead(AnchorHead):
- """YOLACT box head used in https://arxiv.org/abs/1904.02689.
-
- Note that YOLACT head is a light version of RetinaNet head.
- Four differences are described as follows:
-
- 1. YOLACT box head has three-times fewer anchors.
- 2. YOLACT box head shares the convs for box and cls branches.
- 3. YOLACT box head uses OHEM instead of Focal loss.
- 4. YOLACT box head predicts a set of mask coefficients for each box.
-
- Args:
- num_classes (int): Number of categories excluding the background
- category.
- in_channels (int): Number of channels in the input feature map.
- anchor_generator (:obj:`ConfigDict` or dict): Config dict for
- anchor generator
- loss_cls (:obj:`ConfigDict` or dict): Config of classification loss.
- loss_bbox (:obj:`ConfigDict` or dict): Config of localization loss.
- num_head_convs (int): Number of the conv layers shared by
- box and cls branches.
- num_protos (int): Number of the mask coefficients.
- use_ohem (bool): If true, ``loss_single_OHEM`` will be used for
- cls loss calculation. If false, ``loss_single`` will be used.
- conv_cfg (:obj:`ConfigDict` or dict, optional): Dictionary to
- construct and config conv layer.
- norm_cfg (:obj:`ConfigDict` or dict, optional): Dictionary to
- construct and config norm layer.
- init_cfg (:obj:`ConfigDict` or list[:obj:`ConfigDict`] or dict or
- list[dict], optional): Initialization config dict.
- """
-
- def __init__(self,
- num_classes: int,
- in_channels: int,
- anchor_generator: ConfigType = dict(
- type='mmdet.AnchorGenerator',
- octave_base_scale=3,
- scales_per_octave=1,
- ratios=[0.5, 1.0, 2.0],
- strides=[8, 16, 32, 64, 128]),
- loss_cls: ConfigType = dict(
- type='mmdet.CrossEntropyLoss',
- use_sigmoid=False,
- reduction='none',
- loss_weight=1.0),
- loss_bbox: ConfigType = dict(
- type='mmdet.SmoothL1Loss', beta=1.0, loss_weight=1.5),
- num_head_convs: int = 1,
- num_protos: int = 32,
- use_ohem: bool = True,
- conv_cfg: OptConfigType = None,
- norm_cfg: OptConfigType = None,
- init_cfg: OptMultiConfig = dict(
- type='Xavier',
- distribution='uniform',
- bias=0,
- layer='Conv2d'),
- **kwargs) -> None:
- self.num_head_convs = num_head_convs
- self.num_protos = num_protos
- self.use_ohem = use_ohem
- self.conv_cfg = conv_cfg
- self.norm_cfg = norm_cfg
- super().__init__(
- num_classes=num_classes,
- in_channels=in_channels,
- loss_cls=loss_cls,
- loss_bbox=loss_bbox,
- anchor_generator=anchor_generator,
- init_cfg=init_cfg,
- **kwargs)
-
- def _init_layers(self) -> None:
- """Initialize layers of the head."""
- self.relu = nn.ReLU(inplace=True)
- self.head_convs = ModuleList()
- for i in range(self.num_head_convs):
- chn = self.in_channels if i == 0 else self.feat_channels
- self.head_convs.append(
- ConvModule(
- chn,
- self.feat_channels,
- 3,
- stride=1,
- padding=1,
- conv_cfg=self.conv_cfg,
- norm_cfg=self.norm_cfg))
- self.conv_cls = nn.Conv2d(
- self.feat_channels,
- self.num_base_priors * self.cls_out_channels,
- 3,
- padding=1)
- self.conv_reg = nn.Conv2d(
- self.feat_channels, self.num_base_priors * 4, 3, padding=1)
- self.conv_coeff = nn.Conv2d(
- self.feat_channels,
- self.num_base_priors * self.num_protos,
- 3,
- padding=1)
-
- def forward_single(self, x: Tensor) -> tuple:
- """Forward feature of a single scale level.
-
- Args:
- x (Tensor): Features of a single scale level.
-
- Returns:
- tuple:
-
- - cls_score (Tensor): Cls scores for a single scale level
- the channels number is num_anchors * num_classes.
- - bbox_pred (Tensor): Box energies / deltas for a single scale
- level, the channels number is num_anchors * 4.
- - coeff_pred (Tensor): Mask coefficients for a single scale
- level, the channels number is num_anchors * num_protos.
- """
- for head_conv in self.head_convs:
- x = head_conv(x)
- cls_score = self.conv_cls(x)
- bbox_pred = self.conv_reg(x)
- coeff_pred = self.conv_coeff(x).tanh()
- return cls_score, bbox_pred, coeff_pred
-
- def loss_by_feat(
- self,
- cls_scores: List[Tensor],
- bbox_preds: List[Tensor],
- coeff_preds: List[Tensor],
- batch_gt_instances: InstanceList,
- batch_img_metas: List[dict],
- batch_gt_instances_ignore: OptInstanceList = None) -> dict:
- """Calculate the loss based on the features extracted by the bbox head.
-
- When ``self.use_ohem == True``, it functions like ``SSDHead.loss``,
- otherwise, it follows ``AnchorHead.loss``.
-
- Args:
- cls_scores (list[Tensor]): Box scores for each scale level
- has shape (N, num_anchors * num_classes, H, W).
- bbox_preds (list[Tensor]): Box energies / deltas for each scale
- level with shape (N, num_anchors * 4, H, W).
- coeff_preds (list[Tensor]): Mask coefficients for each scale
- level with shape (N, num_anchors * num_protos, H, W)
- batch_gt_instances (list[:obj:`InstanceData`]): Batch of
- gt_instance. It usually includes ``bboxes`` and ``labels``
- attributes.
- batch_img_metas (list[dict]): Meta information of each image, e.g.,
- image size, scaling factor, etc.
- batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
- Batch of gt_instances_ignore. It includes ``bboxes`` attribute
- data that is ignored during training and testing.
- Defaults to None.
-
- Returns:
- dict: A dictionary of loss components.
- """
- featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
- assert len(featmap_sizes) == self.prior_generator.num_levels
-
- device = cls_scores[0].device
-
- anchor_list, valid_flag_list = self.get_anchors(
- featmap_sizes, batch_img_metas, device=device)
- cls_reg_targets = self.get_targets(
- anchor_list,
- valid_flag_list,
- batch_gt_instances,
- batch_img_metas,
- batch_gt_instances_ignore=batch_gt_instances_ignore,
- unmap_outputs=not self.use_ohem,
- return_sampling_results=True)
- (labels_list, label_weights_list, bbox_targets_list, bbox_weights_list,
- avg_factor, sampling_results) = cls_reg_targets
-
- if self.use_ohem:
- num_images = len(batch_img_metas)
- all_cls_scores = torch.cat([
- s.permute(0, 2, 3, 1).reshape(
- num_images, -1, self.cls_out_channels) for s in cls_scores
- ], 1)
- all_labels = torch.cat(labels_list, -1).view(num_images, -1)
- all_label_weights = torch.cat(label_weights_list,
- -1).view(num_images, -1)
- all_bbox_preds = torch.cat([
- b.permute(0, 2, 3, 1).reshape(num_images, -1, 4)
- for b in bbox_preds
- ], -2)
- all_bbox_targets = torch.cat(bbox_targets_list,
- -2).view(num_images, -1, 4)
- all_bbox_weights = torch.cat(bbox_weights_list,
- -2).view(num_images, -1, 4)
-
- # concat all level anchors to a single tensor
- all_anchors = []
- for i in range(num_images):
- all_anchors.append(torch.cat(anchor_list[i]))
-
- # check NaN and Inf
- assert torch.isfinite(all_cls_scores).all().item(), \
- 'classification scores become infinite or NaN!'
- assert torch.isfinite(all_bbox_preds).all().item(), \
- 'bbox predications become infinite or NaN!'
-
- losses_cls, losses_bbox = multi_apply(
- self.OHEMloss_by_feat_single,
- all_cls_scores,
- all_bbox_preds,
- all_anchors,
- all_labels,
- all_label_weights,
- all_bbox_targets,
- all_bbox_weights,
- avg_factor=avg_factor)
- else:
- # anchor number of multi levels
- num_level_anchors = [anchors.size(0) for anchors in anchor_list[0]]
- # concat all level anchors and flags to a single tensor
- concat_anchor_list = []
- for i in range(len(anchor_list)):
- concat_anchor_list.append(torch.cat(anchor_list[i]))
- all_anchor_list = images_to_levels(concat_anchor_list,
- num_level_anchors)
- losses_cls, losses_bbox = multi_apply(
- self.loss_by_feat_single,
- cls_scores,
- bbox_preds,
- all_anchor_list,
- labels_list,
- label_weights_list,
- bbox_targets_list,
- bbox_weights_list,
- avg_factor=avg_factor)
- losses = dict(loss_cls=losses_cls, loss_bbox=losses_bbox)
- # update `_raw_positive_infos`, which will be used when calling
- # `get_positive_infos`.
- self._raw_positive_infos.update(coeff_preds=coeff_preds)
- return losses
-
- def OHEMloss_by_feat_single(self, cls_score: Tensor, bbox_pred: Tensor,
- anchors: Tensor, labels: Tensor,
- label_weights: Tensor, bbox_targets: Tensor,
- bbox_weights: Tensor,
- avg_factor: int) -> tuple:
- """Compute loss of a single image. Similar to
- func:``SSDHead.loss_by_feat_single``
-
- Args:
- cls_score (Tensor): Box scores for eachimage
- Has shape (num_total_anchors, num_classes).
- bbox_pred (Tensor): Box energies / deltas for each image
- level with shape (num_total_anchors, 4).
- anchors (Tensor): Box reference for each scale level with shape
- (num_total_anchors, 4).
- labels (Tensor): Labels of each anchors with shape
- (num_total_anchors,).
- label_weights (Tensor): Label weights of each anchor with shape
- (num_total_anchors,)
- bbox_targets (Tensor): BBox regression targets of each anchor
- weight shape (num_total_anchors, 4).
- bbox_weights (Tensor): BBox regression loss weights of each anchor
- with shape (num_total_anchors, 4).
- avg_factor (int): Average factor that is used to average
- the loss. When using sampling method, avg_factor is usually
- the sum of positive and negative priors. When using
- `PseudoSampler`, `avg_factor` is usually equal to the number
- of positive priors.
-
- Returns:
- Tuple[Tensor, Tensor]: A tuple of cls loss and bbox loss of one
- feature map.
- """
-
- loss_cls_all = self.loss_cls(cls_score, labels, label_weights)
-
- # FG cat_id: [0, num_classes -1], BG cat_id: num_classes
- pos_inds = ((labels >= 0) & (labels < self.num_classes)).nonzero(
- as_tuple=False).reshape(-1)
- neg_inds = (labels == self.num_classes).nonzero(
- as_tuple=False).view(-1)
-
- num_pos_samples = pos_inds.size(0)
- if num_pos_samples == 0:
- num_neg_samples = neg_inds.size(0)
- else:
- num_neg_samples = self.train_cfg['neg_pos_ratio'] * \
- num_pos_samples
- if num_neg_samples > neg_inds.size(0):
- num_neg_samples = neg_inds.size(0)
- topk_loss_cls_neg, _ = loss_cls_all[neg_inds].topk(num_neg_samples)
- loss_cls_pos = loss_cls_all[pos_inds].sum()
- loss_cls_neg = topk_loss_cls_neg.sum()
- loss_cls = (loss_cls_pos + loss_cls_neg) / avg_factor
- if self.reg_decoded_bbox:
- # When the regression loss (e.g. `IouLoss`, `GIouLoss`)
- # is applied directly on the decoded bounding boxes, it
- # decodes the already encoded coordinates to absolute format.
- bbox_pred = self.bbox_coder.decode(anchors, bbox_pred)
- loss_bbox = self.loss_bbox(
- bbox_pred, bbox_targets, bbox_weights, avg_factor=avg_factor)
- return loss_cls[None], loss_bbox
-
- def get_positive_infos(self) -> InstanceList:
- """Get positive information from sampling results.
-
- Returns:
- list[:obj:`InstanceData`]: Positive Information of each image,
- usually including positive bboxes, positive labels, positive
- priors, positive coeffs, etc.
- """
- assert len(self._raw_positive_infos) > 0
- sampling_results = self._raw_positive_infos['sampling_results']
- num_imgs = len(sampling_results)
-
- coeff_pred_list = []
- for coeff_pred_per_level in self._raw_positive_infos['coeff_preds']:
- coeff_pred_per_level = \
- coeff_pred_per_level.permute(
- 0, 2, 3, 1).reshape(num_imgs, -1, self.num_protos)
- coeff_pred_list.append(coeff_pred_per_level)
- coeff_preds = torch.cat(coeff_pred_list, dim=1)
-
- pos_info_list = []
- for idx, sampling_result in enumerate(sampling_results):
- pos_info = InstanceData()
- coeff_preds_single = coeff_preds[idx]
- pos_info.pos_assigned_gt_inds = \
- sampling_result.pos_assigned_gt_inds
- pos_info.pos_inds = sampling_result.pos_inds
- pos_info.coeffs = coeff_preds_single[sampling_result.pos_inds]
- pos_info.bboxes = sampling_result.pos_gt_bboxes
- pos_info_list.append(pos_info)
- return pos_info_list
-
- def predict_by_feat(self,
- cls_scores,
- bbox_preds,
- coeff_preds,
- batch_img_metas,
- cfg=None,
- rescale=True,
- **kwargs):
- """Similar to func:``AnchorHead.get_bboxes``, but additionally
- processes coeff_preds.
-
- Args:
- cls_scores (list[Tensor]): Box scores for each scale level
- with shape (N, num_anchors * num_classes, H, W)
- bbox_preds (list[Tensor]): Box energies / deltas for each scale
- level with shape (N, num_anchors * 4, H, W)
- coeff_preds (list[Tensor]): Mask coefficients for each scale
- level with shape (N, num_anchors * num_protos, H, W)
- batch_img_metas (list[dict]): Batch image meta info.
- cfg (:obj:`Config` | None): Test / postprocessing configuration,
- if None, test_cfg would be used
- rescale (bool): If True, return boxes in original image space.
- Defaults to True.
-
- Returns:
- list[:obj:`InstanceData`]: Object detection results of each image
- after the post process. Each item usually contains following keys.
- - scores (Tensor): Classification scores, has a shape
- (num_instance, )
- - labels (Tensor): Labels of bboxes, has a shape
- (num_instances, ).
- - bboxes (Tensor): Has a shape (num_instances, 4),
- the last dimension 4 arrange as (x1, y1, x2, y2).
- - coeffs (Tensor): the predicted mask coefficients of
- instance inside the corresponding box has a shape
- (n, num_protos).
- """
- assert len(cls_scores) == len(bbox_preds)
- num_levels = len(cls_scores)
-
- device = cls_scores[0].device
- featmap_sizes = [cls_scores[i].shape[-2:] for i in range(num_levels)]
- mlvl_priors = self.prior_generator.grid_priors(
- featmap_sizes, device=device)
-
- result_list = []
- for img_id in range(len(batch_img_metas)):
- img_meta = batch_img_metas[img_id]
- cls_score_list = select_single_mlvl(cls_scores, img_id)
- bbox_pred_list = select_single_mlvl(bbox_preds, img_id)
- coeff_pred_list = select_single_mlvl(coeff_preds, img_id)
- results = self._predict_by_feat_single(
- cls_score_list=cls_score_list,
- bbox_pred_list=bbox_pred_list,
- coeff_preds_list=coeff_pred_list,
- mlvl_priors=mlvl_priors,
- img_meta=img_meta,
- cfg=cfg,
- rescale=rescale)
- result_list.append(results)
- return result_list
-
- def _predict_by_feat_single(self,
- cls_score_list: List[Tensor],
- bbox_pred_list: List[Tensor],
- coeff_preds_list: List[Tensor],
- mlvl_priors: List[Tensor],
- img_meta: dict,
- cfg: ConfigType,
- rescale: bool = True) -> InstanceData:
- """Transform a single image's features extracted from the head into
- bbox results. Similar to func:``AnchorHead._predict_by_feat_single``,
- but additionally processes coeff_preds_list and uses fast NMS instead
- of traditional NMS.
-
- Args:
- cls_score_list (list[Tensor]): Box scores for a single scale level
- Has shape (num_priors * num_classes, H, W).
- bbox_pred_list (list[Tensor]): Box energies / deltas for a single
- scale level with shape (num_priors * 4, H, W).
- coeff_preds_list (list[Tensor]): Mask coefficients for a single
- scale level with shape (num_priors * num_protos, H, W).
- mlvl_priors (list[Tensor]): Each element in the list is
- the priors of a single level in feature pyramid,
- has shape (num_priors, 4).
- img_meta (dict): Image meta info.
- cfg (mmengine.Config): Test / postprocessing configuration,
- if None, test_cfg would be used.
- rescale (bool): If True, return boxes in original image space.
- Defaults to False.
-
- Returns:
- :obj:`InstanceData`: Detection results of each image
- after the post process.
- Each item usually contains following keys.
-
- - scores (Tensor): Classification scores, has a shape
- (num_instance, )
- - labels (Tensor): Labels of bboxes, has a shape
- (num_instances, ).
- - bboxes (Tensor): Has a shape (num_instances, 4),
- the last dimension 4 arrange as (x1, y1, x2, y2).
- - coeffs (Tensor): the predicted mask coefficients of
- instance inside the corresponding box has a shape
- (n, num_protos).
- """
- assert len(cls_score_list) == len(bbox_pred_list) == len(mlvl_priors)
-
- cfg = self.test_cfg if cfg is None else cfg
- cfg = copy.deepcopy(cfg)
- img_shape = img_meta['img_shape']
- nms_pre = cfg.get('nms_pre', -1)
-
- mlvl_bbox_preds = []
- mlvl_valid_priors = []
- mlvl_scores = []
- mlvl_coeffs = []
- for cls_score, bbox_pred, coeff_pred, priors in \
- zip(cls_score_list, bbox_pred_list,
- coeff_preds_list, mlvl_priors):
- assert cls_score.size()[-2:] == bbox_pred.size()[-2:]
- cls_score = cls_score.permute(1, 2,
- 0).reshape(-1, self.cls_out_channels)
- if self.use_sigmoid_cls:
- scores = cls_score.sigmoid()
- else:
- scores = cls_score.softmax(-1)
- bbox_pred = bbox_pred.permute(1, 2, 0).reshape(-1, 4)
- coeff_pred = coeff_pred.permute(1, 2,
- 0).reshape(-1, self.num_protos)
-
- if 0 < nms_pre < scores.shape[0]:
- # Get maximum scores for foreground classes.
- if self.use_sigmoid_cls:
- max_scores, _ = scores.max(dim=1)
- else:
- # remind that we set FG labels to [0, num_class-1]
- # since mmdet v2.0
- # BG cat_id: num_class
- max_scores, _ = scores[:, :-1].max(dim=1)
- _, topk_inds = max_scores.topk(nms_pre)
- priors = priors[topk_inds, :]
- bbox_pred = bbox_pred[topk_inds, :]
- scores = scores[topk_inds, :]
- coeff_pred = coeff_pred[topk_inds, :]
-
- mlvl_bbox_preds.append(bbox_pred)
- mlvl_valid_priors.append(priors)
- mlvl_scores.append(scores)
- mlvl_coeffs.append(coeff_pred)
-
- bbox_pred = torch.cat(mlvl_bbox_preds)
- priors = torch.cat(mlvl_valid_priors)
- multi_bboxes = self.bbox_coder.decode(
- priors, bbox_pred, max_shape=img_shape)
-
- multi_scores = torch.cat(mlvl_scores)
- multi_coeffs = torch.cat(mlvl_coeffs)
-
- return self._bbox_post_process(
- multi_bboxes=multi_bboxes,
- multi_scores=multi_scores,
- multi_coeffs=multi_coeffs,
- cfg=cfg,
- rescale=rescale,
- img_meta=img_meta)
-
- def _bbox_post_process(self,
- multi_bboxes: Tensor,
- multi_scores: Tensor,
- multi_coeffs: Tensor,
- cfg: ConfigType,
- rescale: bool = False,
- img_meta: Optional[dict] = None,
- **kwargs) -> InstanceData:
- """bbox post-processing method.
-
- The boxes would be rescaled to the original image scale and do
- the nms operation. Usually `with_nms` is False is used for aug test.
-
- Args:
- multi_bboxes (Tensor): Predicted bbox that concat all levels.
- multi_scores (Tensor): Bbox scores that concat all levels.
- multi_coeffs (Tensor): Mask coefficients that concat all levels.
- cfg (ConfigDict): Test / postprocessing configuration,
- if None, test_cfg would be used.
- rescale (bool): If True, return boxes in original image space.
- Default to False.
- img_meta (dict, optional): Image meta info. Defaults to None.
-
- Returns:
- :obj:`InstanceData`: Detection results of each image
- after the post process.
- Each item usually contains following keys.
-
- - scores (Tensor): Classification scores, has a shape
- (num_instance, )
- - labels (Tensor): Labels of bboxes, has a shape
- (num_instances, ).
- - bboxes (Tensor): Has a shape (num_instances, 4),
- the last dimension 4 arrange as (x1, y1, x2, y2).
- - coeffs (Tensor): the predicted mask coefficients of
- instance inside the corresponding box has a shape
- (n, num_protos).
- """
- if rescale:
- assert img_meta.get('scale_factor') is not None
- multi_bboxes /= multi_bboxes.new_tensor(
- img_meta['scale_factor']).repeat((1, 2))
- # mlvl_bboxes /= mlvl_bboxes.new_tensor(scale_factor)
-
- if self.use_sigmoid_cls:
- # Add a dummy background class to the backend when using sigmoid
- # remind that we set FG labels to [0, num_class-1] since mmdet v2.0
- # BG cat_id: num_class
-
- padding = multi_scores.new_zeros(multi_scores.shape[0], 1)
- multi_scores = torch.cat([multi_scores, padding], dim=1)
- det_bboxes, det_labels, det_coeffs = fast_nms(
- multi_bboxes, multi_scores, multi_coeffs, cfg.score_thr,
- cfg.iou_thr, cfg.top_k, cfg.max_per_img)
- results = InstanceData()
- results.bboxes = det_bboxes[:, :4]
- results.scores = det_bboxes[:, -1]
- results.labels = det_labels
- results.coeffs = det_coeffs
- return results
-
-
-@MODELS.register_module()
-class YOLACTProtonet(BaseMaskHead):
- """YOLACT mask head used in https://arxiv.org/abs/1904.02689.
-
- This head outputs the mask prototypes for YOLACT.
-
- Args:
- in_channels (int): Number of channels in the input feature map.
- proto_channels (tuple[int]): Output channels of protonet convs.
- proto_kernel_sizes (tuple[int]): Kernel sizes of protonet convs.
- include_last_relu (bool): If keep the last relu of protonet.
- num_protos (int): Number of prototypes.
- num_classes (int): Number of categories excluding the background
- category.
- loss_mask_weight (float): Reweight the mask loss by this factor.
- max_masks_to_train (int): Maximum number of masks to train for
- each image.
- with_seg_branch (bool): Whether to apply a semantic segmentation
- branch and calculate loss during training to increase
- performance with no speed penalty. Defaults to True.
- loss_segm (:obj:`ConfigDict` or dict, optional): Config of
- semantic segmentation loss.
- train_cfg (:obj:`ConfigDict` or dict, optional): Training config
- of head.
- test_cfg (:obj:`ConfigDict` or dict, optional): Testing config of
- head.
- init_cfg (:obj:`ConfigDict` or list[:obj:`ConfigDict`] or dict or
- list[dict], optional): Initialization config dict.
- """
-
- def __init__(
- self,
- num_classes: int,
- in_channels: int = 256,
- proto_channels: tuple = (256, 256, 256, None, 256, 32),
- proto_kernel_sizes: tuple = (3, 3, 3, -2, 3, 1),
- include_last_relu: bool = True,
- num_protos: int = 32,
- loss_mask_weight: float = 1.0,
- max_masks_to_train: int = 100,
- train_cfg: OptConfigType = None,
- test_cfg: OptConfigType = None,
- with_seg_branch: bool = True,
- loss_segm: ConfigType = dict(
- type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0),
- init_cfg=dict(
- type='Xavier',
- distribution='uniform',
- override=dict(name='protonet'))
- ) -> None:
- super().__init__(init_cfg=init_cfg)
- self.in_channels = in_channels
- self.proto_channels = proto_channels
- self.proto_kernel_sizes = proto_kernel_sizes
- self.include_last_relu = include_last_relu
-
- # Segmentation branch
- self.with_seg_branch = with_seg_branch
- self.segm_branch = SegmentationModule(
- num_classes=num_classes, in_channels=in_channels) \
- if with_seg_branch else None
- self.loss_segm = MODELS.build(loss_segm) if with_seg_branch else None
-
- self.loss_mask_weight = loss_mask_weight
- self.num_protos = num_protos
- self.num_classes = num_classes
- self.max_masks_to_train = max_masks_to_train
- self.train_cfg = train_cfg
- self.test_cfg = test_cfg
- self._init_layers()
-
- def _init_layers(self) -> None:
- """Initialize layers of the head."""
- # Possible patterns:
- # ( 256, 3) -> conv
- # ( 256,-2) -> deconv
- # (None,-2) -> bilinear interpolate
- in_channels = self.in_channels
- protonets = ModuleList()
- for num_channels, kernel_size in zip(self.proto_channels,
- self.proto_kernel_sizes):
- if kernel_size > 0:
- layer = nn.Conv2d(
- in_channels,
- num_channels,
- kernel_size,
- padding=kernel_size // 2)
- else:
- if num_channels is None:
- layer = InterpolateModule(
- scale_factor=-kernel_size,
- mode='bilinear',
- align_corners=False)
- else:
- layer = nn.ConvTranspose2d(
- in_channels,
- num_channels,
- -kernel_size,
- padding=kernel_size // 2)
- protonets.append(layer)
- protonets.append(nn.ReLU(inplace=True))
- in_channels = num_channels if num_channels is not None \
- else in_channels
- if not self.include_last_relu:
- protonets = protonets[:-1]
- self.protonet = nn.Sequential(*protonets)
-
- def forward(self, x: tuple, positive_infos: InstanceList) -> tuple:
- """Forward feature from the upstream network to get prototypes and
- linearly combine the prototypes, using masks coefficients, into
- instance masks. Finally, crop the instance masks with given bboxes.
-
- Args:
- x (Tuple[Tensor]): Feature from the upstream network, which is
- a 4D-tensor.
- positive_infos (List[:obj:``InstanceData``]): Positive information
- that calculate from detect head.
-
- Returns:
- tuple: Predicted instance segmentation masks and
- semantic segmentation map.
- """
- # YOLACT used single feature map to get segmentation masks
- single_x = x[0]
-
- # YOLACT segmentation branch, if not training or segmentation branch
- # is None, will not process the forward function.
- if self.segm_branch is not None and self.training:
- segm_preds = self.segm_branch(single_x)
- else:
- segm_preds = None
- # YOLACT mask head
- prototypes = self.protonet(single_x)
- prototypes = prototypes.permute(0, 2, 3, 1).contiguous()
-
- num_imgs = single_x.size(0)
-
- mask_pred_list = []
- for idx in range(num_imgs):
- cur_prototypes = prototypes[idx]
- pos_coeffs = positive_infos[idx].coeffs
-
- # Linearly combine the prototypes with the mask coefficients
- mask_preds = cur_prototypes @ pos_coeffs.t()
- mask_preds = torch.sigmoid(mask_preds)
- mask_pred_list.append(mask_preds)
- return mask_pred_list, segm_preds
-
- def loss_by_feat(self, mask_preds: List[Tensor], segm_preds: List[Tensor],
- batch_gt_instances: InstanceList,
- batch_img_metas: List[dict], positive_infos: InstanceList,
- **kwargs) -> dict:
- """Calculate the loss based on the features extracted by the mask head.
-
- Args:
- mask_preds (list[Tensor]): List of predicted prototypes, each has
- shape (num_classes, H, W).
- segm_preds (Tensor): Predicted semantic segmentation map with
- shape (N, num_classes, H, W)
- batch_gt_instances (list[:obj:`InstanceData`]): Batch of
- gt_instance. It usually includes ``bboxes``, ``masks``,
- and ``labels`` attributes.
- batch_img_metas (list[dict]): Meta information of multiple images.
- positive_infos (List[:obj:``InstanceData``]): Information of
- positive samples of each image that are assigned in detection
- head.
-
- Returns:
- dict[str, Tensor]: A dictionary of loss components.
- """
- assert positive_infos is not None, \
- 'positive_infos should not be None in `YOLACTProtonet`'
- losses = dict()
-
- # crop
- croped_mask_pred = self.crop_mask_preds(mask_preds, batch_img_metas,
- positive_infos)
-
- loss_mask = []
- loss_segm = []
- num_imgs, _, mask_h, mask_w = segm_preds.size()
- assert num_imgs == len(croped_mask_pred)
- segm_avg_factor = num_imgs * mask_h * mask_w
- total_pos = 0
-
- if self.segm_branch is not None:
- assert segm_preds is not None
-
- for idx in range(num_imgs):
- img_meta = batch_img_metas[idx]
-
- (mask_preds, pos_mask_targets, segm_targets, num_pos,
- gt_bboxes_for_reweight) = self._get_targets_single(
- croped_mask_pred[idx], segm_preds[idx],
- batch_gt_instances[idx], positive_infos[idx])
-
- # segmentation loss
- if self.with_seg_branch:
- if segm_targets is None:
- loss = segm_preds[idx].sum() * 0.
- else:
- loss = self.loss_segm(
- segm_preds[idx],
- segm_targets,
- avg_factor=segm_avg_factor)
- loss_segm.append(loss)
- # mask loss
- total_pos += num_pos
- if num_pos == 0 or pos_mask_targets is None:
- loss = mask_preds.sum() * 0.
- else:
- mask_preds = torch.clamp(mask_preds, 0, 1)
- loss = F.binary_cross_entropy(
- mask_preds, pos_mask_targets,
- reduction='none') * self.loss_mask_weight
-
- h, w = img_meta['img_shape'][:2]
- gt_bboxes_width = (gt_bboxes_for_reweight[:, 2] -
- gt_bboxes_for_reweight[:, 0]) / w
- gt_bboxes_height = (gt_bboxes_for_reweight[:, 3] -
- gt_bboxes_for_reweight[:, 1]) / h
- loss = loss.mean(dim=(1,
- 2)) / gt_bboxes_width / gt_bboxes_height
- loss = torch.sum(loss)
- loss_mask.append(loss)
-
- if total_pos == 0:
- total_pos += 1 # avoid nan
- loss_mask = [x / total_pos for x in loss_mask]
-
- losses.update(loss_mask=loss_mask)
- if self.with_seg_branch:
- losses.update(loss_segm=loss_segm)
-
- return losses
-
- def _get_targets_single(self, mask_preds: Tensor, segm_pred: Tensor,
- gt_instances: InstanceData,
- positive_info: InstanceData):
- """Compute targets for predictions of single image.
-
- Args:
- mask_preds (Tensor): Predicted prototypes with shape
- (num_classes, H, W).
- segm_pred (Tensor): Predicted semantic segmentation map
- with shape (num_classes, H, W).
- gt_instances (:obj:`InstanceData`): Ground truth of instance
- annotations. It should includes ``bboxes``, ``labels``,
- and ``masks`` attributes.
- positive_info (:obj:`InstanceData`): Information of positive
- samples that are assigned in detection head. It usually
- contains following keys.
-
- - pos_assigned_gt_inds (Tensor): Assigner GT indexes of
- positive proposals, has shape (num_pos, )
- - pos_inds (Tensor): Positive index of image, has
- shape (num_pos, ).
- - coeffs (Tensor): Positive mask coefficients
- with shape (num_pos, num_protos).
- - bboxes (Tensor): Positive bboxes with shape
- (num_pos, 4)
-
- Returns:
- tuple: Usually returns a tuple containing learning targets.
-
- - mask_preds (Tensor): Positive predicted mask with shape
- (num_pos, mask_h, mask_w).
- - pos_mask_targets (Tensor): Positive mask targets with shape
- (num_pos, mask_h, mask_w).
- - segm_targets (Tensor): Semantic segmentation targets with shape
- (num_classes, segm_h, segm_w).
- - num_pos (int): Positive numbers.
- - gt_bboxes_for_reweight (Tensor): GT bboxes that match to the
- positive priors has shape (num_pos, 4).
- """
- gt_bboxes = gt_instances.bboxes
- gt_labels = gt_instances.labels
- device = gt_bboxes.device
- gt_masks = gt_instances.masks.to_tensor(
- dtype=torch.bool, device=device).float()
- if gt_masks.size(0) == 0:
- return mask_preds, None, None, 0, None
-
- # process with semantic segmentation targets
- if segm_pred is not None:
- num_classes, segm_h, segm_w = segm_pred.size()
- with torch.no_grad():
- downsampled_masks = F.interpolate(
- gt_masks.unsqueeze(0), (segm_h, segm_w),
- mode='bilinear',
- align_corners=False).squeeze(0)
- downsampled_masks = downsampled_masks.gt(0.5).float()
- segm_targets = torch.zeros_like(segm_pred, requires_grad=False)
- for obj_idx in range(downsampled_masks.size(0)):
- segm_targets[gt_labels[obj_idx] - 1] = torch.max(
- segm_targets[gt_labels[obj_idx] - 1],
- downsampled_masks[obj_idx])
- else:
- segm_targets = None
- # process with mask targets
- pos_assigned_gt_inds = positive_info.pos_assigned_gt_inds
- num_pos = pos_assigned_gt_inds.size(0)
- # Since we're producing (near) full image masks,
- # it'd take too much vram to backprop on every single mask.
- # Thus we select only a subset.
- if num_pos > self.max_masks_to_train:
- perm = torch.randperm(num_pos)
- select = perm[:self.max_masks_to_train]
- mask_preds = mask_preds[select]
- pos_assigned_gt_inds = pos_assigned_gt_inds[select]
- num_pos = self.max_masks_to_train
-
- gt_bboxes_for_reweight = gt_bboxes[pos_assigned_gt_inds]
-
- mask_h, mask_w = mask_preds.shape[-2:]
- gt_masks = F.interpolate(
- gt_masks.unsqueeze(0), (mask_h, mask_w),
- mode='bilinear',
- align_corners=False).squeeze(0)
- gt_masks = gt_masks.gt(0.5).float()
- pos_mask_targets = gt_masks[pos_assigned_gt_inds]
-
- return (mask_preds, pos_mask_targets, segm_targets, num_pos,
- gt_bboxes_for_reweight)
-
- def crop_mask_preds(self, mask_preds: List[Tensor],
- batch_img_metas: List[dict],
- positive_infos: InstanceList) -> list:
- """Crop predicted masks by zeroing out everything not in the predicted
- bbox.
-
- Args:
- mask_preds (list[Tensor]): Predicted prototypes with shape
- (num_classes, H, W).
- batch_img_metas (list[dict]): Meta information of multiple images.
- positive_infos (List[:obj:``InstanceData``]): Positive
- information that calculate from detect head.
-
- Returns:
- list: The cropped masks.
- """
- croped_mask_preds = []
- for img_meta, mask_preds, cur_info in zip(batch_img_metas, mask_preds,
- positive_infos):
- bboxes_for_cropping = copy.deepcopy(cur_info.bboxes)
- h, w = img_meta['img_shape'][:2]
- bboxes_for_cropping[:, 0::2] /= w
- bboxes_for_cropping[:, 1::2] /= h
- mask_preds = self.crop_single(mask_preds, bboxes_for_cropping)
- mask_preds = mask_preds.permute(2, 0, 1).contiguous()
- croped_mask_preds.append(mask_preds)
- return croped_mask_preds
-
- def crop_single(self,
- masks: Tensor,
- boxes: Tensor,
- padding: int = 1) -> Tensor:
- """Crop single predicted masks by zeroing out everything not in the
- predicted bbox.
-
- Args:
- masks (Tensor): Predicted prototypes, has shape [H, W, N].
- boxes (Tensor): Bbox coords in relative point form with
- shape [N, 4].
- padding (int): Image padding size.
-
- Return:
- Tensor: The cropped masks.
- """
- h, w, n = masks.size()
- x1, x2 = self.sanitize_coordinates(
- boxes[:, 0], boxes[:, 2], w, padding, cast=False)
- y1, y2 = self.sanitize_coordinates(
- boxes[:, 1], boxes[:, 3], h, padding, cast=False)
-
- rows = torch.arange(
- w, device=masks.device, dtype=x1.dtype).view(1, -1,
- 1).expand(h, w, n)
- cols = torch.arange(
- h, device=masks.device, dtype=x1.dtype).view(-1, 1,
- 1).expand(h, w, n)
-
- masks_left = rows >= x1.view(1, 1, -1)
- masks_right = rows < x2.view(1, 1, -1)
- masks_up = cols >= y1.view(1, 1, -1)
- masks_down = cols < y2.view(1, 1, -1)
-
- crop_mask = masks_left * masks_right * masks_up * masks_down
-
- return masks * crop_mask.float()
-
- def sanitize_coordinates(self,
- x1: Tensor,
- x2: Tensor,
- img_size: int,
- padding: int = 0,
- cast: bool = True) -> tuple:
- """Sanitizes the input coordinates so that x1 < x2, x1 != x2, x1 >= 0,
- and x2 <= image_size. Also converts from relative to absolute
- coordinates and casts the results to long tensors.
-
- Warning: this does things in-place behind the scenes so
- copy if necessary.
-
- Args:
- x1 (Tensor): shape (N, ).
- x2 (Tensor): shape (N, ).
- img_size (int): Size of the input image.
- padding (int): x1 >= padding, x2 <= image_size-padding.
- cast (bool): If cast is false, the result won't be cast to longs.
-
- Returns:
- tuple:
-
- - x1 (Tensor): Sanitized _x1.
- - x2 (Tensor): Sanitized _x2.
- """
- x1 = x1 * img_size
- x2 = x2 * img_size
- if cast:
- x1 = x1.long()
- x2 = x2.long()
- x1 = torch.min(x1, x2)
- x2 = torch.max(x1, x2)
- x1 = torch.clamp(x1 - padding, min=0)
- x2 = torch.clamp(x2 + padding, max=img_size)
- return x1, x2
-
- def predict_by_feat(self,
- mask_preds: List[Tensor],
- segm_preds: Tensor,
- results_list: InstanceList,
- batch_img_metas: List[dict],
- rescale: bool = True,
- **kwargs) -> InstanceList:
- """Transform a batch of output features extracted from the head into
- mask results.
-
- Args:
- mask_preds (list[Tensor]): Predicted prototypes with shape
- (num_classes, H, W).
- results_list (List[:obj:``InstanceData``]): BBoxHead results.
- batch_img_metas (list[dict]): Meta information of all images.
- rescale (bool, optional): Whether to rescale the results.
- Defaults to False.
-
- Returns:
- list[:obj:`InstanceData`]: Processed results of multiple
- images.Each :obj:`InstanceData` usually contains
- following keys.
-
- - scores (Tensor): Classification scores, has shape
- (num_instance,).
- - labels (Tensor): Has shape (num_instances,).
- - masks (Tensor): Processed mask results, has
- shape (num_instances, h, w).
- """
- assert len(mask_preds) == len(results_list) == len(batch_img_metas)
-
- croped_mask_pred = self.crop_mask_preds(mask_preds, batch_img_metas,
- results_list)
-
- for img_id in range(len(batch_img_metas)):
- img_meta = batch_img_metas[img_id]
- results = results_list[img_id]
- bboxes = results.bboxes
- mask_preds = croped_mask_pred[img_id]
- if bboxes.shape[0] == 0 or mask_preds.shape[0] == 0:
- results_list[img_id] = empty_instances(
- [img_meta],
- bboxes.device,
- task_type='mask',
- instance_results=[results])[0]
- else:
- im_mask = self._predict_by_feat_single(
- mask_preds=croped_mask_pred[img_id],
- bboxes=bboxes,
- img_meta=img_meta,
- rescale=rescale)
- results.masks = im_mask
- return results_list
-
- def _predict_by_feat_single(self,
- mask_preds: Tensor,
- bboxes: Tensor,
- img_meta: dict,
- rescale: bool,
- cfg: OptConfigType = None):
- """Transform a single image's features extracted from the head into
- mask results.
-
- Args:
- mask_preds (Tensor): Predicted prototypes, has shape [H, W, N].
- bboxes (Tensor): Bbox coords in relative point form with
- shape [N, 4].
- img_meta (dict): Meta information of each image, e.g.,
- image size, scaling factor, etc.
- rescale (bool): If rescale is False, then returned masks will
- fit the scale of imgs[0].
- cfg (dict, optional): Config used in test phase.
- Defaults to None.
-
- Returns:
- :obj:`InstanceData`: Processed results of single image.
- it usually contains following keys.
-
- - scores (Tensor): Classification scores, has shape
- (num_instance,).
- - labels (Tensor): Has shape (num_instances,).
- - masks (Tensor): Processed mask results, has
- shape (num_instances, h, w).
- """
- cfg = self.test_cfg if cfg is None else cfg
- scale_factor = bboxes.new_tensor(img_meta['scale_factor']).repeat(
- (1, 2))
- img_h, img_w = img_meta['ori_shape'][:2]
- if rescale: # in-placed rescale the bboxes
- scale_factor = bboxes.new_tensor(img_meta['scale_factor']).repeat(
- (1, 2))
- bboxes /= scale_factor
- else:
- w_scale, h_scale = scale_factor[0, 0], scale_factor[0, 1]
- img_h = np.round(img_h * h_scale.item()).astype(np.int32)
- img_w = np.round(img_w * w_scale.item()).astype(np.int32)
-
- masks = F.interpolate(
- mask_preds.unsqueeze(0), (img_h, img_w),
- mode='bilinear',
- align_corners=False).squeeze(0) > cfg.mask_thr
-
- if cfg.mask_thr_binary < 0:
- # for visualization and debugging
- masks = (masks * 255).to(dtype=torch.uint8)
-
- return masks
-
-
-class SegmentationModule(BaseModule):
- """YOLACT segmentation branch used in `_
-
- In mmdet v2.x `segm_loss` is calculated in YOLACTSegmHead, while in
- mmdet v3.x `SegmentationModule` is used to obtain the predicted semantic
- segmentation map and `segm_loss` is calculated in YOLACTProtonet.
-
- Args:
- num_classes (int): Number of categories excluding the background
- category.
- in_channels (int): Number of channels in the input feature map.
- init_cfg (dict or list[dict], optional): Initialization config dict.
- """
-
- def __init__(
- self,
- num_classes: int,
- in_channels: int = 256,
- init_cfg: ConfigType = dict(
- type='Xavier',
- distribution='uniform',
- override=dict(name='segm_conv'))
- ) -> None:
- super().__init__(init_cfg=init_cfg)
- self.in_channels = in_channels
- self.num_classes = num_classes
- self._init_layers()
-
- def _init_layers(self) -> None:
- """Initialize layers of the head."""
- self.segm_conv = nn.Conv2d(
- self.in_channels, self.num_classes, kernel_size=1)
-
- def forward(self, x: Tensor) -> Tensor:
- """Forward feature from the upstream network.
-
- Args:
- x (Tensor): Feature from the upstream network, which is
- a 4D-tensor.
-
- Returns:
- Tensor: Predicted semantic segmentation map with shape
- (N, num_classes, H, W).
- """
- return self.segm_conv(x)
-
-
-class InterpolateModule(BaseModule):
- """This is a module version of F.interpolate.
-
- Any arguments you give it just get passed along for the ride.
- """
-
- def __init__(self, *args, init_cfg=None, **kwargs) -> None:
- super().__init__(init_cfg=init_cfg)
- self.args = args
- self.kwargs = kwargs
-
- def forward(self, x: Tensor) -> Tensor:
- """Forward features from the upstream network.
-
- Args:
- x (Tensor): Feature from the upstream network, which is
- a 4D-tensor.
-
- Returns:
- Tensor: A 4D-tensor feature map.
- """
- return F.interpolate(x, *self.args, **self.kwargs)
diff --git a/spaces/Kynlo/google-flan-t5-xl/README.md b/spaces/Kynlo/google-flan-t5-xl/README.md
deleted file mode 100644
index 0dd0c2100835488e3bc02721b89224a7dc17ba26..0000000000000000000000000000000000000000
--- a/spaces/Kynlo/google-flan-t5-xl/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Google Flan T5 Xl
-emoji: 🏢
-colorFrom: gray
-colorTo: purple
-sdk: gradio
-sdk_version: 3.29.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/LIHUI123/LIHUI123/README.md b/spaces/LIHUI123/LIHUI123/README.md
deleted file mode 100644
index 87d9f7e637da14463530cc91d7a9cd2d589c07a6..0000000000000000000000000000000000000000
--- a/spaces/LIHUI123/LIHUI123/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: LIHUI123
-emoji: 📉
-colorFrom: pink
-colorTo: green
-sdk: docker
-pinned: false
-license: mit
-app_port: 8080
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
\ No newline at end of file
diff --git a/spaces/LZRi/LZR-Bert-VITS2/text/chinese_bert.py b/spaces/LZRi/LZR-Bert-VITS2/text/chinese_bert.py
deleted file mode 100644
index cb84ce0b426cd0a1c7954ddcdf41322c10ed14fa..0000000000000000000000000000000000000000
--- a/spaces/LZRi/LZR-Bert-VITS2/text/chinese_bert.py
+++ /dev/null
@@ -1,50 +0,0 @@
-import torch
-from transformers import AutoTokenizer, AutoModelForMaskedLM
-
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-
-tokenizer = AutoTokenizer.from_pretrained("./bert/chinese-roberta-wwm-ext-large")
-model = AutoModelForMaskedLM.from_pretrained("./bert/chinese-roberta-wwm-ext-large").to(device)
-
-def get_bert_feature(text, word2ph):
- with torch.no_grad():
- inputs = tokenizer(text, return_tensors='pt')
- for i in inputs:
- inputs[i] = inputs[i].to(device)
- res = model(**inputs, output_hidden_states=True)
- res = torch.cat(res['hidden_states'][-3:-2], -1)[0].cpu()
-
- assert len(word2ph) == len(text)+2
- word2phone = word2ph
- phone_level_feature = []
- for i in range(len(word2phone)):
- repeat_feature = res[i].repeat(word2phone[i], 1)
- phone_level_feature.append(repeat_feature)
-
- phone_level_feature = torch.cat(phone_level_feature, dim=0)
-
-
- return phone_level_feature.T
-
-if __name__ == '__main__':
- # feature = get_bert_feature('你好,我是说的道理。')
- import torch
-
- word_level_feature = torch.rand(38, 1024) # 12个词,每个词1024维特征
- word2phone = [1, 2, 1, 2, 2, 1, 2, 2, 1, 2, 2, 1, 2, 2, 2, 2, 2, 1, 1, 2, 2, 1, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 1]
-
- # 计算总帧数
- total_frames = sum(word2phone)
- print(word_level_feature.shape)
- print(word2phone)
- phone_level_feature = []
- for i in range(len(word2phone)):
- print(word_level_feature[i].shape)
-
- # 对每个词重复word2phone[i]次
- repeat_feature = word_level_feature[i].repeat(word2phone[i], 1)
- phone_level_feature.append(repeat_feature)
-
- phone_level_feature = torch.cat(phone_level_feature, dim=0)
- print(phone_level_feature.shape) # torch.Size([36, 1024])
-
diff --git a/spaces/LanguageBind/LanguageBind/v_cls/functional.py b/spaces/LanguageBind/LanguageBind/v_cls/functional.py
deleted file mode 100644
index e6bf3ea02af02e88259590c85d74377e8ac7b8a9..0000000000000000000000000000000000000000
--- a/spaces/LanguageBind/LanguageBind/v_cls/functional.py
+++ /dev/null
@@ -1,90 +0,0 @@
-import numbers
-
-import cv2
-import numpy as np
-import PIL
-import torch
-
-
-def _is_tensor_clip(clip):
- return torch.is_tensor(clip) and clip.ndimension() == 4
-
-
-def crop_clip(clip, min_h, min_w, h, w):
- if isinstance(clip[0], np.ndarray):
- cropped = [img[min_h:min_h + h, min_w:min_w + w, :] for img in clip]
-
- elif isinstance(clip[0], PIL.Image.Image):
- cropped = [
- img.crop((min_w, min_h, min_w + w, min_h + h)) for img in clip
- ]
- else:
- raise TypeError('Expected numpy.ndarray or PIL.Image' +
- 'but got list of {0}'.format(type(clip[0])))
- return cropped
-
-
-def resize_clip(clip, size, interpolation='bilinear'):
- if isinstance(clip[0], np.ndarray):
- if isinstance(size, numbers.Number):
- im_h, im_w, im_c = clip[0].shape
- # Min spatial dim already matches minimal size
- if (im_w <= im_h and im_w == size) or (im_h <= im_w
- and im_h == size):
- return clip
- new_h, new_w = get_resize_sizes(im_h, im_w, size)
- size = (new_w, new_h)
- else:
- size = size[0], size[1]
- if interpolation == 'bilinear':
- np_inter = cv2.INTER_LINEAR
- else:
- np_inter = cv2.INTER_NEAREST
- scaled = [
- cv2.resize(img, size, interpolation=np_inter) for img in clip
- ]
- elif isinstance(clip[0], PIL.Image.Image):
- if isinstance(size, numbers.Number):
- im_w, im_h = clip[0].size
- # Min spatial dim already matches minimal size
- if (im_w <= im_h and im_w == size) or (im_h <= im_w
- and im_h == size):
- return clip
- new_h, new_w = get_resize_sizes(im_h, im_w, size)
- size = (new_w, new_h)
- else:
- size = size[1], size[0]
- if interpolation == 'bilinear':
- pil_inter = PIL.Image.BILINEAR
- else:
- pil_inter = PIL.Image.NEAREST
- scaled = [img.resize(size, pil_inter) for img in clip]
- else:
- raise TypeError('Expected numpy.ndarray or PIL.Image' +
- 'but got list of {0}'.format(type(clip[0])))
- return scaled
-
-
-def get_resize_sizes(im_h, im_w, size):
- if im_w < im_h:
- ow = size
- oh = int(size * im_h / im_w)
- else:
- oh = size
- ow = int(size * im_w / im_h)
- return oh, ow
-
-
-def normalize(clip, mean, std, inplace=False):
- if not _is_tensor_clip(clip):
- raise TypeError('tensor is not a torch clip.')
-
- if not inplace:
- clip = clip.clone()
-
- dtype = clip.dtype
- mean = torch.as_tensor(mean, dtype=dtype, device=clip.device)
- std = torch.as_tensor(std, dtype=dtype, device=clip.device)
- clip.sub_(mean[:, None, None, None]).div_(std[:, None, None, None])
-
- return clip
diff --git a/spaces/LawalAfeez/science-lab/README.md b/spaces/LawalAfeez/science-lab/README.md
deleted file mode 100644
index 41cf728fba5f7fb53e65f86ab569ea5ea5518f89..0000000000000000000000000000000000000000
--- a/spaces/LawalAfeez/science-lab/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Science Lab
-emoji: 🏃
-colorFrom: indigo
-colorTo: indigo
-sdk: gradio
-sdk_version: 3.1.4
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/LightChen2333/OpenSLU/config/README.md b/spaces/LightChen2333/OpenSLU/config/README.md
deleted file mode 100644
index 995c429a5628b1da9aeb6ad6519a4f7cc91d29ab..0000000000000000000000000000000000000000
--- a/spaces/LightChen2333/OpenSLU/config/README.md
+++ /dev/null
@@ -1,348 +0,0 @@
-# Configuation
-
-## 1. Introduction
-
-Configuration is divided into fine-grained reusable modules:
-
-- `base`: basic configuration
-- `logger`: logger setting
-- `model_manager`: loading and saving model parameters
-- `accelerator`: whether to enable multi-GPU
-- `dataset`: dataset management
-- `evaluator`: evaluation and metrics setting.
-- `tokenizer`: Tokenizer initiation and tokenizing setting.
-- `optimizer`: Optimizer initiation setting.
-- `scheduler`: scheduler initiation setting.
-- `model`: model construction setting.
-
-From Sec. 2 to Sec. 11, we will describe the configuration in detail. Or you can see [Examples](examples/README.md) for Quick Start.
-
-NOTE: `_*_` config are reserved fields in OpenSLU.
-
-## Configuration Item Script
-In OpenSLU configuration, we support simple calculation script for each configuration item. For example, we can get `dataset_name` by using `{dataset.dataset_name}`, and fill its value into python script `'LightChen2333/agif-slu-' + '*'`.(Without '', `{dataset.dataset_name}` value will be treated as a variable).
-
-NOTE: each item with `{}` will be treated as python script.
-```yaml
-tokenizer:
- _from_pretrained_: "'LightChen2333/agif-slu-' + '{dataset.dataset_name}'" # Support simple calculation script
-
-```
-
-## `base` Config
-```yaml
-# `start_time` will generated automatically when start any config script, needless to be assigned.
-# start_time: xxxxxxxx
-base:
- name: "OpenSLU" # project/logger name
- multi_intent: false # whether to enable multi-intent setting
- train: True # enable train else enable zero-shot
- test: True # enable test during train.
- device: cuda # device for cuda/cpu
- seed: 42 # random seed
- best_key: EMA # save model by which metric[intent_acc/slot_f1/EMA]
- tokenizer_name: word_tokenizer # tokenizer: word_tokenizer for no pretrained model, else use [AutoTokenizer] tokenizer name
- add_special_tokens: false # whether add [CLS], [SEP] special tokens
- epoch_num: 300 # train epoch num
-# eval_step: 280 # if eval_by_epoch = false and eval_step > 0, will evaluate model by steps
- eval_by_epoch: true # evaluate model by epoch
- batch_size: 16 # batch size
-```
-## `logger` Config
-```yaml
-logger:
- # `wandb` is supported both in single- multi-GPU,
- # `tensorboard` is only supported in multi-GPU,
- # and `fitlog` is only supported in single-GPU
- logger_type: wandb
-```
-## `model_manager` Config
-```yaml
-model_manager:
- # if load_dir != `null`, OpenSLU will try to load checkpoint to continue training,
- # if load_dir == `null`, OpenSLU will restart training.
- load_dir: null
- # The dir path to save model and training state.
- # if save_dir == `null` model will be saved to `save/{start_time}`
- save_dir: save/stack
- # save_mode can be selected in [save-by-step, save-by-eval]
- # `save-by-step` means save model only by {save_step} steps without evaluation.
- # `save-by-eval` means save model by best validation performance
- save_mode: save-by-eval
- # save_step: 100 # only enabled when save_mode == `save-by-step`
- max_save_num: 1 # The number of best models will be saved.
-```
-## `accelerator` Config
-```yaml
-accelerator:
- use_accelerator: false # will enable `accelerator` if use_accelerator is `true`
-```
-## `dataset` Config
-```yaml
-dataset:
- # support load model from hugging-face.
- # dataset_name can be selected in [atis, snips, mix-atis, mix-snips]
- dataset_name: atis
- # support assign any one of dataset path and other dataset split is the same as split in `dataset_name`
- # train: atis # support load model from hugging-face or assigned local data path.
- # validation: {root}/ATIS/dev.jsonl
- # test: {root}/ATIS/test.jsonl
-```
-## `evaluator` Config
-```yaml
-evaluator:
- best_key: EMA # the metric to judge the best model
- eval_by_epoch: true # Evaluate after an epoch if `true`.
- # Evaluate after {eval_step} steps if eval_by_epoch == `false`.
- # eval_step: 1800
- # metric is supported the metric as below:
- # - intent_acc
- # - slot_f1
- # - EMA
- # - intent_f1
- # - macro_intent_f1
- # - micro_intent_f1
- # NOTE: [intent_f1, macro_intent_f1, micro_intent_f1] is only supported in multi-intent setting. intent_f1 and macro_intent_f1 is the same metric.
- metric:
- - intent_acc
- - slot_f1
- - EMA
-```
-## `tokenizer` Config
-```yaml
-tokenizer:
- # Init tokenizer. Support `word_tokenizer` and other tokenizers in huggingface.
- _tokenizer_name_: word_tokenizer
- # if `_tokenizer_name_` is not assigned, you can load pretrained tokenizer from hugging-face.
- # _from_pretrained_: LightChen2333/stack-propagation-slu-atis
- _padding_side_: right # the padding side of tokenizer, support [left/ right]
- # Align mode between text and slot, support [fast/ general],
- # `general` is supported in most tokenizer, `fast` is supported only in small portion of tokenizers.
- _align_mode_: fast
- _to_lower_case_: true
- add_special_tokens: false # other tokenizer args, you can add other args to tokenizer initialization except `_*_` format args
- max_length: 512
-
-```
-## `optimizer` Config
-```yaml
-optimizer:
- _model_target_: torch.optim.Adam # Optimizer class/ function return Optimizer object
- _model_partial_: true # partial load configuration. Here will add model.parameters() to complete all Optimizer parameters
- lr: 0.001 # learning rate
- weight_decay: 1e-6 # weight decay
-```
-## `scheduler` Config
-```yaml
-scheduler:
- _model_target_: transformers.get_scheduler
- _model_partial_: true # partial load configuration. Here will add optimizer, num_training_steps to complete all Optimizer parameters
- name : "linear"
- num_warmup_steps: 0
-```
-## `model` Config
-```yaml
-model:
- # _from_pretrained_: LightChen2333/stack-propagation-slu-atis # load model from hugging-face and is not need to assigned any parameters below.
- _model_target_: model.OpenSLUModel # the general model class, can automatically build the model through configuration.
-
- encoder:
- _model_target_: model.encoder.AutoEncoder # auto-encoder to autoload provided encoder model
- encoder_name: self-attention-lstm # support [lstm/ self-attention-lstm] and other pretrained models those hugging-face supported
-
- embedding: # word embedding layer
-# load_embedding_name: glove.6B.300d.txt # support autoload glove embedding.
- embedding_dim: 256 # embedding dim
- dropout_rate: 0.5 # dropout ratio after embedding
-
- lstm:
- layer_num: 1 # lstm configuration
- bidirectional: true
- output_dim: 256 # module should set output_dim for autoload input_dim in next module. You can also set input_dim manually.
- dropout_rate: 0.5
-
- attention: # self-attention configuration
- hidden_dim: 1024
- output_dim: 128
- dropout_rate: 0.5
-
- return_with_input: true # add inputs information, like attention_mask, to decoder module.
- return_sentence_level_hidden: false # if return sentence representation to decoder module
-
- decoder:
- _model_target_: model.decoder.StackPropagationDecoder # decoder name
- interaction:
- _model_target_: model.decoder.interaction.StackInteraction # interaction module name
- differentiable: false # interaction module config
-
- intent_classifier:
- _model_target_: model.decoder.classifier.AutoregressiveLSTMClassifier # intent classifier module name
- layer_num: 1
- bidirectional: false
- hidden_dim: 64
- force_ratio: 0.9 # teacher-force ratio
- embedding_dim: 8 # intent embedding dim
- ignore_index: -100 # ignore index to compute loss and metric
- dropout_rate: 0.5
- mode: "token-level-intent" # decode mode, support [token-level-intent, intent, slot]
- use_multi: "{base.multi_intent}"
- return_sentence_level: true # whether to return sentence level prediction as decoded input
-
- slot_classifier:
- _model_target_: model.decoder.classifier.AutoregressiveLSTMClassifier
- layer_num: 1
- bidirectional: false
- force_ratio: 0.9
- hidden_dim: 64
- embedding_dim: 32
- ignore_index: -100
- dropout_rate: 0.5
- mode: "slot"
- use_multi: false
- return_sentence_level: false
-```
-
-## Implementing a New Model
-
-### 1. Interaction Re-Implement
-Here we take `DCA-Net` as an example:
-
-In most cases, you just need to rewrite `Interaction` module:
-
-```python
-from common.utils import HiddenData
-from model.decoder.interaction import BaseInteraction
-class DCANetInteraction(BaseInteraction):
- def __init__(self, **config):
- super().__init__(**config)
- self.T_block1 = I_S_Block(self.config["output_dim"], self.config["attention_dropout"], self.config["num_attention_heads"])
- ...
-
- def forward(self, encode_hidden: HiddenData, **kwargs):
- ...
-```
-
-and then you should configure your module:
-```yaml
-base:
- ...
-
-optimizer:
- ...
-
-scheduler:
- ...
-
-model:
- _model_target_: model.OpenSLUModel
- encoder:
- _model_target_: model.encoder.AutoEncoder
- encoder_name: lstm
-
- embedding:
- load_embedding_name: glove.6B.300d.txt
- embedding_dim: 300
- dropout_rate: 0.5
-
- lstm:
- dropout_rate: 0.5
- output_dim: 128
- layer_num: 2
- bidirectional: true
- output_dim: "{model.encoder.lstm.output_dim}"
- return_with_input: true
- return_sentence_level_hidden: false
-
- decoder:
- _model_target_: model.decoder.DCANetDecoder
- interaction:
- _model_target_: model.decoder.interaction.DCANetInteraction
- output_dim: "{model.encoder.output_dim}"
- attention_dropout: 0.5
- num_attention_heads: 8
-
- intent_classifier:
- _model_target_: model.decoder.classifier.LinearClassifier
- mode: "intent"
- input_dim: "{model.decoder.output_dim.output_dim}"
- ignore_index: -100
-
- slot_classifier:
- _model_target_: model.decoder.classifier.LinearClassifier
- mode: "slot"
- input_dim: "{model.decoder.output_dim.output_dim}"
- ignore_index: -100
-```
-
-Oops, you finish all model construction. You can run script as follows to train model:
-```shell
-python run.py -cp config/dca_net.yaml [-ds atis]
-```
-### 2. Decoder Re-Implement
-Sometimes, `interaction then classification` order can not meet your needs. Therefore, you should simply rewrite decoder for flexible interaction order:
-
-Here, we take `stack-propagation` as an example:
-1. We should rewrite interaction module for `stack-propagation`
-```python
-from common.utils import ClassifierOutputData, HiddenData
-from model.decoder.interaction.base_interaction import BaseInteraction
-class StackInteraction(BaseInteraction):
- def __init__(self, **config):
- super().__init__(**config)
- ...
-
- def forward(self, intent_output: ClassifierOutputData, encode_hidden: HiddenData):
- ...
-```
-2. We should rewrite `StackPropagationDecoder` for stack-propagation interaction order:
-```python
-from common.utils import HiddenData, OutputData
-class StackPropagationDecoder(BaseDecoder):
-
- def forward(self, hidden: HiddenData):
- pred_intent = self.intent_classifier(hidden)
- hidden = self.interaction(pred_intent, hidden)
- pred_slot = self.slot_classifier(hidden)
- return OutputData(pred_intent, pred_slot)
-```
-
-3. Then we can easily combine general model by `config/stack-propagation.yaml` configuration file:
-```yaml
-base:
- ...
-
-...
-
-model:
- _model_target_: model.OpenSLUModel
-
- encoder:
- ...
-
- decoder:
- _model_target_: model.decoder.StackPropagationDecoder
- interaction:
- _model_target_: model.decoder.interaction.StackInteraction
- differentiable: false
-
- intent_classifier:
- _model_target_: model.decoder.classifier.AutoregressiveLSTMClassifier
- ... # parameters needed __init__(*)
- mode: "token-level-intent"
- use_multi: false
- return_sentence_level: true
-
- slot_classifier:
- _model_target_: model.decoder.classifier.AutoregressiveLSTMClassifier
- ... # parameters needed __init__(*)
- mode: "slot"
- use_multi: false
- return_sentence_level: false
-```
-4. You can run script as follows to train model:
-```shell
-python run.py -cp config/stack-propagation.yaml
-```
-
-
-
diff --git a/spaces/LittleYuan/My-Real-Bot/realesrgan/train.py b/spaces/LittleYuan/My-Real-Bot/realesrgan/train.py
deleted file mode 100644
index 8a9cec9ed80d9f362984779548dcec921a636a04..0000000000000000000000000000000000000000
--- a/spaces/LittleYuan/My-Real-Bot/realesrgan/train.py
+++ /dev/null
@@ -1,11 +0,0 @@
-# flake8: noqa
-import os.path as osp
-from basicsr.train import train_pipeline
-
-import realesrgan.archs
-import realesrgan.data
-import realesrgan.models
-
-if __name__ == '__main__':
- root_path = osp.abspath(osp.join(__file__, osp.pardir, osp.pardir))
- train_pipeline(root_path)
diff --git a/spaces/Loren/Streamlit_OCR_comparator/configs/_base_/schedules/schedule_adam_step_5e.py b/spaces/Loren/Streamlit_OCR_comparator/configs/_base_/schedules/schedule_adam_step_5e.py
deleted file mode 100644
index 371a3781bfe51ab0b9d841a3911bfe00c4e85197..0000000000000000000000000000000000000000
--- a/spaces/Loren/Streamlit_OCR_comparator/configs/_base_/schedules/schedule_adam_step_5e.py
+++ /dev/null
@@ -1,8 +0,0 @@
-# optimizer
-optimizer = dict(type='Adam', lr=1e-3)
-optimizer_config = dict(grad_clip=None)
-# learning policy
-lr_config = dict(policy='step', step=[3, 4])
-# running settings
-runner = dict(type='EpochBasedRunner', max_epochs=5)
-checkpoint_config = dict(interval=1)
diff --git a/spaces/Loren/Streamlit_OCR_comparator/configs/textrecog/crnn/README.md b/spaces/Loren/Streamlit_OCR_comparator/configs/textrecog/crnn/README.md
deleted file mode 100644
index 52232587e512eb53f16e652e3f3afd0a53686faf..0000000000000000000000000000000000000000
--- a/spaces/Loren/Streamlit_OCR_comparator/configs/textrecog/crnn/README.md
+++ /dev/null
@@ -1,50 +0,0 @@
-# CRNN
-
-> [An end-to-end trainable neural network for image-based sequence recognition and its application to scene text recognition](https://arxiv.org/abs/1507.05717)
-
-
-
-## Abstract
-
-Image-based sequence recognition has been a long-standing research topic in computer vision. In this paper, we investigate the problem of scene text recognition, which is among the most important and challenging tasks in image-based sequence recognition. A novel neural network architecture, which integrates feature extraction, sequence modeling and transcription into a unified framework, is proposed. Compared with previous systems for scene text recognition, the proposed architecture possesses four distinctive properties: (1) It is end-to-end trainable, in contrast to most of the existing algorithms whose components are separately trained and tuned. (2) It naturally handles sequences in arbitrary lengths, involving no character segmentation or horizontal scale normalization. (3) It is not confined to any predefined lexicon and achieves remarkable performances in both lexicon-free and lexicon-based scene text recognition tasks. (4) It generates an effective yet much smaller model, which is more practical for real-world application scenarios. The experiments on standard benchmarks, including the IIIT-5K, Street View Text and ICDAR datasets, demonstrate the superiority of the proposed algorithm over the prior arts. Moreover, the proposed algorithm performs well in the task of image-based music score recognition, which evidently verifies the generality of it.
-
-
-
-
-
-## Dataset
-
-### Train Dataset
-
-| trainset | instance_num | repeat_num | note |
-| :------: | :----------: | :--------: | :---: |
-| Syn90k | 8919273 | 1 | synth |
-
-### Test Dataset
-
-| testset | instance_num | note |
-| :-----: | :----------: | :-------: |
-| IIIT5K | 3000 | regular |
-| SVT | 647 | regular |
-| IC13 | 1015 | regular |
-| IC15 | 2077 | irregular |
-| SVTP | 645 | irregular |
-| CT80 | 288 | irregular |
-
-## Results and models
-
-| methods | | Regular Text | | | | Irregular Text | | download |
-| :------------------------------------------------------: | :----: | :----------: | :--: | :-: | :--: | :------------: | :--: | :-----------------------------------------------------------------------------------------------: |
-| methods | IIIT5K | SVT | IC13 | | IC15 | SVTP | CT80 | |
-| [CRNN](/configs/textrecog/crnn/crnn_academic_dataset.py) | 80.5 | 81.5 | 86.5 | | 54.1 | 59.1 | 55.6 | [model](https://download.openmmlab.com/mmocr/textrecog/crnn/crnn_academic-a723a1c5.pth) \| [log](https://download.openmmlab.com/mmocr/textrecog/crnn/20210326_111035.log.json) |
-
-## Citation
-
-```bibtex
-@article{shi2016end,
- title={An end-to-end trainable neural network for image-based sequence recognition and its application to scene text recognition},
- author={Shi, Baoguang and Bai, Xiang and Yao, Cong},
- journal={IEEE transactions on pattern analysis and machine intelligence},
- year={2016}
-}
-```
diff --git a/spaces/Lycorisdeve/White-box-Cartoonization/README.md b/spaces/Lycorisdeve/White-box-Cartoonization/README.md
deleted file mode 100644
index 9860239cf42c94e385faaaa75a85311e010d64f7..0000000000000000000000000000000000000000
--- a/spaces/Lycorisdeve/White-box-Cartoonization/README.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-python_version: 3.7
-title: White Box Cartoonization
-emoji: 📚
-colorFrom: purple
-colorTo: green
-sdk: gradio
-sdk_version: 2.9.4
-app_file: app.py
-pinned: false
-license: apache-2.0
-duplicated_from: hylee/White-box-Cartoonization
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces#reference
diff --git a/spaces/Manjushri/MusicGen/tests/data/test_audio.py b/spaces/Manjushri/MusicGen/tests/data/test_audio.py
deleted file mode 100644
index 40c0d5ed69eff92a766dc6d176e532f0df6c2b5e..0000000000000000000000000000000000000000
--- a/spaces/Manjushri/MusicGen/tests/data/test_audio.py
+++ /dev/null
@@ -1,239 +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 itertools import product
-import random
-
-import numpy as np
-import torch
-import torchaudio
-
-from audiocraft.data.audio import audio_info, audio_read, audio_write, _av_read
-
-from ..common_utils import TempDirMixin, get_white_noise, save_wav
-
-
-class TestInfo(TempDirMixin):
-
- def test_info_mp3(self):
- sample_rates = [8000, 16_000]
- channels = [1, 2]
- duration = 1.
- for sample_rate, ch in product(sample_rates, channels):
- wav = get_white_noise(ch, int(sample_rate * duration))
- path = self.get_temp_path('sample_wav.mp3')
- save_wav(path, wav, sample_rate)
- info = audio_info(path)
- assert info.sample_rate == sample_rate
- assert info.channels == ch
- # we cannot trust torchaudio for num_frames, so we don't check
-
- def _test_info_format(self, ext: str):
- sample_rates = [8000, 16_000]
- channels = [1, 2]
- duration = 1.
- for sample_rate, ch in product(sample_rates, channels):
- n_frames = int(sample_rate * duration)
- wav = get_white_noise(ch, n_frames)
- path = self.get_temp_path(f'sample_wav{ext}')
- save_wav(path, wav, sample_rate)
- info = audio_info(path)
- assert info.sample_rate == sample_rate
- assert info.channels == ch
- assert np.isclose(info.duration, duration, atol=1e-5)
-
- def test_info_wav(self):
- self._test_info_format('.wav')
-
- def test_info_flac(self):
- self._test_info_format('.flac')
-
- def test_info_ogg(self):
- self._test_info_format('.ogg')
-
- def test_info_m4a(self):
- # TODO: generate m4a file programmatically
- # self._test_info_format('.m4a')
- pass
-
-
-class TestRead(TempDirMixin):
-
- def test_read_full_wav(self):
- sample_rates = [8000, 16_000]
- channels = [1, 2]
- duration = 1.
- for sample_rate, ch in product(sample_rates, channels):
- n_frames = int(sample_rate * duration)
- wav = get_white_noise(ch, n_frames).clamp(-0.99, 0.99)
- path = self.get_temp_path('sample_wav.wav')
- save_wav(path, wav, sample_rate)
- read_wav, read_sr = audio_read(path)
- assert read_sr == sample_rate
- assert read_wav.shape[0] == wav.shape[0]
- assert read_wav.shape[1] == wav.shape[1]
- assert torch.allclose(read_wav, wav, rtol=1e-03, atol=1e-04)
-
- def test_read_partial_wav(self):
- sample_rates = [8000, 16_000]
- channels = [1, 2]
- duration = 1.
- read_duration = torch.rand(1).item()
- for sample_rate, ch in product(sample_rates, channels):
- n_frames = int(sample_rate * duration)
- read_frames = int(sample_rate * read_duration)
- wav = get_white_noise(ch, n_frames).clamp(-0.99, 0.99)
- path = self.get_temp_path('sample_wav.wav')
- save_wav(path, wav, sample_rate)
- read_wav, read_sr = audio_read(path, 0, read_duration)
- assert read_sr == sample_rate
- assert read_wav.shape[0] == wav.shape[0]
- assert read_wav.shape[1] == read_frames
- assert torch.allclose(read_wav[..., 0:read_frames], wav[..., 0:read_frames], rtol=1e-03, atol=1e-04)
-
- def test_read_seek_time_wav(self):
- sample_rates = [8000, 16_000]
- channels = [1, 2]
- duration = 1.
- read_duration = 1.
- for sample_rate, ch in product(sample_rates, channels):
- n_frames = int(sample_rate * duration)
- wav = get_white_noise(ch, n_frames).clamp(-0.99, 0.99)
- path = self.get_temp_path('sample_wav.wav')
- save_wav(path, wav, sample_rate)
- seek_time = torch.rand(1).item()
- read_wav, read_sr = audio_read(path, seek_time, read_duration)
- seek_frames = int(sample_rate * seek_time)
- expected_frames = n_frames - seek_frames
- assert read_sr == sample_rate
- assert read_wav.shape[0] == wav.shape[0]
- assert read_wav.shape[1] == expected_frames
- assert torch.allclose(read_wav, wav[..., seek_frames:], rtol=1e-03, atol=1e-04)
-
- def test_read_seek_time_wav_padded(self):
- sample_rates = [8000, 16_000]
- channels = [1, 2]
- duration = 1.
- read_duration = 1.
- for sample_rate, ch in product(sample_rates, channels):
- n_frames = int(sample_rate * duration)
- read_frames = int(sample_rate * read_duration)
- wav = get_white_noise(ch, n_frames).clamp(-0.99, 0.99)
- path = self.get_temp_path('sample_wav.wav')
- save_wav(path, wav, sample_rate)
- seek_time = torch.rand(1).item()
- seek_frames = int(sample_rate * seek_time)
- expected_frames = n_frames - seek_frames
- read_wav, read_sr = audio_read(path, seek_time, read_duration, pad=True)
- expected_pad_wav = torch.zeros(wav.shape[0], read_frames - expected_frames)
- assert read_sr == sample_rate
- assert read_wav.shape[0] == wav.shape[0]
- assert read_wav.shape[1] == read_frames
- assert torch.allclose(read_wav[..., :expected_frames], wav[..., seek_frames:], rtol=1e-03, atol=1e-04)
- assert torch.allclose(read_wav[..., expected_frames:], expected_pad_wav)
-
-
-class TestAvRead(TempDirMixin):
-
- def test_avread_seek_base(self):
- sample_rates = [8000, 16_000]
- channels = [1, 2]
- duration = 2.
- for sample_rate, ch in product(sample_rates, channels):
- n_frames = int(sample_rate * duration)
- wav = get_white_noise(ch, n_frames)
- path = self.get_temp_path(f'reference_a_{sample_rate}_{ch}.wav')
- save_wav(path, wav, sample_rate)
- for _ in range(100):
- # seek will always load a full duration segment in the file
- seek_time = random.uniform(0.0, 1.0)
- seek_duration = random.uniform(0.001, 1.0)
- read_wav, read_sr = _av_read(path, seek_time, seek_duration)
- assert read_sr == sample_rate
- assert read_wav.shape[0] == wav.shape[0]
- assert read_wav.shape[-1] == int(seek_duration * sample_rate)
-
- def test_avread_seek_partial(self):
- sample_rates = [8000, 16_000]
- channels = [1, 2]
- duration = 1.
- for sample_rate, ch in product(sample_rates, channels):
- n_frames = int(sample_rate * duration)
- wav = get_white_noise(ch, n_frames)
- path = self.get_temp_path(f'reference_b_{sample_rate}_{ch}.wav')
- save_wav(path, wav, sample_rate)
- for _ in range(100):
- # seek will always load a partial segment
- seek_time = random.uniform(0.5, 1.)
- seek_duration = 1.
- expected_num_frames = n_frames - int(seek_time * sample_rate)
- read_wav, read_sr = _av_read(path, seek_time, seek_duration)
- assert read_sr == sample_rate
- assert read_wav.shape[0] == wav.shape[0]
- assert read_wav.shape[-1] == expected_num_frames
-
- def test_avread_seek_outofbound(self):
- sample_rates = [8000, 16_000]
- channels = [1, 2]
- duration = 1.
- for sample_rate, ch in product(sample_rates, channels):
- n_frames = int(sample_rate * duration)
- wav = get_white_noise(ch, n_frames)
- path = self.get_temp_path(f'reference_c_{sample_rate}_{ch}.wav')
- save_wav(path, wav, sample_rate)
- seek_time = 1.5
- read_wav, read_sr = _av_read(path, seek_time, 1.)
- assert read_sr == sample_rate
- assert read_wav.shape[0] == wav.shape[0]
- assert read_wav.shape[-1] == 0
-
- def test_avread_seek_edge(self):
- sample_rates = [8000, 16_000]
- # some of these values will have
- # int(((frames - 1) / sample_rate) * sample_rate) != (frames - 1)
- n_frames = [1000, 1001, 1002]
- channels = [1, 2]
- for sample_rate, ch, frames in product(sample_rates, channels, n_frames):
- duration = frames / sample_rate
- wav = get_white_noise(ch, frames)
- path = self.get_temp_path(f'reference_d_{sample_rate}_{ch}.wav')
- save_wav(path, wav, sample_rate)
- seek_time = (frames - 1) / sample_rate
- seek_frames = int(seek_time * sample_rate)
- read_wav, read_sr = _av_read(path, seek_time, duration)
- assert read_sr == sample_rate
- assert read_wav.shape[0] == wav.shape[0]
- assert read_wav.shape[-1] == (frames - seek_frames)
-
-
-class TestAudioWrite(TempDirMixin):
-
- def test_audio_write_wav(self):
- torch.manual_seed(1234)
- sample_rates = [8000, 16_000]
- n_frames = [1000, 1001, 1002]
- channels = [1, 2]
- strategies = ["peak", "clip", "rms"]
- formats = ["wav", "mp3"]
- for sample_rate, ch, frames in product(sample_rates, channels, n_frames):
- for format_, strategy in product(formats, strategies):
- wav = get_white_noise(ch, frames)
- path = self.get_temp_path(f'pred_{sample_rate}_{ch}')
- audio_write(path, wav, sample_rate, format_, strategy=strategy)
- read_wav, read_sr = torchaudio.load(f'{path}.{format_}')
- if format_ == "wav":
- assert read_wav.shape == wav.shape
-
- if format_ == "wav" and strategy in ["peak", "rms"]:
- rescaled_read_wav = read_wav / read_wav.abs().max() * wav.abs().max()
- # for a Gaussian, the typical max scale will be less than ~5x the std.
- # The error when writing to disk will ~ 1/2**15, and when rescaling, 5x that.
- # For RMS target, rescaling leaves more headroom by default, leading
- # to a 20x rescaling typically
- atol = (5 if strategy == "peak" else 20) / 2**15
- delta = (rescaled_read_wav - wav).abs().max()
- assert torch.allclose(wav, rescaled_read_wav, rtol=0, atol=atol), (delta, atol)
- formats = ["wav"] # faster unit tests
diff --git a/spaces/MarcusSu1216/XingTong/vdecoder/hifigan/env.py b/spaces/MarcusSu1216/XingTong/vdecoder/hifigan/env.py
deleted file mode 100644
index 2bdbc95d4f7a8bad8fd4f5eef657e2b51d946056..0000000000000000000000000000000000000000
--- a/spaces/MarcusSu1216/XingTong/vdecoder/hifigan/env.py
+++ /dev/null
@@ -1,15 +0,0 @@
-import os
-import shutil
-
-
-class AttrDict(dict):
- def __init__(self, *args, **kwargs):
- super(AttrDict, self).__init__(*args, **kwargs)
- self.__dict__ = self
-
-
-def build_env(config, config_name, path):
- t_path = os.path.join(path, config_name)
- if config != t_path:
- os.makedirs(path, exist_ok=True)
- shutil.copyfile(config, os.path.join(path, config_name))
diff --git a/spaces/Mendel192/SAN-Demo/Dockerfile b/spaces/Mendel192/SAN-Demo/Dockerfile
deleted file mode 100644
index 3635a1d698c557f8915c95ce9a519cfac39637a4..0000000000000000000000000000000000000000
--- a/spaces/Mendel192/SAN-Demo/Dockerfile
+++ /dev/null
@@ -1,24 +0,0 @@
-FROM mendelxu/pytorch:d2_nvcr_2008
-
-# Set up a new user named "user" with user ID 1000
-RUN useradd -m -u 1000 user
-# Switch to the "user" user
-USER user
-# Set home to the user's home directory
-ENV HOME=/home/user \
- PATH=/home/user/.local/bin:$PATH
-
-# Set the working directory to the user's home directory
-WORKDIR $HOME/app
-RUN --mount=type=secret,id=HF_TOKEN,mode=0444,required=true
-# clone from the newest code.
-RUN ls -l $HOME/app
-RUN git init && git remote add origin https://github.com/MendelXu/SAN.git
-RUN git pull origin main
-
-# gradio
-RUN pip install gradio
-ENV GRADIO_SERVER_NAME=0.0.0.0
-EXPOSE 7860
-RUN echo "gradio app.py">>run.sh
-CMD ["script","-c","sh run.sh","/dev/null"]
diff --git a/spaces/Mountchicken/MAERec-Gradio/configs/textdet/psenet/README.md b/spaces/Mountchicken/MAERec-Gradio/configs/textdet/psenet/README.md
deleted file mode 100644
index b389f71f8b79a31fc6d3f023b8eb31998f775d05..0000000000000000000000000000000000000000
--- a/spaces/Mountchicken/MAERec-Gradio/configs/textdet/psenet/README.md
+++ /dev/null
@@ -1,41 +0,0 @@
-# PSENet
-
-> [Shape robust text detection with progressive scale expansion network](https://arxiv.org/abs/1903.12473)
-
-
-
-## Abstract
-
-Scene text detection has witnessed rapid progress especially with the recent development of convolutional neural networks. However, there still exists two challenges which prevent the algorithm into industry applications. On the one hand, most of the state-of-art algorithms require quadrangle bounding box which is in-accurate to locate the texts with arbitrary shape. On the other hand, two text instances which are close to each other may lead to a false detection which covers both instances. Traditionally, the segmentation-based approach can relieve the first problem but usually fail to solve the second challenge. To address these two challenges, in this paper, we propose a novel Progressive Scale Expansion Network (PSENet), which can precisely detect text instances with arbitrary shapes. More specifically, PSENet generates the different scale of kernels for each text instance, and gradually expands the minimal scale kernel to the text instance with the complete shape. Due to the fact that there are large geometrical margins among the minimal scale kernels, our method is effective to split the close text instances, making it easier to use segmentation-based methods to detect arbitrary-shaped text instances. Extensive experiments on CTW1500, Total-Text, ICDAR 2015 and ICDAR 2017 MLT validate the effectiveness of PSENet. Notably, on CTW1500, a dataset full of long curve texts, PSENet achieves a F-measure of 74.3% at 27 FPS, and our best F-measure (82.2%) outperforms state-of-art algorithms by 6.6%. The code will be released in the future.
-
-
-
-
-
-## Results and models
-
-### CTW1500
-
-| Method | Backbone | Pretrained Model | Training set | Test set | #epochs | Test size | Precision | Recall | Hmean | Download |
-| :-------------------------------------: | :---------------------------------------: | :--------------: | :-----------: | :----------: | :-----: | :-------: | :-------: | :----: | :----: | :----------------------------------------: |
-| [PSENet](/configs/textdet/psenet/psenet_resnet50_fpnf_600e_ctw1500.py) | ResNet50 | - | CTW1500 Train | CTW1500 Test | 600 | 1280 | 0.7705 | 0.7883 | 0.7793 | [model](https://download.openmmlab.com/mmocr/textdet/psenet/psenet_resnet50_fpnf_600e_ctw1500/psenet_resnet50_fpnf_600e_ctw1500_20220825_221459-7f974ac8.pth) \| [log](https://download.openmmlab.com/mmocr/textdet/psenet/psenet_resnet50_fpnf_600e_ctw1500/20220825_221459.log) |
-| [PSENet_r50-oclip](/configs/textdet/psenet/psenet_resnet50-oclip_fpnf_600e_ctw1500.py) | [ResNet50-oCLIP](https://download.openmmlab.com/mmocr/backbone/resnet50-oclip-7ba0c533.pth) | - | CTW1500 Train | CTW1500 Test | 600 | 1280 | 0.8483 | 0.7636 | 0.8037 | [model](https://download.openmmlab.com/mmocr/textdet/psenet/psenet_resnet50-oclip_fpnf_600e_ctw1500/psenet_resnet50-oclip_fpnf_600e_ctw1500_20221101_140406-d431710d.pth) \| [log](https://download.openmmlab.com/mmocr/textdet/psenet/psenet_resnet50-oclip_fpnf_600e_ctw1500/20221101_140406.log) |
-
-### ICDAR2015
-
-| Method | Backbone | Pretrained Model | Training set | Test set | #epochs | Test size | Precision | Recall | Hmean | Download |
-| :--------------------------------------: | :-----------------------------------------: | :--------------: | :----------: | :-------: | :-----: | :-------: | :-------: | :----: | :----: | :-----------------------------------------: |
-| [PSENet](/configs/textdet/psenet/psenet_resnet50_fpnf_600e_icdar2015.py) | ResNet50 | - | IC15 Train | IC15 Test | 600 | 2240 | 0.8396 | 0.7636 | 0.7998 | [model](https://download.openmmlab.com/mmocr/textdet/psenet/psenet_resnet50_fpnf_600e_icdar2015/psenet_resnet50_fpnf_600e_icdar2015_20220825_222709-b6741ec3.pth) \| [log](https://download.openmmlab.com/mmocr/textdet/psenet/psenet_resnet50_fpnf_600e_icdar2015/20220825_222709.log) |
-| [PSENet_r50-oclip](/configs/textdet/psenet/psenet_resnet50-oclip_fpnf_600e_icdar2015.py) | [ResNet50-oCLIP](https://download.openmmlab.com/mmocr/backbone/resnet50-oclip-7ba0c533.pth) | - | IC15 Train | IC15 Test | 600 | 2240 | 0.8895 | 0.8098 | 0.8478 | [model](https://download.openmmlab.com/mmocr/textdet/psenet/psenet_resnet50-oclip_fpnf_600e_icdar2015/psenet_resnet50-oclip_fpnf_600e_icdar2015_20221101_131357-2bdca389.pth) \| [log](https://download.openmmlab.com/mmocr/textdet/psenet/psenet_resnet50-oclip_fpnf_600e_icdar2015/20221101_131357.log) |
-
-## Citation
-
-```bibtex
-@inproceedings{wang2019shape,
- title={Shape robust text detection with progressive scale expansion network},
- author={Wang, Wenhai and Xie, Enze and Li, Xiang and Hou, Wenbo and Lu, Tong and Yu, Gang and Shao, Shuai},
- booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition},
- pages={9336--9345},
- year={2019}
-}
-```
diff --git a/spaces/Narrativaai/NLLB-Translator/langs.py b/spaces/Narrativaai/NLLB-Translator/langs.py
deleted file mode 100644
index e5e849a4f5427f5b22e1e0bcfbe00102ac0eef10..0000000000000000000000000000000000000000
--- a/spaces/Narrativaai/NLLB-Translator/langs.py
+++ /dev/null
@@ -1,204 +0,0 @@
-LANGS = [
- "ace_Arab",
- "ace_Latn",
- "acm_Arab",
- "acq_Arab",
- "aeb_Arab",
- "afr_Latn",
- "ajp_Arab",
- "aka_Latn",
- "amh_Ethi",
- "apc_Arab",
- "arb_Arab",
- "ars_Arab",
- "ary_Arab",
- "arz_Arab",
- "asm_Beng",
- "ast_Latn",
- "awa_Deva",
- "ayr_Latn",
- "azb_Arab",
- "azj_Latn",
- "bak_Cyrl",
- "bam_Latn",
- "ban_Latn",
- "bel_Cyrl",
- "bem_Latn",
- "ben_Beng",
- "bho_Deva",
- "bjn_Arab",
- "bjn_Latn",
- "bod_Tibt",
- "bos_Latn",
- "bug_Latn",
- "bul_Cyrl",
- "cat_Latn",
- "ceb_Latn",
- "ces_Latn",
- "cjk_Latn",
- "ckb_Arab",
- "crh_Latn",
- "cym_Latn",
- "dan_Latn",
- "deu_Latn",
- "dik_Latn",
- "dyu_Latn",
- "dzo_Tibt",
- "ell_Grek",
- "eng_Latn",
- "epo_Latn",
- "est_Latn",
- "eus_Latn",
- "ewe_Latn",
- "fao_Latn",
- "pes_Arab",
- "fij_Latn",
- "fin_Latn",
- "fon_Latn",
- "fra_Latn",
- "fur_Latn",
- "fuv_Latn",
- "gla_Latn",
- "gle_Latn",
- "glg_Latn",
- "grn_Latn",
- "guj_Gujr",
- "hat_Latn",
- "hau_Latn",
- "heb_Hebr",
- "hin_Deva",
- "hne_Deva",
- "hrv_Latn",
- "hun_Latn",
- "hye_Armn",
- "ibo_Latn",
- "ilo_Latn",
- "ind_Latn",
- "isl_Latn",
- "ita_Latn",
- "jav_Latn",
- "jpn_Jpan",
- "kab_Latn",
- "kac_Latn",
- "kam_Latn",
- "kan_Knda",
- "kas_Arab",
- "kas_Deva",
- "kat_Geor",
- "knc_Arab",
- "knc_Latn",
- "kaz_Cyrl",
- "kbp_Latn",
- "kea_Latn",
- "khm_Khmr",
- "kik_Latn",
- "kin_Latn",
- "kir_Cyrl",
- "kmb_Latn",
- "kon_Latn",
- "kor_Hang",
- "kmr_Latn",
- "lao_Laoo",
- "lvs_Latn",
- "lij_Latn",
- "lim_Latn",
- "lin_Latn",
- "lit_Latn",
- "lmo_Latn",
- "ltg_Latn",
- "ltz_Latn",
- "lua_Latn",
- "lug_Latn",
- "luo_Latn",
- "lus_Latn",
- "mag_Deva",
- "mai_Deva",
- "mal_Mlym",
- "mar_Deva",
- "min_Latn",
- "mkd_Cyrl",
- "plt_Latn",
- "mlt_Latn",
- "mni_Beng",
- "khk_Cyrl",
- "mos_Latn",
- "mri_Latn",
- "zsm_Latn",
- "mya_Mymr",
- "nld_Latn",
- "nno_Latn",
- "nob_Latn",
- "npi_Deva",
- "nso_Latn",
- "nus_Latn",
- "nya_Latn",
- "oci_Latn",
- "gaz_Latn",
- "ory_Orya",
- "pag_Latn",
- "pan_Guru",
- "pap_Latn",
- "pol_Latn",
- "por_Latn",
- "prs_Arab",
- "pbt_Arab",
- "quy_Latn",
- "ron_Latn",
- "run_Latn",
- "rus_Cyrl",
- "sag_Latn",
- "san_Deva",
- "sat_Beng",
- "scn_Latn",
- "shn_Mymr",
- "sin_Sinh",
- "slk_Latn",
- "slv_Latn",
- "smo_Latn",
- "sna_Latn",
- "snd_Arab",
- "som_Latn",
- "sot_Latn",
- "spa_Latn",
- "als_Latn",
- "srd_Latn",
- "srp_Cyrl",
- "ssw_Latn",
- "sun_Latn",
- "swe_Latn",
- "swh_Latn",
- "szl_Latn",
- "tam_Taml",
- "tat_Cyrl",
- "tel_Telu",
- "tgk_Cyrl",
- "tgl_Latn",
- "tha_Thai",
- "tir_Ethi",
- "taq_Latn",
- "taq_Tfng",
- "tpi_Latn",
- "tsn_Latn",
- "tso_Latn",
- "tuk_Latn",
- "tum_Latn",
- "tur_Latn",
- "twi_Latn",
- "tzm_Tfng",
- "uig_Arab",
- "ukr_Cyrl",
- "umb_Latn",
- "urd_Arab",
- "uzn_Latn",
- "vec_Latn",
- "vie_Latn",
- "war_Latn",
- "wol_Latn",
- "xho_Latn",
- "ydd_Hebr",
- "yor_Latn",
- "yue_Hant",
- "zho_Hans",
- "zho_Hant",
- "zul_Latn"
-]
diff --git a/spaces/NeuroSenko/tts-silero/app.py b/spaces/NeuroSenko/tts-silero/app.py
deleted file mode 100644
index 056c44f41d541d8459f7aaec1ff6104392ddccb5..0000000000000000000000000000000000000000
--- a/spaces/NeuroSenko/tts-silero/app.py
+++ /dev/null
@@ -1,139 +0,0 @@
-import os
-from datetime import datetime
-from inspect import signature
-
-import gradio as gr
-import torch
-from omegaconf import OmegaConf
-
-torch.hub.download_url_to_file(
- "https://raw.githubusercontent.com/snakers4/silero-models/master/models.yml",
- "latest_silero_models.yml",
- progress=False,
-)
-
-all_models = OmegaConf.load("latest_silero_models.yml")
-
-language="ru"
-model_id = "v3_1_ru"
-device = torch.device("cpu")
-
-model, example_text = torch.hub.load(
- repo_or_dir="snakers4/silero-models",
- model="silero_tts",
- language=language,
- speaker=model_id,
-)
-model.to(device) # gpu or cpu
-
-sample_rate = 48000
-speaker = "aidar"
-put_accent = True
-put_yo = True
-example_text = "В недрах тундры выдры в г+етрах т+ырят в вёдра ядра к+едров."
-
-models = list(all_models.tts_models.get(language).keys())
-
-model, example_text = torch.hub.load(
- repo_or_dir='snakers4/silero-models',
- model='silero_tts',
- language='ru',
- speaker=model_id
-)
-
-def change_language(language):
- models = list(all_models.tts_models.get(language).keys())
- return model_input.update(choices=models)
-
-def change_model(language, model_name):
- model, example_text = torch.hub.load(
- repo_or_dir='snakers4/silero-models',
- model='silero_tts',
- language=language,
- speaker=model_name
- )
-
- return speaker_input.update(choices=model.speakers)
-
-
-def generate_audio_by_text(text, text_type, speaker):
- output_file_name = "{datetime}.wav".format(datetime=datetime.now().isoformat().replace(':', '-'))
- output = os.path.join("out_audio", output_file_name)
-
- if text_type == 'SSML':
- return model.save_wav(
- audio_path=output,
- ssml_text=text,
- speaker=speaker,
- sample_rate=sample_rate,
- put_accent=put_accent,
- put_yo=put_yo,
- )
- else:
- return model.save_wav(
- audio_path=output,
- text=text,
- speaker=speaker,
- sample_rate=sample_rate,
- put_accent=put_accent,
- put_yo=put_yo,
- )
-
-with gr.Blocks() as demo:
- with gr.Row():
- with gr.Column():
- language_input = gr.Dropdown(
- label="Language",
- choices=list(all_models.tts_models.keys()),
- value="ru",
- interactive=True,
- )
-
- model_input = gr.Dropdown(
- label="Model (based on selected language)",
- value="v3_1_ru",
- choices=models,
- interactive=True,
- )
-
- speaker_input = gr.Dropdown(
- label="Speaker (based on selected model)",
- value="kseniya",
- choices=model.speakers,
- interactive=True,
- )
-
- text_input = gr.Textbox(
- label="Text for generating",
- value="В недрах тундры выдры в г+етрах т+ырят в вёдра +ядра к+едров.",
- lines=5,
- interactive=True,
- )
-
- text_type_input = gr.Radio(
- label="Text type",
- choices=["Common", "SSML"],
- value="Common",
- interactive=True,
- )
-
- language_input.change(change_language, inputs=language_input, outputs=model_input)
- model_input.change(change_model, inputs=[language_input, model_input], outputs=speaker_input)
-
- with gr.Column():
- audio_output = gr.Audio(label="Output audio")
- generate_btn = gr.Button(value="Generate", variant="primary")
- generate_btn.click(
- generate_audio_by_text,
- inputs=[text_input, text_type_input, speaker_input],
- outputs=audio_output,
- )
-
- gr.Markdown(
- "This is a simple frontend for [silero](https://github.com/snakers4/silero-models) project (Text-To-Speech part only)."
- )
- gr.Markdown(
- "You can check [official docs](https://github.com/snakers4/silero-models/wiki/SSML) to find information about SSML syntax."
- )
-
-demo.launch()
\ No newline at end of file
diff --git a/spaces/Nightwing25/AICoverGen/README.md b/spaces/Nightwing25/AICoverGen/README.md
deleted file mode 100644
index 9b50beed4778c8d4f86c294a3b272edff8ef44f9..0000000000000000000000000000000000000000
--- a/spaces/Nightwing25/AICoverGen/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: AICoverGen
-emoji: 🚀
-colorFrom: red
-colorTo: pink
-sdk: gradio
-sdk_version: 3.44.1
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
\ No newline at end of file
diff --git a/spaces/Norod78/distilgpt2_TextIteratorStreamer/app.py b/spaces/Norod78/distilgpt2_TextIteratorStreamer/app.py
deleted file mode 100644
index 3a1eef92edbe32b77d2c9472541b598a54644e2e..0000000000000000000000000000000000000000
--- a/spaces/Norod78/distilgpt2_TextIteratorStreamer/app.py
+++ /dev/null
@@ -1,43 +0,0 @@
-import os
-import gradio as gr
-from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer
-from threading import Thread
-import torch
-
-tok = AutoTokenizer.from_pretrained("distilgpt2")
-model = AutoModelForCausalLM.from_pretrained("distilgpt2")
-
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-n_gpu = 0 if torch.cuda.is_available()==False else torch.cuda.device_count()
-model.to(device)
-
-def generate(text = "", max_new_tokens = 128):
- streamer = TextIteratorStreamer(tok, timeout=10.)
- if len(text) == 0:
- text = " "
- inputs = tok([text], return_tensors="pt").to(device)
- generation_kwargs = dict(inputs, streamer=streamer, repetition_penalty=2.0, do_sample=True, top_k=40, top_p=0.97, max_new_tokens=max_new_tokens, pad_token_id = model.config.eos_token_id, early_stopping=True, no_repeat_ngram_size=4)
- thread = Thread(target=model.generate, kwargs=generation_kwargs)
- thread.start()
- generated_text = ""
- for new_text in streamer:
- yield generated_text + new_text
- generated_text += new_text
- if tok.eos_token in generated_text:
- generated_text = generated_text[: generated_text.find(tok.eos_token) if tok.eos_token else None]
- streamer.end()
- yield generated_text
- return
- return generated_text
-
-demo = gr.Interface(
- title="TextIteratorStreamer + Gradio demo",
- fn=generate,
- inputs=[gr.inputs.Textbox(lines=5, label="Input Text"),
- gr.inputs.Slider(default=128,minimum=5, maximum=256, step=1, label="Maximum number of new tokens")],
- outputs=gr.outputs.Textbox(label="Generated Text"),
- allow_flagging="never"
-)
-
-demo.queue()
-demo.launch()
\ No newline at end of file
diff --git a/spaces/Not-Grim-Refer/GitHub-Tool/app.py b/spaces/Not-Grim-Refer/GitHub-Tool/app.py
deleted file mode 100644
index b8cee70e91a8973d21ac154d4e453315e2c0cf64..0000000000000000000000000000000000000000
--- a/spaces/Not-Grim-Refer/GitHub-Tool/app.py
+++ /dev/null
@@ -1,42 +0,0 @@
-import os
-import logging
-import streamlit as st
-from git import Repo
-from langchain import HuggingFaceHub, LLMChain
-
-# Set page configuration
-st.set_page_config(layout="wide", initial_sidebar_state="auto")
-
-# Collect user inputs
-repository_url = st.text_input("Enter GitHub repository URL:", "")
-access_token = st.text_input("Enter GitHub access token (optional):", "")
-debug_logging = st.checkbox("Enable debug logging")
-
-# Run the process
-if st.button("Run"):
- if debug_logging:
- logging.basicConfig(filename='log.txt', level=logging.DEBUG, format='%(asctime)s %(message)s')
- logging.debug('Starting the process')
-
- # Clone the repository
- local_path = "/tmp/repository"
- Repo.clone_from(repository_url, local_path, branch="main", env={"GIT_TERMINAL_PROMPT": "0", "GIT_SSL_NO_VERIFY": "true"})
-
- # Initialize Hugging Face model
- os.environ['HUGGINGFACEHUB_API_TOKEN'] = access_token
- hub_llm = HuggingFaceHub(repo_id='google/flan-t5-xl', model_kwargs={'temperature': 1e-10})
-
- # Create a prompt template and LLM chain
- prompt = f"What is the main purpose of the repository at {repository_url}?"
- llm_chain = LLMChain(prompt=prompt, llm=hub_llm)
-
- # Get the result
- answer = llm_chain.run()
- st.write("Answer:", answer)
-
- if debug_logging:
- logging.debug('Finished the process')
-
-# Run pip freeze and pip install -r requirements.txt
-os.system("pip freeze > requirements.txt")
-os.system("pip install -r requirements.txt")
\ No newline at end of file
diff --git a/spaces/OFA-Sys/OFA-Visual_Grounding/data/__init__.py b/spaces/OFA-Sys/OFA-Visual_Grounding/data/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/OFA-Sys/OFA-vqa/fairseq/fairseq/data/token_block_dataset.py b/spaces/OFA-Sys/OFA-vqa/fairseq/fairseq/data/token_block_dataset.py
deleted file mode 100644
index d2c65fd7e058072911c3aa60bfc760288a0f83e5..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-vqa/fairseq/fairseq/data/token_block_dataset.py
+++ /dev/null
@@ -1,202 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import numpy as np
-import torch
-from fairseq.data import FairseqDataset, plasma_utils
-from fairseq.data.indexed_dataset import best_fitting_int_dtype
-from typing import Tuple
-
-
-class TokenBlockDataset(FairseqDataset):
- """Break a Dataset of tokens into blocks.
-
- Args:
- dataset (~torch.utils.data.Dataset): dataset to break into blocks
- sizes (List[int]): sentence lengths (required for 'complete' and 'eos')
- block_size (int): maximum block size (ignored in 'eos' break mode)
- break_mode (str, optional): Mode used for breaking tokens. Values can
- be one of:
- - 'none': break tokens into equally sized blocks (up to block_size)
- - 'complete': break tokens into blocks (up to block_size) such that
- blocks contains complete sentences, although block_size may be
- exceeded if some sentences exceed block_size
- - 'complete_doc': similar to 'complete' mode, but do not
- cross document boundaries
- - 'eos': each block contains one sentence (block_size is ignored)
- include_targets (bool, optional): return next tokens as targets
- (default: False).
- document_sep_len (int, optional): document separator size (required for
- 'complete_doc' break mode). Typically 1 if the sentences have eos
- and 0 otherwise.
- """
-
- def __init__(
- self,
- dataset,
- sizes,
- block_size,
- pad,
- eos,
- break_mode=None,
- include_targets=False,
- document_sep_len=1,
- use_plasma_view=False,
- split_path=None,
- plasma_path=None,
- ):
-
- super().__init__()
- self.dataset = dataset
- self.pad = pad
- self.eos = eos
- self.include_targets = include_targets
-
- assert len(dataset) > 0
-
- assert len(dataset) == len(sizes)
- _sizes, block_to_dataset_index, slice_indices = self._build_slice_indices(
- sizes, break_mode, document_sep_len, block_size
- )
- if use_plasma_view:
- plasma_id = (block_size, document_sep_len, str(break_mode), len(dataset))
- self._slice_indices = plasma_utils.PlasmaView(
- slice_indices, split_path, (plasma_id, 0), plasma_path=plasma_path
- )
- self._sizes = plasma_utils.PlasmaView(
- _sizes, split_path, (plasma_id, 1), plasma_path=plasma_path
- )
- self._block_to_dataset_index = plasma_utils.PlasmaView(
- block_to_dataset_index, split_path, (plasma_id, 2), plasma_path=plasma_path,
- )
- else:
- self._slice_indices = plasma_utils.PlasmaArray(slice_indices)
- self._sizes = plasma_utils.PlasmaArray(_sizes)
- self._block_to_dataset_index = plasma_utils.PlasmaArray(
- block_to_dataset_index
- )
-
- @staticmethod
- def _build_slice_indices(
- sizes, break_mode, document_sep_len, block_size
- ) -> Tuple[np.ndarray]:
- """Use token_block_utils_fast to build arrays for indexing into self.dataset"""
- try:
- from fairseq.data.token_block_utils_fast import (
- _get_slice_indices_fast,
- _get_block_to_dataset_index_fast,
- )
- except ImportError:
- raise ImportError(
- "Please build Cython components with: `pip install --editable .` "
- "or `python setup.py build_ext --inplace`"
- )
-
- if isinstance(sizes, list):
- sizes = np.array(sizes, dtype=np.int64)
- else:
- if torch.is_tensor(sizes):
- sizes = sizes.numpy()
- sizes = sizes.astype(np.int64)
-
- break_mode = break_mode if break_mode is not None else "none"
-
- # For "eos" break-mode, block_size is not required parameters.
- if break_mode == "eos" and block_size is None:
- block_size = 0
-
- slice_indices = _get_slice_indices_fast(
- sizes, str(break_mode), block_size, document_sep_len
- )
- _sizes = slice_indices[:, 1] - slice_indices[:, 0]
-
- # build index mapping block indices to the underlying dataset indices
- if break_mode == "eos":
- # much faster version for eos break mode
- block_to_dataset_index = np.stack(
- [
- np.arange(len(sizes)), # starting index in dataset
- np.zeros(
- len(sizes), dtype=np.compat.long
- ), # starting offset within starting index
- np.arange(len(sizes)), # ending index in dataset
- ],
- 1,
- )
- else:
- block_to_dataset_index = _get_block_to_dataset_index_fast(
- sizes, slice_indices,
- )
- size_dtype = np.uint16 if block_size < 65535 else np.uint32
- num_tokens = slice_indices[-1].max()
- slice_indices_dtype = best_fitting_int_dtype(num_tokens)
- slice_indices = slice_indices.astype(slice_indices_dtype)
- _sizes = _sizes.astype(size_dtype)
- block_to_dataset_index = block_to_dataset_index.astype(slice_indices_dtype)
- return _sizes, block_to_dataset_index, slice_indices
-
- @property
- def slice_indices(self):
- return self._slice_indices.array
-
- @property
- def sizes(self):
- return self._sizes.array
-
- @property
- def block_to_dataset_index(self):
- return self._block_to_dataset_index.array
-
- def attr(self, attr: str, index: int):
- start_ds_idx, _, _ = self.block_to_dataset_index[index]
- return self.dataset.attr(attr, start_ds_idx)
-
- def __getitem__(self, index):
- start_ds_idx, start_offset, end_ds_idx = self.block_to_dataset_index[index]
-
- buffer = torch.cat(
- [self.dataset[idx] for idx in range(start_ds_idx, end_ds_idx + 1)]
- )
- slice_s, slice_e = self.slice_indices[index]
- length = slice_e - slice_s
- s, e = start_offset, start_offset + length
- item = buffer[s:e]
-
- if self.include_targets:
- # *target* is the original sentence (=item)
- # *source* is shifted right by 1 (maybe left-padded with eos)
- # *past_target* is shifted right by 2 (left-padded as needed)
- if s == 0:
- source = torch.cat([item.new([self.eos]), buffer[0 : e - 1]])
- past_target = torch.cat(
- [item.new([self.pad, self.eos]), buffer[0 : e - 2]]
- )
- else:
- source = buffer[s - 1 : e - 1]
- if s == 1:
- past_target = torch.cat([item.new([self.eos]), buffer[0 : e - 2]])
- else:
- past_target = buffer[s - 2 : e - 2]
-
- return source, item, past_target
-
- return item
-
- def __len__(self):
- return len(self.slice_indices)
-
- @property
- def supports_prefetch(self):
- return getattr(self.dataset, "supports_prefetch", False)
-
- def prefetch(self, indices):
- self.dataset.prefetch(
- {
- ds_idx
- for index in indices
- for start_ds_idx, _, end_ds_idx in [self.block_to_dataset_index[index]]
- for ds_idx in range(start_ds_idx, end_ds_idx + 1)
- }
- )
diff --git a/spaces/OFA-Sys/OFA-vqa/fairseq/fairseq/modules/quantization/pq/em.py b/spaces/OFA-Sys/OFA-vqa/fairseq/fairseq/modules/quantization/pq/em.py
deleted file mode 100644
index 6f15c3e46bd052b1e00929e7ece9355fb03846c7..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-vqa/fairseq/fairseq/modules/quantization/pq/em.py
+++ /dev/null
@@ -1,211 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import logging
-import os
-import random
-from collections import Counter
-
-import torch
-
-
-class EM:
- """
- EM algorithm used to quantize the columns of W to minimize
-
- ||W - W_hat||^2
-
- Args:
- - W: weight matrix of size (in_features x out_features)
- - n_iter: number of k-means iterations
- - n_centroids: number of centroids (size of codebook)
- - eps: for cluster reassignment when an empty cluster is found
- - max_tentatives for cluster reassignment when an empty cluster is found
- - verbose: print error after each iteration
-
- Remarks:
- - If one cluster is empty, the most populated cluster is split into
- two clusters
- - All the relevant dimensions are specified in the code
- """
-
- def __init__(
- self, W, n_centroids=256, n_iter=20, eps=1e-6, max_tentatives=30, verbose=True
- ):
- self.W = W
- self.n_centroids = n_centroids
- self.n_iter = n_iter
- self.eps = eps
- self.max_tentatives = max_tentatives
- self.verbose = verbose
- self.centroids = torch.Tensor()
- self.assignments = torch.Tensor()
- self.objective = []
-
- def initialize_centroids(self):
- """
- Initializes the centroids by sampling random columns from W.
- """
-
- in_features, out_features = self.W.size()
- indices = torch.randint(
- low=0, high=out_features, size=(self.n_centroids,)
- ).long()
- self.centroids = self.W[:, indices].t() # (n_centroids x in_features)
-
- def step(self, i):
- """
- There are two standard steps for each iteration: expectation (E) and
- minimization (M). The E-step (assignment) is performed with an exhaustive
- search and the M-step (centroid computation) is performed with
- the exact solution.
-
- Args:
- - i: step number
-
- Remarks:
- - The E-step heavily uses PyTorch broadcasting to speed up computations
- and reduce the memory overhead
- """
-
- # assignments (E-step)
- distances = self.compute_distances() # (n_centroids x out_features)
- self.assignments = torch.argmin(distances, dim=0) # (out_features)
- n_empty_clusters = self.resolve_empty_clusters()
-
- # centroids (M-step)
- for k in range(self.n_centroids):
- W_k = self.W[:, self.assignments == k] # (in_features x size_of_cluster_k)
- self.centroids[k] = W_k.mean(dim=1) # (in_features)
-
- # book-keeping
- obj = (self.centroids[self.assignments].t() - self.W).norm(p=2).item()
- self.objective.append(obj)
- if self.verbose:
- logging.info(
- f"Iteration: {i},\t"
- f"objective: {obj:.6f},\t"
- f"resolved empty clusters: {n_empty_clusters}"
- )
-
- def resolve_empty_clusters(self):
- """
- If one cluster is empty, the most populated cluster is split into
- two clusters by shifting the respective centroids. This is done
- iteratively for a fixed number of tentatives.
- """
-
- # empty clusters
- counts = Counter(map(lambda x: x.item(), self.assignments))
- empty_clusters = set(range(self.n_centroids)) - set(counts.keys())
- n_empty_clusters = len(empty_clusters)
-
- tentatives = 0
- while len(empty_clusters) > 0:
- # given an empty cluster, find most populated cluster and split it into two
- k = random.choice(list(empty_clusters))
- m = counts.most_common(1)[0][0]
- e = torch.randn_like(self.centroids[m]) * self.eps
- self.centroids[k] = self.centroids[m].clone()
- self.centroids[k] += e
- self.centroids[m] -= e
-
- # recompute assignments
- distances = self.compute_distances() # (n_centroids x out_features)
- self.assignments = torch.argmin(distances, dim=0) # (out_features)
-
- # check for empty clusters
- counts = Counter(map(lambda x: x.item(), self.assignments))
- empty_clusters = set(range(self.n_centroids)) - set(counts.keys())
-
- # increment tentatives
- if tentatives == self.max_tentatives:
- logging.info(
- f"Could not resolve all empty clusters, {len(empty_clusters)} remaining"
- )
- raise EmptyClusterResolveError
- tentatives += 1
-
- return n_empty_clusters
-
- def compute_distances(self):
- """
- For every centroid m, computes
-
- ||M - m[None, :]||_2
-
- Remarks:
- - We rely on PyTorch's broadcasting to speed up computations
- and reduce the memory overhead
- - Without chunking, the sizes in the broadcasting are modified as:
- (n_centroids x n_samples x out_features) -> (n_centroids x out_features)
- - The broadcasting computation is automatically chunked so that
- the tensors fit into the memory of the GPU
- """
-
- nb_centroids_chunks = 1
-
- while True:
- try:
- return torch.cat(
- [
- (self.W[None, :, :] - centroids_c[:, :, None]).norm(p=2, dim=1)
- for centroids_c in self.centroids.chunk(
- nb_centroids_chunks, dim=0
- )
- ],
- dim=0,
- )
- except RuntimeError:
- nb_centroids_chunks *= 2
-
- def assign(self):
- """
- Assigns each column of W to its closest centroid, thus essentially
- performing the E-step in train().
-
- Remarks:
- - The function must be called after train() or after loading
- centroids using self.load(), otherwise it will return empty tensors
- """
-
- distances = self.compute_distances() # (n_centroids x out_features)
- self.assignments = torch.argmin(distances, dim=0) # (out_features)
-
- def save(self, path, layer):
- """
- Saves centroids and assignments.
-
- Args:
- - path: folder used to save centroids and assignments
- """
-
- torch.save(self.centroids, os.path.join(path, "{}_centroids.pth".format(layer)))
- torch.save(
- self.assignments, os.path.join(path, "{}_assignments.pth".format(layer))
- )
- torch.save(self.objective, os.path.join(path, "{}_objective.pth".format(layer)))
-
- def load(self, path, layer):
- """
- Loads centroids and assignments from a given path
-
- Args:
- - path: folder use to load centroids and assignments
- """
-
- self.centroids = torch.load(
- os.path.join(path, "{}_centroids.pth".format(layer))
- )
- self.assignments = torch.load(
- os.path.join(path, "{}_assignments.pth".format(layer))
- )
- self.objective = torch.load(
- os.path.join(path, "{}_objective.pth".format(layer))
- )
-
-
-class EmptyClusterResolveError(Exception):
- pass
diff --git a/spaces/OpenDILabCommunity/LLMRiddlesChatGLMCN/llmriddles/llms/chatglm.py b/spaces/OpenDILabCommunity/LLMRiddlesChatGLMCN/llmriddles/llms/chatglm.py
deleted file mode 100644
index 120ffd7da32b50747264a0104f88f3360795cb88..0000000000000000000000000000000000000000
--- a/spaces/OpenDILabCommunity/LLMRiddlesChatGLMCN/llmriddles/llms/chatglm.py
+++ /dev/null
@@ -1,26 +0,0 @@
-import zhipuai
-from .base import register_llm
-
-
-def ask_chatglm(message: str, api_key: str):
- zhipuai.api_key = api_key
-
- response = zhipuai.model_api.invoke(
- model="chatglm_turbo",
- prompt=[{
- "role": "user",
- "content": message
- }],
- top_p=0.7,
- temperature=0.9,
- )
-
- response_msg = response['data']['choices'][0]['content']
- # strip the front and end '"'
- if len(response_msg) >= 2:
- response_msg = response_msg[1:-1]
-
- return response_msg
-
-
-register_llm('chatglm', ask_chatglm)
diff --git a/spaces/OpenGVLab/InternGPT/third-party/lama/saicinpainting/training/data/masks.py b/spaces/OpenGVLab/InternGPT/third-party/lama/saicinpainting/training/data/masks.py
deleted file mode 100644
index e91fc74913356481065c5f5906acd50fb05f521c..0000000000000000000000000000000000000000
--- a/spaces/OpenGVLab/InternGPT/third-party/lama/saicinpainting/training/data/masks.py
+++ /dev/null
@@ -1,332 +0,0 @@
-import math
-import random
-import hashlib
-import logging
-from enum import Enum
-
-import cv2
-import numpy as np
-
-from saicinpainting.evaluation.masks.mask import SegmentationMask
-from saicinpainting.utils import LinearRamp
-
-LOGGER = logging.getLogger(__name__)
-
-
-class DrawMethod(Enum):
- LINE = 'line'
- CIRCLE = 'circle'
- SQUARE = 'square'
-
-
-def make_random_irregular_mask(shape, max_angle=4, max_len=60, max_width=20, min_times=0, max_times=10,
- draw_method=DrawMethod.LINE):
- draw_method = DrawMethod(draw_method)
-
- height, width = shape
- mask = np.zeros((height, width), np.float32)
- times = np.random.randint(min_times, max_times + 1)
- for i in range(times):
- start_x = np.random.randint(width)
- start_y = np.random.randint(height)
- for j in range(1 + np.random.randint(5)):
- angle = 0.01 + np.random.randint(max_angle)
- if i % 2 == 0:
- angle = 2 * 3.1415926 - angle
- length = 10 + np.random.randint(max_len)
- brush_w = 5 + np.random.randint(max_width)
- end_x = np.clip((start_x + length * np.sin(angle)).astype(np.int32), 0, width)
- end_y = np.clip((start_y + length * np.cos(angle)).astype(np.int32), 0, height)
- if draw_method == DrawMethod.LINE:
- cv2.line(mask, (start_x, start_y), (end_x, end_y), 1.0, brush_w)
- elif draw_method == DrawMethod.CIRCLE:
- cv2.circle(mask, (start_x, start_y), radius=brush_w, color=1., thickness=-1)
- elif draw_method == DrawMethod.SQUARE:
- radius = brush_w // 2
- mask[start_y - radius:start_y + radius, start_x - radius:start_x + radius] = 1
- start_x, start_y = end_x, end_y
- return mask[None, ...]
-
-
-class RandomIrregularMaskGenerator:
- def __init__(self, max_angle=4, max_len=60, max_width=20, min_times=0, max_times=10, ramp_kwargs=None,
- draw_method=DrawMethod.LINE):
- self.max_angle = max_angle
- self.max_len = max_len
- self.max_width = max_width
- self.min_times = min_times
- self.max_times = max_times
- self.draw_method = draw_method
- self.ramp = LinearRamp(**ramp_kwargs) if ramp_kwargs is not None else None
-
- def __call__(self, img, iter_i=None, raw_image=None):
- coef = self.ramp(iter_i) if (self.ramp is not None) and (iter_i is not None) else 1
- cur_max_len = int(max(1, self.max_len * coef))
- cur_max_width = int(max(1, self.max_width * coef))
- cur_max_times = int(self.min_times + 1 + (self.max_times - self.min_times) * coef)
- return make_random_irregular_mask(img.shape[1:], max_angle=self.max_angle, max_len=cur_max_len,
- max_width=cur_max_width, min_times=self.min_times, max_times=cur_max_times,
- draw_method=self.draw_method)
-
-
-def make_random_rectangle_mask(shape, margin=10, bbox_min_size=30, bbox_max_size=100, min_times=0, max_times=3):
- height, width = shape
- mask = np.zeros((height, width), np.float32)
- bbox_max_size = min(bbox_max_size, height - margin * 2, width - margin * 2)
- times = np.random.randint(min_times, max_times + 1)
- for i in range(times):
- box_width = np.random.randint(bbox_min_size, bbox_max_size)
- box_height = np.random.randint(bbox_min_size, bbox_max_size)
- start_x = np.random.randint(margin, width - margin - box_width + 1)
- start_y = np.random.randint(margin, height - margin - box_height + 1)
- mask[start_y:start_y + box_height, start_x:start_x + box_width] = 1
- return mask[None, ...]
-
-
-class RandomRectangleMaskGenerator:
- def __init__(self, margin=10, bbox_min_size=30, bbox_max_size=100, min_times=0, max_times=3, ramp_kwargs=None):
- self.margin = margin
- self.bbox_min_size = bbox_min_size
- self.bbox_max_size = bbox_max_size
- self.min_times = min_times
- self.max_times = max_times
- self.ramp = LinearRamp(**ramp_kwargs) if ramp_kwargs is not None else None
-
- def __call__(self, img, iter_i=None, raw_image=None):
- coef = self.ramp(iter_i) if (self.ramp is not None) and (iter_i is not None) else 1
- cur_bbox_max_size = int(self.bbox_min_size + 1 + (self.bbox_max_size - self.bbox_min_size) * coef)
- cur_max_times = int(self.min_times + (self.max_times - self.min_times) * coef)
- return make_random_rectangle_mask(img.shape[1:], margin=self.margin, bbox_min_size=self.bbox_min_size,
- bbox_max_size=cur_bbox_max_size, min_times=self.min_times,
- max_times=cur_max_times)
-
-
-class RandomSegmentationMaskGenerator:
- def __init__(self, **kwargs):
- self.impl = None # will be instantiated in first call (effectively in subprocess)
- self.kwargs = kwargs
-
- def __call__(self, img, iter_i=None, raw_image=None):
- if self.impl is None:
- self.impl = SegmentationMask(**self.kwargs)
-
- masks = self.impl.get_masks(np.transpose(img, (1, 2, 0)))
- masks = [m for m in masks if len(np.unique(m)) > 1]
- return np.random.choice(masks)
-
-
-def make_random_superres_mask(shape, min_step=2, max_step=4, min_width=1, max_width=3):
- height, width = shape
- mask = np.zeros((height, width), np.float32)
- step_x = np.random.randint(min_step, max_step + 1)
- width_x = np.random.randint(min_width, min(step_x, max_width + 1))
- offset_x = np.random.randint(0, step_x)
-
- step_y = np.random.randint(min_step, max_step + 1)
- width_y = np.random.randint(min_width, min(step_y, max_width + 1))
- offset_y = np.random.randint(0, step_y)
-
- for dy in range(width_y):
- mask[offset_y + dy::step_y] = 1
- for dx in range(width_x):
- mask[:, offset_x + dx::step_x] = 1
- return mask[None, ...]
-
-
-class RandomSuperresMaskGenerator:
- def __init__(self, **kwargs):
- self.kwargs = kwargs
-
- def __call__(self, img, iter_i=None):
- return make_random_superres_mask(img.shape[1:], **self.kwargs)
-
-
-class DumbAreaMaskGenerator:
- min_ratio = 0.1
- max_ratio = 0.35
- default_ratio = 0.225
-
- def __init__(self, is_training):
- #Parameters:
- # is_training(bool): If true - random rectangular mask, if false - central square mask
- self.is_training = is_training
-
- def _random_vector(self, dimension):
- if self.is_training:
- lower_limit = math.sqrt(self.min_ratio)
- upper_limit = math.sqrt(self.max_ratio)
- mask_side = round((random.random() * (upper_limit - lower_limit) + lower_limit) * dimension)
- u = random.randint(0, dimension-mask_side-1)
- v = u+mask_side
- else:
- margin = (math.sqrt(self.default_ratio) / 2) * dimension
- u = round(dimension/2 - margin)
- v = round(dimension/2 + margin)
- return u, v
-
- def __call__(self, img, iter_i=None, raw_image=None):
- c, height, width = img.shape
- mask = np.zeros((height, width), np.float32)
- x1, x2 = self._random_vector(width)
- y1, y2 = self._random_vector(height)
- mask[x1:x2, y1:y2] = 1
- return mask[None, ...]
-
-
-class OutpaintingMaskGenerator:
- def __init__(self, min_padding_percent:float=0.04, max_padding_percent:int=0.25, left_padding_prob:float=0.5, top_padding_prob:float=0.5,
- right_padding_prob:float=0.5, bottom_padding_prob:float=0.5, is_fixed_randomness:bool=False):
- """
- is_fixed_randomness - get identical paddings for the same image if args are the same
- """
- self.min_padding_percent = min_padding_percent
- self.max_padding_percent = max_padding_percent
- self.probs = [left_padding_prob, top_padding_prob, right_padding_prob, bottom_padding_prob]
- self.is_fixed_randomness = is_fixed_randomness
-
- assert self.min_padding_percent <= self.max_padding_percent
- assert self.max_padding_percent > 0
- assert len([x for x in [self.min_padding_percent, self.max_padding_percent] if (x>=0 and x<=1)]) == 2, f"Padding percentage should be in [0,1]"
- assert sum(self.probs) > 0, f"At least one of the padding probs should be greater than 0 - {self.probs}"
- assert len([x for x in self.probs if (x >= 0) and (x <= 1)]) == 4, f"At least one of padding probs is not in [0,1] - {self.probs}"
- if len([x for x in self.probs if x > 0]) == 1:
- LOGGER.warning(f"Only one padding prob is greater than zero - {self.probs}. That means that the outpainting masks will be always on the same side")
-
- def apply_padding(self, mask, coord):
- mask[int(coord[0][0]*self.img_h):int(coord[1][0]*self.img_h),
- int(coord[0][1]*self.img_w):int(coord[1][1]*self.img_w)] = 1
- return mask
-
- def get_padding(self, size):
- n1 = int(self.min_padding_percent*size)
- n2 = int(self.max_padding_percent*size)
- return self.rnd.randint(n1, n2) / size
-
- @staticmethod
- def _img2rs(img):
- arr = np.ascontiguousarray(img.astype(np.uint8))
- str_hash = hashlib.sha1(arr).hexdigest()
- res = hash(str_hash)%(2**32)
- return res
-
- def __call__(self, img, iter_i=None, raw_image=None):
- c, self.img_h, self.img_w = img.shape
- mask = np.zeros((self.img_h, self.img_w), np.float32)
- at_least_one_mask_applied = False
-
- if self.is_fixed_randomness:
- assert raw_image is not None, f"Cant calculate hash on raw_image=None"
- rs = self._img2rs(raw_image)
- self.rnd = np.random.RandomState(rs)
- else:
- self.rnd = np.random
-
- coords = [[
- (0,0),
- (1,self.get_padding(size=self.img_h))
- ],
- [
- (0,0),
- (self.get_padding(size=self.img_w),1)
- ],
- [
- (0,1-self.get_padding(size=self.img_h)),
- (1,1)
- ],
- [
- (1-self.get_padding(size=self.img_w),0),
- (1,1)
- ]]
-
- for pp, coord in zip(self.probs, coords):
- if self.rnd.random() < pp:
- at_least_one_mask_applied = True
- mask = self.apply_padding(mask=mask, coord=coord)
-
- if not at_least_one_mask_applied:
- idx = self.rnd.choice(range(len(coords)), p=np.array(self.probs)/sum(self.probs))
- mask = self.apply_padding(mask=mask, coord=coords[idx])
- return mask[None, ...]
-
-
-class MixedMaskGenerator:
- def __init__(self, irregular_proba=1/3, irregular_kwargs=None,
- box_proba=1/3, box_kwargs=None,
- segm_proba=1/3, segm_kwargs=None,
- squares_proba=0, squares_kwargs=None,
- superres_proba=0, superres_kwargs=None,
- outpainting_proba=0, outpainting_kwargs=None,
- invert_proba=0):
- self.probas = []
- self.gens = []
-
- if irregular_proba > 0:
- self.probas.append(irregular_proba)
- if irregular_kwargs is None:
- irregular_kwargs = {}
- else:
- irregular_kwargs = dict(irregular_kwargs)
- irregular_kwargs['draw_method'] = DrawMethod.LINE
- self.gens.append(RandomIrregularMaskGenerator(**irregular_kwargs))
-
- if box_proba > 0:
- self.probas.append(box_proba)
- if box_kwargs is None:
- box_kwargs = {}
- self.gens.append(RandomRectangleMaskGenerator(**box_kwargs))
-
- if segm_proba > 0:
- self.probas.append(segm_proba)
- if segm_kwargs is None:
- segm_kwargs = {}
- self.gens.append(RandomSegmentationMaskGenerator(**segm_kwargs))
-
- if squares_proba > 0:
- self.probas.append(squares_proba)
- if squares_kwargs is None:
- squares_kwargs = {}
- else:
- squares_kwargs = dict(squares_kwargs)
- squares_kwargs['draw_method'] = DrawMethod.SQUARE
- self.gens.append(RandomIrregularMaskGenerator(**squares_kwargs))
-
- if superres_proba > 0:
- self.probas.append(superres_proba)
- if superres_kwargs is None:
- superres_kwargs = {}
- self.gens.append(RandomSuperresMaskGenerator(**superres_kwargs))
-
- if outpainting_proba > 0:
- self.probas.append(outpainting_proba)
- if outpainting_kwargs is None:
- outpainting_kwargs = {}
- self.gens.append(OutpaintingMaskGenerator(**outpainting_kwargs))
-
- self.probas = np.array(self.probas, dtype='float32')
- self.probas /= self.probas.sum()
- self.invert_proba = invert_proba
-
- def __call__(self, img, iter_i=None, raw_image=None):
- kind = np.random.choice(len(self.probas), p=self.probas)
- gen = self.gens[kind]
- result = gen(img, iter_i=iter_i, raw_image=raw_image)
- if self.invert_proba > 0 and random.random() < self.invert_proba:
- result = 1 - result
- return result
-
-
-def get_mask_generator(kind, kwargs):
- if kind is None:
- kind = "mixed"
- if kwargs is None:
- kwargs = {}
-
- if kind == "mixed":
- cl = MixedMaskGenerator
- elif kind == "outpainting":
- cl = OutpaintingMaskGenerator
- elif kind == "dumb":
- cl = DumbAreaMaskGenerator
- else:
- raise NotImplementedError(f"No such generator kind = {kind}")
- return cl(**kwargs)
diff --git a/spaces/Pattr/DrumClassification/lilypond-2.24.2/lib/guile/2.2/ccache/rnrs/records/procedural.go b/spaces/Pattr/DrumClassification/lilypond-2.24.2/lib/guile/2.2/ccache/rnrs/records/procedural.go
deleted file mode 100644
index d5f062339842aab44585aad517c7db60e196fed3..0000000000000000000000000000000000000000
Binary files a/spaces/Pattr/DrumClassification/lilypond-2.24.2/lib/guile/2.2/ccache/rnrs/records/procedural.go and /dev/null differ
diff --git a/spaces/PeepDaSlan9/AutoGPT/tests/unit/test_chat.py b/spaces/PeepDaSlan9/AutoGPT/tests/unit/test_chat.py
deleted file mode 100644
index 774f4103762c28d5a02e89c14b224fae0bc0756a..0000000000000000000000000000000000000000
--- a/spaces/PeepDaSlan9/AutoGPT/tests/unit/test_chat.py
+++ /dev/null
@@ -1,86 +0,0 @@
-# Generated by CodiumAI
-import time
-import unittest
-from unittest.mock import patch
-
-from autogpt.chat import create_chat_message, generate_context
-
-
-class TestChat(unittest.TestCase):
- # Tests that the function returns a dictionary with the correct keys and values when valid strings are provided for role and content.
- def test_happy_path_role_content(self):
- result = create_chat_message("system", "Hello, world!")
- self.assertEqual(result, {"role": "system", "content": "Hello, world!"})
-
- # Tests that the function returns a dictionary with the correct keys and values when empty strings are provided for role and content.
- def test_empty_role_content(self):
- result = create_chat_message("", "")
- self.assertEqual(result, {"role": "", "content": ""})
-
- # Tests the behavior of the generate_context function when all input parameters are empty.
- @patch("time.strftime")
- def test_generate_context_empty_inputs(self, mock_strftime):
- # Mock the time.strftime function to return a fixed value
- mock_strftime.return_value = "Sat Apr 15 00:00:00 2023"
- # Arrange
- prompt = ""
- relevant_memory = ""
- full_message_history = []
- model = "gpt-3.5-turbo-0301"
-
- # Act
- result = generate_context(prompt, relevant_memory, full_message_history, model)
-
- # Assert
- expected_result = (
- -1,
- 47,
- 3,
- [
- {"role": "system", "content": ""},
- {
- "role": "system",
- "content": f"The current time and date is {time.strftime('%c')}",
- },
- {
- "role": "system",
- "content": f"This reminds you of these events from your past:\n\n\n",
- },
- ],
- )
- self.assertEqual(result, expected_result)
-
- # Tests that the function successfully generates a current_context given valid inputs.
- def test_generate_context_valid_inputs(self):
- # Given
- prompt = "What is your favorite color?"
- relevant_memory = "You once painted your room blue."
- full_message_history = [
- create_chat_message("user", "Hi there!"),
- create_chat_message("assistant", "Hello! How can I assist you today?"),
- create_chat_message("user", "Can you tell me a joke?"),
- create_chat_message(
- "assistant",
- "Why did the tomato turn red? Because it saw the salad dressing!",
- ),
- create_chat_message("user", "Haha, that's funny."),
- ]
- model = "gpt-3.5-turbo-0301"
-
- # When
- result = generate_context(prompt, relevant_memory, full_message_history, model)
-
- # Then
- self.assertIsInstance(result[0], int)
- self.assertIsInstance(result[1], int)
- self.assertIsInstance(result[2], int)
- self.assertIsInstance(result[3], list)
- self.assertGreaterEqual(result[0], 0)
- self.assertGreaterEqual(result[1], 0)
- self.assertGreaterEqual(result[2], 0)
- self.assertGreaterEqual(
- len(result[3]), 3
- ) # current_context should have at least 3 messages
- self.assertLessEqual(
- result[1], 2048
- ) # token limit for GPT-3.5-turbo-0301 is 2048 tokens
diff --git a/spaces/Pengyey/bingo-chuchu/src/components/button-scroll-to-bottom.tsx b/spaces/Pengyey/bingo-chuchu/src/components/button-scroll-to-bottom.tsx
deleted file mode 100644
index b68ab9c0e48320c356e51a52d11b9ca63909e6c5..0000000000000000000000000000000000000000
--- a/spaces/Pengyey/bingo-chuchu/src/components/button-scroll-to-bottom.tsx
+++ /dev/null
@@ -1,34 +0,0 @@
-'use client'
-
-import * as React from 'react'
-
-import { cn } from '@/lib/utils'
-import { useAtBottom } from '@/lib/hooks/use-at-bottom'
-import { Button, type ButtonProps } from '@/components/ui/button'
-import { IconArrowDown } from '@/components/ui/icons'
-
-export function ButtonScrollToBottom({ className, ...props }: ButtonProps) {
- const isAtBottom = useAtBottom()
-
- return (
-
- )
-}
diff --git a/spaces/PirateXX/ChatGPT-Detector/app.py b/spaces/PirateXX/ChatGPT-Detector/app.py
deleted file mode 100644
index 2affe50e28675ce377337460e4a794db809f6946..0000000000000000000000000000000000000000
--- a/spaces/PirateXX/ChatGPT-Detector/app.py
+++ /dev/null
@@ -1,85 +0,0 @@
-from flask import Flask, request
-from transformers import AutoTokenizer, AutoModelForSequenceClassification
-from transformers import RobertaConfig
-from transformers import RobertaForSequenceClassification, RobertaTokenizer, RobertaConfig
-import torch
-from torch import cuda
-import gradio as gr
-import os
-import re
-
-app = Flask(__name__)
-
-ACCESS_TOKEN = os.environ["ACCESS_TOKEN"]
-
-# config = RobertaConfig.from_pretrained("PirateXX/ChatGPT-Text-Detector", use_auth_token= ACCESS_TOKEN)
-# model = RobertaForSequenceClassification.from_pretrained("PirateXX/ChatGPT-Text-Detector", use_auth_token= ACCESS_TOKEN, config = config)
-
-device = 'cuda' if cuda.is_available() else 'cpu'
-tokenizer = AutoTokenizer.from_pretrained("PirateXX/AI-Content-Detector", use_auth_token= ACCESS_TOKEN)
-model = AutoModelForSequenceClassification.from_pretrained("PirateXX/AI-Content-Detector", use_auth_token= ACCESS_TOKEN)
-model.to(device)
-
-# model_name = "roberta-base"
-# tokenizer = RobertaTokenizer.from_pretrained(model_name, map_location=torch.device('cpu'))
-
-def text_to_sentences(text):
- clean_text = text.replace('\n', ' ')
- return re.split(r'(?<=[^A-Z].[.?]) +(?=[A-Z])', clean_text)
-
-# function to concatenate sentences into chunks of size 900 or less
-def chunks_of_900(text, chunk_size = 900):
- sentences = text_to_sentences(text)
- chunks = []
- current_chunk = ""
- for sentence in sentences:
- if len(current_chunk + sentence) <= chunk_size:
- if len(current_chunk)!=0:
- current_chunk += " "+sentence
- else:
- current_chunk += sentence
- else:
- chunks.append(current_chunk)
- current_chunk = sentence
- chunks.append(current_chunk)
- return chunks
-
-def predict(query):
- tokens = tokenizer.encode(query)
- all_tokens = len(tokens)
- tokens = tokens[:tokenizer.model_max_length - 2]
- used_tokens = len(tokens)
- tokens = torch.tensor([tokenizer.bos_token_id] + tokens + [tokenizer.eos_token_id]).unsqueeze(0)
- mask = torch.ones_like(tokens)
-
- with torch.no_grad():
- logits = model(tokens.to(device), attention_mask=mask.to(device))[0]
- probs = logits.softmax(dim=-1)
-
- fake, real = probs.detach().cpu().flatten().numpy().tolist()
- return real
-
-def findRealProb(text):
- chunksOfText = (chunks_of_900(text))
- results = []
- for chunk in chunksOfText:
- output = predict(chunk)
- results.append([output, len(chunk)])
-
- ans = 0
- cnt = 0
- for prob, length in results:
- cnt += length
- ans = ans + prob*length
- realProb = ans/cnt
- return {"Real": realProb, "Fake": 1-realProb}, results
-
-demo = gr.Interface(
- fn=findRealProb,
- inputs=gr.Textbox(placeholder="Copy and paste here..."),
- article = "Visit AI Content Detector for better user experience!",
- outputs=gr.outputs.JSON(),
- # interpretation="default",
- examples=["Cristiano Ronaldo is a Portuguese professional soccer player who currently plays as a forward for Manchester United and the Portugal national team. He is widely considered one of the greatest soccer players of all time, having won numerous awards and accolades throughout his career. Ronaldo began his professional career with Sporting CP in Portugal before moving to Manchester United in 2003. He spent six seasons with the club, winning three Premier League titles and one UEFA Champions League title. In 2009, he transferred to Real Madrid for a then-world record transfer fee of $131 million. He spent nine seasons with the club, winning four UEFA Champions League titles, two La Liga titles, and two Copa del Rey titles. In 2018, he transferred to Juventus, where he spent three seasons before returning to Manchester United in 2021. He has also had a successful international career with the Portugal national team, having won the UEFA European Championship in 2016 and the UEFA Nations League in 2019.", "One rule of thumb which applies to everything that we do - professionally and personally : Know what the customer want and deliver. In this case, it is important to know what the organisation what from employee. Connect the same to the KRA. Are you part of a delivery which directly ties to the larger organisational objective. If yes, then the next question is success rate of one’s delivery. If the KRAs are achieved or exceeded, then the employee is entitled for a decent hike."])
-
-demo.launch(show_api=False)
\ No newline at end of file
diff --git a/spaces/RMXK/RVC_HFF/julius/resample.py b/spaces/RMXK/RVC_HFF/julius/resample.py
deleted file mode 100644
index fd3b9b547d4c33ec7136d32e5f086420d0a72e14..0000000000000000000000000000000000000000
--- a/spaces/RMXK/RVC_HFF/julius/resample.py
+++ /dev/null
@@ -1,216 +0,0 @@
-# File under the MIT license, see https://github.com/adefossez/julius/LICENSE for details.
-# Author: adefossez, 2020
-"""
-Differentiable, Pytorch based resampling.
-Implementation of Julius O. Smith algorithm for resampling.
-See https://ccrma.stanford.edu/~jos/resample/ for details.
-This implementation is specially optimized for when new_sr / old_sr is a fraction
-with a small numerator and denominator when removing the gcd (e.g. new_sr = 700, old_sr = 500).
-
-Very similar to [bmcfee/resampy](https://github.com/bmcfee/resampy) except this implementation
-is optimized for the case mentioned before, while resampy is slower but more general.
-
-"""
-
-import math
-from typing import Optional
-
-import torch
-from torch.nn import functional as F
-
-from .core import sinc
-from .utils import simple_repr
-
-
-class ResampleFrac(torch.nn.Module):
- """
- Resampling from the sample rate `old_sr` to `new_sr`.
- """
- def __init__(self, old_sr: int, new_sr: int, zeros: int = 24, rolloff: float = 0.945):
- """
- Args:
- old_sr (int): sample rate of the input signal x.
- new_sr (int): sample rate of the output.
- zeros (int): number of zero crossing to keep in the sinc filter.
- rolloff (float): use a lowpass filter that is `rolloff * new_sr / 2`,
- to ensure sufficient margin due to the imperfection of the FIR filter used.
- Lowering this value will reduce anti-aliasing, but will reduce some of the
- highest frequencies.
-
- Shape:
-
- - Input: `[*, T]`
- - Output: `[*, T']` with `T' = int(new_sr * T / old_sr)
-
-
- .. caution::
- After dividing `old_sr` and `new_sr` by their GCD, both should be small
- for this implementation to be fast.
-
- >>> import torch
- >>> resample = ResampleFrac(4, 5)
- >>> x = torch.randn(1000)
- >>> print(len(resample(x)))
- 1250
- """
- super().__init__()
- if not isinstance(old_sr, int) or not isinstance(new_sr, int):
- raise ValueError("old_sr and new_sr should be integers")
- gcd = math.gcd(old_sr, new_sr)
- self.old_sr = old_sr // gcd
- self.new_sr = new_sr // gcd
- self.zeros = zeros
- self.rolloff = rolloff
-
- self._init_kernels()
-
- def _init_kernels(self):
- if self.old_sr == self.new_sr:
- return
-
- kernels = []
- sr = min(self.new_sr, self.old_sr)
- # rolloff will perform antialiasing filtering by removing the highest frequencies.
- # At first I thought I only needed this when downsampling, but when upsampling
- # you will get edge artifacts without this, the edge is equivalent to zero padding,
- # which will add high freq artifacts.
- sr *= self.rolloff
-
- # The key idea of the algorithm is that x(t) can be exactly reconstructed from x[i] (tensor)
- # using the sinc interpolation formula:
- # x(t) = sum_i x[i] sinc(pi * old_sr * (i / old_sr - t))
- # We can then sample the function x(t) with a different sample rate:
- # y[j] = x(j / new_sr)
- # or,
- # y[j] = sum_i x[i] sinc(pi * old_sr * (i / old_sr - j / new_sr))
-
- # We see here that y[j] is the convolution of x[i] with a specific filter, for which
- # we take an FIR approximation, stopping when we see at least `zeros` zeros crossing.
- # But y[j+1] is going to have a different set of weights and so on, until y[j + new_sr].
- # Indeed:
- # y[j + new_sr] = sum_i x[i] sinc(pi * old_sr * ((i / old_sr - (j + new_sr) / new_sr))
- # = sum_i x[i] sinc(pi * old_sr * ((i - old_sr) / old_sr - j / new_sr))
- # = sum_i x[i + old_sr] sinc(pi * old_sr * (i / old_sr - j / new_sr))
- # so y[j+new_sr] uses the same filter as y[j], but on a shifted version of x by `old_sr`.
- # This will explain the F.conv1d after, with a stride of old_sr.
- self._width = math.ceil(self.zeros * self.old_sr / sr)
- # If old_sr is still big after GCD reduction, most filters will be very unbalanced, i.e.,
- # they will have a lot of almost zero values to the left or to the right...
- # There is probably a way to evaluate those filters more efficiently, but this is kept for
- # future work.
- idx = torch.arange(-self._width, self._width + self.old_sr).float()
- for i in range(self.new_sr):
- t = (-i/self.new_sr + idx/self.old_sr) * sr
- t = t.clamp_(-self.zeros, self.zeros)
- t *= math.pi
- window = torch.cos(t/self.zeros/2)**2
- kernel = sinc(t) * window
- # Renormalize kernel to ensure a constant signal is preserved.
- kernel.div_(kernel.sum())
- kernels.append(kernel)
-
- self.register_buffer("kernel", torch.stack(kernels).view(self.new_sr, 1, -1))
-
- def forward(self, x: torch.Tensor, output_length: Optional[int] = None, full: bool = False):
- """
- Resample x.
- Args:
- x (Tensor): signal to resample, time should be the last dimension
- output_length (None or int): This can be set to the desired output length
- (last dimension). Allowed values are between 0 and
- ceil(length * new_sr / old_sr). When None (default) is specified, the
- floored output length will be used. In order to select the largest possible
- size, use the `full` argument.
- full (bool): return the longest possible output from the input. This can be useful
- if you chain resampling operations, and want to give the `output_length` only
- for the last one, while passing `full=True` to all the other ones.
- """
- if self.old_sr == self.new_sr:
- return x
- shape = x.shape
- length = x.shape[-1]
- x = x.reshape(-1, length)
- x = F.pad(x[:, None], (self._width, self._width + self.old_sr), mode='replicate')
- ys = F.conv1d(x, self.kernel, stride=self.old_sr) # type: ignore
- y = ys.transpose(1, 2).reshape(list(shape[:-1]) + [-1])
-
- float_output_length = self.new_sr * length / self.old_sr
- max_output_length = int(math.ceil(float_output_length))
- default_output_length = int(float_output_length)
- if output_length is None:
- output_length = max_output_length if full else default_output_length
- elif output_length < 0 or output_length > max_output_length:
- raise ValueError(f"output_length must be between 0 and {max_output_length}")
- else:
- if full:
- raise ValueError("You cannot pass both full=True and output_length")
- return y[..., :output_length]
-
- def __repr__(self):
- return simple_repr(self)
-
-
-def resample_frac(x: torch.Tensor, old_sr: int, new_sr: int,
- zeros: int = 24, rolloff: float = 0.945,
- output_length: Optional[int] = None, full: bool = False):
- """
- Functional version of `ResampleFrac`, refer to its documentation for more information.
-
- ..warning::
- If you call repeatidly this functions with the same sample rates, then the
- resampling kernel will be recomputed everytime. For best performance, you should use
- and cache an instance of `ResampleFrac`.
- """
- return ResampleFrac(old_sr, new_sr, zeros, rolloff).to(x)(x, output_length, full)
-
-
-# Easier implementations for downsampling and upsampling by a factor of 2
-# Kept for testing and reference
-
-def _kernel_upsample2_downsample2(zeros):
- # Kernel for upsampling and downsampling by a factor of 2. Interestingly,
- # it is the same kernel used for both.
- win = torch.hann_window(4 * zeros + 1, periodic=False)
- winodd = win[1::2]
- t = torch.linspace(-zeros + 0.5, zeros - 0.5, 2 * zeros)
- t *= math.pi
- kernel = (sinc(t) * winodd).view(1, 1, -1)
- return kernel
-
-
-def _upsample2(x, zeros=24):
- """
- Upsample x by a factor of two. The output will be exactly twice as long as the input.
- Args:
- x (Tensor): signal to upsample, time should be the last dimension
- zeros (int): number of zero crossing to keep in the sinc filter.
-
- This function is kept only for reference, you should use the more generic `resample_frac`
- one. This function does not perform anti-aliasing filtering.
- """
- *other, time = x.shape
- kernel = _kernel_upsample2_downsample2(zeros).to(x)
- out = F.conv1d(x.view(-1, 1, time), kernel, padding=zeros)[..., 1:].view(*other, time)
- y = torch.stack([x, out], dim=-1)
- return y.view(*other, -1)
-
-
-def _downsample2(x, zeros=24):
- """
- Downsample x by a factor of two. The output length is half of the input, ceiled.
- Args:
- x (Tensor): signal to downsample, time should be the last dimension
- zeros (int): number of zero crossing to keep in the sinc filter.
-
- This function is kept only for reference, you should use the more generic `resample_frac`
- one. This function does not perform anti-aliasing filtering.
- """
- if x.shape[-1] % 2 != 0:
- x = F.pad(x, (0, 1))
- xeven = x[..., ::2]
- xodd = x[..., 1::2]
- *other, time = xodd.shape
- kernel = _kernel_upsample2_downsample2(zeros).to(x)
- out = xeven + F.conv1d(xodd.view(-1, 1, time), kernel, padding=zeros)[..., :-1].view(
- *other, time)
- return out.view(*other, -1).mul(0.5)
diff --git a/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pip/_vendor/rich/ansi.py b/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pip/_vendor/rich/ansi.py
deleted file mode 100644
index d4c32cef1eeb248399a5df1f6bc1ac8763e798d6..0000000000000000000000000000000000000000
--- a/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pip/_vendor/rich/ansi.py
+++ /dev/null
@@ -1,237 +0,0 @@
-import re
-import sys
-from contextlib import suppress
-from typing import Iterable, NamedTuple, Optional
-
-from .color import Color
-from .style import Style
-from .text import Text
-
-re_ansi = re.compile(
- r"""
-(?:\x1b\](.*?)\x1b\\)|
-(?:\x1b([(@-Z\\-_]|\[[0-?]*[ -/]*[@-~]))
-""",
- re.VERBOSE,
-)
-
-
-class _AnsiToken(NamedTuple):
- """Result of ansi tokenized string."""
-
- plain: str = ""
- sgr: Optional[str] = ""
- osc: Optional[str] = ""
-
-
-def _ansi_tokenize(ansi_text: str) -> Iterable[_AnsiToken]:
- """Tokenize a string in to plain text and ANSI codes.
-
- Args:
- ansi_text (str): A String containing ANSI codes.
-
- Yields:
- AnsiToken: A named tuple of (plain, sgr, osc)
- """
-
- position = 0
- sgr: Optional[str]
- osc: Optional[str]
- for match in re_ansi.finditer(ansi_text):
- start, end = match.span(0)
- osc, sgr = match.groups()
- if start > position:
- yield _AnsiToken(ansi_text[position:start])
- if sgr:
- if sgr.endswith("m"):
- yield _AnsiToken("", sgr[1:-1], osc)
- else:
- yield _AnsiToken("", sgr, osc)
- position = end
- if position < len(ansi_text):
- yield _AnsiToken(ansi_text[position:])
-
-
-SGR_STYLE_MAP = {
- 1: "bold",
- 2: "dim",
- 3: "italic",
- 4: "underline",
- 5: "blink",
- 6: "blink2",
- 7: "reverse",
- 8: "conceal",
- 9: "strike",
- 21: "underline2",
- 22: "not dim not bold",
- 23: "not italic",
- 24: "not underline",
- 25: "not blink",
- 26: "not blink2",
- 27: "not reverse",
- 28: "not conceal",
- 29: "not strike",
- 30: "color(0)",
- 31: "color(1)",
- 32: "color(2)",
- 33: "color(3)",
- 34: "color(4)",
- 35: "color(5)",
- 36: "color(6)",
- 37: "color(7)",
- 39: "default",
- 40: "on color(0)",
- 41: "on color(1)",
- 42: "on color(2)",
- 43: "on color(3)",
- 44: "on color(4)",
- 45: "on color(5)",
- 46: "on color(6)",
- 47: "on color(7)",
- 49: "on default",
- 51: "frame",
- 52: "encircle",
- 53: "overline",
- 54: "not frame not encircle",
- 55: "not overline",
- 90: "color(8)",
- 91: "color(9)",
- 92: "color(10)",
- 93: "color(11)",
- 94: "color(12)",
- 95: "color(13)",
- 96: "color(14)",
- 97: "color(15)",
- 100: "on color(8)",
- 101: "on color(9)",
- 102: "on color(10)",
- 103: "on color(11)",
- 104: "on color(12)",
- 105: "on color(13)",
- 106: "on color(14)",
- 107: "on color(15)",
-}
-
-
-class AnsiDecoder:
- """Translate ANSI code in to styled Text."""
-
- def __init__(self) -> None:
- self.style = Style.null()
-
- def decode(self, terminal_text: str) -> Iterable[Text]:
- """Decode ANSI codes in an interable of lines.
-
- Args:
- lines (Iterable[str]): An iterable of lines of terminal output.
-
- Yields:
- Text: Marked up Text.
- """
- for line in terminal_text.splitlines():
- yield self.decode_line(line)
-
- def decode_line(self, line: str) -> Text:
- """Decode a line containing ansi codes.
-
- Args:
- line (str): A line of terminal output.
-
- Returns:
- Text: A Text instance marked up according to ansi codes.
- """
- from_ansi = Color.from_ansi
- from_rgb = Color.from_rgb
- _Style = Style
- text = Text()
- append = text.append
- line = line.rsplit("\r", 1)[-1]
- for plain_text, sgr, osc in _ansi_tokenize(line):
- if plain_text:
- append(plain_text, self.style or None)
- elif osc is not None:
- if osc.startswith("8;"):
- _params, semicolon, link = osc[2:].partition(";")
- if semicolon:
- self.style = self.style.update_link(link or None)
- elif sgr is not None:
- # Translate in to semi-colon separated codes
- # Ignore invalid codes, because we want to be lenient
- codes = [
- min(255, int(_code) if _code else 0)
- for _code in sgr.split(";")
- if _code.isdigit() or _code == ""
- ]
- iter_codes = iter(codes)
- for code in iter_codes:
- if code == 0:
- # reset
- self.style = _Style.null()
- elif code in SGR_STYLE_MAP:
- # styles
- self.style += _Style.parse(SGR_STYLE_MAP[code])
- elif code == 38:
- # Foreground
- with suppress(StopIteration):
- color_type = next(iter_codes)
- if color_type == 5:
- self.style += _Style.from_color(
- from_ansi(next(iter_codes))
- )
- elif color_type == 2:
- self.style += _Style.from_color(
- from_rgb(
- next(iter_codes),
- next(iter_codes),
- next(iter_codes),
- )
- )
- elif code == 48:
- # Background
- with suppress(StopIteration):
- color_type = next(iter_codes)
- if color_type == 5:
- self.style += _Style.from_color(
- None, from_ansi(next(iter_codes))
- )
- elif color_type == 2:
- self.style += _Style.from_color(
- None,
- from_rgb(
- next(iter_codes),
- next(iter_codes),
- next(iter_codes),
- ),
- )
-
- return text
-
-
-if sys.platform != "win32" and __name__ == "__main__": # pragma: no cover
- import io
- import os
- import pty
- import sys
-
- decoder = AnsiDecoder()
-
- stdout = io.BytesIO()
-
- def read(fd: int) -> bytes:
- data = os.read(fd, 1024)
- stdout.write(data)
- return data
-
- pty.spawn(sys.argv[1:], read)
-
- from .console import Console
-
- console = Console(record=True)
-
- stdout_result = stdout.getvalue().decode("utf-8")
- print(stdout_result)
-
- for line in decoder.decode(stdout_result):
- console.print(line)
-
- console.save_html("stdout.html")
diff --git a/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pip/_vendor/urllib3/contrib/_securetransport/bindings.py b/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pip/_vendor/urllib3/contrib/_securetransport/bindings.py
deleted file mode 100644
index 264d564dbda676b52f446c0d25433a15939a78a3..0000000000000000000000000000000000000000
--- a/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pip/_vendor/urllib3/contrib/_securetransport/bindings.py
+++ /dev/null
@@ -1,519 +0,0 @@
-"""
-This module uses ctypes to bind a whole bunch of functions and constants from
-SecureTransport. The goal here is to provide the low-level API to
-SecureTransport. These are essentially the C-level functions and constants, and
-they're pretty gross to work with.
-
-This code is a bastardised version of the code found in Will Bond's oscrypto
-library. An enormous debt is owed to him for blazing this trail for us. For
-that reason, this code should be considered to be covered both by urllib3's
-license and by oscrypto's:
-
- Copyright (c) 2015-2016 Will Bond
-
- Permission is hereby granted, free of charge, to any person obtaining a
- copy of this software and associated documentation files (the "Software"),
- to deal in the Software without restriction, including without limitation
- the rights to use, copy, modify, merge, publish, distribute, sublicense,
- and/or sell copies of the Software, and to permit persons to whom the
- Software is furnished to do so, subject to the following conditions:
-
- The above copyright notice and this permission notice shall be included in
- all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- DEALINGS IN THE SOFTWARE.
-"""
-from __future__ import absolute_import
-
-import platform
-from ctypes import (
- CDLL,
- CFUNCTYPE,
- POINTER,
- c_bool,
- c_byte,
- c_char_p,
- c_int32,
- c_long,
- c_size_t,
- c_uint32,
- c_ulong,
- c_void_p,
-)
-from ctypes.util import find_library
-
-from ...packages.six import raise_from
-
-if platform.system() != "Darwin":
- raise ImportError("Only macOS is supported")
-
-version = platform.mac_ver()[0]
-version_info = tuple(map(int, version.split(".")))
-if version_info < (10, 8):
- raise OSError(
- "Only OS X 10.8 and newer are supported, not %s.%s"
- % (version_info[0], version_info[1])
- )
-
-
-def load_cdll(name, macos10_16_path):
- """Loads a CDLL by name, falling back to known path on 10.16+"""
- try:
- # Big Sur is technically 11 but we use 10.16 due to the Big Sur
- # beta being labeled as 10.16.
- if version_info >= (10, 16):
- path = macos10_16_path
- else:
- path = find_library(name)
- if not path:
- raise OSError # Caught and reraised as 'ImportError'
- return CDLL(path, use_errno=True)
- except OSError:
- raise_from(ImportError("The library %s failed to load" % name), None)
-
-
-Security = load_cdll(
- "Security", "/System/Library/Frameworks/Security.framework/Security"
-)
-CoreFoundation = load_cdll(
- "CoreFoundation",
- "/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation",
-)
-
-
-Boolean = c_bool
-CFIndex = c_long
-CFStringEncoding = c_uint32
-CFData = c_void_p
-CFString = c_void_p
-CFArray = c_void_p
-CFMutableArray = c_void_p
-CFDictionary = c_void_p
-CFError = c_void_p
-CFType = c_void_p
-CFTypeID = c_ulong
-
-CFTypeRef = POINTER(CFType)
-CFAllocatorRef = c_void_p
-
-OSStatus = c_int32
-
-CFDataRef = POINTER(CFData)
-CFStringRef = POINTER(CFString)
-CFArrayRef = POINTER(CFArray)
-CFMutableArrayRef = POINTER(CFMutableArray)
-CFDictionaryRef = POINTER(CFDictionary)
-CFArrayCallBacks = c_void_p
-CFDictionaryKeyCallBacks = c_void_p
-CFDictionaryValueCallBacks = c_void_p
-
-SecCertificateRef = POINTER(c_void_p)
-SecExternalFormat = c_uint32
-SecExternalItemType = c_uint32
-SecIdentityRef = POINTER(c_void_p)
-SecItemImportExportFlags = c_uint32
-SecItemImportExportKeyParameters = c_void_p
-SecKeychainRef = POINTER(c_void_p)
-SSLProtocol = c_uint32
-SSLCipherSuite = c_uint32
-SSLContextRef = POINTER(c_void_p)
-SecTrustRef = POINTER(c_void_p)
-SSLConnectionRef = c_uint32
-SecTrustResultType = c_uint32
-SecTrustOptionFlags = c_uint32
-SSLProtocolSide = c_uint32
-SSLConnectionType = c_uint32
-SSLSessionOption = c_uint32
-
-
-try:
- Security.SecItemImport.argtypes = [
- CFDataRef,
- CFStringRef,
- POINTER(SecExternalFormat),
- POINTER(SecExternalItemType),
- SecItemImportExportFlags,
- POINTER(SecItemImportExportKeyParameters),
- SecKeychainRef,
- POINTER(CFArrayRef),
- ]
- Security.SecItemImport.restype = OSStatus
-
- Security.SecCertificateGetTypeID.argtypes = []
- Security.SecCertificateGetTypeID.restype = CFTypeID
-
- Security.SecIdentityGetTypeID.argtypes = []
- Security.SecIdentityGetTypeID.restype = CFTypeID
-
- Security.SecKeyGetTypeID.argtypes = []
- Security.SecKeyGetTypeID.restype = CFTypeID
-
- Security.SecCertificateCreateWithData.argtypes = [CFAllocatorRef, CFDataRef]
- Security.SecCertificateCreateWithData.restype = SecCertificateRef
-
- Security.SecCertificateCopyData.argtypes = [SecCertificateRef]
- Security.SecCertificateCopyData.restype = CFDataRef
-
- Security.SecCopyErrorMessageString.argtypes = [OSStatus, c_void_p]
- Security.SecCopyErrorMessageString.restype = CFStringRef
-
- Security.SecIdentityCreateWithCertificate.argtypes = [
- CFTypeRef,
- SecCertificateRef,
- POINTER(SecIdentityRef),
- ]
- Security.SecIdentityCreateWithCertificate.restype = OSStatus
-
- Security.SecKeychainCreate.argtypes = [
- c_char_p,
- c_uint32,
- c_void_p,
- Boolean,
- c_void_p,
- POINTER(SecKeychainRef),
- ]
- Security.SecKeychainCreate.restype = OSStatus
-
- Security.SecKeychainDelete.argtypes = [SecKeychainRef]
- Security.SecKeychainDelete.restype = OSStatus
-
- Security.SecPKCS12Import.argtypes = [
- CFDataRef,
- CFDictionaryRef,
- POINTER(CFArrayRef),
- ]
- Security.SecPKCS12Import.restype = OSStatus
-
- SSLReadFunc = CFUNCTYPE(OSStatus, SSLConnectionRef, c_void_p, POINTER(c_size_t))
- SSLWriteFunc = CFUNCTYPE(
- OSStatus, SSLConnectionRef, POINTER(c_byte), POINTER(c_size_t)
- )
-
- Security.SSLSetIOFuncs.argtypes = [SSLContextRef, SSLReadFunc, SSLWriteFunc]
- Security.SSLSetIOFuncs.restype = OSStatus
-
- Security.SSLSetPeerID.argtypes = [SSLContextRef, c_char_p, c_size_t]
- Security.SSLSetPeerID.restype = OSStatus
-
- Security.SSLSetCertificate.argtypes = [SSLContextRef, CFArrayRef]
- Security.SSLSetCertificate.restype = OSStatus
-
- Security.SSLSetCertificateAuthorities.argtypes = [SSLContextRef, CFTypeRef, Boolean]
- Security.SSLSetCertificateAuthorities.restype = OSStatus
-
- Security.SSLSetConnection.argtypes = [SSLContextRef, SSLConnectionRef]
- Security.SSLSetConnection.restype = OSStatus
-
- Security.SSLSetPeerDomainName.argtypes = [SSLContextRef, c_char_p, c_size_t]
- Security.SSLSetPeerDomainName.restype = OSStatus
-
- Security.SSLHandshake.argtypes = [SSLContextRef]
- Security.SSLHandshake.restype = OSStatus
-
- Security.SSLRead.argtypes = [SSLContextRef, c_char_p, c_size_t, POINTER(c_size_t)]
- Security.SSLRead.restype = OSStatus
-
- Security.SSLWrite.argtypes = [SSLContextRef, c_char_p, c_size_t, POINTER(c_size_t)]
- Security.SSLWrite.restype = OSStatus
-
- Security.SSLClose.argtypes = [SSLContextRef]
- Security.SSLClose.restype = OSStatus
-
- Security.SSLGetNumberSupportedCiphers.argtypes = [SSLContextRef, POINTER(c_size_t)]
- Security.SSLGetNumberSupportedCiphers.restype = OSStatus
-
- Security.SSLGetSupportedCiphers.argtypes = [
- SSLContextRef,
- POINTER(SSLCipherSuite),
- POINTER(c_size_t),
- ]
- Security.SSLGetSupportedCiphers.restype = OSStatus
-
- Security.SSLSetEnabledCiphers.argtypes = [
- SSLContextRef,
- POINTER(SSLCipherSuite),
- c_size_t,
- ]
- Security.SSLSetEnabledCiphers.restype = OSStatus
-
- Security.SSLGetNumberEnabledCiphers.argtype = [SSLContextRef, POINTER(c_size_t)]
- Security.SSLGetNumberEnabledCiphers.restype = OSStatus
-
- Security.SSLGetEnabledCiphers.argtypes = [
- SSLContextRef,
- POINTER(SSLCipherSuite),
- POINTER(c_size_t),
- ]
- Security.SSLGetEnabledCiphers.restype = OSStatus
-
- Security.SSLGetNegotiatedCipher.argtypes = [SSLContextRef, POINTER(SSLCipherSuite)]
- Security.SSLGetNegotiatedCipher.restype = OSStatus
-
- Security.SSLGetNegotiatedProtocolVersion.argtypes = [
- SSLContextRef,
- POINTER(SSLProtocol),
- ]
- Security.SSLGetNegotiatedProtocolVersion.restype = OSStatus
-
- Security.SSLCopyPeerTrust.argtypes = [SSLContextRef, POINTER(SecTrustRef)]
- Security.SSLCopyPeerTrust.restype = OSStatus
-
- Security.SecTrustSetAnchorCertificates.argtypes = [SecTrustRef, CFArrayRef]
- Security.SecTrustSetAnchorCertificates.restype = OSStatus
-
- Security.SecTrustSetAnchorCertificatesOnly.argstypes = [SecTrustRef, Boolean]
- Security.SecTrustSetAnchorCertificatesOnly.restype = OSStatus
-
- Security.SecTrustEvaluate.argtypes = [SecTrustRef, POINTER(SecTrustResultType)]
- Security.SecTrustEvaluate.restype = OSStatus
-
- Security.SecTrustGetCertificateCount.argtypes = [SecTrustRef]
- Security.SecTrustGetCertificateCount.restype = CFIndex
-
- Security.SecTrustGetCertificateAtIndex.argtypes = [SecTrustRef, CFIndex]
- Security.SecTrustGetCertificateAtIndex.restype = SecCertificateRef
-
- Security.SSLCreateContext.argtypes = [
- CFAllocatorRef,
- SSLProtocolSide,
- SSLConnectionType,
- ]
- Security.SSLCreateContext.restype = SSLContextRef
-
- Security.SSLSetSessionOption.argtypes = [SSLContextRef, SSLSessionOption, Boolean]
- Security.SSLSetSessionOption.restype = OSStatus
-
- Security.SSLSetProtocolVersionMin.argtypes = [SSLContextRef, SSLProtocol]
- Security.SSLSetProtocolVersionMin.restype = OSStatus
-
- Security.SSLSetProtocolVersionMax.argtypes = [SSLContextRef, SSLProtocol]
- Security.SSLSetProtocolVersionMax.restype = OSStatus
-
- try:
- Security.SSLSetALPNProtocols.argtypes = [SSLContextRef, CFArrayRef]
- Security.SSLSetALPNProtocols.restype = OSStatus
- except AttributeError:
- # Supported only in 10.12+
- pass
-
- Security.SecCopyErrorMessageString.argtypes = [OSStatus, c_void_p]
- Security.SecCopyErrorMessageString.restype = CFStringRef
-
- Security.SSLReadFunc = SSLReadFunc
- Security.SSLWriteFunc = SSLWriteFunc
- Security.SSLContextRef = SSLContextRef
- Security.SSLProtocol = SSLProtocol
- Security.SSLCipherSuite = SSLCipherSuite
- Security.SecIdentityRef = SecIdentityRef
- Security.SecKeychainRef = SecKeychainRef
- Security.SecTrustRef = SecTrustRef
- Security.SecTrustResultType = SecTrustResultType
- Security.SecExternalFormat = SecExternalFormat
- Security.OSStatus = OSStatus
-
- Security.kSecImportExportPassphrase = CFStringRef.in_dll(
- Security, "kSecImportExportPassphrase"
- )
- Security.kSecImportItemIdentity = CFStringRef.in_dll(
- Security, "kSecImportItemIdentity"
- )
-
- # CoreFoundation time!
- CoreFoundation.CFRetain.argtypes = [CFTypeRef]
- CoreFoundation.CFRetain.restype = CFTypeRef
-
- CoreFoundation.CFRelease.argtypes = [CFTypeRef]
- CoreFoundation.CFRelease.restype = None
-
- CoreFoundation.CFGetTypeID.argtypes = [CFTypeRef]
- CoreFoundation.CFGetTypeID.restype = CFTypeID
-
- CoreFoundation.CFStringCreateWithCString.argtypes = [
- CFAllocatorRef,
- c_char_p,
- CFStringEncoding,
- ]
- CoreFoundation.CFStringCreateWithCString.restype = CFStringRef
-
- CoreFoundation.CFStringGetCStringPtr.argtypes = [CFStringRef, CFStringEncoding]
- CoreFoundation.CFStringGetCStringPtr.restype = c_char_p
-
- CoreFoundation.CFStringGetCString.argtypes = [
- CFStringRef,
- c_char_p,
- CFIndex,
- CFStringEncoding,
- ]
- CoreFoundation.CFStringGetCString.restype = c_bool
-
- CoreFoundation.CFDataCreate.argtypes = [CFAllocatorRef, c_char_p, CFIndex]
- CoreFoundation.CFDataCreate.restype = CFDataRef
-
- CoreFoundation.CFDataGetLength.argtypes = [CFDataRef]
- CoreFoundation.CFDataGetLength.restype = CFIndex
-
- CoreFoundation.CFDataGetBytePtr.argtypes = [CFDataRef]
- CoreFoundation.CFDataGetBytePtr.restype = c_void_p
-
- CoreFoundation.CFDictionaryCreate.argtypes = [
- CFAllocatorRef,
- POINTER(CFTypeRef),
- POINTER(CFTypeRef),
- CFIndex,
- CFDictionaryKeyCallBacks,
- CFDictionaryValueCallBacks,
- ]
- CoreFoundation.CFDictionaryCreate.restype = CFDictionaryRef
-
- CoreFoundation.CFDictionaryGetValue.argtypes = [CFDictionaryRef, CFTypeRef]
- CoreFoundation.CFDictionaryGetValue.restype = CFTypeRef
-
- CoreFoundation.CFArrayCreate.argtypes = [
- CFAllocatorRef,
- POINTER(CFTypeRef),
- CFIndex,
- CFArrayCallBacks,
- ]
- CoreFoundation.CFArrayCreate.restype = CFArrayRef
-
- CoreFoundation.CFArrayCreateMutable.argtypes = [
- CFAllocatorRef,
- CFIndex,
- CFArrayCallBacks,
- ]
- CoreFoundation.CFArrayCreateMutable.restype = CFMutableArrayRef
-
- CoreFoundation.CFArrayAppendValue.argtypes = [CFMutableArrayRef, c_void_p]
- CoreFoundation.CFArrayAppendValue.restype = None
-
- CoreFoundation.CFArrayGetCount.argtypes = [CFArrayRef]
- CoreFoundation.CFArrayGetCount.restype = CFIndex
-
- CoreFoundation.CFArrayGetValueAtIndex.argtypes = [CFArrayRef, CFIndex]
- CoreFoundation.CFArrayGetValueAtIndex.restype = c_void_p
-
- CoreFoundation.kCFAllocatorDefault = CFAllocatorRef.in_dll(
- CoreFoundation, "kCFAllocatorDefault"
- )
- CoreFoundation.kCFTypeArrayCallBacks = c_void_p.in_dll(
- CoreFoundation, "kCFTypeArrayCallBacks"
- )
- CoreFoundation.kCFTypeDictionaryKeyCallBacks = c_void_p.in_dll(
- CoreFoundation, "kCFTypeDictionaryKeyCallBacks"
- )
- CoreFoundation.kCFTypeDictionaryValueCallBacks = c_void_p.in_dll(
- CoreFoundation, "kCFTypeDictionaryValueCallBacks"
- )
-
- CoreFoundation.CFTypeRef = CFTypeRef
- CoreFoundation.CFArrayRef = CFArrayRef
- CoreFoundation.CFStringRef = CFStringRef
- CoreFoundation.CFDictionaryRef = CFDictionaryRef
-
-except (AttributeError):
- raise ImportError("Error initializing ctypes")
-
-
-class CFConst(object):
- """
- A class object that acts as essentially a namespace for CoreFoundation
- constants.
- """
-
- kCFStringEncodingUTF8 = CFStringEncoding(0x08000100)
-
-
-class SecurityConst(object):
- """
- A class object that acts as essentially a namespace for Security constants.
- """
-
- kSSLSessionOptionBreakOnServerAuth = 0
-
- kSSLProtocol2 = 1
- kSSLProtocol3 = 2
- kTLSProtocol1 = 4
- kTLSProtocol11 = 7
- kTLSProtocol12 = 8
- # SecureTransport does not support TLS 1.3 even if there's a constant for it
- kTLSProtocol13 = 10
- kTLSProtocolMaxSupported = 999
-
- kSSLClientSide = 1
- kSSLStreamType = 0
-
- kSecFormatPEMSequence = 10
-
- kSecTrustResultInvalid = 0
- kSecTrustResultProceed = 1
- # This gap is present on purpose: this was kSecTrustResultConfirm, which
- # is deprecated.
- kSecTrustResultDeny = 3
- kSecTrustResultUnspecified = 4
- kSecTrustResultRecoverableTrustFailure = 5
- kSecTrustResultFatalTrustFailure = 6
- kSecTrustResultOtherError = 7
-
- errSSLProtocol = -9800
- errSSLWouldBlock = -9803
- errSSLClosedGraceful = -9805
- errSSLClosedNoNotify = -9816
- errSSLClosedAbort = -9806
-
- errSSLXCertChainInvalid = -9807
- errSSLCrypto = -9809
- errSSLInternal = -9810
- errSSLCertExpired = -9814
- errSSLCertNotYetValid = -9815
- errSSLUnknownRootCert = -9812
- errSSLNoRootCert = -9813
- errSSLHostNameMismatch = -9843
- errSSLPeerHandshakeFail = -9824
- errSSLPeerUserCancelled = -9839
- errSSLWeakPeerEphemeralDHKey = -9850
- errSSLServerAuthCompleted = -9841
- errSSLRecordOverflow = -9847
-
- errSecVerifyFailed = -67808
- errSecNoTrustSettings = -25263
- errSecItemNotFound = -25300
- errSecInvalidTrustSettings = -25262
-
- # Cipher suites. We only pick the ones our default cipher string allows.
- # Source: https://developer.apple.com/documentation/security/1550981-ssl_cipher_suite_values
- TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 = 0xC02C
- TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 = 0xC030
- TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 = 0xC02B
- TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 = 0xC02F
- TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 = 0xCCA9
- TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 = 0xCCA8
- TLS_DHE_RSA_WITH_AES_256_GCM_SHA384 = 0x009F
- TLS_DHE_RSA_WITH_AES_128_GCM_SHA256 = 0x009E
- TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 = 0xC024
- TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 = 0xC028
- TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA = 0xC00A
- TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA = 0xC014
- TLS_DHE_RSA_WITH_AES_256_CBC_SHA256 = 0x006B
- TLS_DHE_RSA_WITH_AES_256_CBC_SHA = 0x0039
- TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 = 0xC023
- TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 = 0xC027
- TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA = 0xC009
- TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA = 0xC013
- TLS_DHE_RSA_WITH_AES_128_CBC_SHA256 = 0x0067
- TLS_DHE_RSA_WITH_AES_128_CBC_SHA = 0x0033
- TLS_RSA_WITH_AES_256_GCM_SHA384 = 0x009D
- TLS_RSA_WITH_AES_128_GCM_SHA256 = 0x009C
- TLS_RSA_WITH_AES_256_CBC_SHA256 = 0x003D
- TLS_RSA_WITH_AES_128_CBC_SHA256 = 0x003C
- TLS_RSA_WITH_AES_256_CBC_SHA = 0x0035
- TLS_RSA_WITH_AES_128_CBC_SHA = 0x002F
- TLS_AES_128_GCM_SHA256 = 0x1301
- TLS_AES_256_GCM_SHA384 = 0x1302
- TLS_AES_128_CCM_8_SHA256 = 0x1305
- TLS_AES_128_CCM_SHA256 = 0x1304
diff --git a/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/setuptools/package_index.py b/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/setuptools/package_index.py
deleted file mode 100644
index 14881d2992273f3c76e8c6c8dca156abdeae5375..0000000000000000000000000000000000000000
--- a/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/setuptools/package_index.py
+++ /dev/null
@@ -1,1126 +0,0 @@
-"""PyPI and direct package downloading"""
-import sys
-import os
-import re
-import io
-import shutil
-import socket
-import base64
-import hashlib
-import itertools
-import warnings
-import configparser
-import html
-import http.client
-import urllib.parse
-import urllib.request
-import urllib.error
-from functools import wraps
-
-import setuptools
-from pkg_resources import (
- CHECKOUT_DIST, Distribution, BINARY_DIST, normalize_path, SOURCE_DIST,
- Environment, find_distributions, safe_name, safe_version,
- to_filename, Requirement, DEVELOP_DIST, EGG_DIST, parse_version,
-)
-from distutils import log
-from distutils.errors import DistutilsError
-from fnmatch import translate
-from setuptools.wheel import Wheel
-from setuptools.extern.more_itertools import unique_everseen
-
-
-EGG_FRAGMENT = re.compile(r'^egg=([-A-Za-z0-9_.+!]+)$')
-HREF = re.compile(r"""href\s*=\s*['"]?([^'"> ]+)""", re.I)
-PYPI_MD5 = re.compile(
- r'([^<]+)\n\s+\(md5\)'
-)
-URL_SCHEME = re.compile('([-+.a-z0-9]{2,}):', re.I).match
-EXTENSIONS = ".tar.gz .tar.bz2 .tar .zip .tgz".split()
-
-__all__ = [
- 'PackageIndex', 'distros_for_url', 'parse_bdist_wininst',
- 'interpret_distro_name',
-]
-
-_SOCKET_TIMEOUT = 15
-
-_tmpl = "setuptools/{setuptools.__version__} Python-urllib/{py_major}"
-user_agent = _tmpl.format(
- py_major='{}.{}'.format(*sys.version_info), setuptools=setuptools)
-
-
-def parse_requirement_arg(spec):
- try:
- return Requirement.parse(spec)
- except ValueError as e:
- raise DistutilsError(
- "Not a URL, existing file, or requirement spec: %r" % (spec,)
- ) from e
-
-
-def parse_bdist_wininst(name):
- """Return (base,pyversion) or (None,None) for possible .exe name"""
-
- lower = name.lower()
- base, py_ver, plat = None, None, None
-
- if lower.endswith('.exe'):
- if lower.endswith('.win32.exe'):
- base = name[:-10]
- plat = 'win32'
- elif lower.startswith('.win32-py', -16):
- py_ver = name[-7:-4]
- base = name[:-16]
- plat = 'win32'
- elif lower.endswith('.win-amd64.exe'):
- base = name[:-14]
- plat = 'win-amd64'
- elif lower.startswith('.win-amd64-py', -20):
- py_ver = name[-7:-4]
- base = name[:-20]
- plat = 'win-amd64'
- return base, py_ver, plat
-
-
-def egg_info_for_url(url):
- parts = urllib.parse.urlparse(url)
- scheme, server, path, parameters, query, fragment = parts
- base = urllib.parse.unquote(path.split('/')[-1])
- if server == 'sourceforge.net' and base == 'download': # XXX Yuck
- base = urllib.parse.unquote(path.split('/')[-2])
- if '#' in base:
- base, fragment = base.split('#', 1)
- return base, fragment
-
-
-def distros_for_url(url, metadata=None):
- """Yield egg or source distribution objects that might be found at a URL"""
- base, fragment = egg_info_for_url(url)
- for dist in distros_for_location(url, base, metadata):
- yield dist
- if fragment:
- match = EGG_FRAGMENT.match(fragment)
- if match:
- for dist in interpret_distro_name(
- url, match.group(1), metadata, precedence=CHECKOUT_DIST
- ):
- yield dist
-
-
-def distros_for_location(location, basename, metadata=None):
- """Yield egg or source distribution objects based on basename"""
- if basename.endswith('.egg.zip'):
- basename = basename[:-4] # strip the .zip
- if basename.endswith('.egg') and '-' in basename:
- # only one, unambiguous interpretation
- return [Distribution.from_location(location, basename, metadata)]
- if basename.endswith('.whl') and '-' in basename:
- wheel = Wheel(basename)
- if not wheel.is_compatible():
- return []
- return [Distribution(
- location=location,
- project_name=wheel.project_name,
- version=wheel.version,
- # Increase priority over eggs.
- precedence=EGG_DIST + 1,
- )]
- if basename.endswith('.exe'):
- win_base, py_ver, platform = parse_bdist_wininst(basename)
- if win_base is not None:
- return interpret_distro_name(
- location, win_base, metadata, py_ver, BINARY_DIST, platform
- )
- # Try source distro extensions (.zip, .tgz, etc.)
- #
- for ext in EXTENSIONS:
- if basename.endswith(ext):
- basename = basename[:-len(ext)]
- return interpret_distro_name(location, basename, metadata)
- return [] # no extension matched
-
-
-def distros_for_filename(filename, metadata=None):
- """Yield possible egg or source distribution objects based on a filename"""
- return distros_for_location(
- normalize_path(filename), os.path.basename(filename), metadata
- )
-
-
-def interpret_distro_name(
- location, basename, metadata, py_version=None, precedence=SOURCE_DIST,
- platform=None
-):
- """Generate alternative interpretations of a source distro name
-
- Note: if `location` is a filesystem filename, you should call
- ``pkg_resources.normalize_path()`` on it before passing it to this
- routine!
- """
- # Generate alternative interpretations of a source distro name
- # Because some packages are ambiguous as to name/versions split
- # e.g. "adns-python-1.1.0", "egenix-mx-commercial", etc.
- # So, we generate each possible interpretation (e.g. "adns, python-1.1.0"
- # "adns-python, 1.1.0", and "adns-python-1.1.0, no version"). In practice,
- # the spurious interpretations should be ignored, because in the event
- # there's also an "adns" package, the spurious "python-1.1.0" version will
- # compare lower than any numeric version number, and is therefore unlikely
- # to match a request for it. It's still a potential problem, though, and
- # in the long run PyPI and the distutils should go for "safe" names and
- # versions in distribution archive names (sdist and bdist).
-
- parts = basename.split('-')
- if not py_version and any(re.match(r'py\d\.\d$', p) for p in parts[2:]):
- # it is a bdist_dumb, not an sdist -- bail out
- return
-
- for p in range(1, len(parts) + 1):
- yield Distribution(
- location, metadata, '-'.join(parts[:p]), '-'.join(parts[p:]),
- py_version=py_version, precedence=precedence,
- platform=platform
- )
-
-
-def unique_values(func):
- """
- Wrap a function returning an iterable such that the resulting iterable
- only ever yields unique items.
- """
-
- @wraps(func)
- def wrapper(*args, **kwargs):
- return unique_everseen(func(*args, **kwargs))
-
- return wrapper
-
-
-REL = re.compile(r"""<([^>]*\srel\s*=\s*['"]?([^'">]+)[^>]*)>""", re.I)
-# this line is here to fix emacs' cruddy broken syntax highlighting
-
-
-@unique_values
-def find_external_links(url, page):
- """Find rel="homepage" and rel="download" links in `page`, yielding URLs"""
-
- for match in REL.finditer(page):
- tag, rel = match.groups()
- rels = set(map(str.strip, rel.lower().split(',')))
- if 'homepage' in rels or 'download' in rels:
- for match in HREF.finditer(tag):
- yield urllib.parse.urljoin(url, htmldecode(match.group(1)))
-
- for tag in ("
Home Page", "
Download URL"):
- pos = page.find(tag)
- if pos != -1:
- match = HREF.search(page, pos)
- if match:
- yield urllib.parse.urljoin(url, htmldecode(match.group(1)))
-
-
-class ContentChecker:
- """
- A null content checker that defines the interface for checking content
- """
-
- def feed(self, block):
- """
- Feed a block of data to the hash.
- """
- return
-
- def is_valid(self):
- """
- Check the hash. Return False if validation fails.
- """
- return True
-
- def report(self, reporter, template):
- """
- Call reporter with information about the checker (hash name)
- substituted into the template.
- """
- return
-
-
-class HashChecker(ContentChecker):
- pattern = re.compile(
- r'(?Psha1|sha224|sha384|sha256|sha512|md5)='
- r'(?P[a-f0-9]+)'
- )
-
- def __init__(self, hash_name, expected):
- self.hash_name = hash_name
- self.hash = hashlib.new(hash_name)
- self.expected = expected
-
- @classmethod
- def from_url(cls, url):
- "Construct a (possibly null) ContentChecker from a URL"
- fragment = urllib.parse.urlparse(url)[-1]
- if not fragment:
- return ContentChecker()
- match = cls.pattern.search(fragment)
- if not match:
- return ContentChecker()
- return cls(**match.groupdict())
-
- def feed(self, block):
- self.hash.update(block)
-
- def is_valid(self):
- return self.hash.hexdigest() == self.expected
-
- def report(self, reporter, template):
- msg = template % self.hash_name
- return reporter(msg)
-
-
-class PackageIndex(Environment):
- """A distribution index that scans web pages for download URLs"""
-
- def __init__(
- self, index_url="https://pypi.org/simple/", hosts=('*',),
- ca_bundle=None, verify_ssl=True, *args, **kw
- ):
- super().__init__(*args, **kw)
- self.index_url = index_url + "/" [:not index_url.endswith('/')]
- self.scanned_urls = {}
- self.fetched_urls = {}
- self.package_pages = {}
- self.allows = re.compile('|'.join(map(translate, hosts))).match
- self.to_scan = []
- self.opener = urllib.request.urlopen
-
- def add(self, dist):
- # ignore invalid versions
- try:
- parse_version(dist.version)
- except Exception:
- return
- return super().add(dist)
-
- # FIXME: 'PackageIndex.process_url' is too complex (14)
- def process_url(self, url, retrieve=False): # noqa: C901
- """Evaluate a URL as a possible download, and maybe retrieve it"""
- if url in self.scanned_urls and not retrieve:
- return
- self.scanned_urls[url] = True
- if not URL_SCHEME(url):
- self.process_filename(url)
- return
- else:
- dists = list(distros_for_url(url))
- if dists:
- if not self.url_ok(url):
- return
- self.debug("Found link: %s", url)
-
- if dists or not retrieve or url in self.fetched_urls:
- list(map(self.add, dists))
- return # don't need the actual page
-
- if not self.url_ok(url):
- self.fetched_urls[url] = True
- return
-
- self.info("Reading %s", url)
- self.fetched_urls[url] = True # prevent multiple fetch attempts
- tmpl = "Download error on %s: %%s -- Some packages may not be found!"
- f = self.open_url(url, tmpl % url)
- if f is None:
- return
- if isinstance(f, urllib.error.HTTPError) and f.code == 401:
- self.info("Authentication error: %s" % f.msg)
- self.fetched_urls[f.url] = True
- if 'html' not in f.headers.get('content-type', '').lower():
- f.close() # not html, we can't process it
- return
-
- base = f.url # handle redirects
- page = f.read()
- if not isinstance(page, str):
- # In Python 3 and got bytes but want str.
- if isinstance(f, urllib.error.HTTPError):
- # Errors have no charset, assume latin1:
- charset = 'latin-1'
- else:
- charset = f.headers.get_param('charset') or 'latin-1'
- page = page.decode(charset, "ignore")
- f.close()
- for match in HREF.finditer(page):
- link = urllib.parse.urljoin(base, htmldecode(match.group(1)))
- self.process_url(link)
- if url.startswith(self.index_url) and getattr(f, 'code', None) != 404:
- page = self.process_index(url, page)
-
- def process_filename(self, fn, nested=False):
- # process filenames or directories
- if not os.path.exists(fn):
- self.warn("Not found: %s", fn)
- return
-
- if os.path.isdir(fn) and not nested:
- path = os.path.realpath(fn)
- for item in os.listdir(path):
- self.process_filename(os.path.join(path, item), True)
-
- dists = distros_for_filename(fn)
- if dists:
- self.debug("Found: %s", fn)
- list(map(self.add, dists))
-
- def url_ok(self, url, fatal=False):
- s = URL_SCHEME(url)
- is_file = s and s.group(1).lower() == 'file'
- if is_file or self.allows(urllib.parse.urlparse(url)[1]):
- return True
- msg = (
- "\nNote: Bypassing %s (disallowed host; see "
- "http://bit.ly/2hrImnY for details).\n")
- if fatal:
- raise DistutilsError(msg % url)
- else:
- self.warn(msg, url)
-
- def scan_egg_links(self, search_path):
- dirs = filter(os.path.isdir, search_path)
- egg_links = (
- (path, entry)
- for path in dirs
- for entry in os.listdir(path)
- if entry.endswith('.egg-link')
- )
- list(itertools.starmap(self.scan_egg_link, egg_links))
-
- def scan_egg_link(self, path, entry):
- with open(os.path.join(path, entry)) as raw_lines:
- # filter non-empty lines
- lines = list(filter(None, map(str.strip, raw_lines)))
-
- if len(lines) != 2:
- # format is not recognized; punt
- return
-
- egg_path, setup_path = lines
-
- for dist in find_distributions(os.path.join(path, egg_path)):
- dist.location = os.path.join(path, *lines)
- dist.precedence = SOURCE_DIST
- self.add(dist)
-
- def _scan(self, link):
- # Process a URL to see if it's for a package page
- NO_MATCH_SENTINEL = None, None
- if not link.startswith(self.index_url):
- return NO_MATCH_SENTINEL
-
- parts = list(map(
- urllib.parse.unquote, link[len(self.index_url):].split('/')
- ))
- if len(parts) != 2 or '#' in parts[1]:
- return NO_MATCH_SENTINEL
-
- # it's a package page, sanitize and index it
- pkg = safe_name(parts[0])
- ver = safe_version(parts[1])
- self.package_pages.setdefault(pkg.lower(), {})[link] = True
- return to_filename(pkg), to_filename(ver)
-
- def process_index(self, url, page):
- """Process the contents of a PyPI page"""
-
- # process an index page into the package-page index
- for match in HREF.finditer(page):
- try:
- self._scan(urllib.parse.urljoin(url, htmldecode(match.group(1))))
- except ValueError:
- pass
-
- pkg, ver = self._scan(url) # ensure this page is in the page index
- if not pkg:
- return "" # no sense double-scanning non-package pages
-
- # process individual package page
- for new_url in find_external_links(url, page):
- # Process the found URL
- base, frag = egg_info_for_url(new_url)
- if base.endswith('.py') and not frag:
- if ver:
- new_url += '#egg=%s-%s' % (pkg, ver)
- else:
- self.need_version_info(url)
- self.scan_url(new_url)
-
- return PYPI_MD5.sub(
- lambda m: '%s' % m.group(1, 3, 2), page
- )
-
- def need_version_info(self, url):
- self.scan_all(
- "Page at %s links to .py file(s) without version info; an index "
- "scan is required.", url
- )
-
- def scan_all(self, msg=None, *args):
- if self.index_url not in self.fetched_urls:
- if msg:
- self.warn(msg, *args)
- self.info(
- "Scanning index of all packages (this may take a while)"
- )
- self.scan_url(self.index_url)
-
- def find_packages(self, requirement):
- self.scan_url(self.index_url + requirement.unsafe_name + '/')
-
- if not self.package_pages.get(requirement.key):
- # Fall back to safe version of the name
- self.scan_url(self.index_url + requirement.project_name + '/')
-
- if not self.package_pages.get(requirement.key):
- # We couldn't find the target package, so search the index page too
- self.not_found_in_index(requirement)
-
- for url in list(self.package_pages.get(requirement.key, ())):
- # scan each page that might be related to the desired package
- self.scan_url(url)
-
- def obtain(self, requirement, installer=None):
- self.prescan()
- self.find_packages(requirement)
- for dist in self[requirement.key]:
- if dist in requirement:
- return dist
- self.debug("%s does not match %s", requirement, dist)
- return super(PackageIndex, self).obtain(requirement, installer)
-
- def check_hash(self, checker, filename, tfp):
- """
- checker is a ContentChecker
- """
- checker.report(
- self.debug,
- "Validating %%s checksum for %s" % filename)
- if not checker.is_valid():
- tfp.close()
- os.unlink(filename)
- raise DistutilsError(
- "%s validation failed for %s; "
- "possible download problem?"
- % (checker.hash.name, os.path.basename(filename))
- )
-
- def add_find_links(self, urls):
- """Add `urls` to the list that will be prescanned for searches"""
- for url in urls:
- if (
- self.to_scan is None # if we have already "gone online"
- or not URL_SCHEME(url) # or it's a local file/directory
- or url.startswith('file:')
- or list(distros_for_url(url)) # or a direct package link
- ):
- # then go ahead and process it now
- self.scan_url(url)
- else:
- # otherwise, defer retrieval till later
- self.to_scan.append(url)
-
- def prescan(self):
- """Scan urls scheduled for prescanning (e.g. --find-links)"""
- if self.to_scan:
- list(map(self.scan_url, self.to_scan))
- self.to_scan = None # from now on, go ahead and process immediately
-
- def not_found_in_index(self, requirement):
- if self[requirement.key]: # we've seen at least one distro
- meth, msg = self.info, "Couldn't retrieve index page for %r"
- else: # no distros seen for this name, might be misspelled
- meth, msg = (
- self.warn,
- "Couldn't find index page for %r (maybe misspelled?)")
- meth(msg, requirement.unsafe_name)
- self.scan_all()
-
- def download(self, spec, tmpdir):
- """Locate and/or download `spec` to `tmpdir`, returning a local path
-
- `spec` may be a ``Requirement`` object, or a string containing a URL,
- an existing local filename, or a project/version requirement spec
- (i.e. the string form of a ``Requirement`` object). If it is the URL
- of a .py file with an unambiguous ``#egg=name-version`` tag (i.e., one
- that escapes ``-`` as ``_`` throughout), a trivial ``setup.py`` is
- automatically created alongside the downloaded file.
-
- If `spec` is a ``Requirement`` object or a string containing a
- project/version requirement spec, this method returns the location of
- a matching distribution (possibly after downloading it to `tmpdir`).
- If `spec` is a locally existing file or directory name, it is simply
- returned unchanged. If `spec` is a URL, it is downloaded to a subpath
- of `tmpdir`, and the local filename is returned. Various errors may be
- raised if a problem occurs during downloading.
- """
- if not isinstance(spec, Requirement):
- scheme = URL_SCHEME(spec)
- if scheme:
- # It's a url, download it to tmpdir
- found = self._download_url(scheme.group(1), spec, tmpdir)
- base, fragment = egg_info_for_url(spec)
- if base.endswith('.py'):
- found = self.gen_setup(found, fragment, tmpdir)
- return found
- elif os.path.exists(spec):
- # Existing file or directory, just return it
- return spec
- else:
- spec = parse_requirement_arg(spec)
- return getattr(self.fetch_distribution(spec, tmpdir), 'location', None)
-
- def fetch_distribution( # noqa: C901 # is too complex (14) # FIXME
- self, requirement, tmpdir, force_scan=False, source=False,
- develop_ok=False, local_index=None):
- """Obtain a distribution suitable for fulfilling `requirement`
-
- `requirement` must be a ``pkg_resources.Requirement`` instance.
- If necessary, or if the `force_scan` flag is set, the requirement is
- searched for in the (online) package index as well as the locally
- installed packages. If a distribution matching `requirement` is found,
- the returned distribution's ``location`` is the value you would have
- gotten from calling the ``download()`` method with the matching
- distribution's URL or filename. If no matching distribution is found,
- ``None`` is returned.
-
- If the `source` flag is set, only source distributions and source
- checkout links will be considered. Unless the `develop_ok` flag is
- set, development and system eggs (i.e., those using the ``.egg-info``
- format) will be ignored.
- """
- # process a Requirement
- self.info("Searching for %s", requirement)
- skipped = {}
- dist = None
-
- def find(req, env=None):
- if env is None:
- env = self
- # Find a matching distribution; may be called more than once
-
- for dist in env[req.key]:
-
- if dist.precedence == DEVELOP_DIST and not develop_ok:
- if dist not in skipped:
- self.warn(
- "Skipping development or system egg: %s", dist,
- )
- skipped[dist] = 1
- continue
-
- test = (
- dist in req
- and (dist.precedence <= SOURCE_DIST or not source)
- )
- if test:
- loc = self.download(dist.location, tmpdir)
- dist.download_location = loc
- if os.path.exists(dist.download_location):
- return dist
-
- if force_scan:
- self.prescan()
- self.find_packages(requirement)
- dist = find(requirement)
-
- if not dist and local_index is not None:
- dist = find(requirement, local_index)
-
- if dist is None:
- if self.to_scan is not None:
- self.prescan()
- dist = find(requirement)
-
- if dist is None and not force_scan:
- self.find_packages(requirement)
- dist = find(requirement)
-
- if dist is None:
- self.warn(
- "No local packages or working download links found for %s%s",
- (source and "a source distribution of " or ""),
- requirement,
- )
- else:
- self.info("Best match: %s", dist)
- return dist.clone(location=dist.download_location)
-
- def fetch(self, requirement, tmpdir, force_scan=False, source=False):
- """Obtain a file suitable for fulfilling `requirement`
-
- DEPRECATED; use the ``fetch_distribution()`` method now instead. For
- backward compatibility, this routine is identical but returns the
- ``location`` of the downloaded distribution instead of a distribution
- object.
- """
- dist = self.fetch_distribution(requirement, tmpdir, force_scan, source)
- if dist is not None:
- return dist.location
- return None
-
- def gen_setup(self, filename, fragment, tmpdir):
- match = EGG_FRAGMENT.match(fragment)
- dists = match and [
- d for d in
- interpret_distro_name(filename, match.group(1), None) if d.version
- ] or []
-
- if len(dists) == 1: # unambiguous ``#egg`` fragment
- basename = os.path.basename(filename)
-
- # Make sure the file has been downloaded to the temp dir.
- if os.path.dirname(filename) != tmpdir:
- dst = os.path.join(tmpdir, basename)
- if not (os.path.exists(dst) and os.path.samefile(filename, dst)):
- shutil.copy2(filename, dst)
- filename = dst
-
- with open(os.path.join(tmpdir, 'setup.py'), 'w') as file:
- file.write(
- "from setuptools import setup\n"
- "setup(name=%r, version=%r, py_modules=[%r])\n"
- % (
- dists[0].project_name, dists[0].version,
- os.path.splitext(basename)[0]
- )
- )
- return filename
-
- elif match:
- raise DistutilsError(
- "Can't unambiguously interpret project/version identifier %r; "
- "any dashes in the name or version should be escaped using "
- "underscores. %r" % (fragment, dists)
- )
- else:
- raise DistutilsError(
- "Can't process plain .py files without an '#egg=name-version'"
- " suffix to enable automatic setup script generation."
- )
-
- dl_blocksize = 8192
-
- def _download_to(self, url, filename):
- self.info("Downloading %s", url)
- # Download the file
- fp = None
- try:
- checker = HashChecker.from_url(url)
- fp = self.open_url(url)
- if isinstance(fp, urllib.error.HTTPError):
- raise DistutilsError(
- "Can't download %s: %s %s" % (url, fp.code, fp.msg)
- )
- headers = fp.info()
- blocknum = 0
- bs = self.dl_blocksize
- size = -1
- if "content-length" in headers:
- # Some servers return multiple Content-Length headers :(
- sizes = headers.get_all('Content-Length')
- size = max(map(int, sizes))
- self.reporthook(url, filename, blocknum, bs, size)
- with open(filename, 'wb') as tfp:
- while True:
- block = fp.read(bs)
- if block:
- checker.feed(block)
- tfp.write(block)
- blocknum += 1
- self.reporthook(url, filename, blocknum, bs, size)
- else:
- break
- self.check_hash(checker, filename, tfp)
- return headers
- finally:
- if fp:
- fp.close()
-
- def reporthook(self, url, filename, blocknum, blksize, size):
- pass # no-op
-
- # FIXME:
- def open_url(self, url, warning=None): # noqa: C901 # is too complex (12)
- if url.startswith('file:'):
- return local_open(url)
- try:
- return open_with_auth(url, self.opener)
- except (ValueError, http.client.InvalidURL) as v:
- msg = ' '.join([str(arg) for arg in v.args])
- if warning:
- self.warn(warning, msg)
- else:
- raise DistutilsError('%s %s' % (url, msg)) from v
- except urllib.error.HTTPError as v:
- return v
- except urllib.error.URLError as v:
- if warning:
- self.warn(warning, v.reason)
- else:
- raise DistutilsError("Download error for %s: %s"
- % (url, v.reason)) from v
- except http.client.BadStatusLine as v:
- if warning:
- self.warn(warning, v.line)
- else:
- raise DistutilsError(
- '%s returned a bad status line. The server might be '
- 'down, %s' %
- (url, v.line)
- ) from v
- except (http.client.HTTPException, socket.error) as v:
- if warning:
- self.warn(warning, v)
- else:
- raise DistutilsError("Download error for %s: %s"
- % (url, v)) from v
-
- def _download_url(self, scheme, url, tmpdir):
- # Determine download filename
- #
- name, fragment = egg_info_for_url(url)
- if name:
- while '..' in name:
- name = name.replace('..', '.').replace('\\', '_')
- else:
- name = "__downloaded__" # default if URL has no path contents
-
- if name.endswith('.egg.zip'):
- name = name[:-4] # strip the extra .zip before download
-
- filename = os.path.join(tmpdir, name)
-
- # Download the file
- #
- if scheme == 'svn' or scheme.startswith('svn+'):
- return self._download_svn(url, filename)
- elif scheme == 'git' or scheme.startswith('git+'):
- return self._download_git(url, filename)
- elif scheme.startswith('hg+'):
- return self._download_hg(url, filename)
- elif scheme == 'file':
- return urllib.request.url2pathname(urllib.parse.urlparse(url)[2])
- else:
- self.url_ok(url, True) # raises error if not allowed
- return self._attempt_download(url, filename)
-
- def scan_url(self, url):
- self.process_url(url, True)
-
- def _attempt_download(self, url, filename):
- headers = self._download_to(url, filename)
- if 'html' in headers.get('content-type', '').lower():
- return self._download_html(url, headers, filename)
- else:
- return filename
-
- def _download_html(self, url, headers, filename):
- file = open(filename)
- for line in file:
- if line.strip():
- # Check for a subversion index page
- if re.search(r'([^- ]+ - )?Revision \d+:', line):
- # it's a subversion index page:
- file.close()
- os.unlink(filename)
- return self._download_svn(url, filename)
- break # not an index page
- file.close()
- os.unlink(filename)
- raise DistutilsError("Unexpected HTML page found at " + url)
-
- def _download_svn(self, url, filename):
- warnings.warn("SVN download support is deprecated", UserWarning)
- url = url.split('#', 1)[0] # remove any fragment for svn's sake
- creds = ''
- if url.lower().startswith('svn:') and '@' in url:
- scheme, netloc, path, p, q, f = urllib.parse.urlparse(url)
- if not netloc and path.startswith('//') and '/' in path[2:]:
- netloc, path = path[2:].split('/', 1)
- auth, host = _splituser(netloc)
- if auth:
- if ':' in auth:
- user, pw = auth.split(':', 1)
- creds = " --username=%s --password=%s" % (user, pw)
- else:
- creds = " --username=" + auth
- netloc = host
- parts = scheme, netloc, url, p, q, f
- url = urllib.parse.urlunparse(parts)
- self.info("Doing subversion checkout from %s to %s", url, filename)
- os.system("svn checkout%s -q %s %s" % (creds, url, filename))
- return filename
-
- @staticmethod
- def _vcs_split_rev_from_url(url, pop_prefix=False):
- scheme, netloc, path, query, frag = urllib.parse.urlsplit(url)
-
- scheme = scheme.split('+', 1)[-1]
-
- # Some fragment identification fails
- path = path.split('#', 1)[0]
-
- rev = None
- if '@' in path:
- path, rev = path.rsplit('@', 1)
-
- # Also, discard fragment
- url = urllib.parse.urlunsplit((scheme, netloc, path, query, ''))
-
- return url, rev
-
- def _download_git(self, url, filename):
- filename = filename.split('#', 1)[0]
- url, rev = self._vcs_split_rev_from_url(url, pop_prefix=True)
-
- self.info("Doing git clone from %s to %s", url, filename)
- os.system("git clone --quiet %s %s" % (url, filename))
-
- if rev is not None:
- self.info("Checking out %s", rev)
- os.system("git -C %s checkout --quiet %s" % (
- filename,
- rev,
- ))
-
- return filename
-
- def _download_hg(self, url, filename):
- filename = filename.split('#', 1)[0]
- url, rev = self._vcs_split_rev_from_url(url, pop_prefix=True)
-
- self.info("Doing hg clone from %s to %s", url, filename)
- os.system("hg clone --quiet %s %s" % (url, filename))
-
- if rev is not None:
- self.info("Updating to %s", rev)
- os.system("hg --cwd %s up -C -r %s -q" % (
- filename,
- rev,
- ))
-
- return filename
-
- def debug(self, msg, *args):
- log.debug(msg, *args)
-
- def info(self, msg, *args):
- log.info(msg, *args)
-
- def warn(self, msg, *args):
- log.warn(msg, *args)
-
-
-# This pattern matches a character entity reference (a decimal numeric
-# references, a hexadecimal numeric reference, or a named reference).
-entity_sub = re.compile(r'&(#(\d+|x[\da-fA-F]+)|[\w.:-]+);?').sub
-
-
-def decode_entity(match):
- what = match.group(0)
- return html.unescape(what)
-
-
-def htmldecode(text):
- """
- Decode HTML entities in the given text.
-
- >>> htmldecode(
- ... 'https://../package_name-0.1.2.tar.gz'
- ... '?tokena=A&tokenb=B">package_name-0.1.2.tar.gz')
- 'https://../package_name-0.1.2.tar.gz?tokena=A&tokenb=B">package_name-0.1.2.tar.gz'
- """
- return entity_sub(decode_entity, text)
-
-
-def socket_timeout(timeout=15):
- def _socket_timeout(func):
- def _socket_timeout(*args, **kwargs):
- old_timeout = socket.getdefaulttimeout()
- socket.setdefaulttimeout(timeout)
- try:
- return func(*args, **kwargs)
- finally:
- socket.setdefaulttimeout(old_timeout)
-
- return _socket_timeout
-
- return _socket_timeout
-
-
-def _encode_auth(auth):
- """
- Encode auth from a URL suitable for an HTTP header.
- >>> str(_encode_auth('username%3Apassword'))
- 'dXNlcm5hbWU6cGFzc3dvcmQ='
-
- Long auth strings should not cause a newline to be inserted.
- >>> long_auth = 'username:' + 'password'*10
- >>> chr(10) in str(_encode_auth(long_auth))
- False
- """
- auth_s = urllib.parse.unquote(auth)
- # convert to bytes
- auth_bytes = auth_s.encode()
- encoded_bytes = base64.b64encode(auth_bytes)
- # convert back to a string
- encoded = encoded_bytes.decode()
- # strip the trailing carriage return
- return encoded.replace('\n', '')
-
-
-class Credential:
- """
- A username/password pair. Use like a namedtuple.
- """
-
- def __init__(self, username, password):
- self.username = username
- self.password = password
-
- def __iter__(self):
- yield self.username
- yield self.password
-
- def __str__(self):
- return '%(username)s:%(password)s' % vars(self)
-
-
-class PyPIConfig(configparser.RawConfigParser):
- def __init__(self):
- """
- Load from ~/.pypirc
- """
- defaults = dict.fromkeys(['username', 'password', 'repository'], '')
- super().__init__(defaults)
-
- rc = os.path.join(os.path.expanduser('~'), '.pypirc')
- if os.path.exists(rc):
- self.read(rc)
-
- @property
- def creds_by_repository(self):
- sections_with_repositories = [
- section for section in self.sections()
- if self.get(section, 'repository').strip()
- ]
-
- return dict(map(self._get_repo_cred, sections_with_repositories))
-
- def _get_repo_cred(self, section):
- repo = self.get(section, 'repository').strip()
- return repo, Credential(
- self.get(section, 'username').strip(),
- self.get(section, 'password').strip(),
- )
-
- def find_credential(self, url):
- """
- If the URL indicated appears to be a repository defined in this
- config, return the credential for that repository.
- """
- for repository, cred in self.creds_by_repository.items():
- if url.startswith(repository):
- return cred
-
-
-def open_with_auth(url, opener=urllib.request.urlopen):
- """Open a urllib2 request, handling HTTP authentication"""
-
- parsed = urllib.parse.urlparse(url)
- scheme, netloc, path, params, query, frag = parsed
-
- # Double scheme does not raise on macOS as revealed by a
- # failing test. We would expect "nonnumeric port". Refs #20.
- if netloc.endswith(':'):
- raise http.client.InvalidURL("nonnumeric port: ''")
-
- if scheme in ('http', 'https'):
- auth, address = _splituser(netloc)
- else:
- auth = None
-
- if not auth:
- cred = PyPIConfig().find_credential(url)
- if cred:
- auth = str(cred)
- info = cred.username, url
- log.info('Authenticating as %s for %s (from .pypirc)', *info)
-
- if auth:
- auth = "Basic " + _encode_auth(auth)
- parts = scheme, address, path, params, query, frag
- new_url = urllib.parse.urlunparse(parts)
- request = urllib.request.Request(new_url)
- request.add_header("Authorization", auth)
- else:
- request = urllib.request.Request(url)
-
- request.add_header('User-Agent', user_agent)
- fp = opener(request)
-
- if auth:
- # Put authentication info back into request URL if same host,
- # so that links found on the page will work
- s2, h2, path2, param2, query2, frag2 = urllib.parse.urlparse(fp.url)
- if s2 == scheme and h2 == address:
- parts = s2, netloc, path2, param2, query2, frag2
- fp.url = urllib.parse.urlunparse(parts)
-
- return fp
-
-
-# copy of urllib.parse._splituser from Python 3.8
-def _splituser(host):
- """splituser('user[:passwd]@host[:port]')
- --> 'user[:passwd]', 'host[:port]'."""
- user, delim, host = host.rpartition('@')
- return (user if delim else None), host
-
-
-# adding a timeout to avoid freezing package_index
-open_with_auth = socket_timeout(_SOCKET_TIMEOUT)(open_with_auth)
-
-
-def fix_sf_url(url):
- return url # backward compatibility
-
-
-def local_open(url):
- """Read a local path, with special support for directories"""
- scheme, server, path, param, query, frag = urllib.parse.urlparse(url)
- filename = urllib.request.url2pathname(path)
- if os.path.isfile(filename):
- return urllib.request.urlopen(url)
- elif path.endswith('/') and os.path.isdir(filename):
- files = []
- for f in os.listdir(filename):
- filepath = os.path.join(filename, f)
- if f == 'index.html':
- with open(filepath, 'r') as fp:
- body = fp.read()
- break
- elif os.path.isdir(filepath):
- f += '/'
- files.append('<a href="{name}">{name}</a>'.format(name=f))
- else:
- tmpl = (
- "<html><head><title>{url}"
- "{files}
-
-