-
-Use Control + F to find your desired software. If your program wasn’t listed, then it is most likely not a pdf downloader and most probably a shareware program. If your program wasn’t listed, then it is most likely not a pdf downloader and most probably a shareware program.
-
-If you’re looking for a free pdf downloader or software that lets you download from websites for free, then you are in the right place. On this page you will find the best programs for this!
-
-The free pdf downloader Program
-
-There are a lot of pdf downloader software to choose from, but most of them are expensive, so we’ve put together a list of the best free software!
-
-The best free pdf downloader & software
-
-#1 DownloadPipe
-
-DownloadPipe is a free download manager for windows which supports multiple platforms like Windows, Mac, and Linux. It supports multiple protocols including HTTPS, FTPS, FTP, etc. to secure the download process. You can quickly download more than 100 of your favorite programs.
-
-With this program you can download anything for free. PDF files, documents, movies, songs, games, software, and more. It has a very simple design and intuitive user interface. Also, DownloadPipe is extremely easy to use and intuitive.
-
-To download a PDF file you need to go to the “Download” menu on the top right corner and select the “Save as” option. You can then specify where you want to download the file to.
-
-#2 Zipeg
-
-Zipeg is a free PDF downloader that lets you download any file from a website. It’s a standalone downloader. Zipeg doesn’t require a browser.
-
-This is a program for users who want to download a PDF file without a web browser. You can use the program without installing it. It’s available as a standalone downloader.
-
-For example, if you have a PDF file that you need to download, then just open the Zipeg app and start the download. Zipeg will prompt you to select the link, the file name and other details.
-
-You can download the PDF file. Zipeg allows you to select any file from your browser and download it to the computer. Also, it can download HTML files. You can download a file from any web page. The program is very simple to use 4fefd39f24
-
-
-
diff --git a/spaces/1gistliPinn/ChatGPT4/Examples/Dark Souls 2 Save Editor Fix.md b/spaces/1gistliPinn/ChatGPT4/Examples/Dark Souls 2 Save Editor Fix.md
deleted file mode 100644
index 30e3d3be11dfe586c20d0116d9721cb6e61da70f..0000000000000000000000000000000000000000
--- a/spaces/1gistliPinn/ChatGPT4/Examples/Dark Souls 2 Save Editor Fix.md
+++ /dev/null
@@ -1,18 +0,0 @@
-
-
-Mar 04, 2017 · 2. Come to the hearts of your viewers and make them feel like they're actually at the show. Be able to produce audio and video content that is consistent in quality. YouTube Help Center. Reply to a video, message or comment. How to: Ask a question; Start a discussion; Share your thoughts; Start or join a discussion. What's your question? How to: Ask a question. How to: Answer a question. How to: Answer a question about your video. How to: Answer a question about your video.
-
-Satisfaction Guarantee. If you aren't completely satisfied, return the item. We've got it. This top rated casino has been around for many years and is a site full of interesting games. This online poker room offers a good welcome bonus for newcomers, a great welcome bonus for repeat players, and a wide selection of unique tournaments. We are an affiliate of the best online poker room in the world.
-
-The first bet is 10. As you can see on this animation, the next bet will be 10 more, for a total bet of 20. The player is at this point committed to the second play.
-
-Create New Account. You are one step away from creating your new account. In order to create your account please select your city:. Select a Username. Select a password. Select your city:. Please select your city. Select a city: Select a state: Select a state. Please select a city. Select a city. Select a state. Please select a city. Please select a city. Please select a state. Please select a state.
-
-Hello mate! This is Renato from the Mexican Casino Club website. Let me introduce ourselves; We are the world's largest online gambling and gaming website that works with an excellent selection of online casinos from around the world.
-
-Have you ever considered what life would be like if you could control every moment, and be able to touch, hear, and taste anything that was around you? It's a fascinating concept, and we think you'd be interested in taking the next step in your experience. Perhaps we should use more of our time to come up with better ways to be at peace with ourselves, our family, and our world, and stop obsessing about the little stuff.
-
-Instead of trying to fix the'symptoms', why not try to 'get rid of the disease'? After all, most people would rather cut off a hand than cut off the 4fefd39f24
-
-
-
diff --git a/spaces/1phancelerku/anime-remove-background/Aprenda a baixar Stick War 3 com dinheiro infinito e desbloquear todos os recursos.md b/spaces/1phancelerku/anime-remove-background/Aprenda a baixar Stick War 3 com dinheiro infinito e desbloquear todos os recursos.md
deleted file mode 100644
index aff188dfacd0654a80580fbc92db7c7236be76fb..0000000000000000000000000000000000000000
--- a/spaces/1phancelerku/anime-remove-background/Aprenda a baixar Stick War 3 com dinheiro infinito e desbloquear todos os recursos.md
+++ /dev/null
@@ -1,81 +0,0 @@
-
-
Stick War 3: How to Download and Play the Ultimate Strategy Game
-
If you are a fan of strategy games, you have probably heard of Stick War 3, one of the most popular and addictive games in the genre. Stick War 3 is a game where you can create your own army, fight against other players or AI opponents, and conquer the world of Inamorta. Whether you prefer single player or multiplayer modes, Stick War 3 has something for everyone. In this article, we will show you how to download and install Stick War 3 on your device, how to play the different modes and features of the game, and how to improve your skills with some tips and tricks.
-
PVP Matches
-
One of the main attractions of Stick War 3 is its real-time multiplayer strategy mode, where you can team up with your friends or battle against strangers from around the world. You can choose from 1v1 or 2v2 matches, and use any deck that you have created or unlocked. The goal is to destroy your enemy's statue before they destroy yours, using your units, spells, enchantments, and strategies.
One of the coolest features of Stick War 3 is that you can take control of any unit at any time, giving you more flexibility and control over your army. You can also use spells such as a giant bubble that blocks incoming projectiles, or snow squall that freezes entire legions. You can also use enchantments such as the rune of reanimation that will cause any poisoned enemy units to respawn as zombies.
-
Another way to make your battles more fun and personalized is to customize your battlefield with skins, statues, voice-lines, and emotes. You can change the appearance of your units, your statue, your tower, and even your voice commands. You can also use emotes to communicate with your allies or taunt your enemies.
-
Single Player Modes
-
If you prefer playing solo or offline, Stick War 3 has plenty of options for you as well. You can play the huge ever expanding campaign mode, where you will follow an epic story with multiple chapters, fully animated comic book style cut scenes, and huge storylines. You will explore the world of Inamorta, where weapons are religion and nations are constantly at war. You will encounter different factions, allies, enemies, secrets, and challenges along the way.
-
You can also practice your strategies against AI opponents in different scenarios in the proving grounds mode. You can choose from various selectable decks and situations to test your skills and learn new tactics. You can also challenge yourself with daily battles, where you will face a special scenario with fixed decks and other special conditions that do not appear in normal gameplay. You can earn gem rewards for completing each difficulty level.
-
Custom Armies
-
One of the most important aspects of Stick War 3 is building your own battle decks with a variety of army types and upgrades. You can collect and unlock new cards from a growing selection of over 40 different nations, each with their own unique units, abilities, and bonuses. You can also research new upgrades and technologies to make your army stronger and more versatile. You can create up to 10 different decks, each with a maximum of 12 cards, and switch between them before each battle.
-
stick war 3 mod apk dinheiro infinito
-stick war 3 hack dinheiro infinito
-stick war 3 legacy dinheiro infinito
-stick war 3 download para android com dinheiro infinito
-stick war 3 atualizado com dinheiro infinito
-stick war 3 jogo online com dinheiro infinito
-stick war 3 como baixar e instalar dinheiro infinito
-stick war 3 dicas e truques para ganhar dinheiro infinito
-stick war 3 versão completa com dinheiro infinito
-stick war 3 multiplayer com dinheiro infinito
-stick war 3 cheats dinheiro infinito
-stick war 3 apk mod menu dinheiro infinito
-stick war 3 tudo desbloqueado com dinheiro infinito
-stick war 3 sem root com dinheiro infinito
-stick war 3 offline com dinheiro infinito
-stick war 3 estratégia de guerra com dinheiro infinito
-stick war 3 skins personalizadas com dinheiro infinito
-stick war 3 novas atualizações com dinheiro infinito
-stick war 3 jogabilidade incrível com dinheiro infinito
-stick war 3 gráficos impressionantes com dinheiro infinito
-stick war 3 download rápido e fácil com dinheiro infinito
-stick war 3 tutorial passo a passo com dinheiro infinito
-stick war 3 melhores armas e unidades com dinheiro infinito
-stick war 3 modo história com dinheiro infinito
-stick war 3 modo sobrevivência com dinheiro infinito
-stick war 3 modo zumbi com dinheiro infinito
-stick war 3 modo clássico com dinheiro infinito
-stick war 3 modo torneio com dinheiro infinito
-stick war 3 modo desafio com dinheiro infinito
-stick war 3 modo sandbox com dinheiro infinito
-stick war 3 modo criativo com dinheiro infinito
-stick war 3 modo cooperativo com dinheiro infinito
-stick war 3 modo versus com dinheiro infinito
-stick war 3 modo ranking com dinheiro infinito
-stick war 3 modo conquista com dinheiro infinito
-stick war 3 modo missão com dinheiro infinito
-stick war 3 modo aventura com dinheiro infinito
-stick war 3 modo campanha com dinheiro infinito
-stick war 3 modo batalha épica com dinheiro infinito
-stick war 3 modo guerra mundial com dinheiro infinito
-
Another way to customize your army is to use generals of each nation, who have their own unique abilities and effects. You can choose one general for each deck, and use their power once per battle. For example, you can use the general of the Order Empire, who can summon a giant sword that deals massive damage to enemies in front of him. Or you can use the general of the Chaos Empire, who can transform into a powerful demon that can fly and shoot fireballs.
-
Tips and Tricks
-
Stick War 3 is a game that requires skill, strategy, and creativity to master. Here are some tips and tricks that can help you improve your gameplay and win more battles.
-
-
Learn the strengths and weaknesses of each unit type and nation. For example, archers are good at dealing damage from a distance, but are vulnerable to melee attacks. Speartons are good at defending and blocking enemy units, but are slow and expensive. The Order Empire is good at balanced and versatile strategies, but lacks specialization. The Chaos Empire is good at aggressive and chaotic strategies, but lacks defense and stability.
-
Use the right units for the right situations. For example, use miners to gather gold and mana, which are essential for building your army and using spells. Use swordwraths to rush your enemy in the early game or flank them in the late game. Use magikills to cast powerful spells that can turn the tide of the battle.
-
Use your spells and enchantments wisely. For example, use heal to restore the health of your units or your statue. Use poison to deal damage over time to enemy units or their statue. Use shield to protect your units or your statue from enemy attacks.
-
Take control of your units when necessary. For example, take control of an archer to aim more accurately or avoid enemy fire. Take control of a spearton to block enemy units or charge at them. Take control of a magikill to cast spells more precisely or escape from danger.
-
Avoid common mistakes and pitfalls in the game. For example, do not overextend your army or leave your statue undefended. Do not waste your gold or mana on unnecessary units or spells. Do not underestimate your enemy or overestimate yourself.
-
-
Conclusion
-
Stick War 3 is a game that will keep you entertained for hours with its amazing graphics, gameplay, and features. Whether you want to play online with other players or offline by yourself, you will find something that suits your taste and style. You can download and install Stick War 3 on your device for free from the official website or from the app store of your choice. You can also follow the game on social media for more news and updates. If you are looking for a fun and challenging strategy game, you should definitely give Stick War 3 a try.
-
FAQs
-
-
Q: How do I download Stick War 3?
-
A: You can download Stick War 3 from the official website or from the app store of your choice. You will need an internet connection to play online modes, but you can play offline modes without it.
-
Q: How do I unlock new cards and generals?
-
A: You can unlock new cards and generals by playing the campaign mode, completing daily battles, opening chests, or buying them with gems.
-
Q: How do I earn gems?
-
A: You can earn gems by playing the campaign mode, completing daily battles, watching ads, or buying them with real money.
-
Q: How do I play with my friends?
-
A: You can play with your friends by inviting them to join your team in PVP matches, or by creating a private room with a code that they can enter.
-
Q: How do I contact the developers?
-
A: You can contact the developers by sending them an email at support@stickwar.com or by filling out a form on their website.
-
- : https://stickwar.com/ : https://play.google.com/store/apps/details?id=com.maxgames.stickwar3&hl=en_US&gl=US : https://www.facebook 401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/1phancelerku/anime-remove-background/Download FF Advance Server APK Juli 2021 How to Register and Play.md b/spaces/1phancelerku/anime-remove-background/Download FF Advance Server APK Juli 2021 How to Register and Play.md
deleted file mode 100644
index a03bc9732935b1d71d0e0bcdc9f0510d97532ab5..0000000000000000000000000000000000000000
--- a/spaces/1phancelerku/anime-remove-background/Download FF Advance Server APK Juli 2021 How to Register and Play.md
+++ /dev/null
@@ -1,91 +0,0 @@
-
-
How to Join and Play Free Fire Advance Server in July 2023
-
Free Fire is one of the most popular and exciting battle royale games on mobile, with millions of players around the world. But did you know that there is a special server where you can try out new features and updates before they are released to the public? This server is called Free Fire Advance Server, and it is a great opportunity for you to experience the latest developments in the game, as well as to help the developers improve the game by reporting bugs and providing feedback.
In this article, we will tell you everything you need to know about Free Fire Advance Server, including what it is, how to register, how to download and install, how to play, and how to enjoy it. So, if you are a fan of Free Fire and want to join the exclusive club of advanced players, read on!
-
What is Free Fire Advance Server?
-
Free Fire Advance Server is a test server that is created by Garena, the developer of Free Fire, for experienced players who want to test new features and items that are not yet available on the regular server. The goal of this server is to allow players to explore and experiment with the upcoming updates, as well as to help the developers identify and fix any bugs or issues that may arise.
-
By joining Free Fire Advance Server, you will be able to access new weapons, characters, skins, modes, maps, events, and more before anyone else. You will also be able to provide your feedback and suggestions directly to the developers, which may influence the final version of the updates. Moreover, you will be rewarded with diamonds for finding and reporting bugs on the server.
-
However, there are some differences between Free Fire Advance Server and the regular server that you should be aware of. First of all, not everyone can join Free Fire Advance Server. You need to register and get an activation code from Garena, which is limited in number. Secondly, Free Fire Advance Server is not always open. It only opens for a certain period of time before each major update. Thirdly, your progress and data on Free Fire Advance Server are not linked to your regular account. You will start from scratch on the test server, and you will not be able to transfer anything back to your regular account.
-
How to Register for Free Fire Advance Server?
-
If you are interested in joining Free Fire Advance Server, you need to register first. The registration process is simple and easy, but you need to act fast because there are only a limited number of activation codes available. Here are the steps you need to follow:
Click or tap on the "Login Facebook" button to sign up for Free Fire Advance Server using your Facebook account. Make sure that your Facebook account is linked to your Free Fire or FF MAX game account.
-
Enter your personal information, such as name, email address, and phone number. Make sure that your email address and phone number are active.
-
Click or tap on the "Submit" button to complete your registration.
-
Wait for an email from Garena with your activation code and the download link for the Free Fire Advance Server APK file. Note that not everyone who registers will receive an activation code, as they are limited in number and given on a first-come, first-served basis.
-
-
If you are lucky enough to get an activation code, you can proceed to download and install the Free Fire Advance Server APK file on your Android device.
-
How to Download and Install Free Fire Advance Server APK?
-
Once you have received your activation code and the download link for the Free Fire Advance Server APK file, you can follow these steps to download and install it on your Android device:
-
-
Click or tap on the download link in the email to download the Free Fire Advance Server APK file. The file size is about 700 MB, so make sure you have enough storage space and a stable internet connection.
-
After the download is complete, locate the APK file on your device and tap on it to install it. You may need to enable the "Install from unknown sources" option in your device settings if you haven't done so before.
-
Once the installation is done, open the Free Fire Advance Server app and log in using your Facebook account that you used to register for the Advance Server.
-
Enter your activation code when prompted and tap on "Confirm". You will then be able to access the Free Fire Advance Server and enjoy the new features and updates.
-
-
Note that the Free Fire Advance Server is only open for a limited period of time, usually a few days before each major update. You can check the official website of Free Fire Advance Server at ff-advance.ff.garena.com to see when the server is open and when it will close. You will not be able to play on the Advance Server once it is closed, so make sure you make the most of it while it is open.
-
How to Play and Enjoy Free Fire Advance Server?
-
Playing on Free Fire Advance Server is similar to playing on the regular server, except that you will have access to new features and updates that are not yet available to the public. You will also start from scratch on the Advance Server, meaning that you will not have any of your previous progress, items, or data from your regular account. You will also not be able to transfer anything from the Advance Server back to your regular account.
-
How to register and download APK for Free Fire advance server July 2021
-Free Fire advance server 2021: latest updates and features
-Free Fire advance server bug hunting and feedback: how to get diamonds
-Free Fire advance server login using Facebook account: step by step guide
-Free Fire advance server timeline: server opening and closing time
-Free Fire advance server rules: what you need to know before playing
-Free Fire advance server main contributor: how to become one and get rewards
-Free Fire advance server APK download link: where to find it and how to install it
-Free Fire advance server activation code: how to get it and use it
-Free Fire advance server FAQ: answers to common questions
-Free Fire advance server review: pros and cons of playing in the test server
-Free Fire advance server tips and tricks: how to survive and win in the new mode
-Free Fire advance server new characters and weapons: what are they and how to use them
-Free Fire advance server bugs and glitches: how to report them and avoid them
-Free Fire advance server system requirements: what you need to play on your device
-Free Fire advance server news and updates: where to find the latest information
-Free Fire advance server feedback form: how to fill it and submit it
-Free Fire advance server download size: how much space you need on your device
-Free Fire advance server gameplay videos: where to watch them and learn from them
-Free Fire advance server community: how to join and interact with other players
-Free Fire advance server support: how to contact Garena if you have any issues
-Free Fire advance server registration status: how to check if you are accepted or not
-Free Fire advance server best settings: how to optimize your game performance
-Free Fire advance server comparison: how is it different from the regular server
-Free Fire advance server rewards redemption: how to claim your diamonds and other prizes
-Free Fire advance server invitation code: how to get it and share it with your friends
-Free Fire advance server maintenance schedule: when will the server be offline and for how long
-Free Fire advance server patch notes: what are the changes and improvements in the new version
-Free Fire advance server error messages: what they mean and how to fix them
-Free Fire advance server feedback survey: how to participate and share your opinions
-Free Fire advance server registration deadline: when is the last day to sign up for the test server
-Free Fire advance server download problem: what to do if you can't download or install the APK file
-Free Fire advance server login problem: what to do if you can't access or play the game
-Free Fire advance server VPN: do you need it and which one to use
-Free Fire advance server emulator: can you play it on PC and which one to use
-
However, this also means that you will have more freedom and fun to explore and experiment with the new features and updates without worrying about losing anything. You will also be able to provide your feedback and suggestions directly to the developers, as well as report any bugs or issues that you encounter on the server. By doing so, you will help improve the game and also earn rewards such as diamonds for your contribution.
-
To play and enjoy Free Fire Advance Server, here are some tips and tricks that you can follow:
-
-
Check out the new weapons, characters, skins, modes, maps, events, and more that are available on the Advance Server. Try them out and see how they work and how they affect your gameplay.
-
Be prepared for some glitches, errors, or crashes that may occur on the Advance Server. Remember that this is a test server and not everything is perfect or stable. If you encounter any problems, report them using the "Report" button on the game screen.
-
Give your honest feedback and suggestions on the new features and updates using the "Feedback" button on the game screen. Tell the developers what you like, what you don't like, what you think can be improved, or what you think is missing.
-
Have fun and enjoy playing with other advanced players who share your passion and enthusiasm for Free Fire. You can also invite your friends who have registered for the Advance Server to join you in testing out the new features and updates.
-
-
Conclusion
-
Free Fire Advance Server is a great opportunity for advanced players who want to experience new features and updates before they are released to the public. By joining Free Fire Advance Server, you will be able to access new weapons, characters, skins, modes, maps, events, and more before anyone else. You will also be able to provide your feedback and suggestions directly to the developers, which may influence the final version of the updates. Moreover, you will be rewarded with diamonds for finding and reporting bugs on the server.
-
If you are a fan of Free Fire and want to join the exclusive club of advanced players, don't miss this chance to register and download Free Fire Advance Server as soon as possible. The registration process is simple and easy, but you need to act fast because there are only a limited number of activation codes available. The download and installation process is also simple and easy, but you need to have an Android device and a stable internet connection. The playing and enjoying process is similar to the regular server, but with more freedom and fun to explore and experiment with the new features and updates. We hope that this article has helped you understand how to join and play Free Fire Advance Server in July 2023. If you have any questions or comments, feel free to leave them below. And don't forget to share this article with your friends who are also fans of Free Fire. Happy gaming!
FAQs
-
Here are some of the frequently asked questions and answers about Free Fire Advance Server:
-
-
What is the difference between Free Fire Advance Server and Free Fire MAX?
-
Free Fire Advance Server is a test server that is only open for a limited period of time before each major update. It allows players to try out new features and updates that are not yet available on the regular server. Free Fire MAX is a enhanced version of Free Fire that offers higher graphics quality, smoother performance, and exclusive content. It is compatible with the regular server and can be played anytime.
-
How can I get more diamonds on Free Fire Advance Server?
-
You can get more diamonds on Free Fire Advance Server by finding and reporting bugs on the server using the "Report" button on the game screen. You will be rewarded with diamonds for each bug that you report, depending on the severity and validity of the bug. You can also get diamonds by providing your feedback and suggestions on the new features and updates using the "Feedback" button on the game screen.
-
Can I play with my friends on Free Fire Advance Server?
-
You can play with your friends on Free Fire Advance Server if they have also registered for the Advance Server and have received an activation code from Garena. You can invite them to join you in testing out the new features and updates on the server. However, you will not be able to play with your friends who are on the regular server, as the two servers are not connected.
-
Will my progress and data on Free Fire Advance Server be saved or transferred to my regular account?
-
No, your progress and data on Free Fire Advance Server will not be saved or transferred to your regular account. You will start from scratch on the Advance Server, and you will not have any of your previous items or data from your regular account. You will also not be able to transfer anything from the Advance Server back to your regular account.
-
When will the new features and updates on Free Fire Advance Server be released to the public?
-
The new features and updates on Free Fire Advance Server will be released to the public after they have been tested and improved by the developers based on the feedback and suggestions from the players on the Advance Server. The exact date of release may vary depending on the update, but it is usually within a few weeks after the closure of the Advance Server.
- 197e85843d
-
-
\ No newline at end of file
diff --git a/spaces/1phancelerku/anime-remove-background/Download The Baby In Yellow APK for Android - Free Horror Game.md b/spaces/1phancelerku/anime-remove-background/Download The Baby In Yellow APK for Android - Free Horror Game.md
deleted file mode 100644
index e75937313753e28ccad80115fd599f8a33a26ab5..0000000000000000000000000000000000000000
--- a/spaces/1phancelerku/anime-remove-background/Download The Baby In Yellow APK for Android - Free Horror Game.md
+++ /dev/null
@@ -1,133 +0,0 @@
-
-
,
,
, etc.) to divide your content into sections and make it easier for the reader to follow. Step 5: Write a rough draft and pare down your outline. The fifth step is to write a rough draft of your article based on your outline. You don't have to worry about grammar, spelling, or formatting at this stage; just focus on getting your ideas down on paper. You can use tools like Google Docs, Microsoft Word, or Grammarly to write and edit your draft. As you write, try to: - Use a conversational style as written by a human (use an informal tone, utilize personal pronouns, keep it simple, engage the reader, use the active voice, keep it brief, use rhetorical questions, and incorporate analogies and metaphors). - Use SEO-optimized keywords and phrases that match the intent of your audience and the topic of your article. - Use fully detailed paragraphs that explain each point clearly and provide examples or evidence. - Use transitions words or phrases (such as however, therefore, moreover, etc.) to connect your paragraphs and sentences. - Use at least one table (using HTML tags such as
,
,
,
, etc.) to display data or information in a structured way. After you finish writing your draft, pare down your outline by removing any unnecessary or redundant information. You can also rearrange the order of your paragraphs or sections if needed. Step 6: Revise and proofread your article. The final step is to revise and proofread your article before publishing it. You can use tools like Hemingway Editor, ProWritingAid, or Grammarly to check for errors in grammar, spelling, punctuation, readability, style, tone, etc. You can also ask someone else to read your article and give you feedback. As you revise and proofread your article, try to: - Make sure that your article is coherent, consistent, and logical. - Make sure that your article is unique and original (you can use tools like Copyscape or Turnitin to check for plagiarism). - Make sure that your article is engaging and informative (you can use tools like CoSchedule Headline Analyzer or Yoast SEO Plugin to check for headline quality and SEO performance). Outline of the article: -
The Baby In Yellow: A Horror Game That Will Make You Think Twice About Babysitting
--
Introduction
- - What is The Baby In Yellow and what is it about? - Why is it a horror game and what makes it scary? - How can you download and play it on your Android device? -
The Baby In Yellow: A Game That Will Test Your Nerves
- -
The premise and the gameplay of The Baby In Yellow
- - You are a babysitter who has to take care of a baby in a yellow onesie - The baby is not a normal baby, but a demonic entity that can do strange things - You have to follow the instructions on the screen and try to survive the night -
The graphics and the sound effects of The Baby In Yellow
- - The game has a low-poly style that creates a contrast between the cute and the creepy - The game has a dark and eerie atmosphere that builds up tension and suspense - The game has realistic and disturbing sound effects that add to the horror -
How to Download and Play The Baby In Yellow on Your Android Device
- -
The requirements and the compatibility of The Baby In Yellow
- - The game requires Android 4.4 or higher and 136 MB of free space - The game is compatible with most Android devices, but some may experience performance issues - The game is free to download and play, but it may contain ads or in-app purchases -
The steps to download and install The Baby In Yellow
- - Go to one of the trusted sources that offer the APK file of The Baby In Yellow, such as [Softonic](^1^), [Tamindir](^2^), or [APKCombo](^3^) - Tap on the download button and wait for the file to be downloaded - Go to your device settings and enable the installation of apps from unknown sources - Locate the downloaded file in your file manager and tap on it to install it - Launch the game and enjoy the horror -
Conclusion
- - Summarize the main points of the article - Restate the thesis and provide a call to action or an interesting insight -
FAQs
- - List five unique FAQs related to the topic of the article Article with HTML formatting:
The Baby In Yellow: A Horror Game That Will Make You Think Twice About Babysitting
-
Introduction
-
If you are looking for a horror game that will challenge your nerves and make you jump out of your seat, you might want to try The Baby In Yellow. This is a first-person horror game developed by Team Terrible, where you will simulate the life of a babysitter. However, what you will babysit is more sinister than he first appears. The Baby In Yellow follows the same premise as the PC game, but it is now available for Android devices. In this article, we will tell you what The Baby In Yellow is about, why it is a horror game, and how you can download and play it on your Android device.
The Baby In Yellow: A Game That Will Test Your Nerves
-
The premise and the gameplay of The Baby In Yellow
-
In The Baby In Yellow, you are a babysitter who has to take care of a baby in a yellow onesie. Sounds easy, right? Well, not quite. The baby is not a normal baby, but a demonic entity that can do strange things. He can teleport, levitate, laugh maniacally, stare at you with glowing eyes, and even summon fire. He can also escape from his crib, his room, or even his house. Your job is to follow the instructions on the screen and try to survive the night. You will have to feed him, change his diaper, put him to bed, and deal with his mischief. But be careful, because he might not like what you do.
-
The graphics and the sound effects of The Baby In Yellow
- from. The game has realistic and disturbing sound effects that add to the horror. You will hear the baby's cries, laughs, whispers, and screams, as well as the creaking of doors, the flickering of lights, and the thumping of footsteps.
-
How to Download and Play The Baby In Yellow on Your Android Device
-
The requirements and the compatibility of The Baby In Yellow
-
The game requires Android 4.4 or higher and 136 MB of free space. The game is compatible with most Android devices, but some may experience performance issues. The game is free to download and play, but it may contain ads or in-app purchases.
-
The steps to download and install The Baby In Yellow
-
To download and play The Baby In Yellow on your Android device, you need to follow these steps:
-
-
-
Step
-
Instruction
-
-
-
1
-
Go to one of the trusted sources that offer the APK file of The Baby In Yellow, such as Softonic, Tamindir, or APKCombo.
-
-
-
2
-
Tap on the download button and wait for the file to be downloaded.
-
-
-
3
-
Go to your device settings and enable the installation of apps from unknown sources.
-
-
-
4
-
Locate the downloaded file in your file manager and tap on it to install it.
-
-
-
5
-
Launch the game and enjoy the horror.
-
-
-
Conclusion
-
The Baby In Yellow is a horror game that will make you think twice about babysitting. It is a game that will test your nerves and make you jump out of your seat. It is a game that has a low-poly style, a dark and eerie atmosphere, and realistic and disturbing sound effects. It is a game that is available for Android devices and can be downloaded and played for free. If you are looking for a horror game that will challenge you and scare you, you might want to try The Baby In Yellow. But be warned, this is not a game for the faint-hearted.
-
FAQs
-
Here are some frequently asked questions related to The Baby In Yellow:
-
-
Is The Baby In Yellow based on a true story?
-
No, The Baby In Yellow is not based on a true story. It is a fictional horror game inspired by a short film called The Thing in the Apartment Chapter 2, which was directed by John William Ross.
-
Is The Baby In Yellow safe to play?
-
The Baby In Yellow is safe to play as long as you are aware that it is a horror game that contains scary and violent scenes. It is not recommended for children or people who are sensitive to horror or gore. It is also advisable to play it in a well-lit room and with someone else nearby.
-
How long does it take to finish The Baby In Yellow?
-
The Baby In Yellow is a short game that can be finished in about 15 minutes. However, it has multiple endings depending on your choices and actions. You can replay the game to see different outcomes and discover more secrets.
-
the baby in yellow download android
-the baby in yellow game apk
-the baby in yellow free apk
-the baby in yellow horror game apk
-the baby in yellow apk mod
-the baby in yellow apk pure
-the baby in yellow apk latest version
-the baby in yellow apk offline
-the baby in yellow apk uptodown
-the baby in yellow apk for pc
-the baby in yellow apk android oyun club
-the baby in yellow apk hile
-the baby in yellow apk indir gezginler
-the baby in yellow apk indir tamindir
-the baby in yellow apk indir softonic
-the baby in yellow apk indir cepde
-the baby in yellow apk indir apkpure
-the baby in yellow apk indir android oyun club
-the baby in yellow apk indir son sürüm
-the baby in yellow apk indir ücretsiz
-the baby in yellow oyunu indir apk
-the baby in yellow oyunu indir android
-the baby in yellow oyunu indir pc
-the baby in yellow oyunu indir ücretsiz
-the baby in yellow oyunu indir tamindir
-the baby in yellow oyunu indir gezginler
-the baby in yellow oyunu indir softonic
-the baby in yellow oyunu indir cepde
-the baby in yellow oyunu indir apkpure
-the baby in yellow oyunu indir android oyun club
-download game the baby in yellow apk
-download game the baby in yellow android
-download game the baby in yellow mod apk
-download game the baby in yellow free apk
-download game the baby in yellow horror apk
-download game the baby in yellow latest version apk
-download game the baby in yellow offline apk
-download game the baby in yellow uptodown apk
-download game the baby in yellow for pc apk
-download game the baby in yellow android oyun club apk
-download game the baby in yellow hileli apk
-download game the baby in yellow gezginler apk
-download game the baby in yellow tamindir apk
-download game the baby in yellow softonic apk
-download game the baby in yellow cepde apk
-download game the baby in yellow apkpure apk
-download game the baby in yellow android oyun club apk
-download game the baby in yellow son sürüm apk
-download game the baby in yellow ücretsiz apk
-
What are some tips and tricks to play The Baby In Yellow?
-
Some tips and tricks to play The Baby In Yellow are:
-
-
Pay attention to the instructions on the screen and follow them carefully.
-
Use the flashlight to see better in the dark.
-
Avoid looking at the baby's eyes or touching him when he is angry.
-
Hide in the closet or under the bed if you hear something suspicious.
-
Don't let the baby escape from his room or his house.
-
Don't trust everything you see or hear.
-
-
Where can I find more games like The Baby In Yellow?
-
If you enjoyed playing The Baby In Yellow, you might also like these games:
-
-
Five Nights at Freddy's: A horror game where you have to survive five nights in a pizzeria haunted by animatronic animals.
-
Slendrina: The Cellar: A horror game where you have to explore a cellar and avoid a ghostly woman.
-
Eyes: The Horror Game: A horror game where you have to collect valuables in a haunted house and avoid a monster.
-
Hello Neighbor: A stealth horror game where you have to sneak into your neighbor's house and discover his secrets.
-
-
-
I hope you enjoyed reading this article and learned something new. If you have any questions or comments, feel free to leave them below. And if you want to play The Baby In Yellow, don't forget to download it from one of the sources mentioned above. But be careful, because this game is not for the faint-hearted.
401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/1phancelerku/anime-remove-background/Epic War 6 How to Conquer Every Spot on the Board.md b/spaces/1phancelerku/anime-remove-background/Epic War 6 How to Conquer Every Spot on the Board.md
deleted file mode 100644
index 808cd6406055ad106b131e08b65ae938d25d5751..0000000000000000000000000000000000000000
--- a/spaces/1phancelerku/anime-remove-background/Epic War 6 How to Conquer Every Spot on the Board.md
+++ /dev/null
@@ -1,134 +0,0 @@
-
-
Epic War 6 APK: A Thrilling Battle Game for Android
-
If you are looking for a game that combines strategy, action, and fantasy, then you should check out Epic War 6 APK. This is a game that lets you command legendary heroes and a strong army in epic battles against powerful enemies. You can choose from six unique heroes, each with their own strengths, weaknesses, and skills. You can also train and upgrade over 40 battle units, from archers and knights to dragons and giants. You can also challenge and defeat huge titans that will test your skills and strategy. And if you want to compete with other players from around the world, you can enter the PVP Arena and show how epic you are.
In this article, we will tell you everything you need to know about Epic War 6 APK, including its features, how to download and install it, how to play it, how it compares with other games, what are its pros and cons, and what is its review. By the end of this article, you will have a clear idea of whether this game is worth playing or not.
-
Features of Epic War 6 APK
-
Epic War 6 APK has a lot of features that make it a fun and exciting game to play. Here are some of them:
-
-
6 unique heroes: You can choose from six different heroes, each with their own personality, backstory, and abilities. Some of them are based on famous characters from mythology or history, such as Thor, Hercules, or Joan of Arc. Each hero has a special skill that can change the outcome of the battle, such as summoning thunderstorms, healing allies, or boosting morale.
Over 40 battle units: You can train and upgrade a variety of units to fight for you in the battlefield. You can choose from different classes, such as infantry, cavalry, ranged, magic, or special. Each class has its own advantages and disadvantages, and you need to balance your army composition according to the situation. You can also unlock new units as you progress in the game, such as ninjas, samurais, or angels.
-
10 powerful titans: You can face and defeat 10 massive titans that will pose a great challenge to your skills and strategy. These titans are based on mythical creatures, such as dragons, hydras, or krakens. They have different abilities and weaknesses, and you need to find the best way to exploit them. You can also use your hero's skill to deal extra damage or gain an edge in the fight.
-
PVP Arena: You can compete with other players from around the world in the PVP Arena mode. You can choose your hero and units and enter a random match against another player. You can also join a clan and participate in clan wars, where you can cooperate with your clan members and fight against other clans. You can earn rewards and rank up in the leaderboards by winning matches and wars.
-
-
How to Download and Install Epic War 6 APK
-
If you want to play Epic War 6 APK on your Android device, you need to download and install it first. Here are the steps that you need to follow:
-
-
Go to the official website of mob.org: This is one of the best sources for downloading free Android games. You can access it by typing mob.org in your browser or clicking on this link.
-
Search for Epic War 6 APK: Once you are on the website, you can use the search bar to look for Epic War 6 APK. You can also browse through the categories or genres to find it. Alternatively, you can use this direct link to go to the download page of Epic War 6 APK.
-
Click on the download button: When you find the game that you want, you can click on the green download button that says "Download Epic War 6". This will start the download process and you will see a progress bar on your screen.
-
Enable unknown sources on your device settings: Before you can install the APK file that you downloaded, you need to allow your device to install apps from unknown sources. To do this, go to your device settings and look for security or privacy options. Then, find the option that says "Unknown sources" or "Allow installation of apps from unknown sources" and enable it.
-
Install the APK file: After enabling unknown sources, you can go to your file manager or downloads folder and find the APK file that you downloaded. Tap on it and follow the instructions on your screen to install it.
-
Launch the game and enjoy the epic battles: Once the installation is complete, you can launch the game by tapping on its icon on your home screen or app drawer. You can then start playing the game and enjoy the epic battles.
-
Gameplay Tips and Tricks for Epic War 6 APK
-
Epic War 6 APK is a game that requires strategy, skill, and patience. You need to plan your moves carefully and use your resources wisely. Here are some tips and tricks that can help you improve your gameplay and win more battles:
-
-
Choose your hero wisely: Each hero has a different skill that can affect the battle in various ways. For example, Thor can summon thunderstorms that deal damage to all enemies, Hercules can heal all allies and boost their morale, and Joan of Arc can increase the attack and defense of all units. You need to choose the hero that suits your playstyle and strategy, and use their skill at the right time and place.
-
Use spells and skills at the right time and place: Apart from your hero's skill, you can also use spells that you can buy from the shop or earn from quests. These spells can have different effects, such as healing, damaging, freezing, or stunning. You need to use them wisely and strategically, as they have a cooldown time and a limited number of uses. You also need to aim them well, as some of them have a specific target or area of effect.
-
Upgrade your units and heroes regularly: As you progress in the game, you will face stronger enemies and tougher challenges. You need to upgrade your units and heroes regularly to increase their power and performance. You can upgrade them by using gold and gems that you can earn from battles, quests, or achievements. You can also equip them with items that you can buy from the shop or find in chests. These items can enhance their stats or give them special abilities.
-
Experiment with different combinations of units and heroes: There are many possible combinations of units and heroes that you can use in the game. You can mix and match different classes, such as infantry, cavalry, ranged, magic, or special. You can also try different heroes with different skills and abilities. You need to experiment with different combinations to find the best synergy and balance for your army.
-
-
Comparison of Epic War 6 APK with Other Games
-
Epic War 6 APK is not the only game that offers strategy and action in a fantasy setting. There are many other games that have similar or different features and gameplay. Here are some of them and how they compare with Epic War 6 APK:
-
-
-
Game
-
Similarities
-
Differences
-
-
-
Epic War Saga
-
- Same developer as Epic War 6 APK - Similar gameplay but with more RPG elements - Same genre of strategy and action
-
- Fewer heroes, units, and titans than Epic War 6 APK - More quests, missions, and achievements than Epic War 6 APK - Different graphics style and theme than Epic War 6 APK
-
-
-
Kingdom Rush
-
- Same genre of strategy and action - Similar gameplay but with tower defense elements - Same theme of fantasy and mythology
-
- Different developer than Epic War 6 APK - Fewer heroes and units than Epic War 6 APK - No titans or PVP mode in Kingdom Rush
-
-
-
Clash of Clans
-
- Same genre of strategy and action - Similar gameplay but with base building and army management elements - Same theme of fantasy and mythology
-
- Different developer than Epic War 6 APK - More online multiplayer features than Epic War 6 APK - Different graphics style and tone than Epic War 6 APK
-
-
Pros and Cons of Epic War 6 APK
-
Epic War 6 APK is a game that has many positive and negative aspects. Here are some of them:
-
Pros
-
-
High-quality graphics: The game has impressive graphics that create a realistic and immersive experience. The heroes, units, and titans are well-designed and animated. The backgrounds and environments are detailed and colorful. The effects and sounds are also realistic and captivating.
-
Addictive gameplay: The game has a simple but engaging gameplay that keeps you hooked for hours. The battles are fast-paced and thrilling, with a lot of strategy and action involved. The game also has a lot of content and features to explore, such as quests, achievements, items, and PVP mode.
-
Diverse heroes and units: The game has a lot of variety and diversity in terms of heroes and units. You can choose from six different heroes, each with their own skills and abilities. You can also train and upgrade over 40 battle units, from archers and knights to dragons and giants. You can also unlock new units as you progress in the game, such as ninjas, samurais, or angels.
-
Online PVP mode: The game has an online PVP mode that lets you compete with other players from around the world. You can choose your hero and units and enter a random match against another player. You can also join a clan and participate in clan wars, where you can cooperate with your clan members and fight against other clans. You can earn rewards and rank up in the leaderboards by winning matches and wars.
-
Free to play: The game is free to download and play on your Android device. You do not need to pay anything to enjoy the game. You can also play the game offline without an internet connection.
-
-
Cons
-
-
High learning curve: The game is not very easy to learn or master. You need to understand the mechanics and strategies of the game, such as how to use your hero's skill, how to upgrade your units, how to use spells, how to defeat titans, etc. You also need to practice a lot to improve your skills and performance.
-
Requires internet connection: The game requires an internet connection to access some of its features, such as PVP mode, clan wars, quests, achievements, etc. If you do not have a stable or fast internet connection, you may experience lagging or crashing issues.
-
May have bugs and glitches: The game may have some bugs and glitches that can affect your gameplay or experience. For example, some users have reported that the game freezes or crashes randomly, that the game does not save their progress or data, that the game does not load properly, etc.
-
May consume battery and storage space: The game may consume a lot of battery power and storage space on your device. This is because the game has high-quality graphics, sounds, and effects that require a lot of resources. You may need to charge your device frequently or clear some space on your device to play the game smoothly.
-
-
Review of Epic War 6 APK
-
Epic War 6 APK is a game that deserves a positive review from us. We think that it is a great game for fans of strategy and action games, with a lot of content and features to enjoy. We like the graphics, the gameplay, the diversity, and the online mode of the game. We think that it is a fun and exciting game to play.
-
However, we also acknowledge that the game has some flaws that need to be fixed or improved. We think that the game is not very easy to learn or master, that it requires an internet connection for some features, that it may have some bugs and glitches, and that it may consume a lot of battery power and storage space on your device.
-
Therefore, we give Epic War 6 APK a rating of 4.5 out of 5 stars based on our experience and feedback from other users. We think that it is a game worth playing if you like strategy and action games.
-
epic war 6 android game download
-epic war 6 free online strategy game
-epic war 6 heroes and titans apk
-epic war 6 unblocked html5 game
-epic war 6 mob.org apk file
-epic war 6 crazygames.com play now
-epic war 6 best army and spells
-epic war 6 mod apk unlimited money
-epic war 6 walkthrough and tips
-epic war 6 latest version update
-epic war 6 cheats and hacks
-epic war 6 review and rating
-epic war 6 gameplay and features
-epic war 6 multiplayer mode apk
-epic war 6 offline play apk
-epic war 6 trailer and screenshots
-epic war 6 system requirements and compatibility
-epic war 6 how to install apk
-epic war 6 similar games and alternatives
-epic war 6 developer and publisher
-epic war 6 forum and community
-epic war 6 guide and wiki
-epic war 6 support and contact
-epic war 6 news and updates
-epic war 6 awards and achievements
-epic war 6 fan art and videos
-epic war 6 merchandise and products
-epic war 6 soundtrack and music
-epic war 6 lore and story
-epic war 6 characters and skills
-epic war 6 units and classes
-epic war 6 maps and levels
-epic war 6 weapons and items
-epic war 6 enemies and bosses
-epic war 6 missions and challenges
-epic war 6 events and tournaments
-epic war 6 codes and coupons
-epic war 6 bugs and issues
-epic war 6 feedback and suggestions
-epic war 6 faq and help
-
Conclusion
-
In conclusion, Epic War 6 APK is a thrilling battle game for Android devices that lets you command legendary heroes and a strong army in epic battles against powerful enemies. You can choose from six unique heroes, each with their own skills and abilities. You can also train and upgrade over 40 battle units, from archers and knights to dragons and giants. You can also challenge and defeat huge titans that will test your skills and strategy. And if you want to compete with other players from around the world, you can enter the PVP Arena and show how epic you are.
-
We have also told you how to download and install Epic War 6 APK on your device, how to play it, how it compares with other games, what are its pros and cons, and what is its review. We hope that this article has been helpful and informative for you.
-
If you are interested in playing Epic War 6 APK, you can download it from the official website of mob.org or use this direct link. You can also visit the official Facebook page of the game for more updates and news. You can also watch this video for a preview of the game.
-
Thank you for reading this article and we hope that you enjoy playing Epic War 6 APK. Have fun and good luck!
-
FAQs
-
Here are some frequently asked questions about Epic War 6 APK:
-
-
What are the requirements to play Epic War 6 APK?
-You need an Android device with Android 4.1 or higher and at least 100 MB of free storage space to play Epic War 6 APK. You also need an internet connection to access some features of the game, such as PVP mode, clan wars, quests, achievements, etc.
-
Is Epic War 6 APK safe to download and install?
-Yes, Epic War 6 APK is safe to download and install on your device. It does not contain any viruses, malware, or spyware that can harm your device or data. However, you need to make sure that you download it from a trusted source, such as mob.org or the direct link that we provided in this article.
-
How can I get more gold and gems in Epic War 6 APK?
-You can get more gold and gems in Epic War 6 APK by winning battles, completing quests, achieving goals, opening chests, watching ads, or buying them with real money. You can use gold and gems to upgrade your units and heroes, buy items and spells, or unlock new features and content.
-
How can I join or create a clan in Epic War 6 APK?
-You can join or create a clan in Epic War 6 APK by going to the clan menu in the game. You can either search for an existing clan that suits your preferences and apply to join it, or create your own clan by choosing a name, a logo, and a description. You can also invite your friends or other players to join your clan. You can participate in clan wars, chat with your clan members, and share resources and tips with them.
-
How can I contact the developer of Epic War 6 APK?
-You can contact the developer of Epic War 6 APK by sending an email to epicwar@artlogicgames.com or by visiting their website at www.artlogicgames.com. You can also follow them on Facebook at www.facebook.com/epicwargames. You can send them your feedback, suggestions, questions, or complaints about the game.
- 401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/1toTree/lora_test/ppdiffusers/pipelines/latent_diffusion_uncond/__init__.py b/spaces/1toTree/lora_test/ppdiffusers/pipelines/latent_diffusion_uncond/__init__.py
deleted file mode 100644
index 3286d84f41f239bbd3662100aaa85257c47cbab5..0000000000000000000000000000000000000000
--- a/spaces/1toTree/lora_test/ppdiffusers/pipelines/latent_diffusion_uncond/__init__.py
+++ /dev/null
@@ -1,17 +0,0 @@
-# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
-# Copyright 2022 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# flake8: noqa
-from .pipeline_latent_diffusion_uncond import LDMPipeline
diff --git a/spaces/AIFILMS/generate_human_motion/app.py b/spaces/AIFILMS/generate_human_motion/app.py
deleted file mode 100644
index 58c1cc635a5a4e8e6e00680a2ab5413668bdbe20..0000000000000000000000000000000000000000
--- a/spaces/AIFILMS/generate_human_motion/app.py
+++ /dev/null
@@ -1,319 +0,0 @@
-import sys
-import os
-import OpenGL.GL as gl
-os.environ["PYOPENGL_PLATFORM"] = "egl"
-os.environ["MESA_GL_VERSION_OVERRIDE"] = "4.1"
-os.system('pip install /home/user/app/pyrender')
-
-sys.argv = ['VQ-Trans/GPT_eval_multi.py']
-os.chdir('VQ-Trans')
-
-sys.path.append('/home/user/app/VQ-Trans')
-sys.path.append('/home/user/app/pyrender')
-
-import options.option_transformer as option_trans
-from huggingface_hub import snapshot_download
-model_path = snapshot_download(repo_id="vumichien/T2M-GPT")
-
-args = option_trans.get_args_parser()
-
-args.dataname = 't2m'
-args.resume_pth = f'{model_path}/VQVAE/net_last.pth'
-args.resume_trans = f'{model_path}/VQTransformer_corruption05/net_best_fid.pth'
-args.down_t = 2
-args.depth = 3
-args.block_size = 51
-
-import clip
-import torch
-import numpy as np
-import models.vqvae as vqvae
-import models.t2m_trans as trans
-from utils.motion_process import recover_from_ric
-import visualization.plot_3d_global as plot_3d
-from models.rotation2xyz import Rotation2xyz
-import numpy as np
-from trimesh import Trimesh
-import gc
-
-import torch
-from visualize.simplify_loc2rot import joints2smpl
-import pyrender
-# import matplotlib.pyplot as plt
-
-import io
-import imageio
-from shapely import geometry
-import trimesh
-from pyrender.constants import RenderFlags
-import math
-# import ffmpeg
-# from PIL import Image
-import hashlib
-import gradio as gr
-import moviepy.editor as mp
-
-## load clip model and datasets
-is_cuda = torch.cuda.is_available()
-device = torch.device("cuda" if is_cuda else "cpu")
-print(device)
-clip_model, clip_preprocess = clip.load("ViT-B/32", device=device, jit=False, download_root='./') # Must set jit=False for training
-
-if is_cuda:
- clip.model.convert_weights(clip_model)
-
-clip_model.eval()
-for p in clip_model.parameters():
- p.requires_grad = False
-
-net = vqvae.HumanVQVAE(args, ## use args to define different parameters in different quantizers
- args.nb_code,
- args.code_dim,
- args.output_emb_width,
- args.down_t,
- args.stride_t,
- args.width,
- args.depth,
- args.dilation_growth_rate)
-
-
-trans_encoder = trans.Text2Motion_Transformer(num_vq=args.nb_code,
- embed_dim=1024,
- clip_dim=args.clip_dim,
- block_size=args.block_size,
- num_layers=9,
- n_head=16,
- drop_out_rate=args.drop_out_rate,
- fc_rate=args.ff_rate)
-
-
-print('loading checkpoint from {}'.format(args.resume_pth))
-ckpt = torch.load(args.resume_pth, map_location='cpu')
-net.load_state_dict(ckpt['net'], strict=True)
-net.eval()
-
-print('loading transformer checkpoint from {}'.format(args.resume_trans))
-ckpt = torch.load(args.resume_trans, map_location='cpu')
-trans_encoder.load_state_dict(ckpt['trans'], strict=True)
-trans_encoder.eval()
-
-mean = torch.from_numpy(np.load(f'{model_path}/meta/mean.npy'))
-std = torch.from_numpy(np.load(f'{model_path}/meta/std.npy'))
-
-if is_cuda:
- net.cuda()
- trans_encoder.cuda()
- mean = mean.cuda()
- std = std.cuda()
-
-def render(motions, device_id=0, name='test_vis'):
- frames, njoints, nfeats = motions.shape
- MINS = motions.min(axis=0).min(axis=0)
- MAXS = motions.max(axis=0).max(axis=0)
-
- height_offset = MINS[1]
- motions[:, :, 1] -= height_offset
- trajec = motions[:, 0, [0, 2]]
- is_cuda = torch.cuda.is_available()
- # device = torch.device("cuda" if is_cuda else "cpu")
- j2s = joints2smpl(num_frames=frames, device_id=0, cuda=is_cuda)
- rot2xyz = Rotation2xyz(device=device)
- faces = rot2xyz.smpl_model.faces
-
- if not os.path.exists(f'output/{name}_pred.pt'):
- print(f'Running SMPLify, it may take a few minutes.')
- motion_tensor, opt_dict = j2s.joint2smpl(motions) # [nframes, njoints, 3]
-
- vertices = rot2xyz(torch.tensor(motion_tensor).clone(), mask=None,
- pose_rep='rot6d', translation=True, glob=True,
- jointstype='vertices',
- vertstrans=True)
- vertices = vertices.detach().cpu()
- torch.save(vertices, f'output/{name}_pred.pt')
- else:
- vertices = torch.load(f'output/{name}_pred.pt')
- frames = vertices.shape[3] # shape: 1, nb_frames, 3, nb_joints
- print(vertices.shape)
- MINS = torch.min(torch.min(vertices[0], axis=0)[0], axis=1)[0]
- MAXS = torch.max(torch.max(vertices[0], axis=0)[0], axis=1)[0]
-
- out_list = []
-
- minx = MINS[0] - 0.5
- maxx = MAXS[0] + 0.5
- minz = MINS[2] - 0.5
- maxz = MAXS[2] + 0.5
- polygon = geometry.Polygon([[minx, minz], [minx, maxz], [maxx, maxz], [maxx, minz]])
- polygon_mesh = trimesh.creation.extrude_polygon(polygon, 1e-5)
-
- vid = []
- for i in range(frames):
- if i % 10 == 0:
- print(i)
-
- mesh = Trimesh(vertices=vertices[0, :, :, i].squeeze().tolist(), faces=faces)
-
- base_color = (0.11, 0.53, 0.8, 0.5)
- ## OPAQUE rendering without alpha
- ## BLEND rendering consider alpha
- material = pyrender.MetallicRoughnessMaterial(
- metallicFactor=0.7,
- alphaMode='OPAQUE',
- baseColorFactor=base_color
- )
-
-
- mesh = pyrender.Mesh.from_trimesh(mesh, material=material)
-
- polygon_mesh.visual.face_colors = [0, 0, 0, 0.21]
- polygon_render = pyrender.Mesh.from_trimesh(polygon_mesh, smooth=False)
-
- bg_color = [1, 1, 1, 0.8]
- scene = pyrender.Scene(bg_color=bg_color, ambient_light=(0.4, 0.4, 0.4))
-
- sx, sy, tx, ty = [0.75, 0.75, 0, 0.10]
-
- camera = pyrender.PerspectiveCamera(yfov=(np.pi / 3.0))
-
- light = pyrender.DirectionalLight(color=[1,1,1], intensity=300)
-
- scene.add(mesh)
-
- c = np.pi / 2
-
- scene.add(polygon_render, pose=np.array([[ 1, 0, 0, 0],
-
- [ 0, np.cos(c), -np.sin(c), MINS[1].cpu().numpy()],
-
- [ 0, np.sin(c), np.cos(c), 0],
-
- [ 0, 0, 0, 1]]))
-
- light_pose = np.eye(4)
- light_pose[:3, 3] = [0, -1, 1]
- scene.add(light, pose=light_pose.copy())
-
- light_pose[:3, 3] = [0, 1, 1]
- scene.add(light, pose=light_pose.copy())
-
- light_pose[:3, 3] = [1, 1, 2]
- scene.add(light, pose=light_pose.copy())
-
-
- c = -np.pi / 6
-
- scene.add(camera, pose=[[ 1, 0, 0, (minx+maxx).cpu().numpy()/2],
-
- [ 0, np.cos(c), -np.sin(c), 1.5],
-
- [ 0, np.sin(c), np.cos(c), max(4, minz.cpu().numpy()+(1.5-MINS[1].cpu().numpy())*2, (maxx-minx).cpu().numpy())],
-
- [ 0, 0, 0, 1]
- ])
-
- # render scene
- r = pyrender.OffscreenRenderer(960, 960)
-
- color, _ = r.render(scene, flags=RenderFlags.RGBA)
- # Image.fromarray(color).save(outdir+'/'+name+'_'+str(i)+'.png')
-
- vid.append(color)
-
- r.delete()
-
- out = np.stack(vid, axis=0)
- imageio.mimwrite(f'output/results.gif', out, fps=20)
- out_video = mp.VideoFileClip(f'output/results.gif')
- out_video.write_videofile("output/results.mp4")
- del out, vertices
- return f'output/results.mp4'
-
-def predict(clip_text, method='fast'):
- gc.collect()
- if torch.cuda.is_available():
- text = clip.tokenize([clip_text], truncate=True).cuda()
- else:
- text = clip.tokenize([clip_text], truncate=True)
- feat_clip_text = clip_model.encode_text(text).float()
- index_motion = trans_encoder.sample(feat_clip_text[0:1], False)
- pred_pose = net.forward_decoder(index_motion)
- pred_xyz = recover_from_ric((pred_pose*std+mean).float(), 22)
- output_name = hashlib.md5(clip_text.encode()).hexdigest()
- if method == 'fast':
- xyz = pred_xyz.reshape(1, -1, 22, 3)
- pose_vis = plot_3d.draw_to_batch(xyz.detach().cpu().numpy(), title_batch=None, outname=[f'output/results.gif'])
- out_video = mp.VideoFileClip("output/results.gif")
- out_video.write_videofile("output/results.mp4")
- return f'output/results.mp4'
- elif method == 'slow':
- output_path = render(pred_xyz.detach().cpu().numpy().squeeze(axis=0), device_id=0, name=output_name)
- return output_path
-
-
-# ---- Gradio Layout -----
-text_prompt = gr.Textbox(label="Text prompt", lines=1, interactive=True)
-video_out = gr.Video(label="Motion", mirror_webcam=False, interactive=False)
-demo = gr.Blocks()
-demo.encrypt = False
-
-with demo:
- gr.Markdown('''
-
-
Generating Human Motion from Textual Descriptions (T2M-GPT)
- This space uses T2M-GPT models based on Vector Quantised-Variational AutoEncoder (VQ-VAE) and Generative Pre-trained Transformer (GPT) for human motion generation from textural descriptions🤗
-
- ''')
- with gr.Row():
- with gr.Column():
- gr.Markdown('''
-
-
- a man starts off in an up right position with botg arms extended out by his sides, he then brings his arms down to his body and claps his hands together. after this he wals down amd the the left where he proceeds to sit on a seat
-
-
- ''')
- with gr.Column():
- gr.Markdown('''
-
-
- a person puts their hands together, leans forwards slightly then swings the arms from right to left
-
-
- ''')
- with gr.Column():
- gr.Markdown('''
-
-
- a man is practicing the waltz with a partner
-
-
- ''')
- with gr.Row():
- with gr.Column():
- gr.Markdown('''
- ### Generate human motion by **T2M-GPT**
- ##### Step 1. Give prompt text describing human motion
- ##### Step 2. Choice method to render output (Fast: Sketch skeleton; Slow: SMPL mesh, only work with GPU and running time around 2 mins)
- ##### Step 3. Generate output and enjoy
- ''')
- with gr.Column():
- with gr.Row():
- text_prompt.render()
- method = gr.Dropdown(["slow", "fast"], label="Method", value="slow")
- with gr.Row():
- generate_btn = gr.Button("Generate")
- generate_btn.click(predict, [text_prompt, method], [video_out], api_name="generate")
- print(video_out)
- with gr.Row():
- video_out.render()
- with gr.Row():
- gr.Markdown('''
- ### You can test by following examples:
- ''')
- examples = gr.Examples(examples=
- [ "a person jogs in place, slowly at first, then increases speed. they then back up and squat down.",
- "a man steps forward and does a handstand",
- "a man rises from the ground, walks in a circle and sits back down on the ground"],
- label="Examples", inputs=[text_prompt])
-
-demo.launch(debug=True)
diff --git a/spaces/AIZerotoHero-Health4All/02-ClinicalTerminology/README.md b/spaces/AIZerotoHero-Health4All/02-ClinicalTerminology/README.md
deleted file mode 100644
index 28796cea638944008464739ccfd3773687e64b3b..0000000000000000000000000000000000000000
--- a/spaces/AIZerotoHero-Health4All/02-ClinicalTerminology/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: 02 ClinicalTerminology
-emoji: 🐠
-colorFrom: red
-colorTo: green
-sdk: gradio
-sdk_version: 3.12.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/ASJMO/freegpt/client/css/buttons.css b/spaces/ASJMO/freegpt/client/css/buttons.css
deleted file mode 100644
index e13f52d9a0414daaa80518bd205913a645a29563..0000000000000000000000000000000000000000
--- a/spaces/ASJMO/freegpt/client/css/buttons.css
+++ /dev/null
@@ -1,4 +0,0 @@
-.buttons {
- display: flex;
- justify-content: left;
-}
diff --git a/spaces/AchyuthGamer/OpenGPT/g4f/Provider/Providers/GptGod.py b/spaces/AchyuthGamer/OpenGPT/g4f/Provider/Providers/GptGod.py
deleted file mode 100644
index 662884ddbec5ebffa03aae98a36727ff2cb6c366..0000000000000000000000000000000000000000
--- a/spaces/AchyuthGamer/OpenGPT/g4f/Provider/Providers/GptGod.py
+++ /dev/null
@@ -1,51 +0,0 @@
-from __future__ import annotations
-import secrets, json
-from aiohttp import ClientSession
-from typing import AsyncGenerator
-from .base_provider import AsyncGeneratorProvider
-from .helper import format_prompt
-
-class GptGod(AsyncGeneratorProvider):
- url = "https://gptgod.site"
- supports_gpt_35_turbo = True
- working = True
-
- @classmethod
- async def create_async_generator(
- cls,
- model: str,
- messages: list[dict[str, str]],
- **kwargs
- ) -> AsyncGenerator:
- headers = {
- "User-Agent": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/118.0",
- "Accept": "text/event-stream",
- "Accept-Language": "de,en-US;q=0.7,en;q=0.3",
- "Accept-Encoding": "gzip, deflate, br",
- "Alt-Used": "gptgod.site",
- "Connection": "keep-alive",
- "Referer": "https://gptgod.site/",
- "Sec-Fetch-Dest": "empty",
- "Sec-Fetch-Mode": "cors",
- "Sec-Fetch-Site": "same-origin",
- "Pragma": "no-cache",
- "Cache-Control": "no-cache",
- }
- async with ClientSession(headers=headers) as session:
- prompt = format_prompt(messages)
- data = {
- "content": prompt,
- "id": secrets.token_hex(16).zfill(32)
- }
- async with session.get(f"{cls.url}/api/session/free/gpt3p5", params=data) as response:
- response.raise_for_status()
- event = None
- async for line in response.content:
- if line.startswith(b'event: '):
- event = line[7:-1]
- elif event == b"data" and line.startswith(b"data: "):
- data = json.loads(line[6:-1])
- if data:
- yield data
- elif event == b"done":
- break
\ No newline at end of file
diff --git a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/maker/builders/Builders.js b/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/maker/builders/Builders.js
deleted file mode 100644
index bedfa7a49c502236aa2dbb9f26cdfd45b98b8cd1..0000000000000000000000000000000000000000
--- a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/maker/builders/Builders.js
+++ /dev/null
@@ -1,79 +0,0 @@
-import CreateImage from './CreateImage.js';
-import CreateSprite from './CreateSprite.js';
-import CreateVideo from './CreateVideo.js';
-import CreateText from './CreateText.js';
-import CreateBBCodeText from './CreateBBCodeText.js';
-import CreateRoundRectangle from './CreateRoundRectangle.js';
-import CreateNinePatch from './CreateNinePatch.js';
-import CreateNinePatch2 from './CreateNinePatch2.js';
-import CreateCanvas from './CreateCanvas.js';
-import CreateCircleMaskImage from './CreateCircleMaskImage.js';
-import CreateSpace from './CreateSpace.js';
-
-import CreateSizer from './CreateSizer.js';
-import CreateFixWidthSizer from './CreateFixWidthSizer.js';
-import CreateGridSizer from './CreateGridSizer.js';
-import CreateOverlapSizer from './CreateOverlapSizer.js';
-
-import CreateButtons from './CreateButtons.js';
-import CreateFixWidthButtons from './CreateFixWidthButtons.js';
-import CreateGridButtons from './CreateGridButtons.js';
-
-import CreateLabel from './CreateLabel.js';
-import CreateBadgeLabel from './CreateBadgeLabel.js';
-import CreateDialog from './CreateDialog.js';
-import CreateTextBox from './CreateTextBox.js';
-import CreateSlider from './CreateSlider.js';
-import CreateNumberBar from './CreateNumberBar.js';
-import CreateScrollBar from './CreateScrollBar.js';
-import CreateTextArea from './CreateTextArea.js';
-import CreatePages from './CreatePages.js';
-import CreateToast from './CreateToast.js';
-import CreateKnob from './CreateKnob.js';
-import CreateHolyGrail from './CreateHolyGrail.js';
-import CreateMenu from './CreateMenu.js';
-
-var Builders = {
- Image: CreateImage,
- Sprite: CreateSprite,
- Video: CreateVideo,
- Text: CreateText,
- BBCodeText: CreateBBCodeText,
- RoundRectangle: CreateRoundRectangle,
- Ninepatch: CreateNinePatch,
- Ninepatch2: CreateNinePatch2,
- Canvas: CreateCanvas,
- CircleMaskImage: CreateCircleMaskImage,
- Space: CreateSpace,
-
- Sizer: CreateSizer,
- FixWidthSizer: CreateFixWidthSizer,
- GridSizer: CreateGridSizer,
- OverlapSizer: CreateOverlapSizer,
-
- Buttons: CreateButtons,
- FixWidthButtons: CreateFixWidthButtons,
- GridButtons: CreateGridButtons,
-
- Label: CreateLabel,
- BadgeLabel: CreateBadgeLabel,
- Dialog: CreateDialog,
- TextBox: CreateTextBox,
- Slider: CreateSlider,
- NumberBar: CreateNumberBar,
- ScrollBar: CreateScrollBar,
- TextArea: CreateTextArea,
- Pages: CreatePages,
- Toast: CreateToast,
- Knob: CreateKnob,
- HolyGrail: CreateHolyGrail,
- Menu: CreateMenu,
-};
-
-/*
-function(scene, data, view, styles, customBuilders) {
- return gameObject;
-}
-*/
-
-export default Builders;
diff --git a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/maker/builders/CreateLabel.js b/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/maker/builders/CreateLabel.js
deleted file mode 100644
index 8c20f7f845f90be917a21a9cc0596c3cd8afabe5..0000000000000000000000000000000000000000
--- a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/maker/builders/CreateLabel.js
+++ /dev/null
@@ -1,8 +0,0 @@
-import CreateAnyLabel from './utils/CreateAnyLabel.js';
-import Label from '../../label/Label.js';
-
-var CreateLabel = function (scene, data, view, styles, customBuilders) {
- return CreateAnyLabel(scene, data, view, styles, customBuilders, Label);
-}
-
-export default CreateLabel;
\ No newline at end of file
diff --git a/spaces/Allie7/Nose/Dockerfile b/spaces/Allie7/Nose/Dockerfile
deleted file mode 100644
index e903078eb67547d100c8e5548b2d7959ce565413..0000000000000000000000000000000000000000
--- a/spaces/Allie7/Nose/Dockerfile
+++ /dev/null
@@ -1,21 +0,0 @@
-FROM node: 18-bullseye-slim
-
-RUN apt-get update && \
-
-apt-get install -y git
-
-RUN git clone https://gitgud.io/khanon/oai-reverse-proxy.git/app
-
-WORKDIR /app
-
-RUN npm install
-
-COPY Dockerfile greeting.md env* ./
-
-RUN npm run build
-
-EXPOSE 7860
-
-ENV NODE_ENV=production
-
-CMD ["npm", "start" ]
\ No newline at end of file
diff --git a/spaces/AnTo2209/3D_Zeroshot_Neural_Style_Transfer/src/model/__init__.py b/spaces/AnTo2209/3D_Zeroshot_Neural_Style_Transfer/src/model/__init__.py
deleted file mode 100644
index b6602d66834efa27a8b88c5eb92ed901389bd9ca..0000000000000000000000000000000000000000
--- a/spaces/AnTo2209/3D_Zeroshot_Neural_Style_Transfer/src/model/__init__.py
+++ /dev/null
@@ -1,6 +0,0 @@
-from src.model.styleRF import StyleRF
-from src.utils.registry import Registry
-
-MODEL_REGISTRY = Registry("MODEL")
-
-MODEL_REGISTRY.register(StyleRF)
\ No newline at end of file
diff --git a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/examples/community/stable_diffusion_tensorrt_img2img.py b/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/examples/community/stable_diffusion_tensorrt_img2img.py
deleted file mode 100644
index 67c7c2d00fbf53f26e42aa96dc5e049ea3b3d796..0000000000000000000000000000000000000000
--- a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/examples/community/stable_diffusion_tensorrt_img2img.py
+++ /dev/null
@@ -1,1055 +0,0 @@
-#
-# Copyright 2023 The HuggingFace Inc. team.
-# SPDX-FileCopyrightText: Copyright (c) 1993-2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import gc
-import os
-from collections import OrderedDict
-from copy import copy
-from typing import List, Optional, Union
-
-import numpy as np
-import onnx
-import onnx_graphsurgeon as gs
-import PIL
-import tensorrt as trt
-import torch
-from huggingface_hub import snapshot_download
-from onnx import shape_inference
-from polygraphy import cuda
-from polygraphy.backend.common import bytes_from_path
-from polygraphy.backend.onnx.loader import fold_constants
-from polygraphy.backend.trt import (
- CreateConfig,
- Profile,
- engine_from_bytes,
- engine_from_network,
- network_from_onnx_path,
- save_engine,
-)
-from polygraphy.backend.trt import util as trt_util
-from transformers import CLIPFeatureExtractor, CLIPTextModel, CLIPTokenizer
-
-from diffusers.models import AutoencoderKL, UNet2DConditionModel
-from diffusers.pipelines.stable_diffusion import (
- StableDiffusionImg2ImgPipeline,
- StableDiffusionPipelineOutput,
- StableDiffusionSafetyChecker,
-)
-from diffusers.schedulers import DDIMScheduler
-from diffusers.utils import DIFFUSERS_CACHE, logging
-
-
-"""
-Installation instructions
-python3 -m pip install --upgrade transformers diffusers>=0.16.0
-python3 -m pip install --upgrade tensorrt>=8.6.1
-python3 -m pip install --upgrade polygraphy>=0.47.0 onnx-graphsurgeon --extra-index-url https://pypi.ngc.nvidia.com
-python3 -m pip install onnxruntime
-"""
-
-TRT_LOGGER = trt.Logger(trt.Logger.ERROR)
-logger = logging.get_logger(__name__) # pylint: disable=invalid-name
-
-# Map of numpy dtype -> torch dtype
-numpy_to_torch_dtype_dict = {
- np.uint8: torch.uint8,
- np.int8: torch.int8,
- np.int16: torch.int16,
- np.int32: torch.int32,
- np.int64: torch.int64,
- np.float16: torch.float16,
- np.float32: torch.float32,
- np.float64: torch.float64,
- np.complex64: torch.complex64,
- np.complex128: torch.complex128,
-}
-if np.version.full_version >= "1.24.0":
- numpy_to_torch_dtype_dict[np.bool_] = torch.bool
-else:
- numpy_to_torch_dtype_dict[np.bool] = torch.bool
-
-# Map of torch dtype -> numpy dtype
-torch_to_numpy_dtype_dict = {value: key for (key, value) in numpy_to_torch_dtype_dict.items()}
-
-
-def device_view(t):
- return cuda.DeviceView(ptr=t.data_ptr(), shape=t.shape, dtype=torch_to_numpy_dtype_dict[t.dtype])
-
-
-def preprocess_image(image):
- """
- image: torch.Tensor
- """
- w, h = image.size
- w, h = (x - x % 32 for x in (w, h)) # resize to integer multiple of 32
- image = image.resize((w, h))
- image = np.array(image).astype(np.float32) / 255.0
- image = image[None].transpose(0, 3, 1, 2)
- image = torch.from_numpy(image).contiguous()
- return 2.0 * image - 1.0
-
-
-class Engine:
- def __init__(self, engine_path):
- self.engine_path = engine_path
- self.engine = None
- self.context = None
- self.buffers = OrderedDict()
- self.tensors = OrderedDict()
-
- def __del__(self):
- [buf.free() for buf in self.buffers.values() if isinstance(buf, cuda.DeviceArray)]
- del self.engine
- del self.context
- del self.buffers
- del self.tensors
-
- def build(
- self,
- onnx_path,
- fp16,
- input_profile=None,
- enable_preview=False,
- enable_all_tactics=False,
- timing_cache=None,
- workspace_size=0,
- ):
- logger.warning(f"Building TensorRT engine for {onnx_path}: {self.engine_path}")
- p = Profile()
- if input_profile:
- for name, dims in input_profile.items():
- assert len(dims) == 3
- p.add(name, min=dims[0], opt=dims[1], max=dims[2])
-
- config_kwargs = {}
-
- config_kwargs["preview_features"] = [trt.PreviewFeature.DISABLE_EXTERNAL_TACTIC_SOURCES_FOR_CORE_0805]
- if enable_preview:
- # Faster dynamic shapes made optional since it increases engine build time.
- config_kwargs["preview_features"].append(trt.PreviewFeature.FASTER_DYNAMIC_SHAPES_0805)
- if workspace_size > 0:
- config_kwargs["memory_pool_limits"] = {trt.MemoryPoolType.WORKSPACE: workspace_size}
- if not enable_all_tactics:
- config_kwargs["tactic_sources"] = []
-
- engine = engine_from_network(
- network_from_onnx_path(onnx_path, flags=[trt.OnnxParserFlag.NATIVE_INSTANCENORM]),
- config=CreateConfig(fp16=fp16, profiles=[p], load_timing_cache=timing_cache, **config_kwargs),
- save_timing_cache=timing_cache,
- )
- save_engine(engine, path=self.engine_path)
-
- def load(self):
- logger.warning(f"Loading TensorRT engine: {self.engine_path}")
- self.engine = engine_from_bytes(bytes_from_path(self.engine_path))
-
- def activate(self):
- self.context = self.engine.create_execution_context()
-
- def allocate_buffers(self, shape_dict=None, device="cuda"):
- for idx in range(trt_util.get_bindings_per_profile(self.engine)):
- binding = self.engine[idx]
- if shape_dict and binding in shape_dict:
- shape = shape_dict[binding]
- else:
- shape = self.engine.get_binding_shape(binding)
- dtype = trt.nptype(self.engine.get_binding_dtype(binding))
- if self.engine.binding_is_input(binding):
- self.context.set_binding_shape(idx, shape)
- tensor = torch.empty(tuple(shape), dtype=numpy_to_torch_dtype_dict[dtype]).to(device=device)
- self.tensors[binding] = tensor
- self.buffers[binding] = cuda.DeviceView(ptr=tensor.data_ptr(), shape=shape, dtype=dtype)
-
- def infer(self, feed_dict, stream):
- start_binding, end_binding = trt_util.get_active_profile_bindings(self.context)
- # shallow copy of ordered dict
- device_buffers = copy(self.buffers)
- for name, buf in feed_dict.items():
- assert isinstance(buf, cuda.DeviceView)
- device_buffers[name] = buf
- bindings = [0] * start_binding + [buf.ptr for buf in device_buffers.values()]
- noerror = self.context.execute_async_v2(bindings=bindings, stream_handle=stream.ptr)
- if not noerror:
- raise ValueError("ERROR: inference failed.")
-
- return self.tensors
-
-
-class Optimizer:
- def __init__(self, onnx_graph):
- self.graph = gs.import_onnx(onnx_graph)
-
- def cleanup(self, return_onnx=False):
- self.graph.cleanup().toposort()
- if return_onnx:
- return gs.export_onnx(self.graph)
-
- def select_outputs(self, keep, names=None):
- self.graph.outputs = [self.graph.outputs[o] for o in keep]
- if names:
- for i, name in enumerate(names):
- self.graph.outputs[i].name = name
-
- def fold_constants(self, return_onnx=False):
- onnx_graph = fold_constants(gs.export_onnx(self.graph), allow_onnxruntime_shape_inference=True)
- self.graph = gs.import_onnx(onnx_graph)
- if return_onnx:
- return onnx_graph
-
- def infer_shapes(self, return_onnx=False):
- onnx_graph = gs.export_onnx(self.graph)
- if onnx_graph.ByteSize() > 2147483648:
- raise TypeError("ERROR: model size exceeds supported 2GB limit")
- else:
- onnx_graph = shape_inference.infer_shapes(onnx_graph)
-
- self.graph = gs.import_onnx(onnx_graph)
- if return_onnx:
- return onnx_graph
-
-
-class BaseModel:
- def __init__(self, model, fp16=False, device="cuda", max_batch_size=16, embedding_dim=768, text_maxlen=77):
- self.model = model
- self.name = "SD Model"
- self.fp16 = fp16
- self.device = device
-
- self.min_batch = 1
- self.max_batch = max_batch_size
- self.min_image_shape = 256 # min image resolution: 256x256
- self.max_image_shape = 1024 # max image resolution: 1024x1024
- self.min_latent_shape = self.min_image_shape // 8
- self.max_latent_shape = self.max_image_shape // 8
-
- self.embedding_dim = embedding_dim
- self.text_maxlen = text_maxlen
-
- def get_model(self):
- return self.model
-
- def get_input_names(self):
- pass
-
- def get_output_names(self):
- pass
-
- def get_dynamic_axes(self):
- return None
-
- def get_sample_input(self, batch_size, image_height, image_width):
- pass
-
- def get_input_profile(self, batch_size, image_height, image_width, static_batch, static_shape):
- return None
-
- def get_shape_dict(self, batch_size, image_height, image_width):
- return None
-
- def optimize(self, onnx_graph):
- opt = Optimizer(onnx_graph)
- opt.cleanup()
- opt.fold_constants()
- opt.infer_shapes()
- onnx_opt_graph = opt.cleanup(return_onnx=True)
- return onnx_opt_graph
-
- def check_dims(self, batch_size, image_height, image_width):
- assert batch_size >= self.min_batch and batch_size <= self.max_batch
- assert image_height % 8 == 0 or image_width % 8 == 0
- latent_height = image_height // 8
- latent_width = image_width // 8
- assert latent_height >= self.min_latent_shape and latent_height <= self.max_latent_shape
- assert latent_width >= self.min_latent_shape and latent_width <= self.max_latent_shape
- return (latent_height, latent_width)
-
- def get_minmax_dims(self, batch_size, image_height, image_width, static_batch, static_shape):
- min_batch = batch_size if static_batch else self.min_batch
- max_batch = batch_size if static_batch else self.max_batch
- latent_height = image_height // 8
- latent_width = image_width // 8
- min_image_height = image_height if static_shape else self.min_image_shape
- max_image_height = image_height if static_shape else self.max_image_shape
- min_image_width = image_width if static_shape else self.min_image_shape
- max_image_width = image_width if static_shape else self.max_image_shape
- min_latent_height = latent_height if static_shape else self.min_latent_shape
- max_latent_height = latent_height if static_shape else self.max_latent_shape
- min_latent_width = latent_width if static_shape else self.min_latent_shape
- max_latent_width = latent_width if static_shape else self.max_latent_shape
- return (
- min_batch,
- max_batch,
- min_image_height,
- max_image_height,
- min_image_width,
- max_image_width,
- min_latent_height,
- max_latent_height,
- min_latent_width,
- max_latent_width,
- )
-
-
-def getOnnxPath(model_name, onnx_dir, opt=True):
- return os.path.join(onnx_dir, model_name + (".opt" if opt else "") + ".onnx")
-
-
-def getEnginePath(model_name, engine_dir):
- return os.path.join(engine_dir, model_name + ".plan")
-
-
-def build_engines(
- models: dict,
- engine_dir,
- onnx_dir,
- onnx_opset,
- opt_image_height,
- opt_image_width,
- opt_batch_size=1,
- force_engine_rebuild=False,
- static_batch=False,
- static_shape=True,
- enable_preview=False,
- enable_all_tactics=False,
- timing_cache=None,
- max_workspace_size=0,
-):
- built_engines = {}
- if not os.path.isdir(onnx_dir):
- os.makedirs(onnx_dir)
- if not os.path.isdir(engine_dir):
- os.makedirs(engine_dir)
-
- # Export models to ONNX
- for model_name, model_obj in models.items():
- engine_path = getEnginePath(model_name, engine_dir)
- if force_engine_rebuild or not os.path.exists(engine_path):
- logger.warning("Building Engines...")
- logger.warning("Engine build can take a while to complete")
- onnx_path = getOnnxPath(model_name, onnx_dir, opt=False)
- onnx_opt_path = getOnnxPath(model_name, onnx_dir)
- if force_engine_rebuild or not os.path.exists(onnx_opt_path):
- if force_engine_rebuild or not os.path.exists(onnx_path):
- logger.warning(f"Exporting model: {onnx_path}")
- model = model_obj.get_model()
- with torch.inference_mode(), torch.autocast("cuda"):
- inputs = model_obj.get_sample_input(opt_batch_size, opt_image_height, opt_image_width)
- torch.onnx.export(
- model,
- inputs,
- onnx_path,
- export_params=True,
- opset_version=onnx_opset,
- do_constant_folding=True,
- input_names=model_obj.get_input_names(),
- output_names=model_obj.get_output_names(),
- dynamic_axes=model_obj.get_dynamic_axes(),
- )
- del model
- torch.cuda.empty_cache()
- gc.collect()
- else:
- logger.warning(f"Found cached model: {onnx_path}")
-
- # Optimize onnx
- if force_engine_rebuild or not os.path.exists(onnx_opt_path):
- logger.warning(f"Generating optimizing model: {onnx_opt_path}")
- onnx_opt_graph = model_obj.optimize(onnx.load(onnx_path))
- onnx.save(onnx_opt_graph, onnx_opt_path)
- else:
- logger.warning(f"Found cached optimized model: {onnx_opt_path} ")
-
- # Build TensorRT engines
- for model_name, model_obj in models.items():
- engine_path = getEnginePath(model_name, engine_dir)
- engine = Engine(engine_path)
- onnx_path = getOnnxPath(model_name, onnx_dir, opt=False)
- onnx_opt_path = getOnnxPath(model_name, onnx_dir)
-
- if force_engine_rebuild or not os.path.exists(engine.engine_path):
- engine.build(
- onnx_opt_path,
- fp16=True,
- input_profile=model_obj.get_input_profile(
- opt_batch_size,
- opt_image_height,
- opt_image_width,
- static_batch=static_batch,
- static_shape=static_shape,
- ),
- enable_preview=enable_preview,
- timing_cache=timing_cache,
- workspace_size=max_workspace_size,
- )
- built_engines[model_name] = engine
-
- # Load and activate TensorRT engines
- for model_name, model_obj in models.items():
- engine = built_engines[model_name]
- engine.load()
- engine.activate()
-
- return built_engines
-
-
-def runEngine(engine, feed_dict, stream):
- return engine.infer(feed_dict, stream)
-
-
-class CLIP(BaseModel):
- def __init__(self, model, device, max_batch_size, embedding_dim):
- super(CLIP, self).__init__(
- model=model, device=device, max_batch_size=max_batch_size, embedding_dim=embedding_dim
- )
- self.name = "CLIP"
-
- def get_input_names(self):
- return ["input_ids"]
-
- def get_output_names(self):
- return ["text_embeddings", "pooler_output"]
-
- def get_dynamic_axes(self):
- return {"input_ids": {0: "B"}, "text_embeddings": {0: "B"}}
-
- def get_input_profile(self, batch_size, image_height, image_width, static_batch, static_shape):
- self.check_dims(batch_size, image_height, image_width)
- min_batch, max_batch, _, _, _, _, _, _, _, _ = self.get_minmax_dims(
- batch_size, image_height, image_width, static_batch, static_shape
- )
- return {
- "input_ids": [(min_batch, self.text_maxlen), (batch_size, self.text_maxlen), (max_batch, self.text_maxlen)]
- }
-
- def get_shape_dict(self, batch_size, image_height, image_width):
- self.check_dims(batch_size, image_height, image_width)
- return {
- "input_ids": (batch_size, self.text_maxlen),
- "text_embeddings": (batch_size, self.text_maxlen, self.embedding_dim),
- }
-
- def get_sample_input(self, batch_size, image_height, image_width):
- self.check_dims(batch_size, image_height, image_width)
- return torch.zeros(batch_size, self.text_maxlen, dtype=torch.int32, device=self.device)
-
- def optimize(self, onnx_graph):
- opt = Optimizer(onnx_graph)
- opt.select_outputs([0]) # delete graph output#1
- opt.cleanup()
- opt.fold_constants()
- opt.infer_shapes()
- opt.select_outputs([0], names=["text_embeddings"]) # rename network output
- opt_onnx_graph = opt.cleanup(return_onnx=True)
- return opt_onnx_graph
-
-
-def make_CLIP(model, device, max_batch_size, embedding_dim, inpaint=False):
- return CLIP(model, device=device, max_batch_size=max_batch_size, embedding_dim=embedding_dim)
-
-
-class UNet(BaseModel):
- def __init__(
- self, model, fp16=False, device="cuda", max_batch_size=16, embedding_dim=768, text_maxlen=77, unet_dim=4
- ):
- super(UNet, self).__init__(
- model=model,
- fp16=fp16,
- device=device,
- max_batch_size=max_batch_size,
- embedding_dim=embedding_dim,
- text_maxlen=text_maxlen,
- )
- self.unet_dim = unet_dim
- self.name = "UNet"
-
- def get_input_names(self):
- return ["sample", "timestep", "encoder_hidden_states"]
-
- def get_output_names(self):
- return ["latent"]
-
- def get_dynamic_axes(self):
- return {
- "sample": {0: "2B", 2: "H", 3: "W"},
- "encoder_hidden_states": {0: "2B"},
- "latent": {0: "2B", 2: "H", 3: "W"},
- }
-
- def get_input_profile(self, batch_size, image_height, image_width, static_batch, static_shape):
- latent_height, latent_width = self.check_dims(batch_size, image_height, image_width)
- (
- min_batch,
- max_batch,
- _,
- _,
- _,
- _,
- min_latent_height,
- max_latent_height,
- min_latent_width,
- max_latent_width,
- ) = self.get_minmax_dims(batch_size, image_height, image_width, static_batch, static_shape)
- return {
- "sample": [
- (2 * min_batch, self.unet_dim, min_latent_height, min_latent_width),
- (2 * batch_size, self.unet_dim, latent_height, latent_width),
- (2 * max_batch, self.unet_dim, max_latent_height, max_latent_width),
- ],
- "encoder_hidden_states": [
- (2 * min_batch, self.text_maxlen, self.embedding_dim),
- (2 * batch_size, self.text_maxlen, self.embedding_dim),
- (2 * max_batch, self.text_maxlen, self.embedding_dim),
- ],
- }
-
- def get_shape_dict(self, batch_size, image_height, image_width):
- latent_height, latent_width = self.check_dims(batch_size, image_height, image_width)
- return {
- "sample": (2 * batch_size, self.unet_dim, latent_height, latent_width),
- "encoder_hidden_states": (2 * batch_size, self.text_maxlen, self.embedding_dim),
- "latent": (2 * batch_size, 4, latent_height, latent_width),
- }
-
- def get_sample_input(self, batch_size, image_height, image_width):
- latent_height, latent_width = self.check_dims(batch_size, image_height, image_width)
- dtype = torch.float16 if self.fp16 else torch.float32
- return (
- torch.randn(
- 2 * batch_size, self.unet_dim, latent_height, latent_width, dtype=torch.float32, device=self.device
- ),
- torch.tensor([1.0], dtype=torch.float32, device=self.device),
- torch.randn(2 * batch_size, self.text_maxlen, self.embedding_dim, dtype=dtype, device=self.device),
- )
-
-
-def make_UNet(model, device, max_batch_size, embedding_dim, inpaint=False):
- return UNet(
- model,
- fp16=True,
- device=device,
- max_batch_size=max_batch_size,
- embedding_dim=embedding_dim,
- unet_dim=(9 if inpaint else 4),
- )
-
-
-class VAE(BaseModel):
- def __init__(self, model, device, max_batch_size, embedding_dim):
- super(VAE, self).__init__(
- model=model, device=device, max_batch_size=max_batch_size, embedding_dim=embedding_dim
- )
- self.name = "VAE decoder"
-
- def get_input_names(self):
- return ["latent"]
-
- def get_output_names(self):
- return ["images"]
-
- def get_dynamic_axes(self):
- return {"latent": {0: "B", 2: "H", 3: "W"}, "images": {0: "B", 2: "8H", 3: "8W"}}
-
- def get_input_profile(self, batch_size, image_height, image_width, static_batch, static_shape):
- latent_height, latent_width = self.check_dims(batch_size, image_height, image_width)
- (
- min_batch,
- max_batch,
- _,
- _,
- _,
- _,
- min_latent_height,
- max_latent_height,
- min_latent_width,
- max_latent_width,
- ) = self.get_minmax_dims(batch_size, image_height, image_width, static_batch, static_shape)
- return {
- "latent": [
- (min_batch, 4, min_latent_height, min_latent_width),
- (batch_size, 4, latent_height, latent_width),
- (max_batch, 4, max_latent_height, max_latent_width),
- ]
- }
-
- def get_shape_dict(self, batch_size, image_height, image_width):
- latent_height, latent_width = self.check_dims(batch_size, image_height, image_width)
- return {
- "latent": (batch_size, 4, latent_height, latent_width),
- "images": (batch_size, 3, image_height, image_width),
- }
-
- def get_sample_input(self, batch_size, image_height, image_width):
- latent_height, latent_width = self.check_dims(batch_size, image_height, image_width)
- return torch.randn(batch_size, 4, latent_height, latent_width, dtype=torch.float32, device=self.device)
-
-
-def make_VAE(model, device, max_batch_size, embedding_dim, inpaint=False):
- return VAE(model, device=device, max_batch_size=max_batch_size, embedding_dim=embedding_dim)
-
-
-class TorchVAEEncoder(torch.nn.Module):
- def __init__(self, model):
- super().__init__()
- self.vae_encoder = model
-
- def forward(self, x):
- return self.vae_encoder.encode(x).latent_dist.sample()
-
-
-class VAEEncoder(BaseModel):
- def __init__(self, model, device, max_batch_size, embedding_dim):
- super(VAEEncoder, self).__init__(
- model=model, device=device, max_batch_size=max_batch_size, embedding_dim=embedding_dim
- )
- self.name = "VAE encoder"
-
- def get_model(self):
- vae_encoder = TorchVAEEncoder(self.model)
- return vae_encoder
-
- def get_input_names(self):
- return ["images"]
-
- def get_output_names(self):
- return ["latent"]
-
- def get_dynamic_axes(self):
- return {"images": {0: "B", 2: "8H", 3: "8W"}, "latent": {0: "B", 2: "H", 3: "W"}}
-
- def get_input_profile(self, batch_size, image_height, image_width, static_batch, static_shape):
- assert batch_size >= self.min_batch and batch_size <= self.max_batch
- min_batch = batch_size if static_batch else self.min_batch
- max_batch = batch_size if static_batch else self.max_batch
- self.check_dims(batch_size, image_height, image_width)
- (
- min_batch,
- max_batch,
- min_image_height,
- max_image_height,
- min_image_width,
- max_image_width,
- _,
- _,
- _,
- _,
- ) = self.get_minmax_dims(batch_size, image_height, image_width, static_batch, static_shape)
-
- return {
- "images": [
- (min_batch, 3, min_image_height, min_image_width),
- (batch_size, 3, image_height, image_width),
- (max_batch, 3, max_image_height, max_image_width),
- ]
- }
-
- def get_shape_dict(self, batch_size, image_height, image_width):
- latent_height, latent_width = self.check_dims(batch_size, image_height, image_width)
- return {
- "images": (batch_size, 3, image_height, image_width),
- "latent": (batch_size, 4, latent_height, latent_width),
- }
-
- def get_sample_input(self, batch_size, image_height, image_width):
- self.check_dims(batch_size, image_height, image_width)
- return torch.randn(batch_size, 3, image_height, image_width, dtype=torch.float32, device=self.device)
-
-
-def make_VAEEncoder(model, device, max_batch_size, embedding_dim, inpaint=False):
- return VAEEncoder(model, device=device, max_batch_size=max_batch_size, embedding_dim=embedding_dim)
-
-
-class TensorRTStableDiffusionImg2ImgPipeline(StableDiffusionImg2ImgPipeline):
- r"""
- Pipeline for image-to-image generation using TensorRT accelerated Stable Diffusion.
-
- This model inherits from [`StableDiffusionImg2ImgPipeline`]. Check the superclass documentation for the generic methods the
- library implements for all the pipelines (such as downloading or saving, running on a particular device, etc.)
-
- Args:
- vae ([`AutoencoderKL`]):
- Variational Auto-Encoder (VAE) Model to encode and decode images to and from latent representations.
- text_encoder ([`CLIPTextModel`]):
- Frozen text-encoder. Stable Diffusion uses the text portion of
- [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), specifically
- the [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14) variant.
- tokenizer (`CLIPTokenizer`):
- Tokenizer of class
- [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer).
- unet ([`UNet2DConditionModel`]): Conditional U-Net architecture to denoise the encoded image latents.
- scheduler ([`SchedulerMixin`]):
- A scheduler to be used in combination with `unet` to denoise the encoded image latents. Can be one of
- [`DDIMScheduler`], [`LMSDiscreteScheduler`], or [`PNDMScheduler`].
- safety_checker ([`StableDiffusionSafetyChecker`]):
- Classification module that estimates whether generated images could be considered offensive or harmful.
- Please, refer to the [model card](https://huggingface.co/runwayml/stable-diffusion-v1-5) for details.
- feature_extractor ([`CLIPFeatureExtractor`]):
- Model that extracts features from generated images to be used as inputs for the `safety_checker`.
- """
-
- def __init__(
- self,
- vae: AutoencoderKL,
- text_encoder: CLIPTextModel,
- tokenizer: CLIPTokenizer,
- unet: UNet2DConditionModel,
- scheduler: DDIMScheduler,
- safety_checker: StableDiffusionSafetyChecker,
- feature_extractor: CLIPFeatureExtractor,
- requires_safety_checker: bool = True,
- stages=["clip", "unet", "vae", "vae_encoder"],
- image_height: int = 512,
- image_width: int = 512,
- max_batch_size: int = 16,
- # ONNX export parameters
- onnx_opset: int = 17,
- onnx_dir: str = "onnx",
- # TensorRT engine build parameters
- engine_dir: str = "engine",
- build_preview_features: bool = True,
- force_engine_rebuild: bool = False,
- timing_cache: str = "timing_cache",
- ):
- super().__init__(
- vae, text_encoder, tokenizer, unet, scheduler, safety_checker, feature_extractor, requires_safety_checker
- )
-
- self.vae.forward = self.vae.decode
-
- self.stages = stages
- self.image_height, self.image_width = image_height, image_width
- self.inpaint = False
- self.onnx_opset = onnx_opset
- self.onnx_dir = onnx_dir
- self.engine_dir = engine_dir
- self.force_engine_rebuild = force_engine_rebuild
- self.timing_cache = timing_cache
- self.build_static_batch = False
- self.build_dynamic_shape = False
- self.build_preview_features = build_preview_features
-
- self.max_batch_size = max_batch_size
- # TODO: Restrict batch size to 4 for larger image dimensions as a WAR for TensorRT limitation.
- if self.build_dynamic_shape or self.image_height > 512 or self.image_width > 512:
- self.max_batch_size = 4
-
- self.stream = None # loaded in loadResources()
- self.models = {} # loaded in __loadModels()
- self.engine = {} # loaded in build_engines()
-
- def __loadModels(self):
- # Load pipeline models
- self.embedding_dim = self.text_encoder.config.hidden_size
- models_args = {
- "device": self.torch_device,
- "max_batch_size": self.max_batch_size,
- "embedding_dim": self.embedding_dim,
- "inpaint": self.inpaint,
- }
- if "clip" in self.stages:
- self.models["clip"] = make_CLIP(self.text_encoder, **models_args)
- if "unet" in self.stages:
- self.models["unet"] = make_UNet(self.unet, **models_args)
- if "vae" in self.stages:
- self.models["vae"] = make_VAE(self.vae, **models_args)
- if "vae_encoder" in self.stages:
- self.models["vae_encoder"] = make_VAEEncoder(self.vae, **models_args)
-
- @classmethod
- def set_cached_folder(cls, pretrained_model_name_or_path: Optional[Union[str, os.PathLike]], **kwargs):
- cache_dir = kwargs.pop("cache_dir", DIFFUSERS_CACHE)
- resume_download = kwargs.pop("resume_download", False)
- proxies = kwargs.pop("proxies", None)
- local_files_only = kwargs.pop("local_files_only", False)
- use_auth_token = kwargs.pop("use_auth_token", None)
- revision = kwargs.pop("revision", None)
-
- cls.cached_folder = (
- pretrained_model_name_or_path
- if os.path.isdir(pretrained_model_name_or_path)
- else snapshot_download(
- pretrained_model_name_or_path,
- cache_dir=cache_dir,
- resume_download=resume_download,
- proxies=proxies,
- local_files_only=local_files_only,
- use_auth_token=use_auth_token,
- revision=revision,
- )
- )
-
- def to(self, torch_device: Optional[Union[str, torch.device]] = None, silence_dtype_warnings: bool = False):
- super().to(torch_device, silence_dtype_warnings=silence_dtype_warnings)
-
- self.onnx_dir = os.path.join(self.cached_folder, self.onnx_dir)
- self.engine_dir = os.path.join(self.cached_folder, self.engine_dir)
- self.timing_cache = os.path.join(self.cached_folder, self.timing_cache)
-
- # set device
- self.torch_device = self._execution_device
- logger.warning(f"Running inference on device: {self.torch_device}")
-
- # load models
- self.__loadModels()
-
- # build engines
- self.engine = build_engines(
- self.models,
- self.engine_dir,
- self.onnx_dir,
- self.onnx_opset,
- opt_image_height=self.image_height,
- opt_image_width=self.image_width,
- force_engine_rebuild=self.force_engine_rebuild,
- static_batch=self.build_static_batch,
- static_shape=not self.build_dynamic_shape,
- enable_preview=self.build_preview_features,
- timing_cache=self.timing_cache,
- )
-
- return self
-
- def __initialize_timesteps(self, timesteps, strength):
- self.scheduler.set_timesteps(timesteps)
- offset = self.scheduler.steps_offset if hasattr(self.scheduler, "steps_offset") else 0
- init_timestep = int(timesteps * strength) + offset
- init_timestep = min(init_timestep, timesteps)
- t_start = max(timesteps - init_timestep + offset, 0)
- timesteps = self.scheduler.timesteps[t_start:].to(self.torch_device)
- return timesteps, t_start
-
- def __preprocess_images(self, batch_size, images=()):
- init_images = []
- for image in images:
- image = image.to(self.torch_device).float()
- image = image.repeat(batch_size, 1, 1, 1)
- init_images.append(image)
- return tuple(init_images)
-
- def __encode_image(self, init_image):
- init_latents = runEngine(self.engine["vae_encoder"], {"images": device_view(init_image)}, self.stream)[
- "latent"
- ]
- init_latents = 0.18215 * init_latents
- return init_latents
-
- def __encode_prompt(self, prompt, negative_prompt):
- r"""
- Encodes the prompt into text encoder hidden states.
-
- Args:
- prompt (`str` or `List[str]`, *optional*):
- prompt to be encoded
- negative_prompt (`str` or `List[str]`, *optional*):
- The prompt or prompts not to guide the image generation. If not defined, one has to pass
- `negative_prompt_embeds`. instead. If not defined, one has to pass `negative_prompt_embeds`. instead.
- Ignored when not using guidance (i.e., ignored if `guidance_scale` is less than `1`).
- """
- # Tokenize prompt
- text_input_ids = (
- self.tokenizer(
- prompt,
- padding="max_length",
- max_length=self.tokenizer.model_max_length,
- truncation=True,
- return_tensors="pt",
- )
- .input_ids.type(torch.int32)
- .to(self.torch_device)
- )
-
- text_input_ids_inp = device_view(text_input_ids)
- # NOTE: output tensor for CLIP must be cloned because it will be overwritten when called again for negative prompt
- text_embeddings = runEngine(self.engine["clip"], {"input_ids": text_input_ids_inp}, self.stream)[
- "text_embeddings"
- ].clone()
-
- # Tokenize negative prompt
- uncond_input_ids = (
- self.tokenizer(
- negative_prompt,
- padding="max_length",
- max_length=self.tokenizer.model_max_length,
- truncation=True,
- return_tensors="pt",
- )
- .input_ids.type(torch.int32)
- .to(self.torch_device)
- )
- uncond_input_ids_inp = device_view(uncond_input_ids)
- uncond_embeddings = runEngine(self.engine["clip"], {"input_ids": uncond_input_ids_inp}, self.stream)[
- "text_embeddings"
- ]
-
- # Concatenate the unconditional and text embeddings into a single batch to avoid doing two forward passes for classifier free guidance
- text_embeddings = torch.cat([uncond_embeddings, text_embeddings]).to(dtype=torch.float16)
-
- return text_embeddings
-
- def __denoise_latent(
- self, latents, text_embeddings, timesteps=None, step_offset=0, mask=None, masked_image_latents=None
- ):
- if not isinstance(timesteps, torch.Tensor):
- timesteps = self.scheduler.timesteps
- for step_index, timestep in enumerate(timesteps):
- # Expand the latents if we are doing classifier free guidance
- latent_model_input = torch.cat([latents] * 2)
- latent_model_input = self.scheduler.scale_model_input(latent_model_input, timestep)
- if isinstance(mask, torch.Tensor):
- latent_model_input = torch.cat([latent_model_input, mask, masked_image_latents], dim=1)
-
- # Predict the noise residual
- timestep_float = timestep.float() if timestep.dtype != torch.float32 else timestep
-
- sample_inp = device_view(latent_model_input)
- timestep_inp = device_view(timestep_float)
- embeddings_inp = device_view(text_embeddings)
- noise_pred = runEngine(
- self.engine["unet"],
- {"sample": sample_inp, "timestep": timestep_inp, "encoder_hidden_states": embeddings_inp},
- self.stream,
- )["latent"]
-
- # Perform guidance
- noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
- noise_pred = noise_pred_uncond + self.guidance_scale * (noise_pred_text - noise_pred_uncond)
-
- latents = self.scheduler.step(noise_pred, timestep, latents).prev_sample
-
- latents = 1.0 / 0.18215 * latents
- return latents
-
- def __decode_latent(self, latents):
- images = runEngine(self.engine["vae"], {"latent": device_view(latents)}, self.stream)["images"]
- images = (images / 2 + 0.5).clamp(0, 1)
- return images.cpu().permute(0, 2, 3, 1).float().numpy()
-
- def __loadResources(self, image_height, image_width, batch_size):
- self.stream = cuda.Stream()
-
- # Allocate buffers for TensorRT engine bindings
- for model_name, obj in self.models.items():
- self.engine[model_name].allocate_buffers(
- shape_dict=obj.get_shape_dict(batch_size, image_height, image_width), device=self.torch_device
- )
-
- @torch.no_grad()
- def __call__(
- self,
- prompt: Union[str, List[str]] = None,
- image: Union[torch.FloatTensor, PIL.Image.Image] = None,
- strength: float = 0.8,
- num_inference_steps: int = 50,
- guidance_scale: float = 7.5,
- negative_prompt: Optional[Union[str, List[str]]] = None,
- generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
- ):
- r"""
- Function invoked when calling the pipeline for generation.
-
- Args:
- prompt (`str` or `List[str]`, *optional*):
- The prompt or prompts to guide the image generation. If not defined, one has to pass `prompt_embeds`.
- instead.
- image (`PIL.Image.Image`):
- `Image`, or tensor representing an image batch which will be inpainted, *i.e.* parts of the image will
- be masked out with `mask_image` and repainted according to `prompt`.
- strength (`float`, *optional*, defaults to 0.8):
- Conceptually, indicates how much to transform the reference `image`. Must be between 0 and 1. `image`
- will be used as a starting point, adding more noise to it the larger the `strength`. The number of
- denoising steps depends on the amount of noise initially added. When `strength` is 1, added noise will
- be maximum and the denoising process will run for the full number of iterations specified in
- `num_inference_steps`. A value of 1, therefore, essentially ignores `image`.
- num_inference_steps (`int`, *optional*, defaults to 50):
- The number of denoising steps. More denoising steps usually lead to a higher quality image at the
- expense of slower inference.
- guidance_scale (`float`, *optional*, defaults to 7.5):
- Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598).
- `guidance_scale` is defined as `w` of equation 2. of [Imagen
- Paper](https://arxiv.org/pdf/2205.11487.pdf). Guidance scale is enabled by setting `guidance_scale >
- 1`. Higher guidance scale encourages to generate images that are closely linked to the text `prompt`,
- usually at the expense of lower image quality.
- negative_prompt (`str` or `List[str]`, *optional*):
- The prompt or prompts not to guide the image generation. If not defined, one has to pass
- `negative_prompt_embeds`. instead. If not defined, one has to pass `negative_prompt_embeds`. instead.
- Ignored when not using guidance (i.e., ignored if `guidance_scale` is less than `1`).
- generator (`torch.Generator` or `List[torch.Generator]`, *optional*):
- One or a list of [torch generator(s)](https://pytorch.org/docs/stable/generated/torch.Generator.html)
- to make generation deterministic.
-
- """
- self.generator = generator
- self.denoising_steps = num_inference_steps
- self.guidance_scale = guidance_scale
-
- # Pre-compute latent input scales and linear multistep coefficients
- self.scheduler.set_timesteps(self.denoising_steps, device=self.torch_device)
-
- # Define call parameters
- if prompt is not None and isinstance(prompt, str):
- batch_size = 1
- prompt = [prompt]
- elif prompt is not None and isinstance(prompt, list):
- batch_size = len(prompt)
- else:
- raise ValueError(f"Expected prompt to be of type list or str but got {type(prompt)}")
-
- if negative_prompt is None:
- negative_prompt = [""] * batch_size
-
- if negative_prompt is not None and isinstance(negative_prompt, str):
- negative_prompt = [negative_prompt]
-
- assert len(prompt) == len(negative_prompt)
-
- if batch_size > self.max_batch_size:
- raise ValueError(
- f"Batch size {len(prompt)} is larger than allowed {self.max_batch_size}. If dynamic shape is used, then maximum batch size is 4"
- )
-
- # load resources
- self.__loadResources(self.image_height, self.image_width, batch_size)
-
- with torch.inference_mode(), torch.autocast("cuda"), trt.Runtime(TRT_LOGGER):
- # Initialize timesteps
- timesteps, t_start = self.__initialize_timesteps(self.denoising_steps, strength)
- latent_timestep = timesteps[:1].repeat(batch_size)
-
- # Pre-process input image
- if isinstance(image, PIL.Image.Image):
- image = preprocess_image(image)
- init_image = self.__preprocess_images(batch_size, (image,))[0]
-
- # VAE encode init image
- init_latents = self.__encode_image(init_image)
-
- # Add noise to latents using timesteps
- noise = torch.randn(
- init_latents.shape, generator=self.generator, device=self.torch_device, dtype=torch.float32
- )
- latents = self.scheduler.add_noise(init_latents, noise, latent_timestep)
-
- # CLIP text encoder
- text_embeddings = self.__encode_prompt(prompt, negative_prompt)
-
- # UNet denoiser
- latents = self.__denoise_latent(latents, text_embeddings, timesteps=timesteps, step_offset=t_start)
-
- # VAE decode latent
- images = self.__decode_latent(latents)
-
- images = self.numpy_to_pil(images)
- return StableDiffusionPipelineOutput(images=images, nsfw_content_detected=None)
diff --git a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/scripts/convert_models_diffuser_to_diffusers.py b/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/scripts/convert_models_diffuser_to_diffusers.py
deleted file mode 100644
index cc5321e33fe088c652f6014c6dab813bb8d5f246..0000000000000000000000000000000000000000
--- a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/scripts/convert_models_diffuser_to_diffusers.py
+++ /dev/null
@@ -1,100 +0,0 @@
-import json
-import os
-
-import torch
-
-from diffusers import UNet1DModel
-
-
-os.makedirs("hub/hopper-medium-v2/unet/hor32", exist_ok=True)
-os.makedirs("hub/hopper-medium-v2/unet/hor128", exist_ok=True)
-
-os.makedirs("hub/hopper-medium-v2/value_function", exist_ok=True)
-
-
-def unet(hor):
- if hor == 128:
- down_block_types = ("DownResnetBlock1D", "DownResnetBlock1D", "DownResnetBlock1D")
- block_out_channels = (32, 128, 256)
- up_block_types = ("UpResnetBlock1D", "UpResnetBlock1D")
-
- elif hor == 32:
- down_block_types = ("DownResnetBlock1D", "DownResnetBlock1D", "DownResnetBlock1D", "DownResnetBlock1D")
- block_out_channels = (32, 64, 128, 256)
- up_block_types = ("UpResnetBlock1D", "UpResnetBlock1D", "UpResnetBlock1D")
- model = torch.load(f"/Users/bglickenhaus/Documents/diffuser/temporal_unet-hopper-mediumv2-hor{hor}.torch")
- state_dict = model.state_dict()
- config = {
- "down_block_types": down_block_types,
- "block_out_channels": block_out_channels,
- "up_block_types": up_block_types,
- "layers_per_block": 1,
- "use_timestep_embedding": True,
- "out_block_type": "OutConv1DBlock",
- "norm_num_groups": 8,
- "downsample_each_block": False,
- "in_channels": 14,
- "out_channels": 14,
- "extra_in_channels": 0,
- "time_embedding_type": "positional",
- "flip_sin_to_cos": False,
- "freq_shift": 1,
- "sample_size": 65536,
- "mid_block_type": "MidResTemporalBlock1D",
- "act_fn": "mish",
- }
- hf_value_function = UNet1DModel(**config)
- print(f"length of state dict: {len(state_dict.keys())}")
- print(f"length of value function dict: {len(hf_value_function.state_dict().keys())}")
- mapping = dict(zip(model.state_dict().keys(), hf_value_function.state_dict().keys()))
- for k, v in mapping.items():
- state_dict[v] = state_dict.pop(k)
- hf_value_function.load_state_dict(state_dict)
-
- torch.save(hf_value_function.state_dict(), f"hub/hopper-medium-v2/unet/hor{hor}/diffusion_pytorch_model.bin")
- with open(f"hub/hopper-medium-v2/unet/hor{hor}/config.json", "w") as f:
- json.dump(config, f)
-
-
-def value_function():
- config = {
- "in_channels": 14,
- "down_block_types": ("DownResnetBlock1D", "DownResnetBlock1D", "DownResnetBlock1D", "DownResnetBlock1D"),
- "up_block_types": (),
- "out_block_type": "ValueFunction",
- "mid_block_type": "ValueFunctionMidBlock1D",
- "block_out_channels": (32, 64, 128, 256),
- "layers_per_block": 1,
- "downsample_each_block": True,
- "sample_size": 65536,
- "out_channels": 14,
- "extra_in_channels": 0,
- "time_embedding_type": "positional",
- "use_timestep_embedding": True,
- "flip_sin_to_cos": False,
- "freq_shift": 1,
- "norm_num_groups": 8,
- "act_fn": "mish",
- }
-
- model = torch.load("/Users/bglickenhaus/Documents/diffuser/value_function-hopper-mediumv2-hor32.torch")
- state_dict = model
- hf_value_function = UNet1DModel(**config)
- print(f"length of state dict: {len(state_dict.keys())}")
- print(f"length of value function dict: {len(hf_value_function.state_dict().keys())}")
-
- mapping = dict(zip(state_dict.keys(), hf_value_function.state_dict().keys()))
- for k, v in mapping.items():
- state_dict[v] = state_dict.pop(k)
-
- hf_value_function.load_state_dict(state_dict)
-
- torch.save(hf_value_function.state_dict(), "hub/hopper-medium-v2/value_function/diffusion_pytorch_model.bin")
- with open("hub/hopper-medium-v2/value_function/config.json", "w") as f:
- json.dump(config, f)
-
-
-if __name__ == "__main__":
- unet(32)
- # unet(128)
- value_function()
diff --git a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/__init__.py b/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/__init__.py
deleted file mode 100644
index c860b95f609c5c94d327df5d5f6541b87cd44488..0000000000000000000000000000000000000000
--- a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/__init__.py
+++ /dev/null
@@ -1,291 +0,0 @@
-__version__ = "0.19.3"
-
-from .configuration_utils import ConfigMixin
-from .utils import (
- OptionalDependencyNotAvailable,
- is_flax_available,
- is_inflect_available,
- is_invisible_watermark_available,
- is_k_diffusion_available,
- is_k_diffusion_version,
- is_librosa_available,
- is_note_seq_available,
- is_onnx_available,
- is_scipy_available,
- is_torch_available,
- is_torchsde_available,
- is_transformers_available,
- is_transformers_version,
- is_unidecode_available,
- logging,
-)
-
-
-try:
- if not is_onnx_available():
- raise OptionalDependencyNotAvailable()
-except OptionalDependencyNotAvailable:
- from .utils.dummy_onnx_objects import * # noqa F403
-else:
- from .pipelines import OnnxRuntimeModel
-
-try:
- if not is_torch_available():
- raise OptionalDependencyNotAvailable()
-except OptionalDependencyNotAvailable:
- from .utils.dummy_pt_objects import * # noqa F403
-else:
- from .models import (
- AsymmetricAutoencoderKL,
- AutoencoderKL,
- ControlNetModel,
- ModelMixin,
- MultiAdapter,
- PriorTransformer,
- T2IAdapter,
- T5FilmDecoder,
- Transformer2DModel,
- UNet1DModel,
- UNet2DConditionModel,
- UNet2DModel,
- UNet3DConditionModel,
- VQModel,
- )
- from .optimization import (
- get_constant_schedule,
- get_constant_schedule_with_warmup,
- get_cosine_schedule_with_warmup,
- get_cosine_with_hard_restarts_schedule_with_warmup,
- get_linear_schedule_with_warmup,
- get_polynomial_decay_schedule_with_warmup,
- get_scheduler,
- )
- from .pipelines import (
- AudioPipelineOutput,
- AutoPipelineForImage2Image,
- AutoPipelineForInpainting,
- AutoPipelineForText2Image,
- ConsistencyModelPipeline,
- DanceDiffusionPipeline,
- DDIMPipeline,
- DDPMPipeline,
- DiffusionPipeline,
- DiTPipeline,
- ImagePipelineOutput,
- KarrasVePipeline,
- LDMPipeline,
- LDMSuperResolutionPipeline,
- PNDMPipeline,
- RePaintPipeline,
- ScoreSdeVePipeline,
- )
- from .schedulers import (
- CMStochasticIterativeScheduler,
- DDIMInverseScheduler,
- DDIMParallelScheduler,
- DDIMScheduler,
- DDPMParallelScheduler,
- DDPMScheduler,
- DEISMultistepScheduler,
- DPMSolverMultistepInverseScheduler,
- DPMSolverMultistepScheduler,
- DPMSolverSinglestepScheduler,
- EulerAncestralDiscreteScheduler,
- EulerDiscreteScheduler,
- HeunDiscreteScheduler,
- IPNDMScheduler,
- KarrasVeScheduler,
- KDPM2AncestralDiscreteScheduler,
- KDPM2DiscreteScheduler,
- PNDMScheduler,
- RePaintScheduler,
- SchedulerMixin,
- ScoreSdeVeScheduler,
- UnCLIPScheduler,
- UniPCMultistepScheduler,
- VQDiffusionScheduler,
- )
- from .training_utils import EMAModel
-
-try:
- if not (is_torch_available() and is_scipy_available()):
- raise OptionalDependencyNotAvailable()
-except OptionalDependencyNotAvailable:
- from .utils.dummy_torch_and_scipy_objects import * # noqa F403
-else:
- from .schedulers import LMSDiscreteScheduler
-
-try:
- if not (is_torch_available() and is_torchsde_available()):
- raise OptionalDependencyNotAvailable()
-except OptionalDependencyNotAvailable:
- from .utils.dummy_torch_and_torchsde_objects import * # noqa F403
-else:
- from .schedulers import DPMSolverSDEScheduler
-
-try:
- if not (is_torch_available() and is_transformers_available()):
- raise OptionalDependencyNotAvailable()
-except OptionalDependencyNotAvailable:
- from .utils.dummy_torch_and_transformers_objects import * # noqa F403
-else:
- from .pipelines import (
- AltDiffusionImg2ImgPipeline,
- AltDiffusionPipeline,
- AudioLDMPipeline,
- CycleDiffusionPipeline,
- IFImg2ImgPipeline,
- IFImg2ImgSuperResolutionPipeline,
- IFInpaintingPipeline,
- IFInpaintingSuperResolutionPipeline,
- IFPipeline,
- IFSuperResolutionPipeline,
- ImageTextPipelineOutput,
- KandinskyCombinedPipeline,
- KandinskyImg2ImgCombinedPipeline,
- KandinskyImg2ImgPipeline,
- KandinskyInpaintCombinedPipeline,
- KandinskyInpaintPipeline,
- KandinskyPipeline,
- KandinskyPriorPipeline,
- KandinskyV22CombinedPipeline,
- KandinskyV22ControlnetImg2ImgPipeline,
- KandinskyV22ControlnetPipeline,
- KandinskyV22Img2ImgCombinedPipeline,
- KandinskyV22Img2ImgPipeline,
- KandinskyV22InpaintCombinedPipeline,
- KandinskyV22InpaintPipeline,
- KandinskyV22Pipeline,
- KandinskyV22PriorEmb2EmbPipeline,
- KandinskyV22PriorPipeline,
- LDMTextToImagePipeline,
- PaintByExamplePipeline,
- SemanticStableDiffusionPipeline,
- ShapEImg2ImgPipeline,
- ShapEPipeline,
- StableDiffusionAdapterPipeline,
- StableDiffusionAttendAndExcitePipeline,
- StableDiffusionControlNetImg2ImgPipeline,
- StableDiffusionControlNetInpaintPipeline,
- StableDiffusionControlNetPipeline,
- StableDiffusionDepth2ImgPipeline,
- StableDiffusionDiffEditPipeline,
- StableDiffusionImageVariationPipeline,
- StableDiffusionImg2ImgPipeline,
- StableDiffusionInpaintPipeline,
- StableDiffusionInpaintPipelineLegacy,
- StableDiffusionInstructPix2PixPipeline,
- StableDiffusionLatentUpscalePipeline,
- StableDiffusionLDM3DPipeline,
- StableDiffusionModelEditingPipeline,
- StableDiffusionPanoramaPipeline,
- StableDiffusionParadigmsPipeline,
- StableDiffusionPipeline,
- StableDiffusionPipelineSafe,
- StableDiffusionPix2PixZeroPipeline,
- StableDiffusionSAGPipeline,
- StableDiffusionUpscalePipeline,
- StableDiffusionXLControlNetPipeline,
- StableDiffusionXLImg2ImgPipeline,
- StableDiffusionXLInpaintPipeline,
- StableDiffusionXLInstructPix2PixPipeline,
- StableDiffusionXLPipeline,
- StableUnCLIPImg2ImgPipeline,
- StableUnCLIPPipeline,
- TextToVideoSDPipeline,
- TextToVideoZeroPipeline,
- UnCLIPImageVariationPipeline,
- UnCLIPPipeline,
- UniDiffuserModel,
- UniDiffuserPipeline,
- UniDiffuserTextDecoder,
- VersatileDiffusionDualGuidedPipeline,
- VersatileDiffusionImageVariationPipeline,
- VersatileDiffusionPipeline,
- VersatileDiffusionTextToImagePipeline,
- VideoToVideoSDPipeline,
- VQDiffusionPipeline,
- )
-
-try:
- if not (is_torch_available() and is_transformers_available() and is_k_diffusion_available()):
- raise OptionalDependencyNotAvailable()
-except OptionalDependencyNotAvailable:
- from .utils.dummy_torch_and_transformers_and_k_diffusion_objects import * # noqa F403
-else:
- from .pipelines import StableDiffusionKDiffusionPipeline
-
-try:
- if not (is_torch_available() and is_transformers_available() and is_onnx_available()):
- raise OptionalDependencyNotAvailable()
-except OptionalDependencyNotAvailable:
- from .utils.dummy_torch_and_transformers_and_onnx_objects import * # noqa F403
-else:
- from .pipelines import (
- OnnxStableDiffusionImg2ImgPipeline,
- OnnxStableDiffusionInpaintPipeline,
- OnnxStableDiffusionInpaintPipelineLegacy,
- OnnxStableDiffusionPipeline,
- OnnxStableDiffusionUpscalePipeline,
- StableDiffusionOnnxPipeline,
- )
-
-try:
- if not (is_torch_available() and is_librosa_available()):
- raise OptionalDependencyNotAvailable()
-except OptionalDependencyNotAvailable:
- from .utils.dummy_torch_and_librosa_objects import * # noqa F403
-else:
- from .pipelines import AudioDiffusionPipeline, Mel
-
-try:
- if not (is_transformers_available() and is_torch_available() and is_note_seq_available()):
- raise OptionalDependencyNotAvailable()
-except OptionalDependencyNotAvailable:
- from .utils.dummy_transformers_and_torch_and_note_seq_objects import * # noqa F403
-else:
- from .pipelines import SpectrogramDiffusionPipeline
-
-try:
- if not is_flax_available():
- raise OptionalDependencyNotAvailable()
-except OptionalDependencyNotAvailable:
- from .utils.dummy_flax_objects import * # noqa F403
-else:
- from .models.controlnet_flax import FlaxControlNetModel
- from .models.modeling_flax_utils import FlaxModelMixin
- from .models.unet_2d_condition_flax import FlaxUNet2DConditionModel
- from .models.vae_flax import FlaxAutoencoderKL
- from .pipelines import FlaxDiffusionPipeline
- from .schedulers import (
- FlaxDDIMScheduler,
- FlaxDDPMScheduler,
- FlaxDPMSolverMultistepScheduler,
- FlaxKarrasVeScheduler,
- FlaxLMSDiscreteScheduler,
- FlaxPNDMScheduler,
- FlaxSchedulerMixin,
- FlaxScoreSdeVeScheduler,
- )
-
-
-try:
- if not (is_flax_available() and is_transformers_available()):
- raise OptionalDependencyNotAvailable()
-except OptionalDependencyNotAvailable:
- from .utils.dummy_flax_and_transformers_objects import * # noqa F403
-else:
- from .pipelines import (
- FlaxStableDiffusionControlNetPipeline,
- FlaxStableDiffusionImg2ImgPipeline,
- FlaxStableDiffusionInpaintPipeline,
- FlaxStableDiffusionPipeline,
- )
-
-try:
- if not (is_note_seq_available()):
- raise OptionalDependencyNotAvailable()
-except OptionalDependencyNotAvailable:
- from .utils.dummy_note_seq_objects import * # noqa F403
-else:
- from .pipelines import MidiProcessor
diff --git a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/pipelines/kandinsky2_2/pipeline_kandinsky2_2_controlnet_img2img.py b/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/pipelines/kandinsky2_2/pipeline_kandinsky2_2_controlnet_img2img.py
deleted file mode 100644
index 53918fede7c2d4e9aaec8c7549630811c21e5bb7..0000000000000000000000000000000000000000
--- a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/pipelines/kandinsky2_2/pipeline_kandinsky2_2_controlnet_img2img.py
+++ /dev/null
@@ -1,409 +0,0 @@
-# Copyright 2023 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from typing import Callable, List, Optional, Union
-
-import numpy as np
-import PIL
-import torch
-from PIL import Image
-
-from ...models import UNet2DConditionModel, VQModel
-from ...schedulers import DDPMScheduler
-from ...utils import (
- is_accelerate_available,
- is_accelerate_version,
- logging,
- randn_tensor,
- replace_example_docstring,
-)
-from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput
-
-
-logger = logging.get_logger(__name__) # pylint: disable=invalid-name
-
-EXAMPLE_DOC_STRING = """
- Examples:
- ```py
- >>> import torch
- >>> import numpy as np
-
- >>> from diffusers import KandinskyV22PriorEmb2EmbPipeline, KandinskyV22ControlnetImg2ImgPipeline
- >>> from transformers import pipeline
- >>> from diffusers.utils import load_image
-
-
- >>> def make_hint(image, depth_estimator):
- ... image = depth_estimator(image)["depth"]
- ... image = np.array(image)
- ... image = image[:, :, None]
- ... image = np.concatenate([image, image, image], axis=2)
- ... detected_map = torch.from_numpy(image).float() / 255.0
- ... hint = detected_map.permute(2, 0, 1)
- ... return hint
-
-
- >>> depth_estimator = pipeline("depth-estimation")
-
- >>> pipe_prior = KandinskyV22PriorEmb2EmbPipeline.from_pretrained(
- ... "kandinsky-community/kandinsky-2-2-prior", torch_dtype=torch.float16
- ... )
- >>> pipe_prior = pipe_prior.to("cuda")
-
- >>> pipe = KandinskyV22ControlnetImg2ImgPipeline.from_pretrained(
- ... "kandinsky-community/kandinsky-2-2-controlnet-depth", torch_dtype=torch.float16
- ... )
- >>> pipe = pipe.to("cuda")
-
- >>> img = load_image(
- ... "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
- ... "/kandinsky/cat.png"
- ... ).resize((768, 768))
-
-
- >>> hint = make_hint(img, depth_estimator).unsqueeze(0).half().to("cuda")
-
- >>> prompt = "A robot, 4k photo"
- >>> negative_prior_prompt = "lowres, text, error, cropped, worst quality, low quality, jpeg artifacts, ugly, duplicate, morbid, mutilated, out of frame, extra fingers, mutated hands, poorly drawn hands, poorly drawn face, mutation, deformed, blurry, dehydrated, bad anatomy, bad proportions, extra limbs, cloned face, disfigured, gross proportions, malformed limbs, missing arms, missing legs, extra arms, extra legs, fused fingers, too many fingers, long neck, username, watermark, signature"
-
- >>> generator = torch.Generator(device="cuda").manual_seed(43)
-
- >>> img_emb = pipe_prior(prompt=prompt, image=img, strength=0.85, generator=generator)
- >>> negative_emb = pipe_prior(prompt=negative_prior_prompt, image=img, strength=1, generator=generator)
-
- >>> images = pipe(
- ... image=img,
- ... strength=0.5,
- ... image_embeds=img_emb.image_embeds,
- ... negative_image_embeds=negative_emb.image_embeds,
- ... hint=hint,
- ... num_inference_steps=50,
- ... generator=generator,
- ... height=768,
- ... width=768,
- ... ).images
-
- >>> images[0].save("robot_cat.png")
- ```
-"""
-
-
-# Copied from diffusers.pipelines.kandinsky2_2.pipeline_kandinsky2_2.downscale_height_and_width
-def downscale_height_and_width(height, width, scale_factor=8):
- new_height = height // scale_factor**2
- if height % scale_factor**2 != 0:
- new_height += 1
- new_width = width // scale_factor**2
- if width % scale_factor**2 != 0:
- new_width += 1
- return new_height * scale_factor, new_width * scale_factor
-
-
-# Copied from diffusers.pipelines.kandinsky.pipeline_kandinsky_img2img.prepare_image
-def prepare_image(pil_image, w=512, h=512):
- pil_image = pil_image.resize((w, h), resample=Image.BICUBIC, reducing_gap=1)
- arr = np.array(pil_image.convert("RGB"))
- arr = arr.astype(np.float32) / 127.5 - 1
- arr = np.transpose(arr, [2, 0, 1])
- image = torch.from_numpy(arr).unsqueeze(0)
- return image
-
-
-class KandinskyV22ControlnetImg2ImgPipeline(DiffusionPipeline):
- """
- Pipeline for image-to-image generation using Kandinsky
-
- This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods the
- library implements for all the pipelines (such as downloading or saving, running on a particular device, etc.)
-
- Args:
- scheduler ([`DDIMScheduler`]):
- A scheduler to be used in combination with `unet` to generate image latents.
- unet ([`UNet2DConditionModel`]):
- Conditional U-Net architecture to denoise the image embedding.
- movq ([`VQModel`]):
- MoVQ Decoder to generate the image from the latents.
- """
-
- def __init__(
- self,
- unet: UNet2DConditionModel,
- scheduler: DDPMScheduler,
- movq: VQModel,
- ):
- super().__init__()
-
- self.register_modules(
- unet=unet,
- scheduler=scheduler,
- movq=movq,
- )
- self.movq_scale_factor = 2 ** (len(self.movq.config.block_out_channels) - 1)
-
- # Copied from diffusers.pipelines.kandinsky.pipeline_kandinsky_img2img.KandinskyImg2ImgPipeline.get_timesteps
- def get_timesteps(self, num_inference_steps, strength, device):
- # get the original timestep using init_timestep
- init_timestep = min(int(num_inference_steps * strength), num_inference_steps)
-
- t_start = max(num_inference_steps - init_timestep, 0)
- timesteps = self.scheduler.timesteps[t_start:]
-
- return timesteps, num_inference_steps - t_start
-
- # Copied from diffusers.pipelines.kandinsky2_2.pipeline_kandinsky2_2_img2img.KandinskyV22Img2ImgPipeline.prepare_latents
- def prepare_latents(self, image, timestep, batch_size, num_images_per_prompt, dtype, device, generator=None):
- if not isinstance(image, (torch.Tensor, PIL.Image.Image, list)):
- raise ValueError(
- f"`image` has to be of type `torch.Tensor`, `PIL.Image.Image` or list but is {type(image)}"
- )
-
- image = image.to(device=device, dtype=dtype)
-
- batch_size = batch_size * num_images_per_prompt
-
- if image.shape[1] == 4:
- init_latents = image
-
- else:
- if isinstance(generator, list) and len(generator) != batch_size:
- raise ValueError(
- f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
- f" size of {batch_size}. Make sure the batch size matches the length of the generators."
- )
-
- elif isinstance(generator, list):
- init_latents = [
- self.movq.encode(image[i : i + 1]).latent_dist.sample(generator[i]) for i in range(batch_size)
- ]
- init_latents = torch.cat(init_latents, dim=0)
- else:
- init_latents = self.movq.encode(image).latent_dist.sample(generator)
-
- init_latents = self.movq.config.scaling_factor * init_latents
-
- init_latents = torch.cat([init_latents], dim=0)
-
- shape = init_latents.shape
- noise = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
-
- # get latents
- init_latents = self.scheduler.add_noise(init_latents, noise, timestep)
-
- latents = init_latents
-
- return latents
-
- # Copied from diffusers.pipelines.kandinsky2_2.pipeline_kandinsky2_2.KandinskyV22Pipeline.enable_model_cpu_offload
- def enable_model_cpu_offload(self, gpu_id=0):
- r"""
- Offloads all models to CPU using accelerate, reducing memory usage with a low impact on performance. Compared
- to `enable_sequential_cpu_offload`, this method moves one whole model at a time to the GPU when its `forward`
- method is called, and the model remains in GPU until the next model runs. Memory savings are lower than with
- `enable_sequential_cpu_offload`, but performance is much better due to the iterative execution of the `unet`.
- """
- if is_accelerate_available() and is_accelerate_version(">=", "0.17.0.dev0"):
- from accelerate import cpu_offload_with_hook
- else:
- raise ImportError("`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher.")
-
- device = torch.device(f"cuda:{gpu_id}")
-
- if self.device.type != "cpu":
- self.to("cpu", silence_dtype_warnings=True)
- torch.cuda.empty_cache() # otherwise we don't see the memory savings (but they probably exist)
-
- hook = None
- for cpu_offloaded_model in [self.unet, self.movq]:
- _, hook = cpu_offload_with_hook(cpu_offloaded_model, device, prev_module_hook=hook)
-
- # We'll offload the last model manually.
- self.final_offload_hook = hook
-
- @torch.no_grad()
- @replace_example_docstring(EXAMPLE_DOC_STRING)
- def __call__(
- self,
- image_embeds: Union[torch.FloatTensor, List[torch.FloatTensor]],
- image: Union[torch.FloatTensor, PIL.Image.Image, List[torch.FloatTensor], List[PIL.Image.Image]],
- negative_image_embeds: Union[torch.FloatTensor, List[torch.FloatTensor]],
- hint: torch.FloatTensor,
- height: int = 512,
- width: int = 512,
- num_inference_steps: int = 100,
- guidance_scale: float = 4.0,
- strength: float = 0.3,
- num_images_per_prompt: int = 1,
- generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
- output_type: Optional[str] = "pil",
- callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None,
- callback_steps: int = 1,
- return_dict: bool = True,
- ):
- """
- Function invoked when calling the pipeline for generation.
-
- Args:
- image_embeds (`torch.FloatTensor` or `List[torch.FloatTensor]`):
- The clip image embeddings for text prompt, that will be used to condition the image generation.
- image (`torch.FloatTensor`, `PIL.Image.Image`, `np.ndarray`, `List[torch.FloatTensor]`, `List[PIL.Image.Image]`, or `List[np.ndarray]`):
- `Image`, or tensor representing an image batch, that will be used as the starting point for the
- process. Can also accpet image latents as `image`, if passing latents directly, it will not be encoded
- again.
- strength (`float`, *optional*, defaults to 0.8):
- Conceptually, indicates how much to transform the reference `image`. Must be between 0 and 1. `image`
- will be used as a starting point, adding more noise to it the larger the `strength`. The number of
- denoising steps depends on the amount of noise initially added. When `strength` is 1, added noise will
- be maximum and the denoising process will run for the full number of iterations specified in
- `num_inference_steps`. A value of 1, therefore, essentially ignores `image`.
- hint (`torch.FloatTensor`):
- The controlnet condition.
- negative_image_embeds (`torch.FloatTensor` or `List[torch.FloatTensor]`):
- The clip image embeddings for negative text prompt, will be used to condition the image generation.
- height (`int`, *optional*, defaults to 512):
- The height in pixels of the generated image.
- width (`int`, *optional*, defaults to 512):
- The width in pixels of the generated image.
- num_inference_steps (`int`, *optional*, defaults to 100):
- The number of denoising steps. More denoising steps usually lead to a higher quality image at the
- expense of slower inference.
- guidance_scale (`float`, *optional*, defaults to 4.0):
- Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598).
- `guidance_scale` is defined as `w` of equation 2. of [Imagen
- Paper](https://arxiv.org/pdf/2205.11487.pdf). Guidance scale is enabled by setting `guidance_scale >
- 1`. Higher guidance scale encourages to generate images that are closely linked to the text `prompt`,
- usually at the expense of lower image quality.
- num_images_per_prompt (`int`, *optional*, defaults to 1):
- The number of images to generate per prompt.
- generator (`torch.Generator` or `List[torch.Generator]`, *optional*):
- One or a list of [torch generator(s)](https://pytorch.org/docs/stable/generated/torch.Generator.html)
- to make generation deterministic.
- output_type (`str`, *optional*, defaults to `"pil"`):
- The output format of the generate image. Choose between: `"pil"` (`PIL.Image.Image`), `"np"`
- (`np.array`) or `"pt"` (`torch.Tensor`).
- callback (`Callable`, *optional*):
- A function that calls every `callback_steps` steps during inference. The function is called with the
- following arguments: `callback(step: int, timestep: int, latents: torch.FloatTensor)`.
- callback_steps (`int`, *optional*, defaults to 1):
- The frequency at which the `callback` function is called. If not specified, the callback is called at
- every step.
- return_dict (`bool`, *optional*, defaults to `True`):
- Whether or not to return a [`~pipelines.ImagePipelineOutput`] instead of a plain tuple.
-
- Examples:
-
- Returns:
- [`~pipelines.ImagePipelineOutput`] or `tuple`
- """
- device = self._execution_device
-
- do_classifier_free_guidance = guidance_scale > 1.0
-
- if isinstance(image_embeds, list):
- image_embeds = torch.cat(image_embeds, dim=0)
- if isinstance(negative_image_embeds, list):
- negative_image_embeds = torch.cat(negative_image_embeds, dim=0)
- if isinstance(hint, list):
- hint = torch.cat(hint, dim=0)
-
- batch_size = image_embeds.shape[0]
-
- if do_classifier_free_guidance:
- image_embeds = image_embeds.repeat_interleave(num_images_per_prompt, dim=0)
- negative_image_embeds = negative_image_embeds.repeat_interleave(num_images_per_prompt, dim=0)
- hint = hint.repeat_interleave(num_images_per_prompt, dim=0)
-
- image_embeds = torch.cat([negative_image_embeds, image_embeds], dim=0).to(
- dtype=self.unet.dtype, device=device
- )
- hint = torch.cat([hint, hint], dim=0).to(dtype=self.unet.dtype, device=device)
-
- if not isinstance(image, list):
- image = [image]
- if not all(isinstance(i, (PIL.Image.Image, torch.Tensor)) for i in image):
- raise ValueError(
- f"Input is in incorrect format: {[type(i) for i in image]}. Currently, we only support PIL image and pytorch tensor"
- )
-
- image = torch.cat([prepare_image(i, width, height) for i in image], dim=0)
- image = image.to(dtype=image_embeds.dtype, device=device)
-
- latents = self.movq.encode(image)["latents"]
- latents = latents.repeat_interleave(num_images_per_prompt, dim=0)
- self.scheduler.set_timesteps(num_inference_steps, device=device)
- timesteps, num_inference_steps = self.get_timesteps(num_inference_steps, strength, device)
- latent_timestep = timesteps[:1].repeat(batch_size * num_images_per_prompt)
- height, width = downscale_height_and_width(height, width, self.movq_scale_factor)
- latents = self.prepare_latents(
- latents, latent_timestep, batch_size, num_images_per_prompt, image_embeds.dtype, device, generator
- )
- for i, t in enumerate(self.progress_bar(timesteps)):
- # expand the latents if we are doing classifier free guidance
- latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents
-
- added_cond_kwargs = {"image_embeds": image_embeds, "hint": hint}
- noise_pred = self.unet(
- sample=latent_model_input,
- timestep=t,
- encoder_hidden_states=None,
- added_cond_kwargs=added_cond_kwargs,
- return_dict=False,
- )[0]
-
- if do_classifier_free_guidance:
- noise_pred, variance_pred = noise_pred.split(latents.shape[1], dim=1)
- noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
- _, variance_pred_text = variance_pred.chunk(2)
- noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
- noise_pred = torch.cat([noise_pred, variance_pred_text], dim=1)
-
- if not (
- hasattr(self.scheduler.config, "variance_type")
- and self.scheduler.config.variance_type in ["learned", "learned_range"]
- ):
- noise_pred, _ = noise_pred.split(latents.shape[1], dim=1)
-
- # compute the previous noisy sample x_t -> x_t-1
-
- latents = self.scheduler.step(
- noise_pred,
- t,
- latents,
- generator=generator,
- )[0]
-
- if callback is not None and i % callback_steps == 0:
- callback(i, t, latents)
-
- # post-processing
- image = self.movq.decode(latents, force_not_quantize=True)["sample"]
-
- # Offload last model to CPU
- if hasattr(self, "final_offload_hook") and self.final_offload_hook is not None:
- self.final_offload_hook.offload()
-
- if output_type not in ["pt", "np", "pil"]:
- raise ValueError(f"Only the output types `pt`, `pil` and `np` are supported not output_type={output_type}")
-
- if output_type in ["np", "pil"]:
- image = image * 0.5 + 0.5
- image = image.clamp(0, 1)
- image = image.cpu().permute(0, 2, 3, 1).float().numpy()
-
- if output_type == "pil":
- image = self.numpy_to_pil(image)
-
- if not return_dict:
- return (image,)
-
- return ImagePipelineOutput(images=image)
diff --git a/spaces/Andy1621/uniformer_image_detection/configs/dcn/mask_rcnn_r50_fpn_mdconv_c3-c5_1x_coco.py b/spaces/Andy1621/uniformer_image_detection/configs/dcn/mask_rcnn_r50_fpn_mdconv_c3-c5_1x_coco.py
deleted file mode 100644
index 5ca2a67cde62bff078b7c4c0d696a585265e4c3a..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_detection/configs/dcn/mask_rcnn_r50_fpn_mdconv_c3-c5_1x_coco.py
+++ /dev/null
@@ -1,5 +0,0 @@
-_base_ = '../mask_rcnn/mask_rcnn_r50_fpn_1x_coco.py'
-model = dict(
- backbone=dict(
- dcn=dict(type='DCNv2', deform_groups=1, fallback_on_stride=False),
- stage_with_dcn=(False, True, True, True)))
diff --git a/spaces/Andy1621/uniformer_image_detection/mmdet/models/dense_heads/anchor_free_head.py b/spaces/Andy1621/uniformer_image_detection/mmdet/models/dense_heads/anchor_free_head.py
deleted file mode 100644
index 1814a0cc4f577f470f74f025440073a0aaa1ebd0..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_detection/mmdet/models/dense_heads/anchor_free_head.py
+++ /dev/null
@@ -1,340 +0,0 @@
-from abc import abstractmethod
-
-import torch
-import torch.nn as nn
-from mmcv.cnn import ConvModule, bias_init_with_prob, normal_init
-from mmcv.runner import force_fp32
-
-from mmdet.core import multi_apply
-from ..builder import HEADS, build_loss
-from .base_dense_head import BaseDenseHead
-from .dense_test_mixins import BBoxTestMixin
-
-
-@HEADS.register_module()
-class AnchorFreeHead(BaseDenseHead, BBoxTestMixin):
- """Anchor-free head (FCOS, Fovea, RepPoints, etc.).
-
- Args:
- num_classes (int): Number of categories excluding the background
- category.
- in_channels (int): Number of channels in the input feature map.
- feat_channels (int): Number of hidden channels. Used in child classes.
- stacked_convs (int): Number of stacking convs of the head.
- strides (tuple): Downsample factor of each feature map.
- dcn_on_last_conv (bool): If true, use dcn in the last layer of
- towers. Default: False.
- conv_bias (bool | str): If specified as `auto`, it will be decided by
- the norm_cfg. Bias of conv will be set as True if `norm_cfg` is
- None, otherwise False. Default: "auto".
- loss_cls (dict): Config of classification loss.
- loss_bbox (dict): Config of localization loss.
- conv_cfg (dict): Config dict for convolution layer. Default: None.
- norm_cfg (dict): Config dict for normalization layer. Default: None.
- train_cfg (dict): Training config of anchor head.
- test_cfg (dict): Testing config of anchor head.
- """ # noqa: W605
-
- _version = 1
-
- def __init__(self,
- num_classes,
- in_channels,
- feat_channels=256,
- stacked_convs=4,
- strides=(4, 8, 16, 32, 64),
- dcn_on_last_conv=False,
- conv_bias='auto',
- loss_cls=dict(
- type='FocalLoss',
- use_sigmoid=True,
- gamma=2.0,
- alpha=0.25,
- loss_weight=1.0),
- loss_bbox=dict(type='IoULoss', loss_weight=1.0),
- conv_cfg=None,
- norm_cfg=None,
- train_cfg=None,
- test_cfg=None):
- super(AnchorFreeHead, self).__init__()
- self.num_classes = num_classes
- self.cls_out_channels = num_classes
- self.in_channels = in_channels
- self.feat_channels = feat_channels
- self.stacked_convs = stacked_convs
- self.strides = strides
- self.dcn_on_last_conv = dcn_on_last_conv
- assert conv_bias == 'auto' or isinstance(conv_bias, bool)
- self.conv_bias = conv_bias
- self.loss_cls = build_loss(loss_cls)
- self.loss_bbox = build_loss(loss_bbox)
- self.train_cfg = train_cfg
- self.test_cfg = test_cfg
- self.conv_cfg = conv_cfg
- self.norm_cfg = norm_cfg
- self.fp16_enabled = False
-
- self._init_layers()
-
- def _init_layers(self):
- """Initialize layers of the head."""
- self._init_cls_convs()
- self._init_reg_convs()
- self._init_predictor()
-
- def _init_cls_convs(self):
- """Initialize classification conv layers of the head."""
- self.cls_convs = nn.ModuleList()
- for i in range(self.stacked_convs):
- chn = self.in_channels if i == 0 else self.feat_channels
- if self.dcn_on_last_conv and i == self.stacked_convs - 1:
- conv_cfg = dict(type='DCNv2')
- else:
- conv_cfg = self.conv_cfg
- self.cls_convs.append(
- ConvModule(
- chn,
- self.feat_channels,
- 3,
- stride=1,
- padding=1,
- conv_cfg=conv_cfg,
- norm_cfg=self.norm_cfg,
- bias=self.conv_bias))
-
- def _init_reg_convs(self):
- """Initialize bbox regression conv layers of the head."""
- self.reg_convs = nn.ModuleList()
- for i in range(self.stacked_convs):
- chn = self.in_channels if i == 0 else self.feat_channels
- if self.dcn_on_last_conv and i == self.stacked_convs - 1:
- conv_cfg = dict(type='DCNv2')
- else:
- conv_cfg = self.conv_cfg
- self.reg_convs.append(
- ConvModule(
- chn,
- self.feat_channels,
- 3,
- stride=1,
- padding=1,
- conv_cfg=conv_cfg,
- norm_cfg=self.norm_cfg,
- bias=self.conv_bias))
-
- def _init_predictor(self):
- """Initialize predictor layers of the head."""
- self.conv_cls = nn.Conv2d(
- self.feat_channels, self.cls_out_channels, 3, padding=1)
- self.conv_reg = nn.Conv2d(self.feat_channels, 4, 3, padding=1)
-
- def init_weights(self):
- """Initialize weights of the head."""
- for m in self.cls_convs:
- if isinstance(m.conv, nn.Conv2d):
- normal_init(m.conv, std=0.01)
- for m in self.reg_convs:
- if isinstance(m.conv, nn.Conv2d):
- normal_init(m.conv, std=0.01)
- bias_cls = bias_init_with_prob(0.01)
- normal_init(self.conv_cls, std=0.01, bias=bias_cls)
- normal_init(self.conv_reg, std=0.01)
-
- def _load_from_state_dict(self, state_dict, prefix, local_metadata, strict,
- missing_keys, unexpected_keys, error_msgs):
- """Hack some keys of the model state dict so that can load checkpoints
- of previous version."""
- version = local_metadata.get('version', None)
- if version is None:
- # the key is different in early versions
- # for example, 'fcos_cls' become 'conv_cls' now
- bbox_head_keys = [
- k for k in state_dict.keys() if k.startswith(prefix)
- ]
- ori_predictor_keys = []
- new_predictor_keys = []
- # e.g. 'fcos_cls' or 'fcos_reg'
- for key in bbox_head_keys:
- ori_predictor_keys.append(key)
- key = key.split('.')
- conv_name = None
- if key[1].endswith('cls'):
- conv_name = 'conv_cls'
- elif key[1].endswith('reg'):
- conv_name = 'conv_reg'
- elif key[1].endswith('centerness'):
- conv_name = 'conv_centerness'
- else:
- assert NotImplementedError
- if conv_name is not None:
- key[1] = conv_name
- new_predictor_keys.append('.'.join(key))
- else:
- ori_predictor_keys.pop(-1)
- for i in range(len(new_predictor_keys)):
- state_dict[new_predictor_keys[i]] = state_dict.pop(
- ori_predictor_keys[i])
- super()._load_from_state_dict(state_dict, prefix, local_metadata,
- strict, missing_keys, unexpected_keys,
- error_msgs)
-
- def forward(self, feats):
- """Forward features from the upstream network.
-
- Args:
- feats (tuple[Tensor]): Features from the upstream network, each is
- a 4D-tensor.
-
- Returns:
- tuple: Usually contain classification scores and bbox predictions.
- cls_scores (list[Tensor]): Box scores for each scale level,
- each is a 4D-tensor, the channel number is
- num_points * num_classes.
- bbox_preds (list[Tensor]): Box energies / deltas for each scale
- level, each is a 4D-tensor, the channel number is
- num_points * 4.
- """
- return multi_apply(self.forward_single, feats)[:2]
-
- def forward_single(self, x):
- """Forward features of a single scale level.
-
- Args:
- x (Tensor): FPN feature maps of the specified stride.
-
- Returns:
- tuple: Scores for each class, bbox predictions, features
- after classification and regression conv layers, some
- models needs these features like FCOS.
- """
- cls_feat = x
- reg_feat = x
-
- for cls_layer in self.cls_convs:
- cls_feat = cls_layer(cls_feat)
- cls_score = self.conv_cls(cls_feat)
-
- for reg_layer in self.reg_convs:
- reg_feat = reg_layer(reg_feat)
- bbox_pred = self.conv_reg(reg_feat)
- return cls_score, bbox_pred, cls_feat, reg_feat
-
- @abstractmethod
- @force_fp32(apply_to=('cls_scores', 'bbox_preds'))
- def loss(self,
- cls_scores,
- bbox_preds,
- gt_bboxes,
- gt_labels,
- img_metas,
- gt_bboxes_ignore=None):
- """Compute loss of the head.
-
- Args:
- cls_scores (list[Tensor]): Box scores for each scale level,
- each is a 4D-tensor, the channel number is
- num_points * num_classes.
- bbox_preds (list[Tensor]): Box energies / deltas for each scale
- level, each is a 4D-tensor, the channel number is
- num_points * 4.
- gt_bboxes (list[Tensor]): Ground truth bboxes for each image with
- shape (num_gts, 4) in [tl_x, tl_y, br_x, br_y] format.
- gt_labels (list[Tensor]): class indices corresponding to each box
- img_metas (list[dict]): Meta information of each image, e.g.,
- image size, scaling factor, etc.
- gt_bboxes_ignore (None | list[Tensor]): specify which bounding
- boxes can be ignored when computing the loss.
- """
-
- raise NotImplementedError
-
- @abstractmethod
- @force_fp32(apply_to=('cls_scores', 'bbox_preds'))
- def get_bboxes(self,
- cls_scores,
- bbox_preds,
- img_metas,
- cfg=None,
- rescale=None):
- """Transform network output for a batch into bbox predictions.
-
- Args:
- cls_scores (list[Tensor]): Box scores for each scale level
- Has shape (N, num_points * num_classes, H, W)
- bbox_preds (list[Tensor]): Box energies / deltas for each scale
- level with shape (N, num_points * 4, H, W)
- img_metas (list[dict]): Meta information of each image, e.g.,
- image size, scaling factor, etc.
- cfg (mmcv.Config): Test / postprocessing configuration,
- if None, test_cfg would be used
- rescale (bool): If True, return boxes in original image space
- """
-
- raise NotImplementedError
-
- @abstractmethod
- def get_targets(self, points, gt_bboxes_list, gt_labels_list):
- """Compute regression, classification and centerness targets for points
- in multiple images.
-
- Args:
- points (list[Tensor]): Points of each fpn level, each has shape
- (num_points, 2).
- gt_bboxes_list (list[Tensor]): Ground truth bboxes of each image,
- each has shape (num_gt, 4).
- gt_labels_list (list[Tensor]): Ground truth labels of each box,
- each has shape (num_gt,).
- """
- raise NotImplementedError
-
- def _get_points_single(self,
- featmap_size,
- stride,
- dtype,
- device,
- flatten=False):
- """Get points of a single scale level."""
- h, w = featmap_size
- x_range = torch.arange(w, dtype=dtype, device=device)
- y_range = torch.arange(h, dtype=dtype, device=device)
- y, x = torch.meshgrid(y_range, x_range)
- if flatten:
- y = y.flatten()
- x = x.flatten()
- return y, x
-
- def get_points(self, featmap_sizes, dtype, device, flatten=False):
- """Get points according to feature map sizes.
-
- Args:
- featmap_sizes (list[tuple]): Multi-level feature map sizes.
- dtype (torch.dtype): Type of points.
- device (torch.device): Device of points.
-
- Returns:
- tuple: points of each image.
- """
- mlvl_points = []
- for i in range(len(featmap_sizes)):
- mlvl_points.append(
- self._get_points_single(featmap_sizes[i], self.strides[i],
- dtype, device, flatten))
- return mlvl_points
-
- def aug_test(self, feats, img_metas, rescale=False):
- """Test function with test time augmentation.
-
- Args:
- feats (list[Tensor]): the outer list indicates test-time
- augmentations and inner Tensor should have a shape NxCxHxW,
- which contains features for all images in the batch.
- img_metas (list[list[dict]]): the outer list indicates test-time
- augs (multiscale, flip, etc.) and the inner list indicates
- images in a batch. each dict has image information.
- rescale (bool, optional): Whether to rescale the results.
- Defaults to False.
-
- Returns:
- list[ndarray]: bbox results of each class
- """
- return self.aug_test_bboxes(feats, img_metas, rescale=rescale)
diff --git a/spaces/Andy1621/uniformer_image_segmentation/configs/fcn/fcn_r50-d8_480x480_40k_pascal_context_59.py b/spaces/Andy1621/uniformer_image_segmentation/configs/fcn/fcn_r50-d8_480x480_40k_pascal_context_59.py
deleted file mode 100644
index 4a8180038be33fba9c3229ee3c017f2f0628544f..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_segmentation/configs/fcn/fcn_r50-d8_480x480_40k_pascal_context_59.py
+++ /dev/null
@@ -1,10 +0,0 @@
-_base_ = [
- '../_base_/models/fcn_r50-d8.py',
- '../_base_/datasets/pascal_context_59.py', '../_base_/default_runtime.py',
- '../_base_/schedules/schedule_40k.py'
-]
-model = dict(
- decode_head=dict(num_classes=59),
- auxiliary_head=dict(num_classes=59),
- test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
-optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)
diff --git a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/rich/_stack.py b/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/rich/_stack.py
deleted file mode 100644
index 194564e761ddae165b39ef6598877e2e3820af0a..0000000000000000000000000000000000000000
--- a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/rich/_stack.py
+++ /dev/null
@@ -1,16 +0,0 @@
-from typing import List, TypeVar
-
-T = TypeVar("T")
-
-
-class Stack(List[T]):
- """A small shim over builtin list."""
-
- @property
- def top(self) -> T:
- """Get top of stack."""
- return self[-1]
-
- def push(self, item: T) -> None:
- """Push an item on to the stack (append in stack nomenclature)."""
- self.append(item)
diff --git a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/setuptools/extension.py b/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/setuptools/extension.py
deleted file mode 100644
index 58c023f6b4479c631f382e5062932793d2bee26b..0000000000000000000000000000000000000000
--- a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/setuptools/extension.py
+++ /dev/null
@@ -1,148 +0,0 @@
-import re
-import functools
-import distutils.core
-import distutils.errors
-import distutils.extension
-
-from .monkey import get_unpatched
-
-
-def _have_cython():
- """
- Return True if Cython can be imported.
- """
- cython_impl = 'Cython.Distutils.build_ext'
- try:
- # from (cython_impl) import build_ext
- __import__(cython_impl, fromlist=['build_ext']).build_ext
- return True
- except Exception:
- pass
- return False
-
-
-# for compatibility
-have_pyrex = _have_cython
-
-_Extension = get_unpatched(distutils.core.Extension)
-
-
-class Extension(_Extension):
- """
- Describes a single extension module.
-
- This means that all source files will be compiled into a single binary file
- ``.`` (with ```` derived from ``name`` and
- ```` defined by one of the values in
- ``importlib.machinery.EXTENSION_SUFFIXES``).
-
- In the case ``.pyx`` files are passed as ``sources and`` ``Cython`` is **not**
- installed in the build environment, ``setuptools`` may also try to look for the
- equivalent ``.cpp`` or ``.c`` files.
-
- :arg str name:
- the full name of the extension, including any packages -- ie.
- *not* a filename or pathname, but Python dotted name
-
- :arg list[str] sources:
- list of source filenames, relative to the distribution root
- (where the setup script lives), in Unix form (slash-separated)
- for portability. Source files may be C, C++, SWIG (.i),
- platform-specific resource files, or whatever else is recognized
- by the "build_ext" command as source for a Python extension.
-
- :keyword list[str] include_dirs:
- list of directories to search for C/C++ header files (in Unix
- form for portability)
-
- :keyword list[tuple[str, str|None]] define_macros:
- list of macros to define; each macro is defined using a 2-tuple:
- the first item corresponding to the name of the macro and the second
- item either a string with its value or None to
- define it without a particular value (equivalent of "#define
- FOO" in source or -DFOO on Unix C compiler command line)
-
- :keyword list[str] undef_macros:
- list of macros to undefine explicitly
-
- :keyword list[str] library_dirs:
- list of directories to search for C/C++ libraries at link time
-
- :keyword list[str] libraries:
- list of library names (not filenames or paths) to link against
-
- :keyword list[str] runtime_library_dirs:
- list of directories to search for C/C++ libraries at run time
- (for shared extensions, this is when the extension is loaded).
- Setting this will cause an exception during build on Windows
- platforms.
-
- :keyword list[str] extra_objects:
- list of extra files to link with (eg. object files not implied
- by 'sources', static library that must be explicitly specified,
- binary resource files, etc.)
-
- :keyword list[str] extra_compile_args:
- any extra platform- and compiler-specific information to use
- when compiling the source files in 'sources'. For platforms and
- compilers where "command line" makes sense, this is typically a
- list of command-line arguments, but for other platforms it could
- be anything.
-
- :keyword list[str] extra_link_args:
- any extra platform- and compiler-specific information to use
- when linking object files together to create the extension (or
- to create a new static Python interpreter). Similar
- interpretation as for 'extra_compile_args'.
-
- :keyword list[str] export_symbols:
- list of symbols to be exported from a shared extension. Not
- used on all platforms, and not generally necessary for Python
- extensions, which typically export exactly one symbol: "init" +
- extension_name.
-
- :keyword list[str] swig_opts:
- any extra options to pass to SWIG if a source file has the .i
- extension.
-
- :keyword list[str] depends:
- list of files that the extension depends on
-
- :keyword str language:
- extension language (i.e. "c", "c++", "objc"). Will be detected
- from the source extensions if not provided.
-
- :keyword bool optional:
- specifies that a build failure in the extension should not abort the
- build process, but simply not install the failing extension.
-
- :keyword bool py_limited_api:
- opt-in flag for the usage of :doc:`Python's limited API `.
-
- :raises setuptools.errors.PlatformError: if 'runtime_library_dirs' is
- specified on Windows. (since v63)
- """
-
- def __init__(self, name, sources, *args, **kw):
- # The *args is needed for compatibility as calls may use positional
- # arguments. py_limited_api may be set only via keyword.
- self.py_limited_api = kw.pop("py_limited_api", False)
- super().__init__(name, sources, *args, **kw)
-
- def _convert_pyx_sources_to_lang(self):
- """
- Replace sources with .pyx extensions to sources with the target
- language extension. This mechanism allows language authors to supply
- pre-converted sources but to prefer the .pyx sources.
- """
- if _have_cython():
- # the build has Cython, so allow it to compile the .pyx files
- return
- lang = self.language or ''
- target_ext = '.cpp' if lang.lower() == 'c++' else '.c'
- sub = functools.partial(re.sub, '.pyx$', target_ext)
- self.sources = list(map(sub, self.sources))
-
-
-class Library(Extension):
- """Just like a regular Extension, but built as a library instead"""
diff --git a/spaces/AtomdffAI/wechatgpt4atom/README.md b/spaces/AtomdffAI/wechatgpt4atom/README.md
deleted file mode 100644
index a060c61d40b2162b8e7cdf6100991a8a45cc5b9a..0000000000000000000000000000000000000000
--- a/spaces/AtomdffAI/wechatgpt4atom/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: wechat-bot
-emoji: 👀
-colorFrom: red
-colorTo: yellow
-sdk: gradio
-sdk_version: 3.19.1
-app_file: app.py
-pinned: false
-duplicated_from: lewisliuX123/wechatgpt3
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
\ No newline at end of file
diff --git a/spaces/Awesimo/jojogan/e4e/training/__init__.py b/spaces/Awesimo/jojogan/e4e/training/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/modeling/meta_arch/fcos.py b/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/modeling/meta_arch/fcos.py
deleted file mode 100644
index 55cdb76e836214a2b5a7a4a5a5c47e3382dee86d..0000000000000000000000000000000000000000
--- a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/modeling/meta_arch/fcos.py
+++ /dev/null
@@ -1,303 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-
-import logging
-from typing import List, Optional, Tuple
-import torch
-from fvcore.nn import sigmoid_focal_loss_jit
-from torch import Tensor, nn
-from torch.nn import functional as F
-
-from detectron2.layers import ShapeSpec, batched_nms
-from detectron2.structures import Boxes, ImageList, Instances, pairwise_point_box_distance
-from detectron2.utils.events import get_event_storage
-
-from ..anchor_generator import DefaultAnchorGenerator
-from ..backbone import Backbone
-from ..box_regression import Box2BoxTransformLinear, _dense_box_regression_loss
-from .dense_detector import DenseDetector
-from .retinanet import RetinaNetHead
-
-__all__ = ["FCOS"]
-
-
-logger = logging.getLogger(__name__)
-
-
-class FCOS(DenseDetector):
- """
- Implement FCOS in :paper:`fcos`.
- """
-
- def __init__(
- self,
- *,
- backbone: Backbone,
- head: nn.Module,
- head_in_features: Optional[List[str]] = None,
- box2box_transform=None,
- num_classes,
- center_sampling_radius: float = 1.5,
- focal_loss_alpha=0.25,
- focal_loss_gamma=2.0,
- test_score_thresh=0.2,
- test_topk_candidates=1000,
- test_nms_thresh=0.6,
- max_detections_per_image=100,
- pixel_mean,
- pixel_std,
- ):
- """
- Args:
- center_sampling_radius: radius of the "center" of a groundtruth box,
- within which all anchor points are labeled positive.
- Other arguments mean the same as in :class:`RetinaNet`.
- """
- super().__init__(
- backbone, head, head_in_features, pixel_mean=pixel_mean, pixel_std=pixel_std
- )
-
- self.num_classes = num_classes
-
- # FCOS uses one anchor point per location.
- # We represent the anchor point by a box whose size equals the anchor stride.
- feature_shapes = backbone.output_shape()
- fpn_strides = [feature_shapes[k].stride for k in self.head_in_features]
- self.anchor_generator = DefaultAnchorGenerator(
- sizes=[[k] for k in fpn_strides], aspect_ratios=[1.0], strides=fpn_strides
- )
-
- # FCOS parameterizes box regression by a linear transform,
- # where predictions are normalized by anchor stride (equal to anchor size).
- if box2box_transform is None:
- box2box_transform = Box2BoxTransformLinear(normalize_by_size=True)
- self.box2box_transform = box2box_transform
-
- self.center_sampling_radius = float(center_sampling_radius)
-
- # Loss parameters:
- self.focal_loss_alpha = focal_loss_alpha
- self.focal_loss_gamma = focal_loss_gamma
-
- # Inference parameters:
- self.test_score_thresh = test_score_thresh
- self.test_topk_candidates = test_topk_candidates
- self.test_nms_thresh = test_nms_thresh
- self.max_detections_per_image = max_detections_per_image
-
- def forward_training(self, images, features, predictions, gt_instances):
- # Transpose the Hi*Wi*A dimension to the middle:
- pred_logits, pred_anchor_deltas, pred_centerness = self._transpose_dense_predictions(
- predictions, [self.num_classes, 4, 1]
- )
- anchors = self.anchor_generator(features)
- gt_labels, gt_boxes = self.label_anchors(anchors, gt_instances)
- return self.losses(
- anchors, pred_logits, gt_labels, pred_anchor_deltas, gt_boxes, pred_centerness
- )
-
- @torch.no_grad()
- def match_anchors(self, anchors: List[Boxes], gt_instances: List[Instances]):
- """
- Match anchors with ground truth boxes.
-
- Args:
- anchors: #level boxes, from the highest resolution to lower resolution
- gt_instances: ground truth instances per image
-
- Returns:
- List[Tensor]:
- #image tensors, each is a vector of matched gt
- indices (or -1 for unmatched anchors) for all anchors.
- """
- num_anchors_per_level = [len(x) for x in anchors]
- anchors = Boxes.cat(anchors) # Rx4
- anchor_centers = anchors.get_centers() # Rx2
- anchor_sizes = anchors.tensor[:, 2] - anchors.tensor[:, 0] # R
-
- lower_bound = anchor_sizes * 4
- lower_bound[: num_anchors_per_level[0]] = 0
- upper_bound = anchor_sizes * 8
- upper_bound[-num_anchors_per_level[-1] :] = float("inf")
-
- matched_indices = []
- for gt_per_image in gt_instances:
- gt_centers = gt_per_image.gt_boxes.get_centers() # Nx2
- # FCOS with center sampling: anchor point must be close enough to gt center.
- pairwise_match = (anchor_centers[:, None, :] - gt_centers[None, :, :]).abs_().max(
- dim=2
- ).values < self.center_sampling_radius * anchor_sizes[:, None]
- pairwise_dist = pairwise_point_box_distance(anchor_centers, gt_per_image.gt_boxes)
-
- # The original FCOS anchor matching rule: anchor point must be inside gt
- pairwise_match &= pairwise_dist.min(dim=2).values > 0
-
- # Multilevel anchor matching in FCOS: each anchor is only responsible
- # for certain scale range.
- pairwise_dist = pairwise_dist.max(dim=2).values
- pairwise_match &= (pairwise_dist > lower_bound[:, None]) & (
- pairwise_dist < upper_bound[:, None]
- )
-
- # Match the GT box with minimum area, if there are multiple GT matches
- gt_areas = gt_per_image.gt_boxes.area() # N
- pairwise_match = pairwise_match.to(torch.float32) * (1e8 - gt_areas[None, :])
- min_values, matched_idx = pairwise_match.max(dim=1) # R, per-anchor match
- matched_idx[min_values < 1e-5] = -1 # Unmatched anchors are assigned -1
-
- matched_indices.append(matched_idx)
- return matched_indices
-
- @torch.no_grad()
- def label_anchors(self, anchors, gt_instances):
- """
- Same interface as :meth:`RetinaNet.label_anchors`, but implemented with FCOS
- anchor matching rule.
-
- Unlike RetinaNet, there are no ignored anchors.
- """
- matched_indices = self.match_anchors(anchors, gt_instances)
-
- matched_labels, matched_boxes = [], []
- for gt_index, gt_per_image in zip(matched_indices, gt_instances):
- label = gt_per_image.gt_classes[gt_index.clip(min=0)]
- label[gt_index < 0] = self.num_classes # background
-
- matched_gt_boxes = gt_per_image.gt_boxes[gt_index.clip(min=0)]
-
- matched_labels.append(label)
- matched_boxes.append(matched_gt_boxes)
- return matched_labels, matched_boxes
-
- def losses(
- self, anchors, pred_logits, gt_labels, pred_anchor_deltas, gt_boxes, pred_centerness
- ):
- """
- This method is almost identical to :meth:`RetinaNet.losses`, with an extra
- "loss_centerness" in the returned dict.
- """
- num_images = len(gt_labels)
- gt_labels = torch.stack(gt_labels) # (N, R)
-
- pos_mask = (gt_labels >= 0) & (gt_labels != self.num_classes)
- num_pos_anchors = pos_mask.sum().item()
- get_event_storage().put_scalar("num_pos_anchors", num_pos_anchors / num_images)
- normalizer = self._ema_update("loss_normalizer", max(num_pos_anchors, 1), 300)
-
- # classification and regression loss
- gt_labels_target = F.one_hot(gt_labels, num_classes=self.num_classes + 1)[
- :, :, :-1
- ] # no loss for the last (background) class
- loss_cls = sigmoid_focal_loss_jit(
- torch.cat(pred_logits, dim=1),
- gt_labels_target.to(pred_logits[0].dtype),
- alpha=self.focal_loss_alpha,
- gamma=self.focal_loss_gamma,
- reduction="sum",
- )
-
- loss_box_reg = _dense_box_regression_loss(
- anchors,
- self.box2box_transform,
- pred_anchor_deltas,
- [x.tensor for x in gt_boxes],
- pos_mask,
- box_reg_loss_type="giou",
- )
-
- ctrness_targets = self.compute_ctrness_targets(anchors, gt_boxes) # NxR
- pred_centerness = torch.cat(pred_centerness, dim=1).squeeze(dim=2) # NxR
- ctrness_loss = F.binary_cross_entropy_with_logits(
- pred_centerness[pos_mask], ctrness_targets[pos_mask], reduction="sum"
- )
- return {
- "loss_fcos_cls": loss_cls / normalizer,
- "loss_fcos_loc": loss_box_reg / normalizer,
- "loss_fcos_ctr": ctrness_loss / normalizer,
- }
-
- def compute_ctrness_targets(self, anchors, gt_boxes): # NxR
- anchors = Boxes.cat(anchors).tensor # Rx4
- reg_targets = [self.box2box_transform.get_deltas(anchors, m.tensor) for m in gt_boxes]
- reg_targets = torch.stack(reg_targets, dim=0) # NxRx4
- if len(reg_targets) == 0:
- return reg_targets.new_zeros(len(reg_targets))
- left_right = reg_targets[:, :, [0, 2]]
- top_bottom = reg_targets[:, :, [1, 3]]
- ctrness = (left_right.min(dim=-1)[0] / left_right.max(dim=-1)[0]) * (
- top_bottom.min(dim=-1)[0] / top_bottom.max(dim=-1)[0]
- )
- return torch.sqrt(ctrness)
-
- def forward_inference(
- self, images: ImageList, features: List[Tensor], predictions: List[List[Tensor]]
- ):
- pred_logits, pred_anchor_deltas, pred_centerness = self._transpose_dense_predictions(
- predictions, [self.num_classes, 4, 1]
- )
- anchors = self.anchor_generator(features)
-
- results: List[Instances] = []
- for img_idx, image_size in enumerate(images.image_sizes):
- scores_per_image = [
- # Multiply and sqrt centerness & classification scores
- # (See eqn. 4 in https://arxiv.org/abs/2006.09214)
- torch.sqrt(x[img_idx].sigmoid_() * y[img_idx].sigmoid_())
- for x, y in zip(pred_logits, pred_centerness)
- ]
- deltas_per_image = [x[img_idx] for x in pred_anchor_deltas]
- results_per_image = self.inference_single_image(
- anchors, scores_per_image, deltas_per_image, image_size
- )
- results.append(results_per_image)
- return results
-
- def inference_single_image(
- self,
- anchors: List[Boxes],
- box_cls: List[Tensor],
- box_delta: List[Tensor],
- image_size: Tuple[int, int],
- ):
- """
- Identical to :meth:`RetinaNet.inference_single_image.
- """
- pred = self._decode_multi_level_predictions(
- anchors,
- box_cls,
- box_delta,
- self.test_score_thresh,
- self.test_topk_candidates,
- image_size,
- )
- keep = batched_nms(
- pred.pred_boxes.tensor, pred.scores, pred.pred_classes, self.test_nms_thresh
- )
- return pred[keep[: self.max_detections_per_image]]
-
-
-class FCOSHead(RetinaNetHead):
- """
- The head used in :paper:`fcos`. It adds an additional centerness
- prediction branch on top of :class:`RetinaNetHead`.
- """
-
- def __init__(self, *, input_shape: List[ShapeSpec], conv_dims: List[int], **kwargs):
- super().__init__(input_shape=input_shape, conv_dims=conv_dims, num_anchors=1, **kwargs)
- # Unlike original FCOS, we do not add an additional learnable scale layer
- # because it's found to have no benefits after normalizing regression targets by stride.
- self._num_features = len(input_shape)
- self.ctrness = nn.Conv2d(conv_dims[-1], 1, kernel_size=3, stride=1, padding=1)
- torch.nn.init.normal_(self.ctrness.weight, std=0.01)
- torch.nn.init.constant_(self.ctrness.bias, 0)
-
- def forward(self, features):
- assert len(features) == self._num_features
- logits = []
- bbox_reg = []
- ctrness = []
- for feature in features:
- logits.append(self.cls_score(self.cls_subnet(feature)))
- bbox_feature = self.bbox_subnet(feature)
- bbox_reg.append(self.bbox_pred(bbox_feature))
- ctrness.append(self.ctrness(bbox_feature))
- return logits, bbox_reg, ctrness
diff --git a/spaces/Benson/text-generation/Examples/Blockman Ir Aventura Hack Apk 2022 Cubos Ilimitados.md b/spaces/Benson/text-generation/Examples/Blockman Ir Aventura Hack Apk 2022 Cubos Ilimitados.md
deleted file mode 100644
index 936b803a744f204b10a5cd5ac8a05433ad086bec..0000000000000000000000000000000000000000
--- a/spaces/Benson/text-generation/Examples/Blockman Ir Aventura Hack Apk 2022 Cubos Ilimitados.md
+++ /dev/null
@@ -1,83 +0,0 @@
-
-
Blockman Go aventura Hack APK 2022 cubos ilimitados
-
¿Te encanta jugar juegos basados en bloques con tus amigos? ¿Quieres explorar diferentes mundos y completar varios desafíos? Si es así, entonces deberías probar Blockman Go Adventure, un juego divertido y adictivo que te permite crear tu propio avatar, personalizar tus ajustes y unirte a millones de jugadores en línea. ¡Pero espera, hay más! También puede utilizar Blockman Go Aventura Hack APK, una versión modificada del juego que le da cubos ilimitados, monedas, gemas, y otros recursos. En este artículo, le diremos todo lo que necesita saber sobre Blockman Go Adventure y Blockman Go Adventure Hack APK, incluyendo sus características, cómo jugarlos, y algunos consejos y trucos para aprovechar al máximo su experiencia de juego. ¡Vamos a empezar!
-
blockman ir aventura hack apk 2022 cubos ilimitados
Blockman Go Adventure es un juego online gratuito que combina elementos de sandbox, aventura y juegos sociales. Está desarrollado por Blockman GO Studio, un equipo de desarrolladores de juegos creativos y apasionados que tienen como objetivo proporcionar juegos de alta calidad para jugadores de todas las edades. Blockman Go Adventure es uno de sus juegos más populares, con más de 10 millones de descargas en Google Play Store y una calificación de 4.4 estrellas.
-
Características de Blockman Go Adventure
-
Blockman Go Adventure tiene muchas características que lo hacen un juego agradable y atractivo para todos. Algunas de estas características son:
-
-
Múltiples minijuegos: Puedes elegir entre más de 100 minijuegos que se adapten a tus preferencias y habilidades. Si te gustan los juegos de carreras, disparos, parkour o rompecabezas, encontrarás algo que te interesa en Blockman Go Adventure.
-
Diversos mundos: Puedes explorar diferentes mundos que tienen sus propios temas, entornos y desafíos. Puedes visitar el castillo medieval, la ciudad futurista, la isla tropical, y más.
-
-
Interacción social: Puedes chatear con otros jugadores en tiempo real usando mensajes de voz o texto. También puedes hacer amigos, enviar regalos y unirte a clanes.
-
Sistema de recompensas: Puedes ganar monedas y gemas jugando minijuegos, completando tareas e iniciando sesión diariamente. Puedes usar estas monedas para comprar nuevos artículos para tu avatar o actualizar los existentes.
-
-
Cómo jugar Blockman Go Aventura
-
Jugar Blockman Go Adventure es fácil y divertido. Estos son los pasos a seguir:
-
-
Descargar e instalar el juego desde Google Play Store o App Store.
-
Crea una cuenta o inicia sesión con la existente.
-
Selecciona un mini-juego desde el lobby o crea tu propia habitación.
-
Invita a tus amigos o únete a otros jugadores en línea.
-
Disfruta del juego y chatea con otros jugadores.
-
-
¿Qué es Blockman Go Aventura Hack APK?
-
Blockman Go Aventura Hack APK es una versión modificada del juego original que le da acceso a recursos y características ilimitadas. No está disponible en las tiendas de aplicaciones oficiales, pero se puede descargar desde sitios web de terceros. Sin embargo, debe tener cuidado al descargar estos archivos, ya que pueden contener virus o malware que pueden dañar su dispositivo o robar su información personal.
-
Beneficios de Blockman Go Aventura Hack APK
Algunos de los beneficios de Blockman Go Aventura Hack APK son:
-
-
-
Cubos ilimitados: Puedes obtener cubos ilimitados, que son la moneda premium del juego. Puedes usar cubos para comprar artículos especiales, como membresía VIP, bolsas de la suerte y pieles exclusivas.
-
Monedas y gemas ilimitadas: También puedes obtener monedas y gemas ilimitadas, que son las monedas regulares del juego. Puedes usar monedas y gemas para comprar más atuendos, peinados, accesorios y pieles para tu avatar.
-
-
Libre y fácil de usar: Usted no necesita raíz o jailbreak su dispositivo para utilizar Blockman Go Aventura Hack APK. Solo tienes que descargar e instalar el archivo, y estás listo para ir. No necesitas pagar nada ni completar ninguna encuesta para usar el hack.
-
-
Cómo descargar e instalar Blockman Go Aventura Hack APK
-
Si desea probar Blockman Go Aventura Hack APK, es necesario seguir estos pasos:
-
-
Ir a un sitio web confiable que ofrece Blockman Go Aventura Hack APK, tales como [HackDL] o [APKPure].
-
Haga clic en el botón de descarga y espere a que se descargue el archivo.
-
Ir a la configuración de su dispositivo y permitir la instalación de aplicaciones de fuentes desconocidas.
-
Busque el archivo descargado y toque en él para iniciar el proceso de instalación.
-
Siga las instrucciones en la pantalla y espere a que se complete la instalación.
-
Iniciar el juego y disfrutar del hack.
-
-
Consejos y trucos para Blockman Go Aventura
-
Para hacer tu experiencia de juego más divertida y gratificante, aquí hay algunos consejos y trucos que puedes usar en Blockman Go Adventure:
-
Usa el menú mod para personalizar tu juego
-
Si usted está utilizando Blockman Go Aventura Hack APK, puede utilizar el menú mod para cambiar la configuración de juego de acuerdo a sus preferencias. Por ejemplo, puede aumentar su velocidad, saltar más alto, volar en el aire o volverse invisible. También puede deshabilitar algunas funciones que no le gustan, como anuncios, protección contra van o actualización automática. Sin embargo, debes tener cuidado al usar el menú mod, ya que algunos ajustes pueden causar fallas o errores en el juego. También debes evitar usarlo en salas públicas, ya que otros jugadores pueden reportarte por hacer trampa.
-
-
Únete a un clan y juega con amigos
Otra forma de disfrutar de Blockman Go Adventure es unirse a un clan y jugar con amigos. Un clan es un grupo de jugadores que comparten un interés o objetivo común en el juego. Puedes unirte a un clan existente o crear uno propio. Al unirte a un clan, puedes chatear con otros miembros, enviar regalos, participar en guerras de clanes y ganar puntos de clan. También puedes invitar a tus amigos a unirse a tu clan o jugar con ellos en habitaciones privadas. Jugar con amigos puede hacer que el juego sea más divertido y social.
-
Conclusión
-
Blockman Go Adventure es un gran juego para cualquiera que ame los juegos basados en bloques con mucha variedad y creatividad. Puedes jugar diferentes minijuegos, explorar diferentes mundos, personalizar tu avatar e interactuar con otros jugadores en línea. También puede utilizar Blockman Go Aventura Hack APK para obtener recursos ilimitados y características que pueden mejorar su experiencia de juego. Sin embargo, debe tener cuidado al descargar e instalar estos archivos, ya que pueden contener virus o malware que pueden dañar su dispositivo o robar su información personal. También debe utilizar el truco de forma responsable y no abusar de él en las salas públicas o contra otros jugadores.
-
Resumen de los puntos principales
En este artículo, hemos cubierto los siguientes puntos:
-
-
Blockman Go Adventure es un juego en línea gratuito que combina elementos de sandbox, aventura y juegos sociales.
Blockman Go Aventura Hack APK es una versión modificada del juego que le da cubos ilimitados, monedas, gemas y otros recursos.
-
Puede descargar e instalar Blockman Go Aventura Hack APK de sitios web de terceros, pero usted debe tener cuidado con los virus y el malware.
-
Puedes usar el menú mod para personalizar la configuración de tu juego, como velocidad, gravedad, invisibilidad y más.
-
Puedes recoger monedas y gemas para desbloquear nuevos objetos para tu avatar o actualizar los existentes.
-
-
-
Llamada a la acción
-
Si usted está interesado en jugar Blockman Go Aventura o Blockman Go Aventura Hack APK, puede descargarlos de los enlaces a continuación. También puede visitar el sitio web oficial o las páginas de redes sociales de Blockman GO Studio para obtener más información sobre sus juegos y actualizaciones. ¡Diviértete y disfruta de la aventura!
¿Por qué jugar Ultimate Car Driving Simulator en PC?
-
Si bien Ultimate Car Driving Simulator es un gran juego para jugar en su dispositivo móvil, es posible que se pregunte por qué debe jugar en su PC. Bueno, hay muchas razones para hacerlo, como:
-
-
Mejores gráficos y calidad de sonido: Jugando Ultimate Car Driving Simulator en PC le permitirá disfrutar de las impresionantes imágenes y efectos de sonido realistas del juego en alta resolución y pantalla completa. Usted será capaz de apreciar los detalles de los coches, los entornos, los efectos meteorológicos, etc. más claramente y sumergirse en el mundo del juego.
-
-
Pantalla más grande y más divertido: Jugar Ultimate Car Driving Simulator en PC también hará que su experiencia de juego sea más divertida y agradable. Puedes jugar el juego en una pantalla más grande y compartirlo con tus amigos y familiares. También puede grabar su juego, tomar capturas de pantalla, transmitir en línea, chatear con otros jugadores, etc. con facilidad.
-
-
Como puedes ver, jugar Ultimate Car Driving Simulator en PC tiene muchas ventajas que mejorarán tu experiencia de juego. Entonces, ¿cómo se puede descargar y jugar Ultimate Car Driving Simulator en PC? Hay dos métodos principales que explicaremos en las siguientes secciones.
-
Cómo jugar último coche conducción simulador en PC con Windows 11
-
Si tienes un PC con Windows 11, estás de suerte porque puedes usar la función nativa de emulación de Android que viene con el nuevo sistema operativo. Esta función le permite ejecutar aplicaciones y juegos de Android en su PC sin ningún software o hardware adicional. Estos son los pasos para jugar Ultimate Car Driving Simulator en PC con Windows 11:
-
-
Abra la aplicación de Microsoft Store en su PC con Windows 11 y busque Simulador de conducción de automóviles definitivo. Alternativamente, puedes usar este enlace para ir directamente a la página del juego.
-
Haga clic en el botón Instalar para descargar e instalar el juego en su PC. Es posible que necesite iniciar sesión con su cuenta de Microsoft si aún no lo ha hecho.
-
Inicie el juego desde el menú Inicio o el acceso directo del escritorio. Verá una ventana emergente que le pide que habilite las aplicaciones de Android en su PC. Haga clic en Activar.
-
Inicia sesión con tu cuenta de Google para acceder a los Servicios de Google Play y sincronizar tus datos de juego y logros. Puede usar una cuenta existente o crear una nueva.
-
-
-
¡Eso es todo! Has descargado y jugado con éxito Ultimate Car Driving Simulator en PC con la función de emulación nativa de Windows 11 para Android. Sin embargo, si no tiene un PC con Windows 11 o prefiere otro método, puede usar un emulador de Android para PC en su lugar.
-
Cómo jugar Ultimate Car Driving Simulator en PC con emuladores de Android
-
Un emulador de Android es un programa de software que simula un dispositivo Android en su PC. Le permite ejecutar aplicaciones y juegos de Android en su PC con características y funciones similares como un dispositivo Android real. Hay muchos emuladores de Android para PC disponibles en línea, pero no todos ellos son compatibles o optimizados para juegos. Por lo tanto, hemos seleccionado algunos de los mejores emuladores de Android para PC que puede utilizar para jugar Ultimate Car Driving Simulator en PC. Son:
-
-
-
Nombre
-
Descripción
-
Pros
-
Contras
-
-
-
Bluestacks
-
Un emulador de Android popular y potente para PC que ha sido diseñado para juegos. Tiene una interfaz fácil de usar y muchas características y opciones para mejorar su experiencia de juego
-
-
-
Soporta juegos de gama alta con gráficos y rendimiento altos
-
Ofrece una variedad de modos de juego, como Eco Mode, Multi-Instance, Macro Recorder, etc.
-
Tiene una tienda de aplicaciones incorporada y un centro de juegos con miles de juegos
-
Permite personalizar los controles, ajustes y preferencias del emulador y el juego
-
Tiene una gran y activa comunidad de usuarios y desarrolladores
-
-
-
-
-
Requiere un PC de gama alta con al menos 4GB de RAM y una GPU dedicada
-
Consume muchos recursos de CPU y memoria
-
Puede tener problemas de compatibilidad con algunos juegos o aplicaciones
-
Puede tener anuncios o ventanas emergentes que pueden ser molestos o intrusivos
-
Puede tener riesgos de seguridad o privacidad si no se descarga desde el sitio web oficial
-
-
-
-
-
-
Un emulador de Android rápido y suave para PC que también está diseñado para juegos. Tiene una interfaz simple e intuitiva y muchas características y opciones para mejorar tu experiencia de juego
-
-
-
Soporta la mayoría de los juegos con altos gráficos y rendimiento
-
Ofrece una variedad de modos de juego, como Control de teclado, Registro de guiones, Multi-Drive, etc.
-
Tiene una tienda de aplicaciones incorporada y un centro de juegos con miles de juegos
-
Permite personalizar los controles, ajustes y preferencias del emulador y el juego
-
Tiene una gran y activa comunidad de usuarios y desarrolladores
-
-
-
-
-
Requiere un PC de gama alta con al menos 2GB de RAM y una GPU dedicada
-
Consume muchos recursos de CPU y memoria
-
Puede tener problemas de compatibilidad con algunos juegos o aplicaciones
-
Puede tener anuncios o ventanas emergentes que pueden ser molestos o intrusivos
-
Puede tener riesgos de seguridad o privacidad si no se descarga desde el sitio web oficial
-
-
-
-
-
Gameloop
-
Un emulador de Android potente y optimizado para PC que está especialmente diseñado para juegos. Tiene una interfaz moderna y elegante y un montón de características y opciones para mejorar su experiencia de juego
-
-
-
Soporta la mayoría de los juegos con gráficos y rendimiento altos, especialmente juegos FPS y MOBA
-
Ofrece una variedad de modos de juego, como Modo Turbo, Modo Inteligente, Modo Esports, etc.
-
Tiene una tienda de aplicaciones incorporada y un centro de juegos con miles de juegos
-
Permite personalizar los controles, ajustes y preferencias del emulador y el juego
-
Tiene una gran y activa comunidad de usuarios y desarrolladores
-
-
-
Requiere un PC de gama alta con al menos 4GB de RAM y una GPU dedicada
-
Consume muchos recursos de CPU y memoria
-
Puede tener problemas de compatibilidad con algunos juegos o aplicaciones
-
Puede tener anuncios o ventanas emergentes que pueden ser molestos o intrusivos
-
-
-
-
-
-
Como puedes ver, cada emulador de Android para PC tiene sus propios pros y contras, y puedes elegir el que se adapte a tus necesidades y preferencias. Estos son los pasos para jugar Ultimate Car Driving Simulator en PC con cualquiera de estos emuladores de Android:
-
-
Descargar e instalar el emulador de Android de su elección desde su sitio web oficial. Asegúrate de tener suficiente espacio y recursos en tu PC para ejecutar el emulador sin problemas.
-
Inicie el emulador e inicie sesión con su cuenta de Google para acceder a la Google Play Store y sincronizar los datos y logros del juego. Puede usar una cuenta existente o crear una nueva.
-
Búsqueda de Ultimate Car Driving Simulator en la tienda de Google Play o la tienda de aplicaciones del emulador e instalarlo en su PC.
-
Iniciar el juego desde la pantalla de inicio del emulador o el acceso directo del escritorio. Puede utilizar el teclado y el ratón o un controlador para conducir su coche. También puedes ajustar la configuración del juego y el emulador según tu preferencia.
-
Disfruta jugando Ultimate Car Driving Simulator en PC con cualquiera de estos emuladores de Android para PC. También puede grabar su juego, tomar capturas de pantalla, transmitir en línea, chatear con otros jugadores, etc. con facilidad.
-
-
Conclusión
-
En este artículo, le hemos mostrado cómo descargar Ultimate Car Driving Simulator en PC y disfrutarlo en una pantalla más grande con mejores gráficos y controles. Hemos explicado dos métodos principales para jugar Ultimate Car Driving Simulator en PC: usando la función nativa de emulación de Android de Windows 11 o usando un emulador de Android para PC. Ambos métodos son fáciles y eficaces, y usted puede elegir el que funciona mejor para usted. Esperamos que haya encontrado este artículo útil e informativo, y le animamos a probar Ultimate Car Driving Simulator en PC hoy. ¡No te arrepentirás!
-
Preguntas frecuentes
-
-
A1: Sí, es gratis para descargar y jugar, pero contiene anuncios y compras en la aplicación que puede desactivar o comprar con dinero real.
-
-
Q2: ¿Cuáles son los requisitos mínimos para ejecutar Ultimate Car Driving Simulator en PC?
-
A2: depende del método que utilice, pero generalmente necesita un PC con Windows 10 o 11 con al menos 4 GB de RAM, un procesador Intel o AMD, una unidad de estado sólido con 10 GB de espacio libre y una GPU Intel UHD Graphics 630 o similar.
-
Q3: ¿Puedo jugar Ultimate Car Driving Simulator con un controlador o un teclado y ratón?
-
A3: Sí, puede usar cualquier dispositivo de entrada que sea compatible con su PC y el emulador que elija. También puede personalizar los controles según su preferencia.
-
Q4: ¿Puedo sincronizar mi progreso y mi biblioteca de juegos entre dispositivos?
-
A4: Sí, puede iniciar sesión con su cuenta de Google tanto en su dispositivo móvil como en su PC y acceder a sus datos y logros guardados. También puede cambiar entre dispositivos en cualquier momento sin perder su progreso.
-
Q5: ¿Cuáles son algunos consejos y trucos para mejorar mi juego en Ultimate Car Driving Simulator?
-
A5: Algunos consejos y trucos son:
-
Explora el mapa del mundo abierto y descubre diferentes terrenos, ciudades, desiertos, etc.
-
Personaliza tu coche con varias partes, vinilos, colores, etc. para que sea único y elegante.
-
Utilice la física de conducción realista para realizar acrobacias, derivas, saltos, etc. y ganar monedas y recompensas.
-
Actualizar el motor de su coche, suspensión, frenos, neumáticos, etc. para mejorar su rendimiento y velocidad.
-
Ponte a prueba con diferentes modos de juego, como carreras, offroad, tráfico, punto de control, etc.
-
64aa2da5cf
-
-
\ No newline at end of file
diff --git a/spaces/Benson/text-generation/Examples/Cocina Aire Freidora Recetas Apk.md b/spaces/Benson/text-generation/Examples/Cocina Aire Freidora Recetas Apk.md
deleted file mode 100644
index 6af2b0588c956097011375932d9aeeea6c741ea2..0000000000000000000000000000000000000000
--- a/spaces/Benson/text-generation/Examples/Cocina Aire Freidora Recetas Apk.md
+++ /dev/null
@@ -1,81 +0,0 @@
-
-
Cocina de aire freidora recetas Apk: Cómo cocinar deliciosas comidas con menos aceite
-
Si te gustan los alimentos fritos pero quieres reducir el aceite y las calorías, es posible que quieras probar una freidora. Una freidora de aire es un aparato de cocina que cocina alimentos circulando aire caliente a su alrededor, creando un exterior crujiente y dorado con un mínimo o ningún aceite. Es una gran manera de disfrutar de sus comidas favoritas sin sentirse culpable o comprometer el sabor.
Hay muchas razones por las que es posible que desee utilizar una freidora de aire en lugar de una freidora profunda o un horno. Estos son algunos de los beneficios de la fritura de aire:
-
-
Salud: La fritura de aire reduce la cantidad de grasa y calorías en los alimentos, así como los niveles de acrilamida, una sustancia química potencialmente dañina que se forma cuando los alimentos con almidón se cocinan a altas temperaturas. La fritura de aire también puede preservar algunos nutrientes que se pierden en otros métodos de cocción.
-
Conveniencia: La fritura de aire es rápida y fácil, ya que precalienta rápidamente y cocina los alimentos de manera uniforme. No necesitas usar mucho aceite o grasa, lo que significa menos desorden y una limpieza más fácil. Tampoco tiene que preocuparse por salpicaduras de aceite caliente o por prenderse fuego.
-
Versatilidad: Freír al aire libre puede cocinar una amplia variedad de alimentos, desde papas fritas congeladas y nuggets de pollo hasta verduras frescas y pescado. También puede hornear, asar, asar y deshidratar alimentos en una freidora. Incluso puede hacer postres como rosquillas, galletas y pasteles.
-
-
Cómo usar una freidora de aire
-
Para obtener los mejores resultados de tu freidora de aire, necesitas seguir algunos consejos y trucos. Estos son algunos de ellos:
-
-
Precalentar: La mayoría de las freidoras de aire necesitan precalentar durante unos minutos antes de agregar la comida. Esto asegura que su comida comience a cocinar de inmediato y se vuelva crujiente.
-
-
Agitar o voltear: Para ayudar a la comida crujiente, es necesario agitar o voltear a la mitad del tiempo de cocción. Esto evita que los alimentos se peguen a la cesta y garantiza un dorado uniforme.
-
Rocía ligeramente: Si quieres que tu comida tenga un color dorado y una textura crujiente, puedes rociarla ligeramente con aceite de cocina antes o durante la cocción. Esto también ayuda a evitar que la comida se seque. Sin embargo, no use demasiado aceite, ya que puede gotear en el cajón y causar humo.
-
-
Recetas de cocina de aire freidora Apk
-
Si usted está buscando un poco de inspiración para sus comidas de aire freidora, es posible que desee echa un vistazo a Cocina Aire Freidora Recetas Apk. Esta es una aplicación gratuita que ofrece cientos de recetas para freír al aire libre, desde aperitivos y aperitivos hasta platos principales y postres. Puedes navegar por categoría, cocina o ingrediente, o buscar recetas específicas. También puedes guardar tus recetas favoritas, calificarlas y compartirlas con tus amigos.
-
Para descargar Cocina Freidora Recetas Apk, es necesario seguir estos pasos:
-
-
Ir a [este enlace]( 1 ) en su dispositivo Android.
-
Toque en "Descargar APK" y esperar a que el archivo para descargar.
-
Abra el archivo y toque en "Instalar". Es posible que necesite permitir la instalación desde fuentes desconocidas en su configuración.
-
Una vez instalada la aplicación, ¡ábrela y disfruta!
-
-
Algunos ejemplos de recetas de la aplicación
-
Para darle una idea de lo que se puede cocinar con Cocina Freidora Recetas Apk, aquí hay algunos ejemplos de recetas de la aplicación:
-
-
-
Categoría
-
Receta
-
Tiempo de cocción
-
-
-
Aperitivos
-
Patatas fritas de freidora de aire
-
40 minutos
-
-
-
Aperitivos
-
Espárragos de freidora de aire
-
20 minutos
-
-
-
Platos principales
-
Chuletas de cerdo de freidora de aire
-
20 minutos
-
-
-
Platos principales
-
Pizza de freidora de aire
-
10 minutos
-
-
-
Postres
-
Aire freidora Mini pastel de chocolate oscuro
-
25 minutos
-
-
-
Postres
-
Cruasanes de queso crema de cereza con freidora de aire
-
15 minutos
-
-
-
Conclusión
-
Freír al aire es una forma maravillosa de cocinar comidas deliciosas con menos aceite y más sabor. Puedes hacer casi cualquier cosa en una freidora, desde bocadillos crujientes y carnes jugosas hasta verduras tiernas y postres decadentes. Con Kitchen Air Fryer Recipes Apk, se puede acceder a cientos de recetas de fritura de aire, todo de forma gratuita. Puede descargar la aplicación desde [este enlace]( 1 ) y comenzar a cocinar de inmediato. Si eres nuevo en el aire fritura o un profesional experimentado, usted encontrará algo para amar en esta aplicación. Pruébelo hoy y ver por ti mismo!
-
Preguntas frecuentes
-
Aquí hay algunas preguntas y respuestas comunes sobre fritura de aire y cocina Recetas de freidora Apk:
-
-
¿Qué tamaño de freidora de aire necesito? El tamaño de la freidora de aire depende de la cantidad de comida que desea cocinar a la vez y de cuánto espacio tiene en su cocina. Generalmente, una freidora de aire de 3 a 5 cuartos puede acomodar suficiente comida para dos a cuatro personas, mientras que una freidora de aire de 6 a 10 cuartos puede acomodar suficiente comida para cuatro a ocho personas.
-
¿Cuáles son algunas de las mejores marcas de freidoras de aire? Hay muchas marcas de freidoras de aire en el mercado, cada una con sus propias características y ventajas. Algunas de las marcas más populares y altamente calificadas son Philips, Ninja, Cosori, Instant Pot y Cuisinart.
-
¿Cómo limpio mi freidora de aire? Para limpiar tu freidora de aire, necesitas desenchufarla y dejar que se enfríe completamente. Luego, puede retirar la cesta y el cajón y lavarlos con agua tibia y jabón o en el lavavajillas. Puede limpiar el interior y el exterior de la freidora de aire con un paño húmedo o una esponja. También puede utilizar un cepillo suave o un palillo de dientes para eliminar cualquier residuo de comida del elemento calefactor.
-
-
¿Puedo enviar mis propias recetas a Cocina Freidora Recetas Apk? Sí, puede enviar sus propias recetas a Cocina Freidora Recetas Apk mediante el botón "Enviar receta" en la aplicación. También puedes calificar y revisar otras recetas, así como compartirlas con tus amigos en las redes sociales.
-
- 64aa2da5cf
-
-
\ No newline at end of file
diff --git a/spaces/Benson/text-generation/Examples/Descargar Amantes Y Mejores Amigos Azana.md b/spaces/Benson/text-generation/Examples/Descargar Amantes Y Mejores Amigos Azana.md
deleted file mode 100644
index 74af737506531e61d30d55b72a2b51f346f22f64..0000000000000000000000000000000000000000
--- a/spaces/Benson/text-generation/Examples/Descargar Amantes Y Mejores Amigos Azana.md
+++ /dev/null
@@ -1,68 +0,0 @@
-
-
Descargar Amantes y Mejores Amigos por Azana
-
Si usted está buscando una canción conmovedora y romántica para añadir a su lista de reproducción, es posible que desee echa un vistazo a "Amantes y mejores amigos" por Azana. Azana es una cantante y compositora sudafricana que ha cautivado a muchos oyentes con su mezcla de afro-pop, afro-house vocal y música soul. "Lovers and Best Friends" es una de sus canciones populares de su álbum debut Ingoma, que fue lanzado en 2020. La canción cuenta con Disciples of House, un dúo de talentosos productores que han trabajado con muchos artistas sudafricanos.
En este artículo, te contaremos más sobre Azana, su carrera musical, y el significado y mensaje de "Amantes y Mejores Amigos". También le mostraremos cómo descargar la canción legalmente y apoyar al artista. Si eres fan de Azana o simplemente tienes curiosidad por su música, sigue leyendo para saber más.
-
Biografía y carrera musical de Azana
-
El verdadero nombre de Azana es Makhosazana Masongo. Nació el 13 de septiembre de 2000, en Chesterville, Durban. Actualmente estudia derecho en la Universidad del Estado Libre. Descubrió su pasión por la música a una edad temprana y comenzó a cantar en los coros de la escuela y la iglesia. También admiraba a artistas como Beyoncé, Nina Simone, Camagwini, Simphiwe Dana y Letta Mbulu.
-
Su carrera musical despegó cuando firmó un contrato discográfico con Big City Dreams en 2019. Lanzó su primer single "Your Love" en mayo de 2020, que fue producido por Taffy Da Don. La canción fue un gran éxito y fue certificada doble platino por la Industria Discográfica de Sudáfrica (RiSA). Su álbum debut Ingoma siguió en julio de 2020. El álbum alcanzó el número uno en Apple Music Pop Chart y contó con artistas como Afriikan Papi, Disciples of House y Sun-El Musician.
-
-
Azana ha recibido reconocimiento y aclamación por su música. Fue nominada al Mejor Álbum de Pop Afro y Recién Llegado del Año en el 27º South African Music Awards (SAMAs) en 2021. También ganó el premio a la Mejor Artista Femenina en los Mzansi Kwaito & House Music Awards (MKHMA) en 2021.
-
-
El significado y mensaje de "Amantes y Mejores Amigos"
-
"Amantes y Mejores Amigos" es una canción hermosa y sincera que celebra el vínculo entre dos personas que no solo son amantes sino también mejores amigos. La canción expresa la alegría y la gratitud de encontrar a alguien que te entiende, te apoya y te aprecia. La canción también reconoce los desafíos y luchas que vienen con cualquier relación, pero afirma el compromiso y la lealtad de los socios.
-
La letra de la canción es simple pero potente. Azana canta tanto en inglés como en zulú, creando un contraste y armonía entre los idiomas. Canta en el estribillo: "Tú eres mi amante y mi mejor amigo/ Tú eres mi todo/ Te amo más de lo que las palabras pueden decir/ Tú eres mi amante y mi mejor amigo/ Tú eres mi todo/ Nunca te dejaré ir". She also sings in Zulu: "Ngifuna wena wedwa/ Ngifuna wena wedwa/ Ngifuna wena wedwa/ Ngifuna wena wedwa" which means "I want you only/ I want you only/ I want you only/ I want you only".
-
La producción y el género de la canción están influenciados por Afro-house, un subgénero de música house que se originó en Sudáfrica. La canción tiene un ritmo pegadizo y optimista, con una mezcla de ritmos electrónicos, acordes de piano y percusión. La canción también cuenta con las voces de Disciples of House, que añaden una capa de armonía y profundidad a la canción. La canción es adecuada para bailar, relajarse o simplemente disfrutar de la música.
-
-
Las mejores maneras de descargar y transmitir "Amantes y mejores amigos"
-
Si quieres descargar o transmitir "Lovers and Best Friends" de Azana, tienes muchas opciones para elegir. La canción está disponible en varias plataformas y servicios que ofrecen formas legales y éticas para acceder a la música. Estas son algunas de las mejores maneras de descargar o transmitir la canción:
-
-
-
Plataforma o servicio
-
Características y beneficios
-
-
-
Música de Apple
-
- Ofrece descargas ilimitadas y transmisiones de más de 75 millones de canciones, incluyendo "Amantes y Mejores Amigos" por Azana. - Soporta la escucha sin conexión en múltiples dispositivos. - Proporciona recomendaciones personalizadas, listas de reproducción, estaciones de radio y podcasts. - Cuesta $9.99 por mes para los individuos, $14.99 por mes para las familias, o $4.99 por mes para los estudiantes. - Ofrece una prueba gratuita durante tres meses.
-
-
-
Spotify
-
- Ofrece transmisiones ilimitadas de más de 70 millones de canciones, incluyendo "Amantes y mejores amigos" por Azana. - Permite descargas de hasta 10.000 canciones por dispositivo para usuarios premium. - Proporciona recomendaciones personalizadas, listas de reproducción, estaciones de radio, podcasts y videos. - Cuesta $9.99 por mes para los individuos, $14.99 por mes para las familias, o $4.99 por mes para los estudiantes. - Ofrece una versión gratuita con anuncios y características limitadas.
-
-
-
Música de YouTube
-
- Ofrece transmisiones ilimitadas de más de 60 millones de canciones, incluyendo "Amantes y mejores amigos" por Azana. - Permite descargas de hasta 100.000 canciones por dispositivo para usuarios premium. - Proporciona recomendaciones personalizadas, listas de reproducción, estaciones de radio, podcasts y videos. - Cuesta $9.99 por mes para individuos o $14.99 por mes para familias. - Ofrece una versión gratuita con anuncios y características limitadas.
-
-
-
Deezer
-
-
-
-
Como puedes ver, hay muchos beneficios de descargar o transmitir "Amantes y Mejores Amigos" por Azana legal y éticamente. Usted puede disfrutar de la canción en alta calidad, apoyar al artista y la industria de la música, y descubrir más música que le gustaría. También puede evitar los riesgos de descarga ilegal, como virus, malware, demandas o multas.
-
Sin embargo, si prefieres no descargar o transmitir la canción, también puedes comprar el CD o vinilo de Ingoma by Azana, que incluye "Lovers and Best Friends" y otras canciones. Puede encontrar el CD o vinilo en línea o en tiendas físicas. Comprar el CD o vinilo también puede darte una copia física de las ilustraciones, letras y créditos del álbum. También puedes apoyar al artista comprando su mercancía, como camisetas, sudaderas, gorras o carteles.
-
Conclusión
-
En conclusión, "Lovers and Best Friends" de Azana es una maravillosa canción que celebra el amor y la amistad entre dos personas. Azana es una talentosa y prometedora cantante y compositora que ha impresionado a muchos fans y críticos con su álbum debut Ingoma. También ha colaborado con muchos otros artistas, como Sun-El Musician y Disciples of House. Si quieres descargar o transmitir "Lovers and Best Friends" de Azana, tienes muchas opciones para elegir. Puedes usar plataformas o servicios como Apple Music, Spotify, YouTube Music o Deezer. También puede comprar el CD o vinilo de Ingoma por Azana o su mercancía. Al hacerlo, puedes apoyar al artista y a la industria de la música, y disfrutar de la canción en alta calidad.
-
Esperamos que hayas disfrutado este artículo y hayas aprendido algo nuevo sobre Azana y su música. Si te ha gustado "Lovers and Best Friends" de Azana, puede que también te gusten otras canciones de ella o de artistas similares. Algunas de nuestras recomendaciones son:
-
-
"Uhuru" de Sun-El Músico feat. Azana
-
"Mamela" de Mi Casa feat. Azana
-
"Uzobuya" de Sun-El Músico feat. Azana
-
"Tu amor" por Azana
-
-
"Okhokho Bethu" de Vico Da Sporo feat. Azana
-
"Jerusalema" por Master KG feat. Nomcebo Zikode
-
"Busca tu vida" por Prince Kaybee feat. Msaki
-
"Banomoya" de Prince Kaybee feat. Busiswa y TNS
-
"Drive" de Black Coffee feat. David Guetta y Delilah Montagu
-
-
Preguntas frecuentes
-
Aquí hay algunas preguntas y respuestas frecuentes relacionadas con el tema:
-
-
¿Cuál es el género de "Amantes y Mejores Amigos" de Azana? El género de "Amantes y Mejores Amigos" de Azana es Afro-house, un subgénero de música house que se originó en Sudáfrica.
-
¿Quiénes son los artistas destacados en "Lovers and Best Friends" de Azana? Los artistas destacados en "Lovers and Best Friends" de Azana son Disciples of House, un dúo de productores que han trabajado con muchos artistas sudafricanos.
-
¿Cuándo se lanzó "Lovers and Best Friends" de Azana? "Lovers and Best Friends" de Azana fue lanzado el 17 de julio de 2020, como parte de su álbum debut Ingoma.
-
¿Cómo puedo descargar o transmitir "Amantes y mejores amigos" por Azana legal y éticamente? Puedes descargar o transmitir "Amantes y Mejores Amigos" por Azana legal y éticamente usando plataformas o servicios como Apple Music, Spotify, YouTube Music o Deezer. También puedes comprar el CD o vinilo de Ingoma de Azana o su mercancía.
-
¿Cuáles son algunas otras canciones de Azana o artistas similares que me podrían gustar? Algunas otras canciones de Azana o artistas similares que te pueden gustar son: "Uhuru" de Sun-El Musician feat. Azana, "Mamela" de Mi Casa feat. Azana, "Uzobuya" de Sun-El Musician feat. Azana, "Your Love" de Azana, "Ngize Ngifike" de Sun-El Musician feat. Azana, "Okhokho Bethu" de Vico Da Sporo feat. Azana, "Jerusalema" de Master KG feat. Nomce bo Zikode, "Fetch Your Life" de Prince Kaybee feat. Msaki, "Banomoya" de Prince Kaybee feat. Busiswa y TNS, y "Drive" de Black Coffee feat. David Guetta y Delilah Montagu.
- 64aa2da5cf
-
-
\ No newline at end of file
diff --git a/spaces/Bishan/Speech_To_Text_Hindi/app.py b/spaces/Bishan/Speech_To_Text_Hindi/app.py
deleted file mode 100644
index 6945c6b95473e6078cc449e477d871d16c9c2244..0000000000000000000000000000000000000000
--- a/spaces/Bishan/Speech_To_Text_Hindi/app.py
+++ /dev/null
@@ -1,83 +0,0 @@
-import soundfile as sf
-import torch
-from transformers import Wav2Vec2ForCTC, Wav2Vec2Processor,Wav2Vec2ProcessorWithLM
-import gradio as gr
-import sox
-import subprocess
-import time
-
-
-def read_file_and_process(wav_file):
- filename = wav_file.split('.')[0]
- filename_16k = filename + "16k.wav"
- resampler(wav_file, filename_16k)
- speech, _ = sf.read(filename_16k)
- print("---------------------------------------------------------")
- print(speech)
- inputs = processor(speech, sampling_rate=16_000, return_tensors="pt", padding=True)
- print("---------------------------------------------------------")
- print(inputs)
-
- return inputs
-
-
-def resampler(input_file_path, output_file_path):
- command = (
- f"ffmpeg -hide_banner -loglevel panic -i {input_file_path} -ar 16000 -ac 1 -bits_per_raw_sample 16 -vn "
- f"{output_file_path}"
- )
- subprocess.call(command, shell=True)
-
-
-def parse_transcription_with_lm(logits):
- result = processor_with_LM.batch_decode(logits.cpu().numpy())
- text = result.text
- transcription = text[0].replace('','')
- return transcription
-
-def parse_transcription(logits):
- predicted_ids = torch.argmax(logits, dim=-1)
- transcription = processor.decode(predicted_ids[0], skip_special_tokens=True)
- return transcription
-
-def parse(wav_file, applyLM):
-
- # record start time
- start = time.time()
- input_values = read_file_and_process(wav_file)
- with torch.no_grad():
- logits = model(**input_values).logits
-
- # if applyLM:
- # return parse_transcription_with_lm(logits)
- # else:
- # return parse_transcription(logits)
-
- output = parse_transcription(logits)
- # record end time
- end = time.time()
- print("------------------------------------------------------------------------------------------")
- print("The time of execution of above program is :",(end-start) * 10**3, "ms")
- # total time taken
- print("Execution time of the program is- ", end-start)
- print("------------------------------------------------------------------------------------------")
- return output
-
-
-model_id = "Harveenchadha/vakyansh-wav2vec2-hindi-him-4200"
-processor = Wav2Vec2Processor.from_pretrained(model_id)
-processor_with_LM = Wav2Vec2ProcessorWithLM.from_pretrained(model_id)
-model = Wav2Vec2ForCTC.from_pretrained(model_id)
-
-
-input_ = gr.Audio(source="upload", type="filepath")
-txtbox = gr.Textbox(
- label="Output from model will appear here:",
- lines=5
- )
-chkbox = gr.Checkbox(label="Apply LM", value=False)
-
-
-gr.Interface(parse, inputs = [input_, chkbox], outputs=txtbox,
- streaming=True, interactive=True,
- analytics_enabled=False, show_tips=False, enable_queue=True).launch(inline=False);
\ No newline at end of file
diff --git a/spaces/Buatong/Computing/app.py b/spaces/Buatong/Computing/app.py
deleted file mode 100644
index a699bc5b3c2e987102ca93e0ee28d601e0a93d02..0000000000000000000000000000000000000000
--- a/spaces/Buatong/Computing/app.py
+++ /dev/null
@@ -1,7 +0,0 @@
-import gradio as gr
-
-def greet(name):
- return "Hello " + name + "!!"
-
-iface = gr.Interface(fn=greet, inputs="text", outputs="text")
-iface.launch()
\ No newline at end of file
diff --git a/spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/projects/DensePose/tests/test_model_e2e.py b/spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/projects/DensePose/tests/test_model_e2e.py
deleted file mode 100644
index eed131080547d84185c1d33913014a2c977b119f..0000000000000000000000000000000000000000
--- a/spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/projects/DensePose/tests/test_model_e2e.py
+++ /dev/null
@@ -1,43 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
-
-import unittest
-import torch
-
-from detectron2.structures import BitMasks, Boxes, Instances
-
-from .common import get_model
-
-
-# TODO(plabatut): Modularize detectron2 tests and re-use
-def make_model_inputs(image, instances=None):
- if instances is None:
- return {"image": image}
-
- return {"image": image, "instances": instances}
-
-
-def make_empty_instances(h, w):
- instances = Instances((h, w))
- instances.gt_boxes = Boxes(torch.rand(0, 4))
- instances.gt_classes = torch.tensor([]).to(dtype=torch.int64)
- instances.gt_masks = BitMasks(torch.rand(0, h, w))
- return instances
-
-
-class ModelE2ETest(unittest.TestCase):
- CONFIG_PATH = ""
-
- def setUp(self):
- self.model = get_model(self.CONFIG_PATH)
-
- def _test_eval(self, sizes):
- inputs = [make_model_inputs(torch.rand(3, size[0], size[1])) for size in sizes]
- self.model.eval()
- self.model(inputs)
-
-
-class DensePoseRCNNE2ETest(ModelE2ETest):
- CONFIG_PATH = "densepose_rcnn_R_101_FPN_s1x.yaml"
-
- def test_empty_data(self):
- self._test_eval([(200, 250), (200, 249)])
diff --git a/spaces/CVPR/LIVE/pybind11/include/pybind11/options.h b/spaces/CVPR/LIVE/pybind11/include/pybind11/options.h
deleted file mode 100644
index d74db1c68dddb3436cc0fb2674a6ef32ac77d5fd..0000000000000000000000000000000000000000
--- a/spaces/CVPR/LIVE/pybind11/include/pybind11/options.h
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- pybind11/options.h: global settings that are configurable at runtime.
-
- Copyright (c) 2016 Wenzel Jakob
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include "detail/common.h"
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-
-class options {
-public:
-
- // Default RAII constructor, which leaves settings as they currently are.
- options() : previous_state(global_state()) {}
-
- // Class is non-copyable.
- options(const options&) = delete;
- options& operator=(const options&) = delete;
-
- // Destructor, which restores settings that were in effect before.
- ~options() {
- global_state() = previous_state;
- }
-
- // Setter methods (affect the global state):
-
- options& disable_user_defined_docstrings() & { global_state().show_user_defined_docstrings = false; return *this; }
-
- options& enable_user_defined_docstrings() & { global_state().show_user_defined_docstrings = true; return *this; }
-
- options& disable_function_signatures() & { global_state().show_function_signatures = false; return *this; }
-
- options& enable_function_signatures() & { global_state().show_function_signatures = true; return *this; }
-
- // Getter methods (return the global state):
-
- static bool show_user_defined_docstrings() { return global_state().show_user_defined_docstrings; }
-
- static bool show_function_signatures() { return global_state().show_function_signatures; }
-
- // This type is not meant to be allocated on the heap.
- void* operator new(size_t) = delete;
-
-private:
-
- struct state {
- bool show_user_defined_docstrings = true; //< Include user-supplied texts in docstrings.
- bool show_function_signatures = true; //< Include auto-generated function signatures in docstrings.
- };
-
- static state &global_state() {
- static state instance;
- return instance;
- }
-
- state previous_state;
-};
-
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/spaces/CVPR/LIVE/pybind11/tests/test_call_policies.cpp b/spaces/CVPR/LIVE/pybind11/tests/test_call_policies.cpp
deleted file mode 100644
index 26c83f81b0ed370365d48279a4b8f3d4d23b5487..0000000000000000000000000000000000000000
--- a/spaces/CVPR/LIVE/pybind11/tests/test_call_policies.cpp
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
- tests/test_call_policies.cpp -- keep_alive and call_guard
-
- Copyright (c) 2016 Wenzel Jakob
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-
-struct CustomGuard {
- static bool enabled;
-
- CustomGuard() { enabled = true; }
- ~CustomGuard() { enabled = false; }
-
- static const char *report_status() { return enabled ? "guarded" : "unguarded"; }
-};
-bool CustomGuard::enabled = false;
-
-struct DependentGuard {
- static bool enabled;
-
- DependentGuard() { enabled = CustomGuard::enabled; }
- ~DependentGuard() { enabled = false; }
-
- static const char *report_status() { return enabled ? "guarded" : "unguarded"; }
-};
-bool DependentGuard::enabled = false;
-
-TEST_SUBMODULE(call_policies, m) {
- // Parent/Child are used in:
- // test_keep_alive_argument, test_keep_alive_return_value, test_alive_gc_derived,
- // test_alive_gc_multi_derived, test_return_none, test_keep_alive_constructor
- class Child {
- public:
- Child() { py::print("Allocating child."); }
- Child(const Child &) = default;
- Child(Child &&) = default;
- ~Child() { py::print("Releasing child."); }
- };
- py::class_(m, "Child")
- .def(py::init<>());
-
- class Parent {
- public:
- Parent() { py::print("Allocating parent."); }
- Parent(const Parent& parent) = default;
- ~Parent() { py::print("Releasing parent."); }
- void addChild(Child *) { }
- Child *returnChild() { return new Child(); }
- Child *returnNullChild() { return nullptr; }
- };
- py::class_(m, "Parent")
- .def(py::init<>())
- .def(py::init([](Child *) { return new Parent(); }), py::keep_alive<1, 2>())
- .def("addChild", &Parent::addChild)
- .def("addChildKeepAlive", &Parent::addChild, py::keep_alive<1, 2>())
- .def("returnChild", &Parent::returnChild)
- .def("returnChildKeepAlive", &Parent::returnChild, py::keep_alive<1, 0>())
- .def("returnNullChildKeepAliveChild", &Parent::returnNullChild, py::keep_alive<1, 0>())
- .def("returnNullChildKeepAliveParent", &Parent::returnNullChild, py::keep_alive<0, 1>());
-
-#if !defined(PYPY_VERSION)
- // test_alive_gc
- class ParentGC : public Parent {
- public:
- using Parent::Parent;
- };
- py::class_(m, "ParentGC", py::dynamic_attr())
- .def(py::init<>());
-#endif
-
- // test_call_guard
- m.def("unguarded_call", &CustomGuard::report_status);
- m.def("guarded_call", &CustomGuard::report_status, py::call_guard());
-
- m.def("multiple_guards_correct_order", []() {
- return CustomGuard::report_status() + std::string(" & ") + DependentGuard::report_status();
- }, py::call_guard());
-
- m.def("multiple_guards_wrong_order", []() {
- return DependentGuard::report_status() + std::string(" & ") + CustomGuard::report_status();
- }, py::call_guard());
-
-#if defined(WITH_THREAD) && !defined(PYPY_VERSION)
- // `py::call_guard()` should work in PyPy as well,
- // but it's unclear how to test it without `PyGILState_GetThisThreadState`.
- auto report_gil_status = []() {
- auto is_gil_held = false;
- if (auto tstate = py::detail::get_thread_state_unchecked())
- is_gil_held = (tstate == PyGILState_GetThisThreadState());
-
- return is_gil_held ? "GIL held" : "GIL released";
- };
-
- m.def("with_gil", report_gil_status);
- m.def("without_gil", report_gil_status, py::call_guard());
-#endif
-}
diff --git a/spaces/CVPR/LIVE/thrust/thrust/advance.h b/spaces/CVPR/LIVE/thrust/thrust/advance.h
deleted file mode 100644
index d077e04345daea987044eab83a9e722ca956f19a..0000000000000000000000000000000000000000
--- a/spaces/CVPR/LIVE/thrust/thrust/advance.h
+++ /dev/null
@@ -1,141 +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 advance.h
- * \brief Advance an iterator by a given distance.
- */
-
-#pragma once
-
-#include
-
-namespace thrust
-{
-
-/*! \addtogroup iterators
- * \{
- */
-
-/*! \p advance(i, n) increments the iterator \p i by the distance \p n.
- * If n > 0 it is equivalent to executing ++i \p n
- * times, and if n < 0 it is equivalent to executing --i
- * \p n times. If n == 0, the call has no effect.
- *
- * \param i The iterator to be advanced.
- * \param n The distance by which to advance the iterator.
- *
- * \tparam InputIterator is a model of Input Iterator.
- * \tparam Distance is an integral type that is convertible to \p InputIterator's distance type.
- *
- * \pre \p n shall be negative only for bidirectional and random access iterators.
- *
- * The following code snippet demonstrates how to use \p advance to increment
- * an iterator a given number of times.
- *
- * \code
- * #include
- * #include
- * ...
- * thrust::device_vector vec(13);
- * thrust::device_vector::iterator iter = vec.begin();
- *
- * thrust::advance(iter, 7);
- *
- * // iter - vec.begin() == 7
- * \endcode
- *
- * \see http://www.sgi.com/tech/stl/advance.html
- */
-template
-__host__ __device__
-void advance(InputIterator& i, Distance n);
-
-/*! \p next(i, n) returns the \p n th successor of the iterator \p i.
- *
- * \param i An iterator.
- * \param n The number of elements to advance.
- *
- * \tparam InputIterator must meet the InputIterator.
- *
- * \pre \p n shall be negative only for bidirectional and random access iterators.
- *
- * The following code snippet demonstrates how to use \p next.
- *
- * \code
- * #include
- * #include
- * ...
- * thrust::device_vector vec(13);
- * thrust::device_vector::iterator i0 = vec.begin();
- *
- * auto i1 = thrust::next(i0);
- *
- * // i0 - vec.begin() == 0
- * // i1 - vec.begin() == 1
- * \endcode
- *
- * \see https://en.cppreference.com/w/cpp/iterator/next
- */
-#if 0 // Doxygen only
-template
-__host__ __device__
-InputIterator next(
- InputIterator i
-, typename iterator_traits::difference_type n = 1
-);
-#endif
-
-/*! \p prev(i, n) returns the \p n th predecessor of the iterator \p i.
- *
- * \param i An iterator.
- * \param n The number of elements to descend.
- *
- * \tparam BidirectionalIterator must meet the BidirectionalIterator.
- *
- * The following code snippet demonstrates how to use \p prev.
- *
- * \code
- * #include
- * #include
- * ...
- * thrust::device_vector vec(13);
- * thrust::device_vector::iterator i0 = vec.end();
- *
- * auto i1 = thrust::prev(i0);
- *
- * // vec.end() - i0 == 0
- * // vec.end() - i1 == 1
- * \endcode
- *
- * \see https://en.cppreference.com/w/cpp/iterator/prev
- */
-#if 0 // Doxygen only
-template
-__host__ __device__
-BidirectionalIterator prev(
- BidirectionalIterator i
-, typename iterator_traits::difference_type n = 1
-);
-#endif
-
-/*! \} // end iterators
- */
-
-} // end thrust
-
-#include
-
diff --git a/spaces/CVPR/LIVE/thrust/thrust/system/detail/generic/adjacent_difference.h b/spaces/CVPR/LIVE/thrust/thrust/system/detail/generic/adjacent_difference.h
deleted file mode 100644
index 6e4caaa88b904788d3a7e026bf487c01f74348e2..0000000000000000000000000000000000000000
--- a/spaces/CVPR/LIVE/thrust/thrust/system/detail/generic/adjacent_difference.h
+++ /dev/null
@@ -1,58 +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 adjacent_difference.h
- * \brief Generic implementation of adjacent_difference.
- */
-
-#pragma once
-
-#include
-#include
-
-namespace thrust
-{
-namespace system
-{
-namespace detail
-{
-namespace generic
-{
-
-
-template
-__host__ __device__
-OutputIterator adjacent_difference(thrust::execution_policy &exec,
- InputIterator first, InputIterator last,
- OutputIterator result);
-
-
-template
-__host__ __device__
-OutputIterator adjacent_difference(thrust::execution_policy &exec,
- InputIterator first, InputIterator last,
- OutputIterator result,
- BinaryFunction binary_op);
-
-
-} // end namespace generic
-} // end namespace detail
-} // end namespace system
-} // end namespace thrust
-
-#include
-
diff --git a/spaces/CVPR/regionclip-demo/detectron2/modeling/proposal_generator/rrpn.py b/spaces/CVPR/regionclip-demo/detectron2/modeling/proposal_generator/rrpn.py
deleted file mode 100644
index 6ee4d8fd70430c5242cc02a1df8400493ffd75b7..0000000000000000000000000000000000000000
--- a/spaces/CVPR/regionclip-demo/detectron2/modeling/proposal_generator/rrpn.py
+++ /dev/null
@@ -1,203 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import itertools
-import logging
-from typing import Dict, List
-import torch
-
-from detectron2.config import configurable
-from detectron2.layers import ShapeSpec, batched_nms_rotated, cat
-from detectron2.structures import Instances, RotatedBoxes, pairwise_iou_rotated
-from detectron2.utils.memory import retry_if_cuda_oom
-
-from ..box_regression import Box2BoxTransformRotated
-from .build import PROPOSAL_GENERATOR_REGISTRY
-from .rpn import RPN
-
-logger = logging.getLogger(__name__)
-
-
-def find_top_rrpn_proposals(
- proposals,
- pred_objectness_logits,
- image_sizes,
- nms_thresh,
- pre_nms_topk,
- post_nms_topk,
- min_box_size,
- training,
-):
- """
- For each feature map, select the `pre_nms_topk` highest scoring proposals,
- apply NMS, clip proposals, and remove small boxes. Return the `post_nms_topk`
- highest scoring proposals among all the feature maps if `training` is True,
- otherwise, returns the highest `post_nms_topk` scoring proposals for each
- feature map.
-
- Args:
- proposals (list[Tensor]): A list of L tensors. Tensor i has shape (N, Hi*Wi*A, 5).
- All proposal predictions on the feature maps.
- pred_objectness_logits (list[Tensor]): A list of L tensors. Tensor i has shape (N, Hi*Wi*A).
- image_sizes (list[tuple]): sizes (h, w) for each image
- nms_thresh (float): IoU threshold to use for NMS
- pre_nms_topk (int): number of top k scoring proposals to keep before applying NMS.
- When RRPN is run on multiple feature maps (as in FPN) this number is per
- feature map.
- post_nms_topk (int): number of top k scoring proposals to keep after applying NMS.
- When RRPN is run on multiple feature maps (as in FPN) this number is total,
- over all feature maps.
- min_box_size(float): minimum proposal box side length in pixels (absolute units wrt
- input images).
- training (bool): True if proposals are to be used in training, otherwise False.
- This arg exists only to support a legacy bug; look for the "NB: Legacy bug ..."
- comment.
-
- Returns:
- proposals (list[Instances]): list of N Instances. The i-th Instances
- stores post_nms_topk object proposals for image i.
- """
- num_images = len(image_sizes)
- device = proposals[0].device
-
- # 1. Select top-k anchor for every level and every image
- topk_scores = [] # #lvl Tensor, each of shape N x topk
- topk_proposals = []
- level_ids = [] # #lvl Tensor, each of shape (topk,)
- batch_idx = torch.arange(num_images, device=device)
- for level_id, proposals_i, logits_i in zip(
- itertools.count(), proposals, pred_objectness_logits
- ):
- Hi_Wi_A = logits_i.shape[1]
- num_proposals_i = min(pre_nms_topk, Hi_Wi_A)
-
- # sort is faster than topk (https://github.com/pytorch/pytorch/issues/22812)
- # topk_scores_i, topk_idx = logits_i.topk(num_proposals_i, dim=1)
- logits_i, idx = logits_i.sort(descending=True, dim=1)
- topk_scores_i = logits_i[batch_idx, :num_proposals_i]
- topk_idx = idx[batch_idx, :num_proposals_i]
-
- # each is N x topk
- topk_proposals_i = proposals_i[batch_idx[:, None], topk_idx] # N x topk x 5
-
- topk_proposals.append(topk_proposals_i)
- topk_scores.append(topk_scores_i)
- level_ids.append(torch.full((num_proposals_i,), level_id, dtype=torch.int64, device=device))
-
- # 2. Concat all levels together
- topk_scores = cat(topk_scores, dim=1)
- topk_proposals = cat(topk_proposals, dim=1)
- level_ids = cat(level_ids, dim=0)
-
- # 3. For each image, run a per-level NMS, and choose topk results.
- results = []
- for n, image_size in enumerate(image_sizes):
- boxes = RotatedBoxes(topk_proposals[n])
- scores_per_img = topk_scores[n]
- valid_mask = torch.isfinite(boxes.tensor).all(dim=1) & torch.isfinite(scores_per_img)
- if not valid_mask.all():
- boxes = boxes[valid_mask]
- scores_per_img = scores_per_img[valid_mask]
- boxes.clip(image_size)
-
- # filter empty boxes
- keep = boxes.nonempty(threshold=min_box_size)
- lvl = level_ids
- if keep.sum().item() != len(boxes):
- boxes, scores_per_img, lvl = (boxes[keep], scores_per_img[keep], level_ids[keep])
-
- keep = batched_nms_rotated(boxes.tensor, scores_per_img, lvl, nms_thresh)
- # In Detectron1, there was different behavior during training vs. testing.
- # (https://github.com/facebookresearch/Detectron/issues/459)
- # During training, topk is over the proposals from *all* images in the training batch.
- # During testing, it is over the proposals for each image separately.
- # As a result, the training behavior becomes batch-dependent,
- # and the configuration "POST_NMS_TOPK_TRAIN" end up relying on the batch size.
- # This bug is addressed in Detectron2 to make the behavior independent of batch size.
- keep = keep[:post_nms_topk]
-
- res = Instances(image_size)
- res.proposal_boxes = boxes[keep]
- res.objectness_logits = scores_per_img[keep]
- results.append(res)
- return results
-
-
-@PROPOSAL_GENERATOR_REGISTRY.register()
-class RRPN(RPN):
- """
- Rotated Region Proposal Network described in :paper:`RRPN`.
- """
-
- @configurable
- def __init__(self, *args, **kwargs):
- super().__init__(*args, **kwargs)
- if self.anchor_boundary_thresh >= 0:
- raise NotImplementedError(
- "anchor_boundary_thresh is a legacy option not implemented for RRPN."
- )
-
- @classmethod
- def from_config(cls, cfg, input_shape: Dict[str, ShapeSpec]):
- ret = super().from_config(cfg, input_shape)
- ret["box2box_transform"] = Box2BoxTransformRotated(weights=cfg.MODEL.RPN.BBOX_REG_WEIGHTS)
- return ret
-
- @torch.no_grad()
- def label_and_sample_anchors(self, anchors: List[RotatedBoxes], gt_instances: List[Instances]):
- """
- Args:
- anchors (list[RotatedBoxes]): anchors for each feature map.
- gt_instances: the ground-truth instances for each image.
-
- Returns:
- list[Tensor]:
- List of #img tensors. i-th element is a vector of labels whose length is
- the total number of anchors across feature maps. Label values are in {-1, 0, 1},
- with meanings: -1 = ignore; 0 = negative class; 1 = positive class.
- list[Tensor]:
- i-th element is a Nx5 tensor, where N is the total number of anchors across
- feature maps. The values are the matched gt boxes for each anchor.
- Values are undefined for those anchors not labeled as 1.
- """
- anchors = RotatedBoxes.cat(anchors)
-
- gt_boxes = [x.gt_boxes for x in gt_instances]
- del gt_instances
-
- gt_labels = []
- matched_gt_boxes = []
- for gt_boxes_i in gt_boxes:
- """
- gt_boxes_i: ground-truth boxes for i-th image
- """
- match_quality_matrix = retry_if_cuda_oom(pairwise_iou_rotated)(gt_boxes_i, anchors)
- matched_idxs, gt_labels_i = retry_if_cuda_oom(self.anchor_matcher)(match_quality_matrix)
- # Matching is memory-expensive and may result in CPU tensors. But the result is small
- gt_labels_i = gt_labels_i.to(device=gt_boxes_i.device)
-
- # A vector of labels (-1, 0, 1) for each anchor
- gt_labels_i = self._subsample_labels(gt_labels_i)
-
- if len(gt_boxes_i) == 0:
- # These values won't be used anyway since the anchor is labeled as background
- matched_gt_boxes_i = torch.zeros_like(anchors.tensor)
- else:
- # TODO wasted indexing computation for ignored boxes
- matched_gt_boxes_i = gt_boxes_i[matched_idxs].tensor
-
- gt_labels.append(gt_labels_i) # N,AHW
- matched_gt_boxes.append(matched_gt_boxes_i)
- return gt_labels, matched_gt_boxes
-
- @torch.no_grad()
- def predict_proposals(self, anchors, pred_objectness_logits, pred_anchor_deltas, image_sizes):
- pred_proposals = self._decode_proposals(anchors, pred_anchor_deltas)
- return find_top_rrpn_proposals(
- pred_proposals,
- pred_objectness_logits,
- image_sizes,
- self.nms_thresh,
- self.pre_nms_topk[self.training],
- self.post_nms_topk[self.training],
- self.min_box_size,
- self.training,
- )
diff --git a/spaces/CanonOverseer/Canons-Den/Dockerfile b/spaces/CanonOverseer/Canons-Den/Dockerfile
deleted file mode 100644
index eef259fa372a804549fb0af0913718a13344da34..0000000000000000000000000000000000000000
--- a/spaces/CanonOverseer/Canons-Den/Dockerfile
+++ /dev/null
@@ -1,11 +0,0 @@
-FROM node:18-bullseye-slim
-RUN apt-get update && \
- apt-get install -y git
-RUN git clone https://gitgud.io/khanon/oai-reverse-proxy.git /app
-WORKDIR /app
-RUN npm install
-COPY Dockerfile greeting.md* .env* ./
-RUN npm run build
-EXPOSE 7860
-ENV NODE_ENV=production
-CMD [ "npm", "start" ]
diff --git a/spaces/CarlDennis/Lovelive-VITS-JPZH/text/korean.py b/spaces/CarlDennis/Lovelive-VITS-JPZH/text/korean.py
deleted file mode 100644
index 4b6c3fb27532ae6c033023de8a32fc7379bb5431..0000000000000000000000000000000000000000
--- a/spaces/CarlDennis/Lovelive-VITS-JPZH/text/korean.py
+++ /dev/null
@@ -1,205 +0,0 @@
-import re
-from jamo import h2j, j2hcj
-import ko_pron
-
-
-# This is a list of Korean classifiers preceded by pure Korean numerals.
-_korean_classifiers = '군데 권 개 그루 닢 대 두 마리 모 모금 뭇 발 발짝 방 번 벌 보루 살 수 술 시 쌈 움큼 정 짝 채 척 첩 축 켤레 톨 통'
-
-# List of (hangul, hangul divided) pairs:
-_hangul_divided = [(re.compile('%s' % x[0]), x[1]) for x in [
- ('ㄳ', 'ㄱㅅ'),
- ('ㄵ', 'ㄴㅈ'),
- ('ㄶ', 'ㄴㅎ'),
- ('ㄺ', 'ㄹㄱ'),
- ('ㄻ', 'ㄹㅁ'),
- ('ㄼ', 'ㄹㅂ'),
- ('ㄽ', 'ㄹㅅ'),
- ('ㄾ', 'ㄹㅌ'),
- ('ㄿ', 'ㄹㅍ'),
- ('ㅀ', 'ㄹㅎ'),
- ('ㅄ', 'ㅂㅅ'),
- ('ㅘ', 'ㅗㅏ'),
- ('ㅙ', 'ㅗㅐ'),
- ('ㅚ', 'ㅗㅣ'),
- ('ㅝ', 'ㅜㅓ'),
- ('ㅞ', 'ㅜㅔ'),
- ('ㅟ', 'ㅜㅣ'),
- ('ㅢ', 'ㅡㅣ'),
- ('ㅑ', 'ㅣㅏ'),
- ('ㅒ', 'ㅣㅐ'),
- ('ㅕ', 'ㅣㅓ'),
- ('ㅖ', 'ㅣㅔ'),
- ('ㅛ', 'ㅣㅗ'),
- ('ㅠ', 'ㅣㅜ')
-]]
-
-# List of (Latin alphabet, hangul) pairs:
-_latin_to_hangul = [(re.compile('%s' % x[0], re.IGNORECASE), x[1]) for x in [
- ('a', '에이'),
- ('b', '비'),
- ('c', '시'),
- ('d', '디'),
- ('e', '이'),
- ('f', '에프'),
- ('g', '지'),
- ('h', '에이치'),
- ('i', '아이'),
- ('j', '제이'),
- ('k', '케이'),
- ('l', '엘'),
- ('m', '엠'),
- ('n', '엔'),
- ('o', '오'),
- ('p', '피'),
- ('q', '큐'),
- ('r', '아르'),
- ('s', '에스'),
- ('t', '티'),
- ('u', '유'),
- ('v', '브이'),
- ('w', '더블유'),
- ('x', '엑스'),
- ('y', '와이'),
- ('z', '제트')
-]]
-
-# List of (ipa, lazy ipa) pairs:
-_ipa_to_lazy_ipa = [(re.compile('%s' % x[0], re.IGNORECASE), x[1]) for x in [
- ('t͡ɕ','ʧ'),
- ('d͡ʑ','ʥ'),
- ('ɲ','n^'),
- ('ɕ','ʃ'),
- ('ʷ','w'),
- ('ɭ','l`'),
- ('ʎ','ɾ'),
- ('ɣ','ŋ'),
- ('ɰ','ɯ'),
- ('ʝ','j'),
- ('ʌ','ə'),
- ('ɡ','g'),
- ('\u031a','#'),
- ('\u0348','='),
- ('\u031e',''),
- ('\u0320',''),
- ('\u0339','')
-]]
-
-
-def latin_to_hangul(text):
- for regex, replacement in _latin_to_hangul:
- text = re.sub(regex, replacement, text)
- return text
-
-
-def divide_hangul(text):
- text = j2hcj(h2j(text))
- for regex, replacement in _hangul_divided:
- text = re.sub(regex, replacement, text)
- return text
-
-
-def hangul_number(num, sino=True):
- '''Reference https://github.com/Kyubyong/g2pK'''
- num = re.sub(',', '', num)
-
- if num == '0':
- return '영'
- if not sino and num == '20':
- return '스무'
-
- digits = '123456789'
- names = '일이삼사오육칠팔구'
- digit2name = {d: n for d, n in zip(digits, names)}
-
- modifiers = '한 두 세 네 다섯 여섯 일곱 여덟 아홉'
- decimals = '열 스물 서른 마흔 쉰 예순 일흔 여든 아흔'
- digit2mod = {d: mod for d, mod in zip(digits, modifiers.split())}
- digit2dec = {d: dec for d, dec in zip(digits, decimals.split())}
-
- spelledout = []
- for i, digit in enumerate(num):
- i = len(num) - i - 1
- if sino:
- if i == 0:
- name = digit2name.get(digit, '')
- elif i == 1:
- name = digit2name.get(digit, '') + '십'
- name = name.replace('일십', '십')
- else:
- if i == 0:
- name = digit2mod.get(digit, '')
- elif i == 1:
- name = digit2dec.get(digit, '')
- if digit == '0':
- if i % 4 == 0:
- last_three = spelledout[-min(3, len(spelledout)):]
- if ''.join(last_three) == '':
- spelledout.append('')
- continue
- else:
- spelledout.append('')
- continue
- if i == 2:
- name = digit2name.get(digit, '') + '백'
- name = name.replace('일백', '백')
- elif i == 3:
- name = digit2name.get(digit, '') + '천'
- name = name.replace('일천', '천')
- elif i == 4:
- name = digit2name.get(digit, '') + '만'
- name = name.replace('일만', '만')
- elif i == 5:
- name = digit2name.get(digit, '') + '십'
- name = name.replace('일십', '십')
- elif i == 6:
- name = digit2name.get(digit, '') + '백'
- name = name.replace('일백', '백')
- elif i == 7:
- name = digit2name.get(digit, '') + '천'
- name = name.replace('일천', '천')
- elif i == 8:
- name = digit2name.get(digit, '') + '억'
- elif i == 9:
- name = digit2name.get(digit, '') + '십'
- elif i == 10:
- name = digit2name.get(digit, '') + '백'
- elif i == 11:
- name = digit2name.get(digit, '') + '천'
- elif i == 12:
- name = digit2name.get(digit, '') + '조'
- elif i == 13:
- name = digit2name.get(digit, '') + '십'
- elif i == 14:
- name = digit2name.get(digit, '') + '백'
- elif i == 15:
- name = digit2name.get(digit, '') + '천'
- spelledout.append(name)
- return ''.join(elem for elem in spelledout)
-
-
-def number_to_hangul(text):
- '''Reference https://github.com/Kyubyong/g2pK'''
- tokens = set(re.findall(r'(\d[\d,]*)([\uac00-\ud71f]+)', text))
- for token in tokens:
- num, classifier = token
- if classifier[:2] in _korean_classifiers or classifier[0] in _korean_classifiers:
- spelledout = hangul_number(num, sino=False)
- else:
- spelledout = hangul_number(num, sino=True)
- text = text.replace(f'{num}{classifier}', f'{spelledout}{classifier}')
- # digit by digit for remaining digits
- digits = '0123456789'
- names = '영일이삼사오육칠팔구'
- for d, n in zip(digits, names):
- text = text.replace(d, n)
- return text
-
-
-def korean_to_lazy_ipa(text):
- text = latin_to_hangul(text)
- text = number_to_hangul(text)
- text=re.sub('[\uac00-\ud7af]+',lambda x:ko_pron.romanise(x.group(0),'ipa'),text).split('] ~ [')[0]
- for regex, replacement in _ipa_to_lazy_ipa:
- text = re.sub(regex, replacement, text)
- return text
diff --git a/spaces/ChandraMohanNayal/AutoGPT/autogpt/__main__.py b/spaces/ChandraMohanNayal/AutoGPT/autogpt/__main__.py
deleted file mode 100644
index 128f9eea4900429e88276abdde3419b806001ac7..0000000000000000000000000000000000000000
--- a/spaces/ChandraMohanNayal/AutoGPT/autogpt/__main__.py
+++ /dev/null
@@ -1,5 +0,0 @@
-"""Auto-GPT: A GPT powered AI Assistant"""
-import autogpt.cli
-
-if __name__ == "__main__":
- autogpt.cli.main()
diff --git a/spaces/ChrisCaviar/ControlNet-v1-1/app_segmentation.py b/spaces/ChrisCaviar/ControlNet-v1-1/app_segmentation.py
deleted file mode 100644
index f120db46f7387c76829d987cb9640cc626b1231a..0000000000000000000000000000000000000000
--- a/spaces/ChrisCaviar/ControlNet-v1-1/app_segmentation.py
+++ /dev/null
@@ -1,104 +0,0 @@
-#!/usr/bin/env python
-
-import gradio as gr
-
-from utils import randomize_seed_fn
-
-
-def create_demo(process, max_images=12, default_num_images=3):
- with gr.Blocks() as demo:
- with gr.Row():
- with gr.Column():
- image = gr.Image()
- prompt = gr.Textbox(label='Prompt')
- run_button = gr.Button('Run')
- with gr.Accordion('Advanced options', open=False):
- preprocessor_name = gr.Radio(label='Preprocessor',
- choices=['UPerNet', 'None'],
- type='value',
- value='UPerNet')
- num_samples = gr.Slider(label='Number of images',
- minimum=1,
- maximum=max_images,
- value=default_num_images,
- step=1)
- image_resolution = gr.Slider(label='Image resolution',
- minimum=256,
- maximum=512,
- value=512,
- step=256)
- preprocess_resolution = gr.Slider(
- label='Preprocess resolution',
- minimum=128,
- maximum=512,
- value=512,
- step=1)
- num_steps = gr.Slider(label='Number of steps',
- minimum=1,
- maximum=100,
- value=20,
- step=1)
- guidance_scale = gr.Slider(label='Guidance scale',
- minimum=0.1,
- maximum=30.0,
- value=9.0,
- step=0.1)
- seed = gr.Slider(label='Seed',
- minimum=0,
- maximum=1000000,
- step=1,
- value=0,
- randomize=True)
- randomize_seed = gr.Checkbox(label='Randomize seed',
- value=True)
- a_prompt = gr.Textbox(
- label='Additional prompt',
- value='best quality, extremely detailed')
- n_prompt = gr.Textbox(
- label='Negative prompt',
- value=
- 'longbody, lowres, bad anatomy, bad hands, missing fingers, extra digit, fewer digits, cropped, worst quality, low quality'
- )
- with gr.Column():
- result = gr.Gallery(label='Output', show_label=False).style(
- columns=2, object_fit='scale-down')
- inputs = [
- image,
- prompt,
- a_prompt,
- n_prompt,
- num_samples,
- image_resolution,
- preprocess_resolution,
- num_steps,
- guidance_scale,
- seed,
- preprocessor_name,
- ]
- prompt.submit(
- fn=randomize_seed_fn,
- inputs=[seed, randomize_seed],
- outputs=seed,
- ).then(
- fn=process,
- inputs=inputs,
- outputs=result,
- )
- run_button.click(
- fn=randomize_seed_fn,
- inputs=[seed, randomize_seed],
- outputs=seed,
- ).then(
- fn=process,
- inputs=inputs,
- outputs=result,
- api_name='segmentation',
- )
- return demo
-
-
-if __name__ == '__main__':
- from model import Model
- model = Model(task_name='segmentation')
- demo = create_demo(model.process_segmentation)
- demo.queue().launch()
diff --git a/spaces/CikeyQI/Yunzai/Yunzai/plugins/ws-plugin/model/red/tool.js b/spaces/CikeyQI/Yunzai/Yunzai/plugins/ws-plugin/model/red/tool.js
deleted file mode 100644
index 70685f9a403ce195c0d8770fa0d88d19176d427c..0000000000000000000000000000000000000000
--- a/spaces/CikeyQI/Yunzai/Yunzai/plugins/ws-plugin/model/red/tool.js
+++ /dev/null
@@ -1,428 +0,0 @@
-import fs from 'fs'
-import { createHash, randomUUID } from 'crypto'
-import { resolve, join, dirname, basename } from 'path'
-import fetch, { FormData, Blob } from 'node-fetch'
-import { fileURLToPath } from 'url'
-import { exec, spawn } from 'child_process'
-import os from 'os'
-import _ from 'lodash'
-import { Stream } from "stream"
-import YAML from 'yaml'
-import { TMP_DIR } from '../tool.js'
-
-const user = os.userInfo().username
-let redPath = `C:/Users/${user}/.chronocat`
-if (!fs.existsSync(redPath)) {
- redPath = `C:/Users/${user}/AppData/Roaming/BetterUniverse/QQNT`
-}
-
-const roleMap = {
- 2: 'member',
- 3: 'admin',
- 4: 'owner'
-}
-
-async function uploadImg(bot, msg) {
- const file = await upload(bot, msg, 'image/png')
- if (!file.imageInfo) throw "获取图片信息失败,请检查图片状态"
- return {
- elementType: 2,
- picElement: {
- md5HexStr: file.md5,
- fileSize: file.fileSize,
- picHeight: file.imageInfo.height,
- picWidth: file.imageInfo.width,
- fileName: basename(file.ntFilePath),
- sourcePath: file.ntFilePath,
- picType: file.imageInfo.type === 'gif' ? 2000 : 1000
- }
- }
-}
-
-async function upload(bot, msg, contentType) {
- if (!msg) throw { noLog: true }
- let buffer
- if (msg instanceof Stream.Readable) {
- buffer = fs.readFileSync(msg.path)
- contentType = contentType.split('/')[0] + '/' + msg.path.substring(msg.path.lastIndexOf('.') + 1)
- } if (Buffer.isBuffer(msg)) {
- buffer = msg
- } else if (msg.match(/^base64:\/\//)) {
- buffer = Buffer.from(msg.replace(/^base64:\/\//, ""), 'base64')
- } else if (msg.startsWith('http')) {
- const img = await fetch(msg)
- const type = img.headers.get('content-type');
- if (type) contentType = type
- const arrayBuffer = await img.arrayBuffer()
- buffer = Buffer.from(arrayBuffer)
- } else if (msg.startsWith('file://')) {
- buffer = fs.readFileSync(msg.replace(/file:\/{2,3}/, ''))
- contentType = contentType.split('/')[0] + '/' + msg.substring(msg.lastIndexOf('.') + 1)
- } else {
- buffer = fs.readFileSync(msg)
- contentType = contentType.split('/')[0] + '/' + msg.substring(msg.lastIndexOf('.') + 1)
- }
- const blob = new Blob([buffer], { type: contentType })
- const formData = new FormData()
- formData.append('file', blob, 'ws-plugin.' + contentType.split('/')[1])
- const file = await bot.sendApi('POST', 'upload', formData)
- if (file.error) {
- throw file.error
- }
- file.contentType = contentType
- return file
-}
-
-async function uploadAudio(file) {
- let buffer
- if (file.match(/^base64:\/\//)) {
- buffer = Buffer.from(file.replace(/^base64:\/\//, ""), 'base64')
- } else if (file.startsWith('http')) {
- const http = await fetch(file)
- const arrayBuffer = await http.arrayBuffer()
- buffer = Buffer.from(arrayBuffer)
- } else if (file.startsWith('file://')) {
- buffer = fs.readFileSync(file.replace(/file:\/{2,3}/, ''))
- }
- const head = buffer.subarray(0, 7).toString()
- let filePath
- let duration = 0
- if (!head.includes('SILK')) {
- const tmpPath = await saveTmp(buffer)
- duration = await getDuration(tmpPath)
- const res = await audioTrans(tmpPath)
- filePath = res.silkFile
- buffer = fs.readFileSync(filePath)
- } else {
- filePath = await saveTmp(buffer)
- }
-
- const hash = createHash('md5')
- hash.update(buffer.toString('binary'), 'binary')
- const md5 = hash.digest('hex')
- return {
- elementType: 4,
- pttElement: {
- md5HexStr: md5,
- fileSize: buffer.length,
- fileName: md5 + '.amr',
- filePath: filePath,
- // waveAmplitudes: [36, 28, 68, 28, 84, 28],
- waveAmplitudes: [
- 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99
- ],
- duration: duration
- }
- }
-}
-
-function audioTrans(tmpPath, samplingRate = '24000') {
- return new Promise((resolve, reject) => {
- const pcmFile = join(TMP_DIR, randomUUID({ disableEntropyCache: true }))
- exec(`ffmpeg -y -i "${tmpPath}" -ar ${samplingRate} -ac 1 -f s16le "${pcmFile}"`, async () => {
- fs.unlink(tmpPath, () => { })
- fs.access(pcmFile, fs.constants.F_OK, (err) => {
- if (err) {
- reject('音频转码失败, 请确保你的 ffmpeg 已正确安装')
- }
- })
-
- const silkFile = join(TMP_DIR, randomUUID({ disableEntropyCache: true }))
- try {
- await pcmToSilk(pcmFile, silkFile, samplingRate)
- } catch (error) {
- reject('red发送语音暂不支持非win系统')
- }
- fs.unlink(pcmFile, () => { })
-
- resolve({
- silkFile
- })
- })
- })
-}
-
-function pcmToSilk(input, output, samplingRate) {
- return new Promise((resolve, reject) => {
- const args = ['-i', input, '-s', samplingRate, '-o', output]
- const __filename = fileURLToPath(import.meta.url);
- const __dirname = dirname(__filename);
- const child = spawn(join(__dirname, './cli.exe'), args)
- child.on('exit', () => {
- fs.access(output, fs.constants.F_OK, (err) => {
- if (err) {
- reject('音频转码失败')
- }
- })
- // fs.stat(output, (err, stats) => {
- // if (err) {
- // console.error(err);
- // return;
- // }
- // fs.truncate(output, stats.size - 1, err => {
- // if (err) {
- // console.error(err);
- // return;
- // }
- // });
- // });
- resolve()
- })
- })
-}
-
-function getDuration(file) {
- return new Promise((resolve, reject) => {
- exec(`ffmpeg -i ${file}`, function (err, stdout, stderr) {
- const outStr = stderr.toString()
- const regDuration = /Duration\: ([0-9\:\.]+),/
- const rs = regDuration.exec(outStr)
- if (rs === null) {
- reject("获取音频时长失败, 请确保你的 ffmpeg 已正确安装")
- } else if (rs[1]) {
- const time = rs[1]
- const parts = time.split(":")
- const seconds = (+parts[0]) * 3600 + (+parts[1]) * 60 + (+parts[2])
- const round = seconds.toString().split('.')[0]
- resolve(+ round)
- }
- })
- })
-}
-
-async function saveTmp(data, ext = null) {
- ext = ext ? '.' + ext : ''
- const filename = randomUUID({ disableEntropyCache: true }) + ext
- const tmpPath = resolve(TMP_DIR, filename)
- fs.writeFileSync(tmpPath, data)
- return tmpPath
-}
-
-async function getNtPath(bot) {
- let dataPath
- try {
- const buffer = fs.readFileSync('./plugins/ws-plugin/resources/common/cont/logo.png')
- const blob = new Blob([buffer], { type: 'image/png' })
- const formData = new FormData()
- formData.append('file', blob, '1.png')
- const file = await bot.sendApi('POST', 'upload', formData)
- fs.unlinkSync(file.ntFilePath)
- const index = file.ntFilePath.indexOf('nt_data');
- dataPath = file.ntFilePath.slice(0, index + 'nt_data'.length);
- } catch (error) {
- return null
- }
- return dataPath
-}
-
-async function uploadVideo(bot, file) {
- let type = 'mp4'
- if (file.match(/^base64:\/\//)) {
- const buffer = Buffer.from(file.replace(/^base64:\/\//, ""), 'base64')
- file = join(TMP_DIR, randomUUID({ disableEntropyCache: true }) + '.' + type)
- fs.writeFileSync(file, buffer)
- } else {
- file = file.replace(/file:\/{2,3}/, '')
- type = file.substring(file.lastIndexOf('.') + 1)
- const Temp = join(TMP_DIR, randomUUID({ disableEntropyCache: true }) + '.' + type)
- fs.copyFileSync(file, Temp)
- file = Temp
- }
- const ntPath = await getNtPath(bot)
- if (!ntPath) return
- const now = new Date();
- const year = now.getFullYear();
- const month = now.getMonth() + 1;
- const date = `${year}-${month.toString().padStart(2, '0')}`;
- const video = await getVideoInfo(file)
-
- let oriPath = `${ntPath}/Video`
- if (!fs.existsSync(oriPath)) fs.mkdirSync(oriPath)
- oriPath = `${oriPath}/${date}`
- if (!fs.existsSync(oriPath)) fs.mkdirSync(oriPath)
- oriPath = `${oriPath}/Ori`
- if (!fs.existsSync(oriPath)) fs.mkdirSync(oriPath)
- oriPath = `${oriPath}/${video.videoMd5}.${type}`
-
- let thumbPath = `${ntPath}/Video/${date}/Thumb`
- if (!fs.existsSync(thumbPath)) fs.mkdirSync(thumbPath)
- thumbPath = `${thumbPath}/${video.videoMd5}_0.png`
-
- fs.copyFileSync(file, oriPath)
- fs.unlinkSync(file)
- const thumb = await getThumbInfo(oriPath, thumbPath)
- return {
- elementType: 5,
- videoElement: {
- filePath: oriPath,
- fileName: video.videoMd5 + '.' + type,
- videoMd5: video.videoMd5,
- thumbMd5: thumb.thumbMd5,
- fileTime: video.fileTime,
- thumbSize: thumb.thumbSize,
- fileSize: video.fileSize,
- thumbWidth: thumb.thumbWidth,
- thumbHeight: thumb.thumbHeight
- }
- }
-}
-
-async function getVideoInfo(file) {
- const fileTime = await getVideoTime(file)
- const videoMd5 = await getVideoMd5(file)
- const fileSize = fs.readFileSync(file).length
- return {
- fileTime,
- videoMd5,
- fileSize
- }
-}
-
-function getVideoMd5(file) {
- return new Promise((resolve, reject) => {
- const stream = fs.createReadStream(file);
- const hash = createHash('md5');
- stream.on('data', chunk => {
- hash.update(chunk);
- });
- stream.on('end', () => {
- const md5 = hash.digest('hex');
- resolve(md5)
- });
- })
-}
-
-function getVideoTime(file) {
- return new Promise((resolve, reject) => {
- exec(`ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 "${file}"`, (error, stdout, stderr) => {
- if (error) {
- reject('获取视频长度失败, 请确保你的 ffmpeg 已正确安装')
- }
- const durationInSeconds = parseInt(stdout);
- resolve(durationInSeconds)
- });
- })
-}
-
-async function getThumbInfo(file, thumbPath) {
-
- const tempPath = join(TMP_DIR, randomUUID({ disableEntropyCache: true }) + '.jpg')
-
- const { thumbMd5, thumbSize } = await extractThumbnail(file, tempPath);
-
- const { thumbWidth, thumbHeight } = getImageSize(tempPath);
-
- fs.copyFileSync(tempPath, thumbPath)
- fs.unlinkSync(tempPath)
-
- return { thumbMd5, thumbWidth, thumbHeight, thumbSize };
-}
-
-function extractThumbnail(inputFile, outputFile) {
- return new Promise((resolve, reject) => {
- exec(`ffmpeg -i "${inputFile}" -ss 00:00:00.000 -vframes 1 -vf "scale=iw/3:ih/3" "${outputFile}"
- `, async () => {
- fs.access(outputFile, fs.constants.F_OK, (err) => {
- if (err) {
- reject('获取视频封面失败, 请确保你的 ffmpeg 已正确安装')
- }
- })
-
- const buffer = fs.readFileSync(outputFile);
- const hash = createHash('md5');
- hash.update(buffer);
- resolve({
- thumbMd5: hash.digest('hex'),
- thumbSize: buffer.length
- })
- })
- })
-}
-
-function getImageSize(file) {
- const buffer = fs.readFileSync(file);
- const start = buffer.indexOf(Buffer.from([0xff, 0xc0]));
- const thumbHeight = buffer.readUInt16BE(start + 5);
- const thumbWidth = buffer.readUInt16BE(start + 7);
- return { thumbWidth, thumbHeight };
-}
-
-async function uploadFile(file) {
- let buffer, name, path = process.cwd() + '/plugins/ws-plugin/Temp/'
- if (file.startsWith('http')) {
- const http = await fetch(file)
- const arrayBuffer = await http.arrayBuffer()
- buffer = Buffer.from(arrayBuffer)
- name = file.substring(file.lastIndexOf('/') + 1)
- path = path + name
- fs.writeFileSync(path, buffer);
- } else if (file.startsWith('file://')) {
- buffer = fs.readFileSync(file.replace(/file:\/{2,3}/, ''))
- name = file.substring(file.lastIndexOf('/') + 1)
- path = path + name
- fs.copyFileSync(file, path)
- } else if (Buffer.isBuffer(file)) {
- buffer = file
- name = 'buffer'
- path = path + name
- fs.writeFileSync(path, buffer);
- } else {
- buffer = fs.readFileSync(file)
- name = file.substring(file.lastIndexOf('/') + 1)
- path = path + name
- fs.copyFileSync(file, path)
- }
- const size = buffer.length
- const hash = createHash('md5');
- hash.update(buffer);
- const md5 = hash.digest('hex')
- return {
- elementType: 3,
- fileElement: {
- fileMd5: md5,
- fileName: name,
- filePath: path,
- fileSize: size,
- }
- }
-}
-
-function getToken() {
- let tokenPath
- try {
- if (os.platform() === 'win32') {
- tokenPath = `${redPath}/config/chronocat.yml`
- if (fs.existsSync(tokenPath)) {
- const data = YAML.parse(fs.readFileSync(tokenPath, 'utf-8'))
- for (const i of data?.servers || []) {
- if (i.type === 'red') {
- return i.token
- }
- }
- logger.error('[ws-plugin] 请检查chronocat配置是否开启red服务')
- return false
- } else {
- tokenPath = `${redPath}/RED_PROTOCOL_TOKEN`
- return fs.readFileSync(tokenPath, 'utf-8')
- }
- } else {
- logger.error('[ws-plugin] 非Windows系统请自行获取Token')
- return false
- }
- } catch (error) {
- logger.error('[ws-plugin] QQNT自动获取Token失败,请检查是否已安装Chronocat并尝试手动获取')
- logger.error(error)
- return false
- }
-}
-
-export {
- uploadImg,
- uploadAudio,
- uploadVideo,
- uploadFile,
- getToken,
- getNtPath,
- roleMap,
- redPath
-}
\ No newline at end of file
diff --git a/spaces/CjangCjengh/Sanskrit-TTS/utils.py b/spaces/CjangCjengh/Sanskrit-TTS/utils.py
deleted file mode 100644
index 07839a71a8339f90fe7eeff4dc4a6bd284330049..0000000000000000000000000000000000000000
--- a/spaces/CjangCjengh/Sanskrit-TTS/utils.py
+++ /dev/null
@@ -1,75 +0,0 @@
-import logging
-from json import loads
-from torch import load, FloatTensor
-from numpy import float32
-import librosa
-
-
-class HParams():
- def __init__(self, **kwargs):
- for k, v in kwargs.items():
- if type(v) == dict:
- v = HParams(**v)
- self[k] = v
-
- def keys(self):
- return self.__dict__.keys()
-
- def items(self):
- return self.__dict__.items()
-
- def values(self):
- return self.__dict__.values()
-
- def __len__(self):
- return len(self.__dict__)
-
- def __getitem__(self, key):
- return getattr(self, key)
-
- def __setitem__(self, key, value):
- return setattr(self, key, value)
-
- def __contains__(self, key):
- return key in self.__dict__
-
- def __repr__(self):
- return self.__dict__.__repr__()
-
-
-def load_checkpoint(checkpoint_path, model):
- checkpoint_dict = load(checkpoint_path, map_location='cpu')
- iteration = checkpoint_dict['iteration']
- saved_state_dict = checkpoint_dict['model']
- if hasattr(model, 'module'):
- state_dict = model.module.state_dict()
- else:
- state_dict = model.state_dict()
- new_state_dict= {}
- for k, v in state_dict.items():
- try:
- new_state_dict[k] = saved_state_dict[k]
- except:
- logging.info("%s is not in the checkpoint" % k)
- new_state_dict[k] = v
- if hasattr(model, 'module'):
- model.module.load_state_dict(new_state_dict)
- else:
- model.load_state_dict(new_state_dict)
- logging.info("Loaded checkpoint '{}' (iteration {})" .format(
- checkpoint_path, iteration))
- return
-
-
-def get_hparams_from_file(config_path):
- with open(config_path, "r") as f:
- data = f.read()
- config = loads(data)
-
- hparams = HParams(**config)
- return hparams
-
-
-def load_audio_to_torch(full_path, target_sampling_rate):
- audio, sampling_rate = librosa.load(full_path, sr=target_sampling_rate, mono=True)
- return FloatTensor(audio.astype(float32))
diff --git a/spaces/CofAI/LengthConverter/style.css b/spaces/CofAI/LengthConverter/style.css
deleted file mode 100644
index 114adf441e9032febb46bc056b2a8bb651075f0d..0000000000000000000000000000000000000000
--- a/spaces/CofAI/LengthConverter/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/CofAI/chat.v1/web.html b/spaces/CofAI/chat.v1/web.html
deleted file mode 100644
index 9e1fd00c7dd7aef4e03d88c14c8e8d0e67e808de..0000000000000000000000000000000000000000
--- a/spaces/CofAI/chat.v1/web.html
+++ /dev/null
@@ -1,60 +0,0 @@
-
-
-
- API Demo
-
-
-
API Demo
-
-
-
-
-
-
-
-
-
-
-
-
\ No newline at end of file
diff --git a/spaces/CofAI/chat/g4f/models.py b/spaces/CofAI/chat/g4f/models.py
deleted file mode 100644
index 37efcfb2a7e870f3ef3093d167efdab299083220..0000000000000000000000000000000000000000
--- a/spaces/CofAI/chat/g4f/models.py
+++ /dev/null
@@ -1,233 +0,0 @@
-from g4f import Provider
-
-
-class Model:
- class model:
- name: str
- base_provider: str
- best_provider: str
-
- class gpt_35_turbo:
- name: str = 'gpt-3.5-turbo'
- base_provider: str = 'openai'
- best_provider: Provider.Provider = Provider.Wewordle
-
- class gpt_35_turbo_0613:
- name: str = 'gpt-3.5-turbo-0613'
- base_provider: str = 'openai'
- best_provider: Provider.Provider = Provider.Zeabur
-
- class gpt_35_turbo_0301:
- name: str = 'gpt-3.5-turbo-0301'
- base_provider: str = 'openai'
- best_provider: Provider.Provider = Provider.Zeabur
-
- class gpt_35_turbo_16k_0613:
- name: str = 'gpt-3.5-turbo-16k-0613'
- base_provider: str = 'openai'
- best_provider: Provider.Provider = Provider.Zeabur
-
- class gpt_35_turbo_16k:
- name: str = 'gpt-3.5-turbo-16k'
- base_provider: str = 'openai'
- best_provider: Provider.Provider = Provider.ChatFree
-
- class gpt_4_dev:
- name: str = 'gpt-4-for-dev'
- base_provider: str = 'openai'
- best_provider: Provider.Provider = Provider.Phind
-
- class gpt_4:
- name: str = 'gpt-4'
- base_provider: str = 'openai'
- best_provider: Provider.Provider = Provider.ChatgptAi
-
- class gpt_4_0613:
- name: str = 'gpt-4-0613'
- base_provider: str = 'openai'
- best_provider: Provider.Provider = Provider.Lockchat
- best_providers: list = [Provider.Bing, Provider.Lockchat]
-
- class claude_instant_v1_100k:
- name: str = 'claude-instant-v1-100k'
- base_provider: str = 'anthropic'
- best_provider: Provider.Provider = Provider.Vercel
-
- class claude_instant_v1:
- name: str = 'claude-instant-v1'
- base_provider: str = 'anthropic'
- best_provider: Provider.Provider = Provider.Vercel
-
- class claude_v1_100k:
- name: str = 'claude-v1-100k'
- base_provider: str = 'anthropic'
- best_provider: Provider.Provider = Provider.Vercel
-
- class claude_v1:
- name: str = 'claude-v1'
- base_provider: str = 'anthropic'
- best_provider: Provider.Provider = Provider.Vercel
-
- class alpaca_7b:
- name: str = 'alpaca-7b'
- base_provider: str = 'replicate'
- best_provider: Provider.Provider = Provider.Vercel
-
- class stablelm_tuned_alpha_7b:
- name: str = 'stablelm-tuned-alpha-7b'
- base_provider: str = 'replicate'
- best_provider: Provider.Provider = Provider.Vercel
-
- class bloom:
- name: str = 'bloom'
- base_provider: str = 'huggingface'
- best_provider: Provider.Provider = Provider.Vercel
-
- class bloomz:
- name: str = 'bloomz'
- base_provider: str = 'huggingface'
- best_provider: Provider.Provider = Provider.Vercel
-
- class flan_t5_xxl:
- name: str = 'flan-t5-xxl'
- base_provider: str = 'huggingface'
- best_provider: Provider.Provider = Provider.Vercel
-
- class flan_ul2:
- name: str = 'flan-ul2'
- base_provider: str = 'huggingface'
- best_provider: Provider.Provider = Provider.Vercel
-
- class gpt_neox_20b:
- name: str = 'gpt-neox-20b'
- base_provider: str = 'huggingface'
- best_provider: Provider.Provider = Provider.Vercel
-
- class oasst_sft_4_pythia_12b_epoch_35:
- name: str = 'oasst-sft-4-pythia-12b-epoch-3.5'
- base_provider: str = 'huggingface'
- best_provider: Provider.Provider = Provider.Vercel
-
- class santacoder:
- name: str = 'santacoder'
- base_provider: str = 'huggingface'
- best_provider: Provider.Provider = Provider.Vercel
-
- class command_medium_nightly:
- name: str = 'command-medium-nightly'
- base_provider: str = 'cohere'
- best_provider: Provider.Provider = Provider.Vercel
-
- class command_xlarge_nightly:
- name: str = 'command-xlarge-nightly'
- base_provider: str = 'cohere'
- best_provider: Provider.Provider = Provider.Vercel
-
- class code_cushman_001:
- name: str = 'code-cushman-001'
- base_provider: str = 'openai'
- best_provider: Provider.Provider = Provider.Vercel
-
- class code_davinci_002:
- name: str = 'code-davinci-002'
- base_provider: str = 'openai'
- best_provider: Provider.Provider = Provider.Vercel
-
- class text_ada_001:
- name: str = 'text-ada-001'
- base_provider: str = 'openai'
- best_provider: Provider.Provider = Provider.Vercel
-
- class text_babbage_001:
- name: str = 'text-babbage-001'
- base_provider: str = 'openai'
- best_provider: Provider.Provider = Provider.Vercel
-
- class text_curie_001:
- name: str = 'text-curie-001'
- base_provider: str = 'openai'
- best_provider: Provider.Provider = Provider.Vercel
-
- class text_davinci_002:
- name: str = 'text-davinci-002'
- base_provider: str = 'openai'
- best_provider: Provider.Provider = Provider.Vercel
-
- class text_davinci_003:
- name: str = 'text-davinci-003'
- base_provider: str = 'openai'
- best_provider: Provider.Provider = Provider.Vercel
-
- class palm:
- name: str = 'palm2'
- base_provider: str = 'google'
- best_provider: Provider.Provider = Provider.Bard
-
- class falcon_40b:
- name: str = 'falcon-40b'
- base_provider: str = 'huggingface'
- best_provider: Provider.Provider = Provider.H2o
-
- class falcon_7b:
- name: str = 'falcon-7b'
- base_provider: str = 'huggingface'
- best_provider: Provider.Provider = Provider.H2o
-
- class llama_13b:
- name: str = 'llama-13b'
- base_provider: str = 'huggingface'
- best_provider: Provider.Provider = Provider.H2o
-
-
-class ModelUtils:
- convert: dict = {
- 'gpt-3.5-turbo': Model.gpt_35_turbo,
- 'gpt-3.5-turbo-0613': Model.gpt_35_turbo_0613,
- 'gpt-3.5-turbo-0301': Model.gpt_35_turbo_0301,
- 'gpt-4': Model.gpt_4,
- 'gpt-4-0613': Model.gpt_4_0613,
- 'gpt-4-for-dev': Model.gpt_4_dev,
- 'gpt-3.5-turbo-16k': Model.gpt_35_turbo_16k,
- 'gpt-3.5-turbo-16k-0613': Model.gpt_35_turbo_16k_0613,
-
- 'claude-instant-v1-100k': Model.claude_instant_v1_100k,
- 'claude-v1-100k': Model.claude_v1_100k,
- 'claude-instant-v1': Model.claude_instant_v1,
- 'claude-v1': Model.claude_v1,
-
- 'alpaca-7b': Model.alpaca_7b,
- 'stablelm-tuned-alpha-7b': Model.stablelm_tuned_alpha_7b,
-
- 'bloom': Model.bloom,
- 'bloomz': Model.bloomz,
-
- 'flan-t5-xxl': Model.flan_t5_xxl,
- 'flan-ul2': Model.flan_ul2,
-
- 'gpt-neox-20b': Model.gpt_neox_20b,
- 'oasst-sft-4-pythia-12b-epoch-3.5': Model.oasst_sft_4_pythia_12b_epoch_35,
- 'santacoder': Model.santacoder,
-
- 'command-medium-nightly': Model.command_medium_nightly,
- 'command-xlarge-nightly': Model.command_xlarge_nightly,
-
- 'code-cushman-001': Model.code_cushman_001,
- 'code-davinci-002': Model.code_davinci_002,
-
- 'text-ada-001': Model.text_ada_001,
- 'text-babbage-001': Model.text_babbage_001,
- 'text-curie-001': Model.text_curie_001,
- 'text-davinci-002': Model.text_davinci_002,
- 'text-davinci-003': Model.text_davinci_003,
-
- 'palm2': Model.palm,
- 'palm': Model.palm,
- 'google': Model.palm,
- 'google-bard': Model.palm,
- 'google-palm': Model.palm,
- 'bard': Model.palm,
-
- 'falcon-40b': Model.falcon_40b,
- 'falcon-7b': Model.falcon_7b,
- 'llama-13b': Model.llama_13b,
- }
diff --git a/spaces/CyberHarem/find_my_waifu/civitai.py b/spaces/CyberHarem/find_my_waifu/civitai.py
deleted file mode 100644
index 7f235e092ca6430818213fc5de8ffd141c26cc16..0000000000000000000000000000000000000000
--- a/spaces/CyberHarem/find_my_waifu/civitai.py
+++ /dev/null
@@ -1,26 +0,0 @@
-from gchar.games.dispatch.access import GAME_CHARS
-
-
-def try_find_title(char_name, game_name):
- try:
- game_cls = GAME_CHARS[game_name.lower()]
- ch = game_cls.get(char_name)
- if ch:
- names = []
- if ch.enname:
- names.append(str(ch.enname))
- if ch.jpname:
- names.append(str(ch.jpname))
- if ch.cnname:
- names.append(str(ch.cnname))
- if hasattr(ch, 'krname') and ch.krname:
- names.append(str(ch.krname))
-
- return f"{'/'.join(names)} ({game_cls.__official_name__})"
-
- else:
- cname = ' '.join(list(map(str.capitalize, char_name.split(' '))))
- return f'{cname} ({game_cls.__official_name__})'
-
- except KeyError:
- return None
diff --git a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/PIL/PSDraw.py b/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/PIL/PSDraw.py
deleted file mode 100644
index 13b3048f67e18ac58170c3a1bd25cb18d66b30fe..0000000000000000000000000000000000000000
--- a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/PIL/PSDraw.py
+++ /dev/null
@@ -1,229 +0,0 @@
-#
-# The Python Imaging Library
-# $Id$
-#
-# Simple PostScript graphics interface
-#
-# History:
-# 1996-04-20 fl Created
-# 1999-01-10 fl Added gsave/grestore to image method
-# 2005-05-04 fl Fixed floating point issue in image (from Eric Etheridge)
-#
-# Copyright (c) 1997-2005 by Secret Labs AB. All rights reserved.
-# Copyright (c) 1996 by Fredrik Lundh.
-#
-# See the README file for information on usage and redistribution.
-#
-
-import sys
-
-from . import EpsImagePlugin
-
-##
-# Simple PostScript graphics interface.
-
-
-class PSDraw:
- """
- Sets up printing to the given file. If ``fp`` is omitted,
- ``sys.stdout.buffer`` or ``sys.stdout`` is assumed.
- """
-
- def __init__(self, fp=None):
- if not fp:
- try:
- fp = sys.stdout.buffer
- except AttributeError:
- fp = sys.stdout
- self.fp = fp
-
- def begin_document(self, id=None):
- """Set up printing of a document. (Write PostScript DSC header.)"""
- # FIXME: incomplete
- self.fp.write(
- b"%!PS-Adobe-3.0\n"
- b"save\n"
- b"/showpage { } def\n"
- b"%%EndComments\n"
- b"%%BeginDocument\n"
- )
- # self.fp.write(ERROR_PS) # debugging!
- self.fp.write(EDROFF_PS)
- self.fp.write(VDI_PS)
- self.fp.write(b"%%EndProlog\n")
- self.isofont = {}
-
- def end_document(self):
- """Ends printing. (Write PostScript DSC footer.)"""
- self.fp.write(b"%%EndDocument\nrestore showpage\n%%End\n")
- if hasattr(self.fp, "flush"):
- self.fp.flush()
-
- def setfont(self, font, size):
- """
- Selects which font to use.
-
- :param font: A PostScript font name
- :param size: Size in points.
- """
- font = bytes(font, "UTF-8")
- if font not in self.isofont:
- # reencode font
- self.fp.write(b"/PSDraw-%s ISOLatin1Encoding /%s E\n" % (font, font))
- self.isofont[font] = 1
- # rough
- self.fp.write(b"/F0 %d /PSDraw-%s F\n" % (size, font))
-
- def line(self, xy0, xy1):
- """
- Draws a line between the two points. Coordinates are given in
- PostScript point coordinates (72 points per inch, (0, 0) is the lower
- left corner of the page).
- """
- self.fp.write(b"%d %d %d %d Vl\n" % (*xy0, *xy1))
-
- def rectangle(self, box):
- """
- Draws a rectangle.
-
- :param box: A tuple of four integers, specifying left, bottom, width and
- height.
- """
- self.fp.write(b"%d %d M 0 %d %d Vr\n" % box)
-
- def text(self, xy, text):
- """
- Draws text at the given position. You must use
- :py:meth:`~PIL.PSDraw.PSDraw.setfont` before calling this method.
- """
- text = bytes(text, "UTF-8")
- text = b"\\(".join(text.split(b"("))
- text = b"\\)".join(text.split(b")"))
- xy += (text,)
- self.fp.write(b"%d %d M (%s) S\n" % xy)
-
- def image(self, box, im, dpi=None):
- """Draw a PIL image, centered in the given box."""
- # default resolution depends on mode
- if not dpi:
- if im.mode == "1":
- dpi = 200 # fax
- else:
- dpi = 100 # greyscale
- # image size (on paper)
- x = im.size[0] * 72 / dpi
- y = im.size[1] * 72 / dpi
- # max allowed size
- xmax = float(box[2] - box[0])
- ymax = float(box[3] - box[1])
- if x > xmax:
- y = y * xmax / x
- x = xmax
- if y > ymax:
- x = x * ymax / y
- y = ymax
- dx = (xmax - x) / 2 + box[0]
- dy = (ymax - y) / 2 + box[1]
- self.fp.write(b"gsave\n%f %f translate\n" % (dx, dy))
- if (x, y) != im.size:
- # EpsImagePlugin._save prints the image at (0,0,xsize,ysize)
- sx = x / im.size[0]
- sy = y / im.size[1]
- self.fp.write(b"%f %f scale\n" % (sx, sy))
- EpsImagePlugin._save(im, self.fp, None, 0)
- self.fp.write(b"\ngrestore\n")
-
-
-# --------------------------------------------------------------------
-# PostScript driver
-
-#
-# EDROFF.PS -- PostScript driver for Edroff 2
-#
-# History:
-# 94-01-25 fl: created (edroff 2.04)
-#
-# Copyright (c) Fredrik Lundh 1994.
-#
-
-
-EDROFF_PS = b"""\
-/S { show } bind def
-/P { moveto show } bind def
-/M { moveto } bind def
-/X { 0 rmoveto } bind def
-/Y { 0 exch rmoveto } bind def
-/E { findfont
- dup maxlength dict begin
- {
- 1 index /FID ne { def } { pop pop } ifelse
- } forall
- /Encoding exch def
- dup /FontName exch def
- currentdict end definefont pop
-} bind def
-/F { findfont exch scalefont dup setfont
- [ exch /setfont cvx ] cvx bind def
-} bind def
-"""
-
-#
-# VDI.PS -- PostScript driver for VDI meta commands
-#
-# History:
-# 94-01-25 fl: created (edroff 2.04)
-#
-# Copyright (c) Fredrik Lundh 1994.
-#
-
-VDI_PS = b"""\
-/Vm { moveto } bind def
-/Va { newpath arcn stroke } bind def
-/Vl { moveto lineto stroke } bind def
-/Vc { newpath 0 360 arc closepath } bind def
-/Vr { exch dup 0 rlineto
- exch dup 0 exch rlineto
- exch neg 0 rlineto
- 0 exch neg rlineto
- setgray fill } bind def
-/Tm matrix def
-/Ve { Tm currentmatrix pop
- translate scale newpath 0 0 .5 0 360 arc closepath
- Tm setmatrix
-} bind def
-/Vf { currentgray exch setgray fill setgray } bind def
-"""
-
-#
-# ERROR.PS -- Error handler
-#
-# History:
-# 89-11-21 fl: created (pslist 1.10)
-#
-
-ERROR_PS = b"""\
-/landscape false def
-/errorBUF 200 string def
-/errorNL { currentpoint 10 sub exch pop 72 exch moveto } def
-errordict begin /handleerror {
- initmatrix /Courier findfont 10 scalefont setfont
- newpath 72 720 moveto $error begin /newerror false def
- (PostScript Error) show errorNL errorNL
- (Error: ) show
- /errorname load errorBUF cvs show errorNL errorNL
- (Command: ) show
- /command load dup type /stringtype ne { errorBUF cvs } if show
- errorNL errorNL
- (VMstatus: ) show
- vmstatus errorBUF cvs show ( bytes available, ) show
- errorBUF cvs show ( bytes used at level ) show
- errorBUF cvs show errorNL errorNL
- (Operand stargck: ) show errorNL /ostargck load {
- dup type /stringtype ne { errorBUF cvs } if 72 0 rmoveto show errorNL
- } forall errorNL
- (Execution stargck: ) show errorNL /estargck load {
- dup type /stringtype ne { errorBUF cvs } if 72 0 rmoveto show errorNL
- } forall
- end showpage
-} def end
-"""
diff --git a/spaces/DaleChen/AutoGPT/autogpt/workspace.py b/spaces/DaleChen/AutoGPT/autogpt/workspace.py
deleted file mode 100644
index 6fb0e3113eb2c1338edf7f86c6e162fc27c61e50..0000000000000000000000000000000000000000
--- a/spaces/DaleChen/AutoGPT/autogpt/workspace.py
+++ /dev/null
@@ -1,47 +0,0 @@
-from __future__ import annotations
-
-import os
-from pathlib import Path
-
-from autogpt.config import Config
-
-CFG = Config()
-
-# Set a dedicated folder for file I/O
-WORKSPACE_PATH = Path(os.getcwd()) / "auto_gpt_workspace"
-
-# Create the directory if it doesn't exist
-if not os.path.exists(WORKSPACE_PATH):
- os.makedirs(WORKSPACE_PATH)
-
-
-def path_in_workspace(relative_path: str | Path) -> Path:
- """Get full path for item in workspace
-
- Parameters:
- relative_path (str | Path): Path to translate into the workspace
-
- Returns:
- Path: Absolute path for the given path in the workspace
- """
- return safe_path_join(WORKSPACE_PATH, relative_path)
-
-
-def safe_path_join(base: Path, *paths: str | Path) -> Path:
- """Join one or more path components, asserting the resulting path is within the workspace.
-
- Args:
- base (Path): The base path
- *paths (str): The paths to join to the base path
-
- Returns:
- Path: The joined path
- """
- joined_path = base.joinpath(*paths).resolve()
-
- if CFG.restrict_to_workspace and not joined_path.is_relative_to(base):
- raise ValueError(
- f"Attempted to access path '{joined_path}' outside of workspace '{base}'."
- )
-
- return joined_path
diff --git a/spaces/Danil/AnyNameHack/indexer.py b/spaces/Danil/AnyNameHack/indexer.py
deleted file mode 100644
index ed643b491109c741df1e914e801c88b9fbb02b32..0000000000000000000000000000000000000000
--- a/spaces/Danil/AnyNameHack/indexer.py
+++ /dev/null
@@ -1,161 +0,0 @@
-import pickle
-import faiss
-import numpy as np
-import pandas as pd
-from utils import *
-from sentence_transformers import SentenceTransformer
-
-from tqdm import tqdm
-from typing import List
-
-
-class FAISS:
- def __init__(self, dimensions: int) -> None:
- self.dimensions = dimensions
- self.index = faiss.IndexFlatL2(dimensions)
- self.vectors = {}
- self.counter = 0
- self.model_name = 'paraphrase-multilingual-MiniLM-L12-v2'
- self.sentence_encoder = SentenceTransformer(self.model_name)
-
- def init_vectors(self, path: str) -> None:
- """
- Заполняет набор векторов предобученными значениями
-
- Args:
- path: путь к файлу в формате pickle
- """
- with open(path, 'rb') as pkl_file:
- self.vectors = pickle.load(pkl_file)
-
- self.counter = len(self.vectors)
-
- def init_index(self, path) -> None:
- """
- Заполняет индекс FAISS предобученными значениями
-
- Args:
- path: путь к файлу в формате FAISS
- """
- self.index = faiss.read_index(path)
-
- def save_vectors(self, path: str) -> None:
- """
- Сохраняет набор векторов
-
- Args:
- path: желаемый путь к файлу
- """
- with open(path, "wb") as fp:
- pickle.dump(self.index.vectors, fp)
-
- def save_index(self, path: str) -> None:
- """
- Сохраняет индекс FAISS
-
- Args:
- path: желаемый путь к файлу
- """
- faiss.write_index(self.index, path)
-
- def add(self, text: str, idx: int, pop: float, emb=None) -> None:
- """
- Добавляет в поисковый индекс новый вектор
-
- Args:
- text: текст запроса
- idx: индекс нового вектора
- pop: популярность запроса
- emb (optional): эмбеддинг текста запроса (если не указан, то будет подготовлен с помощью self.sentence_encoder)
- """
- if emb is None:
- text_vec = self.sentence_encoder.encode([text])
- else:
- text_vec = emb
-
- self.index.add(text_vec)
- self.vectors[self.counter] = (idx, text, pop, text_vec)
-
- self.counter += 1
-
- def search(self, v: List, k: int = 10) -> List[List]:
- """
- Ищет в поисковом индексе ближайших соседей к вектору v
-
- Args:
- v: вектор для поиска ближайших соседей
- k: число векторов в выдаче
- Returns:
- список векторов, ближайших к вектору v, в формате [idx, text, popularity, similarity]
- """
- result = []
- distance, item_index = self.index.search(v, k)
- for dist, i in zip(distance[0], item_index[0]):
- if i == -1:
- break
- else:
- result.append((self.vectors[i][0], self.vectors[i][1], self.vectors[i][2], dist))
-
- return result
-
- def suggest_tags(self, query: str, top_n: int = 10, k: int = 30) -> List[str]:
- """
- Получает список тегов для пользователя по текстовому запросу
-
- Args:
- query: запрос пользователя
- top_n (optional): число тегов в выдаче
- k (optional): число векторов из индекса, среди которых будут искаться теги для выдачи
- Returns:
- список тегов для выдачи пользователю
- """
- emb = self.sentence_encoder.encode([query.lower()])
- r = self.search(emb, k)
-
- result = []
- for i in r:
- if check(query, i[1]):
- result.append(i)
- # надо добавить вес относительно длины
- result = sorted(result, key=lambda x: x[0] * 0.3 - x[-1], reverse=True)
- total_result = []
- for i in range(len(result)):
- flag = True
- for j in result[i + 1:]:
- flag &= easy_check(result[i][1], j[1])
- if flag:
- total_result.append(result[i][1])
-
- return total_result[:top_n]
-
- def fill(self, queries: List[str], popularities: pd.DataFrame) -> None:
- """
- Заполняет поисковый индекс запросами queries, популярности которых берутся из таблицы popularities
-
- Args:
- queries: список запросов
- popularities: таблица, в которой содержатся колонки query и query_popularity
- """
- idx = -1
- for query in tqdm(queries):
- idx += 1
- if type(query) == str:
- emb = self.index.sentence_encoder.encode([query.lower()])
- bool_add = True
- search_sim = self.index.search(emb, 1)
-
- try:
- popularity = popularities[popularities["query"] == query]["query_popularity"].item()
- except ValueError:
- # Если для текущего запроса неизвестна популярность, возьмем значение 5
- popularity = 5
-
- if len(search_sim) > 0:
- search_sim = search_sim[0]
- if search_sim[-1] < 0.15:
- # Не добавляем вектор, если он находится достаточно близко к уже присутствующему в индексе
- bool_add = False
- if bool_add:
- self.index.add(query, popularity, idx, emb)
- else:
- self.index.add(query, popularity, idx, emb)
\ No newline at end of file
diff --git a/spaces/Datasculptor/StyleGAN-NADA/e4e/utils/common.py b/spaces/Datasculptor/StyleGAN-NADA/e4e/utils/common.py
deleted file mode 100644
index b19e18ddcb78b06678fa18e4a76da44fc511b789..0000000000000000000000000000000000000000
--- a/spaces/Datasculptor/StyleGAN-NADA/e4e/utils/common.py
+++ /dev/null
@@ -1,55 +0,0 @@
-from PIL import Image
-import matplotlib.pyplot as plt
-
-
-# Log images
-def log_input_image(x, opts):
- return tensor2im(x)
-
-
-def tensor2im(var):
- # var shape: (3, H, W)
- var = var.cpu().detach().transpose(0, 2).transpose(0, 1).numpy()
- var = ((var + 1) / 2)
- var[var < 0] = 0
- var[var > 1] = 1
- var = var * 255
- return Image.fromarray(var.astype('uint8'))
-
-
-def vis_faces(log_hooks):
- display_count = len(log_hooks)
- fig = plt.figure(figsize=(8, 4 * display_count))
- gs = fig.add_gridspec(display_count, 3)
- for i in range(display_count):
- hooks_dict = log_hooks[i]
- fig.add_subplot(gs[i, 0])
- if 'diff_input' in hooks_dict:
- vis_faces_with_id(hooks_dict, fig, gs, i)
- else:
- vis_faces_no_id(hooks_dict, fig, gs, i)
- plt.tight_layout()
- return fig
-
-
-def vis_faces_with_id(hooks_dict, fig, gs, i):
- plt.imshow(hooks_dict['input_face'])
- plt.title('Input\nOut Sim={:.2f}'.format(float(hooks_dict['diff_input'])))
- fig.add_subplot(gs[i, 1])
- plt.imshow(hooks_dict['target_face'])
- plt.title('Target\nIn={:.2f}, Out={:.2f}'.format(float(hooks_dict['diff_views']),
- float(hooks_dict['diff_target'])))
- fig.add_subplot(gs[i, 2])
- plt.imshow(hooks_dict['output_face'])
- plt.title('Output\n Target Sim={:.2f}'.format(float(hooks_dict['diff_target'])))
-
-
-def vis_faces_no_id(hooks_dict, fig, gs, i):
- plt.imshow(hooks_dict['input_face'], cmap="gray")
- plt.title('Input')
- fig.add_subplot(gs[i, 1])
- plt.imshow(hooks_dict['target_face'])
- plt.title('Target')
- fig.add_subplot(gs[i, 2])
- plt.imshow(hooks_dict['output_face'])
- plt.title('Output')
diff --git a/spaces/Deci/DeciDiffusion-v1-0/header.html b/spaces/Deci/DeciDiffusion-v1-0/header.html
deleted file mode 100644
index fafbcb3146686659a84a80ead9d1c4b7998dd94b..0000000000000000000000000000000000000000
--- a/spaces/Deci/DeciDiffusion-v1-0/header.html
+++ /dev/null
@@ -1,17 +0,0 @@
-
\ No newline at end of file
diff --git a/spaces/Detomo/ai-comic-generation/src/components/ui/input.tsx b/spaces/Detomo/ai-comic-generation/src/components/ui/input.tsx
deleted file mode 100644
index 0757ddebdca3800bbd4a46fe1c2c17dff86c5e2f..0000000000000000000000000000000000000000
--- a/spaces/Detomo/ai-comic-generation/src/components/ui/input.tsx
+++ /dev/null
@@ -1,25 +0,0 @@
-import * as React from "react"
-
-import { cn } from "@/lib/utils"
-
-export interface InputProps
- extends React.InputHTMLAttributes {}
-
-const Input = React.forwardRef(
- ({ className, type, ...props }, ref) => {
- return (
-
- )
- }
-)
-Input.displayName = "Input"
-
-export { Input }
diff --git a/spaces/ECCV2022/PSG/OpenPSG/configs/gpsnet/panoptic_fpn_r101_fpn_1x_predcls_psg.py b/spaces/ECCV2022/PSG/OpenPSG/configs/gpsnet/panoptic_fpn_r101_fpn_1x_predcls_psg.py
deleted file mode 100644
index 1be5fdcf74eeb3e941ef2829546cfb14338face8..0000000000000000000000000000000000000000
--- a/spaces/ECCV2022/PSG/OpenPSG/configs/gpsnet/panoptic_fpn_r101_fpn_1x_predcls_psg.py
+++ /dev/null
@@ -1,26 +0,0 @@
-_base_ = './panoptic_fpn_r50_fpn_1x_predcls_psg.py'
-
-model = dict(backbone=dict(
- depth=101,
- init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet101')))
-
-# Log config
-project_name = 'openpsg'
-expt_name = 'gpsnet_panoptic_fpn_r101_fpn_1x_predcls_psg'
-work_dir = f'./work_dirs/{expt_name}'
-
-log_config = dict(
- interval=50,
- hooks=[
- dict(type='TextLoggerHook'),
- dict(
- type='WandbLoggerHook',
- init_kwargs=dict(
- project=project_name,
- name=expt_name,
- ),
- ),
- ],
-)
-
-load_from = 'work_dirs/checkpoints/panoptic_fpn_r101_fpn_1x_coco_20210820_193950-ab9157a2.pth'
diff --git a/spaces/EPFL-VILAB/MultiMAE/mask2former/utils/misc.py b/spaces/EPFL-VILAB/MultiMAE/mask2former/utils/misc.py
deleted file mode 100644
index 874d9805b482f52bbffc1be620e36e0cffc07c46..0000000000000000000000000000000000000000
--- a/spaces/EPFL-VILAB/MultiMAE/mask2former/utils/misc.py
+++ /dev/null
@@ -1,111 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-# Modified by Bowen Cheng from https://github.com/facebookresearch/detr/blob/master/util/misc.py
-"""
-Misc functions, including distributed helpers.
-
-Mostly copy-paste from torchvision references.
-"""
-from typing import List, Optional
-
-import torch
-import torch.distributed as dist
-import torchvision
-from torch import Tensor
-
-
-def _max_by_axis(the_list):
- # type: (List[List[int]]) -> List[int]
- maxes = the_list[0]
- for sublist in the_list[1:]:
- for index, item in enumerate(sublist):
- maxes[index] = max(maxes[index], item)
- return maxes
-
-
-class NestedTensor(object):
- def __init__(self, tensors, mask: Optional[Tensor]):
- self.tensors = tensors
- self.mask = mask
-
- def to(self, device):
- # type: (Device) -> NestedTensor # noqa
- cast_tensor = self.tensors.to(device)
- mask = self.mask
- if mask is not None:
- assert mask is not None
- cast_mask = mask.to(device)
- else:
- cast_mask = None
- return NestedTensor(cast_tensor, cast_mask)
-
- def decompose(self):
- return self.tensors, self.mask
-
- def __repr__(self):
- return str(self.tensors)
-
-
-def nested_tensor_from_tensor_list(tensor_list: List[Tensor]):
- # TODO make this more general
- if tensor_list[0].ndim == 3:
- if torchvision._is_tracing():
- # nested_tensor_from_tensor_list() does not export well to ONNX
- # call _onnx_nested_tensor_from_tensor_list() instead
- return _onnx_nested_tensor_from_tensor_list(tensor_list)
-
- # TODO make it support different-sized images
- max_size = _max_by_axis([list(img.shape) for img in tensor_list])
- # min_size = tuple(min(s) for s in zip(*[img.shape for img in tensor_list]))
- batch_shape = [len(tensor_list)] + max_size
- b, c, h, w = batch_shape
- dtype = tensor_list[0].dtype
- device = tensor_list[0].device
- tensor = torch.zeros(batch_shape, dtype=dtype, device=device)
- mask = torch.ones((b, h, w), dtype=torch.bool, device=device)
- for img, pad_img, m in zip(tensor_list, tensor, mask):
- pad_img[: img.shape[0], : img.shape[1], : img.shape[2]].copy_(img)
- m[: img.shape[1], : img.shape[2]] = False
- else:
- raise ValueError("not supported")
- return NestedTensor(tensor, mask)
-
-
-# _onnx_nested_tensor_from_tensor_list() is an implementation of
-# nested_tensor_from_tensor_list() that is supported by ONNX tracing.
-@torch.jit.unused
-def _onnx_nested_tensor_from_tensor_list(tensor_list: List[Tensor]) -> NestedTensor:
- max_size = []
- for i in range(tensor_list[0].dim()):
- max_size_i = torch.max(
- torch.stack([img.shape[i] for img in tensor_list]).to(torch.float32)
- ).to(torch.int64)
- max_size.append(max_size_i)
- max_size = tuple(max_size)
-
- # work around for
- # pad_img[: img.shape[0], : img.shape[1], : img.shape[2]].copy_(img)
- # m[: img.shape[1], :img.shape[2]] = False
- # which is not yet supported in onnx
- padded_imgs = []
- padded_masks = []
- for img in tensor_list:
- padding = [(s1 - s2) for s1, s2 in zip(max_size, tuple(img.shape))]
- padded_img = torch.nn.functional.pad(img, (0, padding[2], 0, padding[1], 0, padding[0]))
- padded_imgs.append(padded_img)
-
- m = torch.zeros_like(img[0], dtype=torch.int, device=img.device)
- padded_mask = torch.nn.functional.pad(m, (0, padding[2], 0, padding[1]), "constant", 1)
- padded_masks.append(padded_mask.to(torch.bool))
-
- tensor = torch.stack(padded_imgs)
- mask = torch.stack(padded_masks)
-
- return NestedTensor(tensor, mask=mask)
-
-
-def is_dist_avail_and_initialized():
- if not dist.is_available():
- return False
- if not dist.is_initialized():
- return False
- return True
diff --git a/spaces/EXPOSUREEE/Ai-Image-Enhancer/scripts/pytorch2onnx.py b/spaces/EXPOSUREEE/Ai-Image-Enhancer/scripts/pytorch2onnx.py
deleted file mode 100644
index 09d99b2e0171265e70e7507ed8e882b616b449a1..0000000000000000000000000000000000000000
--- a/spaces/EXPOSUREEE/Ai-Image-Enhancer/scripts/pytorch2onnx.py
+++ /dev/null
@@ -1,36 +0,0 @@
-import argparse
-import torch
-import torch.onnx
-from basicsr.archs.rrdbnet_arch import RRDBNet
-
-
-def main(args):
- # An instance of the model
- model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=23, num_grow_ch=32, scale=4)
- if args.params:
- keyname = 'params'
- else:
- keyname = 'params_ema'
- model.load_state_dict(torch.load(args.input)[keyname])
- # set the train mode to false since we will only run the forward pass.
- model.train(False)
- model.cpu().eval()
-
- # An example input
- x = torch.rand(1, 3, 64, 64)
- # Export the model
- with torch.no_grad():
- torch_out = torch.onnx._export(model, x, args.output, opset_version=11, export_params=True)
- print(torch_out.shape)
-
-
-if __name__ == '__main__':
- """Convert pytorch model to onnx models"""
- parser = argparse.ArgumentParser()
- parser.add_argument(
- '--input', type=str, default='experiments/pretrained_models/RealESRGAN_x4plus.pth', help='Input model path')
- parser.add_argument('--output', type=str, default='realesrgan-x4.onnx', help='Output onnx path')
- parser.add_argument('--params', action='store_false', help='Use params instead of params_ema')
- args = parser.parse_args()
-
- main(args)
diff --git a/spaces/EinsteinCoder/sf-voicebot/README.md b/spaces/EinsteinCoder/sf-voicebot/README.md
deleted file mode 100644
index 92d2c1835bad28014b06dd84025016837ace0b91..0000000000000000000000000000000000000000
--- a/spaces/EinsteinCoder/sf-voicebot/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: SF VoiceBot
-emoji: 💻
-colorFrom: pink
-colorTo: green
-sdk: docker
-pinned: false
-license: other
-app_port: 5050
-duplicated_from: EinsteinCoder/fastapi-demo
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
\ No newline at end of file
diff --git a/spaces/ElainaFanBoy/IRONY-Real-ESRGAN/realesrgan/data/__init__.py b/spaces/ElainaFanBoy/IRONY-Real-ESRGAN/realesrgan/data/__init__.py
deleted file mode 100644
index a3f8fdd1aa47c12de9687c578094303eb7369246..0000000000000000000000000000000000000000
--- a/spaces/ElainaFanBoy/IRONY-Real-ESRGAN/realesrgan/data/__init__.py
+++ /dev/null
@@ -1,10 +0,0 @@
-import importlib
-from basicsr.utils import scandir
-from os import path as osp
-
-# automatically scan and import dataset modules for registry
-# scan all the files that end with '_dataset.py' under the data folder
-data_folder = osp.dirname(osp.abspath(__file__))
-dataset_filenames = [osp.splitext(osp.basename(v))[0] for v in scandir(data_folder) if v.endswith('_dataset.py')]
-# import all the dataset modules
-_dataset_modules = [importlib.import_module(f'realesrgan.data.{file_name}') for file_name in dataset_filenames]
diff --git a/spaces/EronSamez/RVC_HFmeu/lib/uvr5_pack/lib_v5/layers_123812KB .py b/spaces/EronSamez/RVC_HFmeu/lib/uvr5_pack/lib_v5/layers_123812KB .py
deleted file mode 100644
index b82f06bb4993cd63f076e68d7e24185269b1bc42..0000000000000000000000000000000000000000
--- a/spaces/EronSamez/RVC_HFmeu/lib/uvr5_pack/lib_v5/layers_123812KB .py
+++ /dev/null
@@ -1,118 +0,0 @@
-import torch
-from torch import nn
-import torch.nn.functional as F
-
-from . import spec_utils
-
-
-class Conv2DBNActiv(nn.Module):
- def __init__(self, nin, nout, ksize=3, stride=1, pad=1, dilation=1, activ=nn.ReLU):
- super(Conv2DBNActiv, self).__init__()
- self.conv = nn.Sequential(
- nn.Conv2d(
- nin,
- nout,
- kernel_size=ksize,
- stride=stride,
- padding=pad,
- dilation=dilation,
- bias=False,
- ),
- nn.BatchNorm2d(nout),
- activ(),
- )
-
- def __call__(self, x):
- return self.conv(x)
-
-
-class SeperableConv2DBNActiv(nn.Module):
- def __init__(self, nin, nout, ksize=3, stride=1, pad=1, dilation=1, activ=nn.ReLU):
- super(SeperableConv2DBNActiv, self).__init__()
- self.conv = nn.Sequential(
- nn.Conv2d(
- nin,
- nin,
- kernel_size=ksize,
- stride=stride,
- padding=pad,
- dilation=dilation,
- groups=nin,
- bias=False,
- ),
- nn.Conv2d(nin, nout, kernel_size=1, bias=False),
- nn.BatchNorm2d(nout),
- activ(),
- )
-
- def __call__(self, x):
- return self.conv(x)
-
-
-class Encoder(nn.Module):
- def __init__(self, nin, nout, ksize=3, stride=1, pad=1, activ=nn.LeakyReLU):
- super(Encoder, self).__init__()
- self.conv1 = Conv2DBNActiv(nin, nout, ksize, 1, pad, activ=activ)
- self.conv2 = Conv2DBNActiv(nout, nout, ksize, stride, pad, activ=activ)
-
- def __call__(self, x):
- skip = self.conv1(x)
- h = self.conv2(skip)
-
- return h, skip
-
-
-class Decoder(nn.Module):
- def __init__(
- self, nin, nout, ksize=3, stride=1, pad=1, activ=nn.ReLU, dropout=False
- ):
- super(Decoder, self).__init__()
- self.conv = Conv2DBNActiv(nin, nout, ksize, 1, pad, activ=activ)
- self.dropout = nn.Dropout2d(0.1) if dropout else None
-
- def __call__(self, x, skip=None):
- x = F.interpolate(x, scale_factor=2, mode="bilinear", align_corners=True)
- if skip is not None:
- skip = spec_utils.crop_center(skip, x)
- x = torch.cat([x, skip], dim=1)
- h = self.conv(x)
-
- if self.dropout is not None:
- h = self.dropout(h)
-
- return h
-
-
-class ASPPModule(nn.Module):
- def __init__(self, nin, nout, dilations=(4, 8, 16), activ=nn.ReLU):
- super(ASPPModule, self).__init__()
- self.conv1 = nn.Sequential(
- nn.AdaptiveAvgPool2d((1, None)),
- Conv2DBNActiv(nin, nin, 1, 1, 0, activ=activ),
- )
- self.conv2 = Conv2DBNActiv(nin, nin, 1, 1, 0, activ=activ)
- self.conv3 = SeperableConv2DBNActiv(
- nin, nin, 3, 1, dilations[0], dilations[0], activ=activ
- )
- self.conv4 = SeperableConv2DBNActiv(
- nin, nin, 3, 1, dilations[1], dilations[1], activ=activ
- )
- self.conv5 = SeperableConv2DBNActiv(
- nin, nin, 3, 1, dilations[2], dilations[2], activ=activ
- )
- self.bottleneck = nn.Sequential(
- Conv2DBNActiv(nin * 5, nout, 1, 1, 0, activ=activ), nn.Dropout2d(0.1)
- )
-
- def forward(self, x):
- _, _, h, w = x.size()
- feat1 = F.interpolate(
- self.conv1(x), size=(h, w), mode="bilinear", align_corners=True
- )
- feat2 = self.conv2(x)
- feat3 = self.conv3(x)
- feat4 = self.conv4(x)
- feat5 = self.conv5(x)
- out = torch.cat((feat1, feat2, feat3, feat4, feat5), dim=1)
- bottle = self.bottleneck(out)
- return bottle
diff --git a/spaces/FridaZuley/RVC_HFKawaii/julius/fftconv.py b/spaces/FridaZuley/RVC_HFKawaii/julius/fftconv.py
deleted file mode 100644
index 1920e5369bb49b76eeea1832b7be2a0ddbc8db6b..0000000000000000000000000000000000000000
--- a/spaces/FridaZuley/RVC_HFKawaii/julius/fftconv.py
+++ /dev/null
@@ -1,183 +0,0 @@
-# File under the MIT license, see https://github.com/adefossez/julius/LICENSE for details.
-# Author: adefossez, 2020
-
-"""
-Implementation of a FFT based 1D convolution in PyTorch.
-While FFT is used in CUDNN for small kernel sizes, it is not the case for long ones, e.g. 512.
-This module implements efficient FFT based convolutions for such convolutions. A typical
-application is for evaluationg FIR filters with a long receptive field, typically
-evaluated with a stride of 1.
-"""
-from typing import Optional
-
-import torch
-try:
- import torch.fft as new_fft
-except ImportError:
- new_fft = None # type: ignore
-from torch.nn import functional as F
-
-from .core import pad_to, unfold
-from .utils import simple_repr
-
-
-# This is quite verbose, but sadly needed to make TorchScript happy.
-def _new_rfft(x: torch.Tensor):
- z = new_fft.rfft(x, dim=-1)
- return torch.view_as_real(z)
-
-
-def _old_rfft(x: torch.Tensor):
- return torch.rfft(x, 1) # type: ignore
-
-
-def _old_irfft(x: torch.Tensor, length: int):
- result = torch.irfft(x, 1, signal_sizes=(length,)) # type: ignore
- return result
-
-
-def _new_irfft(x: torch.Tensor, length: int):
- x = torch.view_as_complex(x)
- return new_fft.irfft(x, length, dim=-1)
-
-
-if new_fft is None:
- _rfft = _old_rfft
- _irfft = _old_irfft
-else:
- _rfft = _new_rfft
- _irfft = _new_irfft
-
-
-def _compl_mul_conjugate(a: torch.Tensor, b: torch.Tensor):
- """
- Given a and b two tensors of dimension 4
- with the last dimension being the real and imaginary part,
- returns a multiplied by the conjugate of b, the multiplication
- being with respect to the second dimension.
-
- """
- # PyTorch 1.7 supports complex number, but not for all operations.
- # Once the support is widespread, this can likely go away.
-
- op = "bcft,dct->bdft"
- return torch.stack([
- torch.einsum(op, a[..., 0], b[..., 0]) + torch.einsum(op, a[..., 1], b[..., 1]),
- torch.einsum(op, a[..., 1], b[..., 0]) - torch.einsum(op, a[..., 0], b[..., 1])
- ],
- dim=-1)
-
-
-def fft_conv1d(
- input: torch.Tensor, weight: torch.Tensor,
- bias: Optional[torch.Tensor] = None, stride: int = 1, padding: int = 0,
- block_ratio: float = 5):
- """
- Same as `torch.nn.functional.conv1d` but using FFT for the convolution.
- Please check PyTorch documentation for more information.
-
- Args:
- input (Tensor): input signal of shape `[B, C, T]`.
- weight (Tensor): weight of the convolution `[D, C, K]` with `D` the number
- of output channels.
- bias (Tensor or None): if not None, bias term for the convolution.
- stride (int): stride of convolution.
- padding (int): padding to apply to the input.
- block_ratio (float): can be tuned for speed. The input is splitted in chunks
- with a size of `int(block_ratio * kernel_size)`.
-
- Shape:
-
- - Inputs: `input` is `[B, C, T]`, `weight` is `[D, C, K]` and bias is `[D]`.
- - Output: `(*, T)`
-
-
- ..note::
- This function is faster than `torch.nn.functional.conv1d` only in specific cases.
- Typically, the kernel size should be of the order of 256 to see any real gain,
- for a stride of 1.
-
- ..Warning::
- Dilation and groups are not supported at the moment. This function might use
- more memory than the default Conv1d implementation.
- """
- input = F.pad(input, (padding, padding))
- batch, channels, length = input.shape
- out_channels, _, kernel_size = weight.shape
-
- if length < kernel_size:
- raise RuntimeError(f"Input should be at least as large as the kernel size {kernel_size}, "
- f"but it is only {length} samples long.")
- if block_ratio < 1:
- raise RuntimeError("Block ratio must be greater than 1.")
-
- # We are going to process the input blocks by blocks, as for some reason it is faster
- # and less memory intensive (I think the culprit is `torch.einsum`.
- block_size: int = min(int(kernel_size * block_ratio), length)
- fold_stride = block_size - kernel_size + 1
- weight = pad_to(weight, block_size)
- weight_z = _rfft(weight)
-
- # We pad the input and get the different frames, on which
- frames = unfold(input, block_size, fold_stride)
-
- frames_z = _rfft(frames)
- out_z = _compl_mul_conjugate(frames_z, weight_z)
- out = _irfft(out_z, block_size)
- # The last bit is invalid, because FFT will do a circular convolution.
- out = out[..., :-kernel_size + 1]
- out = out.reshape(batch, out_channels, -1)
- out = out[..., ::stride]
- target_length = (length - kernel_size) // stride + 1
- out = out[..., :target_length]
- if bias is not None:
- out += bias[:, None]
- return out
-
-
-class FFTConv1d(torch.nn.Module):
- """
- Same as `torch.nn.Conv1d` but based on `fft_conv1d`.
- Please check PyTorch documentation for more information.
-
- Args:
- in_channels (int): number of input channels.
- out_channels (int): number of output channels.
- kernel_size (int): kernel size of convolution.
- stride (int): stride of convolution.
- padding (int): padding to apply to the input.
- bias (bool): if True, use a bias term.
-
- ..note::
- This module is faster than `torch.nn.Conv1d` only in specific cases.
- Typically, `kernel_size` should be of the order of 256 to see any real gain,
- for a stride of 1.
-
- ..warning::
- Dilation and groups are not supported at the moment. This module might use
- more memory than the default Conv1d implementation.
-
- >>> fftconv = FFTConv1d(12, 24, 128, 4)
- >>> x = torch.randn(4, 12, 1024)
- >>> print(list(fftconv(x).shape))
- [4, 24, 225]
- """
- def __init__(self, in_channels: int, out_channels: int, kernel_size: int,
- stride: int = 1, padding: int = 0, bias: bool = True):
- super().__init__()
- self.in_channels = in_channels
- self.out_channels = out_channels
- self.kernel_size = kernel_size
- self.stride = stride
- self.padding = padding
-
- conv = torch.nn.Conv1d(in_channels, out_channels, kernel_size, bias=bias)
- self.weight = conv.weight
- self.bias = conv.bias
-
- def forward(self, input: torch.Tensor):
- return fft_conv1d(
- input, self.weight, self.bias, self.stride, self.padding)
-
- def __repr__(self):
- return simple_repr(self, overrides={"bias": self.bias is not None})
diff --git a/spaces/GAIR/Factool/factool/math/pipeline.py b/spaces/GAIR/Factool/factool/math/pipeline.py
deleted file mode 100644
index afa860f172b87d5145dfa2aa1b388a320291b71f..0000000000000000000000000000000000000000
--- a/spaces/GAIR/Factool/factool/math/pipeline.py
+++ /dev/null
@@ -1,192 +0,0 @@
-import json
-import math
-import os
-from typing import List, Dict
-import yaml
-import pdb
-
-from factool.math.tool import python_executor
-from factool.utils.base.pipeline import pipeline
-
-class math_pipeline(pipeline):
- def __init__(self, foundation_model):
- super().__init__('math', foundation_model)
-
- self.tool = python_executor()
-
- with open(os.path.join(self.prompts_path, "claim_extraction.yaml"), 'r') as file:
- data = yaml.load(file, Loader=yaml.FullLoader)
- self.claim_prompt = data['math']
-
- with open(os.path.join(self.prompts_path, 'query_generation.yaml'), 'r') as file:
- data = yaml.load(file, Loader=yaml.FullLoader)
- self.query_prompt = data['math']
-
- def _verification(self, exec_results):
- classification_results = [True for _ in range(len(exec_results))]
- for i in range(len(exec_results)):
- if exec_results[i] is not None and 'False' in exec_results[i]:
- classification_results[i] = False
-
- return classification_results
-
- async def _claim_extraction(self, samples):
- messages_list = [
- [
- {"role": "system", "content": self.claim_prompt['system']},
- {"role": "user", "content": self.claim_prompt['user'].format(input_question=sample['prompt'], input_solution=sample['response'])},
- ]
- for sample in samples
- ]
- return await self.chat.async_run(messages_list, List)
-
- async def _query_generation(self, claims):
- messages_list = [
- [
- {"role": "system", "content": self.query_prompt['system']},
- {"role": "user", "content": self.query_prompt['user'].format(math_calculation=claim['math_calculation'], calculated_answer=claim['calculated_answer'])},
- ]
- for claim in claims
- ]
- return await self.chat.async_run(messages_list, Dict)
-
- async def run_with_tool_live(self, samples):
- claims_in_responses = await self._claim_extraction(samples)
- queries_in_responses = []
- exec_results_in_responses = []
- verifications_in_responses = []
- for claims_in_response in claims_in_responses:
- queries = await self._query_generation(claims_in_response)
- queries_in_responses.append(queries)
- exec_results = []
- for query in queries:
- try:
- exec_results.append(self.tool.run(query['python_snippet']))
- except:
- exec_results.append('None')
- exec_results_in_responses.append(exec_results)
- verifications = self._verification(exec_results)
- verifications_in_responses.append(verifications)
-
- return claims_in_responses, queries_in_responses, exec_results_in_responses, verifications_in_responses
-
- async def run_with_tool_live_without_claim_extraction(self, claims):
- queries = await self._query_generation(claims)
-
- exec_results = []
- for query in queries:
- try:
- exec_results.append(self.tool.run(query['python_snippet']))
- except:
- exec_results.append(None)
- classification_results = self._verification(exec_results)
- return queries, exec_results, classification_results
-
- async def run_with_tool_api_call(self, prompts, responses):
- batch_size = 5
- num_batches = math.ceil(len(prompts) / batch_size)
-
- self.sample_list = [{"prompt": prompt, "response": response, "category": 'math'} for prompt, response in zip(prompts, responses)]
-
- for i in range(num_batches):
- print(i)
- batch_start = i * batch_size
- batch_end = min((i + 1) * batch_size, len(responses))
-
- claims_in_responses, queries_in_responses, exec_results_in_response, verifications_in_responses = await self.run_with_tool_live(self.sample_list[batch_start: batch_end])
-
- for j, (claims_in_response, queries_in_response, exec_results_in_response, verifications_in_response) in enumerate(zip(claims_in_responses, queries_in_responses, exec_results_in_response, verifications_in_responses)):
- index = batch_start + j
-
- self.sample_list[index].update({
- 'claims': claims_in_response,
- 'queries': queries_in_response,
- 'execution_results': exec_results_in_response,
- 'claim_level_factuality': verifications_in_response,
- 'response_level_factuality': all([verification if verification != None else True for verification in verifications_in_response])
- })
-
- return self.sample_list
-
- async def run_with_tool_dataset(self, annotated_dataset_path: str, with_tool_classified_dataset_path: str, rerun: bool = False, rerun_indices: list = []):
- data_path = annotated_dataset_path if not rerun else with_tool_classified_dataset_path
- with open(data_path, 'r') as f:
- data = [json.loads(line) for line in f]
- self.sample_list = data if rerun else [claim for sample in data for claim in sample['claims']]
- rerun_elements = self.sample_list if not rerun else [self.sample_list[i] for i in rerun_indices]
-
- batch_size = 10
- num_batches = math.ceil(len(rerun_elements) / batch_size) # 5
-
- for i in range(num_batches):
- print("test1")
- print(i)
- batch_start = i * batch_size
- batch_end = min((i + 1) * batch_size, len(rerun_elements))
- batch = rerun_elements[batch_start:batch_end]
-
- queries, exec_results, classification_results = await self.run_with_tool_live_without_claim_extraction(batch)
-
- for j, (query, exec_result, classification_result) in enumerate(zip(queries, exec_results, classification_results)):
- index = batch_start + j if not rerun else rerun_indices[batch_start + j]
- self.sample_list[index].update({
- 'query': query,
- 'exec_result': exec_result,
- 'with_tool_classification': classification_result,
- })
-
- # save everything after each batch to prevent data loss
- with open(with_tool_classified_dataset_path, 'w') as f:
- for item in self.sample_list:
- try:
- json_str = json.dumps(item)
- except:
- continue
- f.write(json_str + '\n')
-
- async def run_self_check_live(self, fewshot, batch):
- user_prompt_key = 'user_3_shot_CoT' if fewshot else 'user_zero_shot_CoT'
- messages_list = [
- [
- {"role": "system", "content": self.self_check_prompt['system']},
- {"role": "user", "content": self.self_check_prompt[user_prompt_key].format(input_calculation=response['math_calculation'], input_calculated_answer=response['calculated_answer'])},
- ]
- for response in batch
- ]
- return await self.chat.async_run(messages_list, Dict)
-
- async def run_self_check_dataset(self, annotated_dataset_path: str, self_check_classified_dataset_path: str, fewshot: bool = False, rerun: bool = False, rerun_indices: list = []):
- data_path = annotated_dataset_path if not rerun else self_check_classified_dataset_path
- with open(data_path, 'r') as f:
- data = [json.loads(line) for line in f]
- self.sample_list = data if rerun else [claim for sample in data for claim in sample['claims']]
- rerun_elements = self.sample_list if not rerun else [self.sample_list[i] for i in rerun_indices]
-
- batch_size = 10
- num_batches = math.ceil(len(rerun_elements) / batch_size)
-
- for i in range(num_batches):
- print(i)
- batch_start = i * batch_size
- batch_end = min((i + 1) * batch_size, len(rerun_elements))
- batch = rerun_elements[batch_start:batch_end]
-
- responses = await self.run_self_check_live(fewshot, batch)
- for j, response in enumerate(responses):
- index = batch_start + j if not rerun else rerun_indices[batch_start + j]
- if response is None:
- self.sample_list[index].update({
- 'self_check_classification': 'None',
- 'self_check_reasoning': 'None'
- })
- else:
- self.sample_list[index].update({
- 'self_check_classification': response.get('factuality', 'None'),
- 'self_check_reasoning': response.get('reasoning', 'None')
- })
-
- # save everything after each batch to prevent data loss
- with open(self_check_classified_dataset_path, 'w') as f:
- for item in self.sample_list:
- json_str = json.dumps(item)
- f.write(json_str + '\n')
\ No newline at end of file
diff --git a/spaces/Gradio-Blocks/EmojiGAN/torch_utils/ops/conv2d_resample.py b/spaces/Gradio-Blocks/EmojiGAN/torch_utils/ops/conv2d_resample.py
deleted file mode 100644
index cd4750744c83354bab78704d4ef51ad1070fcc4a..0000000000000000000000000000000000000000
--- a/spaces/Gradio-Blocks/EmojiGAN/torch_utils/ops/conv2d_resample.py
+++ /dev/null
@@ -1,156 +0,0 @@
-# Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
-#
-# NVIDIA CORPORATION and its licensors retain all intellectual property
-# and proprietary rights in and to this software, related documentation
-# and any modifications thereto. Any use, reproduction, disclosure or
-# distribution of this software and related documentation without an express
-# license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-"""2D convolution with optional up/downsampling."""
-
-import torch
-
-from .. import misc
-from . import conv2d_gradfix
-from . import upfirdn2d
-from .upfirdn2d import _parse_padding
-from .upfirdn2d import _get_filter_size
-
-#----------------------------------------------------------------------------
-
-def _get_weight_shape(w):
- with misc.suppress_tracer_warnings(): # this value will be treated as a constant
- shape = [int(sz) for sz in w.shape]
- misc.assert_shape(w, shape)
- return shape
-
-#----------------------------------------------------------------------------
-
-def _conv2d_wrapper(x, w, stride=1, padding=0, groups=1, transpose=False, flip_weight=True):
- """Wrapper for the underlying `conv2d()` and `conv_transpose2d()` implementations.
- """
- out_channels, in_channels_per_group, kh, kw = _get_weight_shape(w)
-
- # Flip weight if requested.
- if not flip_weight: # conv2d() actually performs correlation (flip_weight=True) not convolution (flip_weight=False).
- w = w.flip([2, 3])
-
- # Workaround performance pitfall in cuDNN 8.0.5, triggered when using
- # 1x1 kernel + memory_format=channels_last + less than 64 channels.
- if kw == 1 and kh == 1 and stride == 1 and padding in [0, [0, 0], (0, 0)] and not transpose:
- if x.stride()[1] == 1 and min(out_channels, in_channels_per_group) < 64:
- if out_channels <= 4 and groups == 1:
- in_shape = x.shape
- x = w.squeeze(3).squeeze(2) @ x.reshape([in_shape[0], in_channels_per_group, -1])
- x = x.reshape([in_shape[0], out_channels, in_shape[2], in_shape[3]])
- else:
- x = x.to(memory_format=torch.contiguous_format)
- w = w.to(memory_format=torch.contiguous_format)
- x = conv2d_gradfix.conv2d(x, w, groups=groups)
- return x.to(memory_format=torch.channels_last)
-
- # Otherwise => execute using conv2d_gradfix.
- op = conv2d_gradfix.conv_transpose2d if transpose else conv2d_gradfix.conv2d
- return op(x, w, stride=stride, padding=padding, groups=groups)
-
-#----------------------------------------------------------------------------
-
-@misc.profiled_function
-def conv2d_resample(x, w, f=None, up=1, down=1, padding=0, groups=1, flip_weight=True, flip_filter=False):
- r"""2D convolution with optional up/downsampling.
-
- Padding is performed only once at the beginning, not between the operations.
-
- Args:
- x: Input tensor of shape
- `[batch_size, in_channels, in_height, in_width]`.
- w: Weight tensor of shape
- `[out_channels, in_channels//groups, kernel_height, kernel_width]`.
- f: Low-pass filter for up/downsampling. Must be prepared beforehand by
- calling upfirdn2d.setup_filter(). None = identity (default).
- up: Integer upsampling factor (default: 1).
- down: Integer downsampling factor (default: 1).
- padding: Padding with respect to the upsampled image. Can be a single number
- or a list/tuple `[x, y]` or `[x_before, x_after, y_before, y_after]`
- (default: 0).
- groups: Split input channels into N groups (default: 1).
- flip_weight: False = convolution, True = correlation (default: True).
- flip_filter: False = convolution, True = correlation (default: False).
-
- Returns:
- Tensor of the shape `[batch_size, num_channels, out_height, out_width]`.
- """
- # Validate arguments.
- assert isinstance(x, torch.Tensor) and (x.ndim == 4)
- assert isinstance(w, torch.Tensor) and (w.ndim == 4) and (w.dtype == x.dtype)
- assert f is None or (isinstance(f, torch.Tensor) and f.ndim in [1, 2] and f.dtype == torch.float32)
- assert isinstance(up, int) and (up >= 1)
- assert isinstance(down, int) and (down >= 1)
- assert isinstance(groups, int) and (groups >= 1)
- out_channels, in_channels_per_group, kh, kw = _get_weight_shape(w)
- fw, fh = _get_filter_size(f)
- px0, px1, py0, py1 = _parse_padding(padding)
-
- # Adjust padding to account for up/downsampling.
- if up > 1:
- px0 += (fw + up - 1) // 2
- px1 += (fw - up) // 2
- py0 += (fh + up - 1) // 2
- py1 += (fh - up) // 2
- if down > 1:
- px0 += (fw - down + 1) // 2
- px1 += (fw - down) // 2
- py0 += (fh - down + 1) // 2
- py1 += (fh - down) // 2
-
- # Fast path: 1x1 convolution with downsampling only => downsample first, then convolve.
- if kw == 1 and kh == 1 and (down > 1 and up == 1):
- x = upfirdn2d.upfirdn2d(x=x, f=f, down=down, padding=[px0,px1,py0,py1], flip_filter=flip_filter)
- x = _conv2d_wrapper(x=x, w=w, groups=groups, flip_weight=flip_weight)
- return x
-
- # Fast path: 1x1 convolution with upsampling only => convolve first, then upsample.
- if kw == 1 and kh == 1 and (up > 1 and down == 1):
- x = _conv2d_wrapper(x=x, w=w, groups=groups, flip_weight=flip_weight)
- x = upfirdn2d.upfirdn2d(x=x, f=f, up=up, padding=[px0,px1,py0,py1], gain=up**2, flip_filter=flip_filter)
- return x
-
- # Fast path: downsampling only => use strided convolution.
- if down > 1 and up == 1:
- x = upfirdn2d.upfirdn2d(x=x, f=f, padding=[px0,px1,py0,py1], flip_filter=flip_filter)
- x = _conv2d_wrapper(x=x, w=w, stride=down, groups=groups, flip_weight=flip_weight)
- return x
-
- # Fast path: upsampling with optional downsampling => use transpose strided convolution.
- if up > 1:
- if groups == 1:
- w = w.transpose(0, 1)
- else:
- w = w.reshape(groups, out_channels // groups, in_channels_per_group, kh, kw)
- w = w.transpose(1, 2)
- w = w.reshape(groups * in_channels_per_group, out_channels // groups, kh, kw)
- px0 -= kw - 1
- px1 -= kw - up
- py0 -= kh - 1
- py1 -= kh - up
- pxt = max(min(-px0, -px1), 0)
- pyt = max(min(-py0, -py1), 0)
- x = _conv2d_wrapper(x=x, w=w, stride=up, padding=[pyt,pxt], groups=groups, transpose=True, flip_weight=(not flip_weight))
- x = upfirdn2d.upfirdn2d(x=x, f=f, padding=[px0+pxt,px1+pxt,py0+pyt,py1+pyt], gain=up**2, flip_filter=flip_filter)
- if down > 1:
- x = upfirdn2d.upfirdn2d(x=x, f=f, down=down, flip_filter=flip_filter)
- return x
-
- # Fast path: no up/downsampling, padding supported by the underlying implementation => use plain conv2d.
- if up == 1 and down == 1:
- if px0 == px1 and py0 == py1 and px0 >= 0 and py0 >= 0:
- return _conv2d_wrapper(x=x, w=w, padding=[py0,px0], groups=groups, flip_weight=flip_weight)
-
- # Fallback: Generic reference implementation.
- x = upfirdn2d.upfirdn2d(x=x, f=(f if up > 1 else None), up=up, padding=[px0,px1,py0,py1], gain=up**2, flip_filter=flip_filter)
- x = _conv2d_wrapper(x=x, w=w, groups=groups, flip_weight=flip_weight)
- if down > 1:
- x = upfirdn2d.upfirdn2d(x=x, f=f, down=down, flip_filter=flip_filter)
- return x
-
-#----------------------------------------------------------------------------
diff --git a/spaces/Gradio-Blocks/StyleGAN-NADA/e4e/models/encoders/helpers.py b/spaces/Gradio-Blocks/StyleGAN-NADA/e4e/models/encoders/helpers.py
deleted file mode 100644
index c4a58b34ea5ca6912fe53c63dede0a8696f5c024..0000000000000000000000000000000000000000
--- a/spaces/Gradio-Blocks/StyleGAN-NADA/e4e/models/encoders/helpers.py
+++ /dev/null
@@ -1,140 +0,0 @@
-from collections import namedtuple
-import torch
-import torch.nn.functional as F
-from torch.nn import Conv2d, BatchNorm2d, PReLU, ReLU, Sigmoid, MaxPool2d, AdaptiveAvgPool2d, Sequential, Module
-
-"""
-ArcFace implementation from [TreB1eN](https://github.com/TreB1eN/InsightFace_Pytorch)
-"""
-
-
-class Flatten(Module):
- def forward(self, input):
- return input.view(input.size(0), -1)
-
-
-def l2_norm(input, axis=1):
- norm = torch.norm(input, 2, axis, True)
- output = torch.div(input, norm)
- return output
-
-
-class Bottleneck(namedtuple('Block', ['in_channel', 'depth', 'stride'])):
- """ A named tuple describing a ResNet block. """
-
-
-def get_block(in_channel, depth, num_units, stride=2):
- return [Bottleneck(in_channel, depth, stride)] + [Bottleneck(depth, depth, 1) for i in range(num_units - 1)]
-
-
-def get_blocks(num_layers):
- if num_layers == 50:
- blocks = [
- get_block(in_channel=64, depth=64, num_units=3),
- get_block(in_channel=64, depth=128, num_units=4),
- get_block(in_channel=128, depth=256, num_units=14),
- get_block(in_channel=256, depth=512, num_units=3)
- ]
- elif num_layers == 100:
- blocks = [
- get_block(in_channel=64, depth=64, num_units=3),
- get_block(in_channel=64, depth=128, num_units=13),
- get_block(in_channel=128, depth=256, num_units=30),
- get_block(in_channel=256, depth=512, num_units=3)
- ]
- elif num_layers == 152:
- blocks = [
- get_block(in_channel=64, depth=64, num_units=3),
- get_block(in_channel=64, depth=128, num_units=8),
- get_block(in_channel=128, depth=256, num_units=36),
- get_block(in_channel=256, depth=512, num_units=3)
- ]
- else:
- raise ValueError("Invalid number of layers: {}. Must be one of [50, 100, 152]".format(num_layers))
- return blocks
-
-
-class SEModule(Module):
- def __init__(self, channels, reduction):
- super(SEModule, self).__init__()
- self.avg_pool = AdaptiveAvgPool2d(1)
- self.fc1 = Conv2d(channels, channels // reduction, kernel_size=1, padding=0, bias=False)
- self.relu = ReLU(inplace=True)
- self.fc2 = Conv2d(channels // reduction, channels, kernel_size=1, padding=0, bias=False)
- self.sigmoid = Sigmoid()
-
- def forward(self, x):
- module_input = x
- x = self.avg_pool(x)
- x = self.fc1(x)
- x = self.relu(x)
- x = self.fc2(x)
- x = self.sigmoid(x)
- return module_input * x
-
-
-class bottleneck_IR(Module):
- def __init__(self, in_channel, depth, stride):
- super(bottleneck_IR, self).__init__()
- if in_channel == depth:
- self.shortcut_layer = MaxPool2d(1, stride)
- else:
- self.shortcut_layer = Sequential(
- Conv2d(in_channel, depth, (1, 1), stride, bias=False),
- BatchNorm2d(depth)
- )
- self.res_layer = Sequential(
- BatchNorm2d(in_channel),
- Conv2d(in_channel, depth, (3, 3), (1, 1), 1, bias=False), PReLU(depth),
- Conv2d(depth, depth, (3, 3), stride, 1, bias=False), BatchNorm2d(depth)
- )
-
- def forward(self, x):
- shortcut = self.shortcut_layer(x)
- res = self.res_layer(x)
- return res + shortcut
-
-
-class bottleneck_IR_SE(Module):
- def __init__(self, in_channel, depth, stride):
- super(bottleneck_IR_SE, self).__init__()
- if in_channel == depth:
- self.shortcut_layer = MaxPool2d(1, stride)
- else:
- self.shortcut_layer = Sequential(
- Conv2d(in_channel, depth, (1, 1), stride, bias=False),
- BatchNorm2d(depth)
- )
- self.res_layer = Sequential(
- BatchNorm2d(in_channel),
- Conv2d(in_channel, depth, (3, 3), (1, 1), 1, bias=False),
- PReLU(depth),
- Conv2d(depth, depth, (3, 3), stride, 1, bias=False),
- BatchNorm2d(depth),
- SEModule(depth, 16)
- )
-
- def forward(self, x):
- shortcut = self.shortcut_layer(x)
- res = self.res_layer(x)
- return res + shortcut
-
-
-def _upsample_add(x, y):
- """Upsample and add two feature maps.
- Args:
- x: (Variable) top feature map to be upsampled.
- y: (Variable) lateral feature map.
- Returns:
- (Variable) added feature map.
- Note in PyTorch, when input size is odd, the upsampled feature map
- with `F.upsample(..., scale_factor=2, mode='nearest')`
- maybe not equal to the lateral feature map size.
- e.g.
- original input size: [N,_,15,15] ->
- conv2d feature map size: [N,_,8,8] ->
- upsampled feature map size: [N,_,16,16]
- So we choose bilinear upsample which supports arbitrary output sizes.
- """
- _, _, H, W = y.size()
- return F.interpolate(x, size=(H, W), mode='bilinear', align_corners=True) + y
diff --git a/spaces/Gradio-Blocks/uniformer_image_segmentation/configs/_base_/models/pspnet_unet_s5-d16.py b/spaces/Gradio-Blocks/uniformer_image_segmentation/configs/_base_/models/pspnet_unet_s5-d16.py
deleted file mode 100644
index fcff9ec4f41fad158344ecd77313dc14564f3682..0000000000000000000000000000000000000000
--- a/spaces/Gradio-Blocks/uniformer_image_segmentation/configs/_base_/models/pspnet_unet_s5-d16.py
+++ /dev/null
@@ -1,50 +0,0 @@
-# model settings
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
- type='EncoderDecoder',
- pretrained=None,
- backbone=dict(
- type='UNet',
- in_channels=3,
- base_channels=64,
- num_stages=5,
- strides=(1, 1, 1, 1, 1),
- enc_num_convs=(2, 2, 2, 2, 2),
- dec_num_convs=(2, 2, 2, 2),
- downsamples=(True, True, True, True),
- enc_dilations=(1, 1, 1, 1, 1),
- dec_dilations=(1, 1, 1, 1),
- with_cp=False,
- conv_cfg=None,
- norm_cfg=norm_cfg,
- act_cfg=dict(type='ReLU'),
- upsample_cfg=dict(type='InterpConv'),
- norm_eval=False),
- decode_head=dict(
- type='PSPHead',
- in_channels=64,
- in_index=4,
- channels=16,
- pool_scales=(1, 2, 3, 6),
- dropout_ratio=0.1,
- num_classes=2,
- norm_cfg=norm_cfg,
- align_corners=False,
- loss_decode=dict(
- type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
- auxiliary_head=dict(
- type='FCNHead',
- in_channels=128,
- in_index=3,
- channels=64,
- num_convs=1,
- concat_input=False,
- dropout_ratio=0.1,
- num_classes=2,
- norm_cfg=norm_cfg,
- align_corners=False,
- loss_decode=dict(
- type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
- # model training and testing settings
- train_cfg=dict(),
- test_cfg=dict(mode='slide', crop_size=256, stride=170))
diff --git a/spaces/Grezz/generate_human_motion/VQ-Trans/models/modules.py b/spaces/Grezz/generate_human_motion/VQ-Trans/models/modules.py
deleted file mode 100644
index 4f06cd98d4f6029bd3df073095cf50498483d54a..0000000000000000000000000000000000000000
--- a/spaces/Grezz/generate_human_motion/VQ-Trans/models/modules.py
+++ /dev/null
@@ -1,109 +0,0 @@
-import torch
-import torch.nn as nn
-from torch.nn.utils.rnn import pack_padded_sequence
-
-def init_weight(m):
- if isinstance(m, nn.Conv1d) or isinstance(m, nn.Linear) or isinstance(m, nn.ConvTranspose1d):
- nn.init.xavier_normal_(m.weight)
- # m.bias.data.fill_(0.01)
- if m.bias is not None:
- nn.init.constant_(m.bias, 0)
-
-
-class MovementConvEncoder(nn.Module):
- def __init__(self, input_size, hidden_size, output_size):
- super(MovementConvEncoder, self).__init__()
- self.main = nn.Sequential(
- nn.Conv1d(input_size, hidden_size, 4, 2, 1),
- nn.Dropout(0.2, inplace=True),
- nn.LeakyReLU(0.2, inplace=True),
- nn.Conv1d(hidden_size, output_size, 4, 2, 1),
- nn.Dropout(0.2, inplace=True),
- nn.LeakyReLU(0.2, inplace=True),
- )
- self.out_net = nn.Linear(output_size, output_size)
- self.main.apply(init_weight)
- self.out_net.apply(init_weight)
-
- def forward(self, inputs):
- inputs = inputs.permute(0, 2, 1)
- outputs = self.main(inputs).permute(0, 2, 1)
- # print(outputs.shape)
- return self.out_net(outputs)
-
-
-
-class TextEncoderBiGRUCo(nn.Module):
- def __init__(self, word_size, pos_size, hidden_size, output_size, device):
- super(TextEncoderBiGRUCo, self).__init__()
- self.device = device
-
- self.pos_emb = nn.Linear(pos_size, word_size)
- self.input_emb = nn.Linear(word_size, hidden_size)
- self.gru = nn.GRU(hidden_size, hidden_size, batch_first=True, bidirectional=True)
- self.output_net = nn.Sequential(
- nn.Linear(hidden_size * 2, hidden_size),
- nn.LayerNorm(hidden_size),
- nn.LeakyReLU(0.2, inplace=True),
- nn.Linear(hidden_size, output_size)
- )
-
- self.input_emb.apply(init_weight)
- self.pos_emb.apply(init_weight)
- self.output_net.apply(init_weight)
- self.hidden_size = hidden_size
- self.hidden = nn.Parameter(torch.randn((2, 1, self.hidden_size), requires_grad=True))
-
- # input(batch_size, seq_len, dim)
- def forward(self, word_embs, pos_onehot, cap_lens):
- num_samples = word_embs.shape[0]
-
- pos_embs = self.pos_emb(pos_onehot)
- inputs = word_embs + pos_embs
- input_embs = self.input_emb(inputs)
- hidden = self.hidden.repeat(1, num_samples, 1)
-
- cap_lens = cap_lens.data.tolist()
- emb = pack_padded_sequence(input_embs, cap_lens, batch_first=True)
-
- gru_seq, gru_last = self.gru(emb, hidden)
-
- gru_last = torch.cat([gru_last[0], gru_last[1]], dim=-1)
-
- return self.output_net(gru_last)
-
-
-class MotionEncoderBiGRUCo(nn.Module):
- def __init__(self, input_size, hidden_size, output_size, device):
- super(MotionEncoderBiGRUCo, self).__init__()
- self.device = device
-
- self.input_emb = nn.Linear(input_size, hidden_size)
- self.gru = nn.GRU(hidden_size, hidden_size, batch_first=True, bidirectional=True)
- self.output_net = nn.Sequential(
- nn.Linear(hidden_size*2, hidden_size),
- nn.LayerNorm(hidden_size),
- nn.LeakyReLU(0.2, inplace=True),
- nn.Linear(hidden_size, output_size)
- )
-
- self.input_emb.apply(init_weight)
- self.output_net.apply(init_weight)
- self.hidden_size = hidden_size
- self.hidden = nn.Parameter(torch.randn((2, 1, self.hidden_size), requires_grad=True))
-
- # input(batch_size, seq_len, dim)
- def forward(self, inputs, m_lens):
- num_samples = inputs.shape[0]
-
- input_embs = self.input_emb(inputs)
- hidden = self.hidden.repeat(1, num_samples, 1)
-
- cap_lens = m_lens.data.tolist()
- emb = pack_padded_sequence(input_embs, cap_lens, batch_first=True, enforce_sorted=False)
-
- gru_seq, gru_last = self.gru(emb, hidden)
-
- gru_last = torch.cat([gru_last[0], gru_last[1]], dim=-1)
-
- return self.output_net(gru_last)
diff --git a/spaces/GroveStreet/GTA_SOVITS/diffusion/logger/saver.py b/spaces/GroveStreet/GTA_SOVITS/diffusion/logger/saver.py
deleted file mode 100644
index ef78b52b6bcd32106f962b731d3784d72d5f0cce..0000000000000000000000000000000000000000
--- a/spaces/GroveStreet/GTA_SOVITS/diffusion/logger/saver.py
+++ /dev/null
@@ -1,150 +0,0 @@
-'''
-author: wayn391@mastertones
-'''
-
-import os
-import json
-import time
-import yaml
-import datetime
-import torch
-import matplotlib.pyplot as plt
-from . import utils
-from torch.utils.tensorboard import SummaryWriter
-
-class Saver(object):
- def __init__(
- self,
- args,
- initial_global_step=-1):
-
- self.expdir = args.env.expdir
- self.sample_rate = args.data.sampling_rate
-
- # cold start
- self.global_step = initial_global_step
- self.init_time = time.time()
- self.last_time = time.time()
-
- # makedirs
- os.makedirs(self.expdir, exist_ok=True)
-
- # path
- self.path_log_info = os.path.join(self.expdir, 'log_info.txt')
-
- # ckpt
- os.makedirs(self.expdir, exist_ok=True)
-
- # writer
- self.writer = SummaryWriter(os.path.join(self.expdir, 'logs'))
-
- # save config
- path_config = os.path.join(self.expdir, 'config.yaml')
- with open(path_config, "w") as out_config:
- yaml.dump(dict(args), out_config)
-
-
- def log_info(self, msg):
- '''log method'''
- if isinstance(msg, dict):
- msg_list = []
- for k, v in msg.items():
- tmp_str = ''
- if isinstance(v, int):
- tmp_str = '{}: {:,}'.format(k, v)
- else:
- tmp_str = '{}: {}'.format(k, v)
-
- msg_list.append(tmp_str)
- msg_str = '\n'.join(msg_list)
- else:
- msg_str = msg
-
- # dsplay
- print(msg_str)
-
- # save
- with open(self.path_log_info, 'a') as fp:
- fp.write(msg_str+'\n')
-
- def log_value(self, dict):
- for k, v in dict.items():
- self.writer.add_scalar(k, v, self.global_step)
-
- def log_spec(self, name, spec, spec_out, vmin=-14, vmax=3.5):
- spec_cat = torch.cat([(spec_out - spec).abs() + vmin, spec, spec_out], -1)
- spec = spec_cat[0]
- if isinstance(spec, torch.Tensor):
- spec = spec.cpu().numpy()
- fig = plt.figure(figsize=(12, 9))
- plt.pcolor(spec.T, vmin=vmin, vmax=vmax)
- plt.tight_layout()
- self.writer.add_figure(name, fig, self.global_step)
-
- def log_audio(self, dict):
- for k, v in dict.items():
- self.writer.add_audio(k, v, global_step=self.global_step, sample_rate=self.sample_rate)
-
- def get_interval_time(self, update=True):
- cur_time = time.time()
- time_interval = cur_time - self.last_time
- if update:
- self.last_time = cur_time
- return time_interval
-
- def get_total_time(self, to_str=True):
- total_time = time.time() - self.init_time
- if to_str:
- total_time = str(datetime.timedelta(
- seconds=total_time))[:-5]
- return total_time
-
- def save_model(
- self,
- model,
- optimizer,
- name='model',
- postfix='',
- to_json=False):
- # path
- if postfix:
- postfix = '_' + postfix
- path_pt = os.path.join(
- self.expdir , name+postfix+'.pt')
-
- # check
- print(' [*] model checkpoint saved: {}'.format(path_pt))
-
- # save
- if optimizer is not None:
- torch.save({
- 'global_step': self.global_step,
- 'model': model.state_dict(),
- 'optimizer': optimizer.state_dict()}, path_pt)
- else:
- torch.save({
- 'global_step': self.global_step,
- 'model': model.state_dict()}, path_pt)
-
- # to json
- if to_json:
- path_json = os.path.join(
- self.expdir , name+'.json')
- utils.to_json(path_params, path_json)
-
- def delete_model(self, name='model', postfix=''):
- # path
- if postfix:
- postfix = '_' + postfix
- path_pt = os.path.join(
- self.expdir , name+postfix+'.pt')
-
- # delete
- if os.path.exists(path_pt):
- os.remove(path_pt)
- print(' [*] model checkpoint deleted: {}'.format(path_pt))
-
- def global_step_increment(self):
- self.global_step += 1
-
-
diff --git a/spaces/HCMUT-GraduateThesis-HNTThinh/rgbdsod-multimae-demo/utils/masking_generator.py b/spaces/HCMUT-GraduateThesis-HNTThinh/rgbdsod-multimae-demo/utils/masking_generator.py
deleted file mode 100644
index 5603eb30b40e6fea64f23d1f406f47041cc000fc..0000000000000000000000000000000000000000
--- a/spaces/HCMUT-GraduateThesis-HNTThinh/rgbdsod-multimae-demo/utils/masking_generator.py
+++ /dev/null
@@ -1,33 +0,0 @@
-# --------------------------------------------------------
-# Based on BEiT, timm, DINO and DeiT code bases
-# https://github.com/microsoft/unilm/tree/master/beit
-# https://github.com/rwightman/pytorch-image-models/tree/master/timm
-# https://github.com/facebookresearch/deit
-# https://github.com/facebookresearch/dino
-# --------------------------------------------------------
-import numpy as np
-
-
-class RandomMaskingGenerator:
- def __init__(self, input_size, mask_ratio):
- if not isinstance(input_size, tuple):
- input_size = (input_size,) * 2
-
- self.height, self.width = input_size
-
- self.num_patches = self.height * self.width
- self.num_mask = int(mask_ratio * self.num_patches)
-
- def __repr__(self):
- repr_str = "Maks: total patches {}, mask patches {}".format(
- self.num_patches, self.num_mask
- )
- return repr_str
-
- def __call__(self):
- mask = np.hstack([
- np.zeros(self.num_patches - self.num_mask),
- np.ones(self.num_mask),
- ])
- np.random.shuffle(mask)
- return mask # [196]
diff --git a/spaces/HaloMaster/chinesesummary/fengshen/examples/FastDemo/README.md b/spaces/HaloMaster/chinesesummary/fengshen/examples/FastDemo/README.md
deleted file mode 100644
index 132519b95da3fd35f4c4fb6aae5d8c44faad3a42..0000000000000000000000000000000000000000
--- a/spaces/HaloMaster/chinesesummary/fengshen/examples/FastDemo/README.md
+++ /dev/null
@@ -1,105 +0,0 @@
-# 「streamlit」快速搭建你的算法demo
-在搭建demo之前，首先得做好这些准备工作：
-- 模型训练完毕
-- 模型的入参确定
-- 安装streamlit库，`pip install streamlit` 就可以安装。
-
-streamlit脚本的启动方式是 `streamlit run demo.py`，很简单就启动了一个demo页面，页面会随着脚本代码的改变实时刷新的。所以在没有经验的时候，可以创建一个demo.py的文件，照着下面的教程一步一步添加代码，看页面的展示情况。下面开始上干货，具体细节在代码注释中有说明！
-
-### 第一步 导包
-```python
-import streamlit as st
-# 其他包更具你的需要导入
-```
-[streamlit](https://streamlit.io)是一个用于构建机器学习、深度学习、数据可视化demo的python框架。它不需要你有web开发的经验，会写python就可以高效的开发你的demo。
-
-### 第二步 页面导航信息以及布局配置
-
-```python
-st.set_page_config(
- page_title="余元医疗问答", # 页面标签标题
- page_icon=":shark:", # 页面标签图标
- layout="wide", # 页面的布局
- initial_sidebar_state="expanded", # 左侧的sidebar的布局方式
- # 配置菜单按钮的信息
- menu_items={
- 'Get Help': 'https://www.extremelycoolapp.com/help',
- 'Report a bug': "https://www.extremelycoolapp.com/bug",
- 'About': "# This is a header. This is an *extremely* cool app!"
- }
- )
-```
-这一步可以省略，如果想让app更加个性化，可以添加这些设置。
-
-### 第三步 设置demo标题
-```python
-st.title('Demo for MedicalQA')
-```
-streamlit的每一个小组件对应于页面都有一个默认的样式展示。
-
-### 第四步 配置demo的参数
-
-```python
-# 此处是用的sidebar，侧边栏作为参数配置模块
-st.sidebar.header("参数配置")
-# 这里是在sidebar里面创建了表单，每个表单一定有一个标题和提交按钮
-sbform = st.sidebar.form("固定参数设置")
-# slider是滑动条组建，可以配置数值型参数
-n_sample = sbform.slider("设置返回条数",min_value=1,max_value=10,value=3)
-text_length = sbform.slider('生成长度:',min_value=32,max_value=512,value=64,step=32)
-text_level = sbform.slider('文本多样性:',min_value=0.1,max_value=1.0,value=0.9,step=0.1)
-# number_input也可以配置数值型参数
-model_id = sbform.number_input('选择模型号:',min_value=0,max_value=13,value=13,step=1)
-# selectbox选择组建，只能选择配置的选项
-trans = sbform.selectbox('选择翻译内核',['百度通用','医疗生物'])
-# 提交表单的配置，这些参数的赋值才生效
-sbform.form_submit_button("提交配置")
-
-# 这里是页面中的参数配置，也是demo的主体之一
-form = st.form("参数设置")
-# 本demo是qa demo，所以要录入用户的文本输入，text_input组建可以实现
-input_text = form.text_input('请输入你的问题:',value='',placeholder='例如：糖尿病的症状有哪些？')
-form.form_submit_button("提交")
-```
-以上就把demo的参数基本配置完成了。
-
-### 第五步 模型预测
-```python
-# 定义一个前向预测的方法
-# @st.cache(suppress_st_warning=True)
-def generate_qa(input_text,n_sample,model_id='7',length=64,translator='baidu',level=0.7):
- # 这里我们是把模型用fastapi搭建了一个api服务
- URL = 'http://192.168.190.63:6605/qa'
- data = {
- "text":input_text,"n_sample":n_sample,
- "model_id":model_id,"length":length,
- 'translator':translator,'level':level
- }
- r = requests.get(URL,params=data)
- return r.text
-# 模型预测结果
-results = generate_qa(input_text,n_sample,model_id=str(model_id),
- translator=translator,length=text_length,level=text_level)
-```
-这里说明一下，由于demo展示机器没有GPU，所以模型部署采用的是Fastapi部署在后台的。如果demo展示的机器可以直接部署模型，这里可以直接把模型预测的方法写在这里，不需要另外部署模型，再用api的方式调用。这样做有一个值得注意的地方，因为streamlit的代码每一次运行，都是从头到尾执行一遍，就导致模型可能会重复加载，所以这里需要用到st.cache组建，当内容没有更新的时候，会把这一步的结果缓存，而不会重新执行。保证了效率不会因此而下降。
-
-### 第六步 结果展示
-```python
-with st.spinner('老夫正在思考中🤔...'):
- if input_text:
- results = generate_qa(input_text,n_sample,model_id=str(model_id),
- translator=translator,length=text_length,level=text_level)
- for idx,item in enumerate(eval(results),start=1):
- st.markdown(f"""
- **候选回答「{idx}」:**\n
- """)
- st.info('中文：%s'%item['fy_next_sentence'])
- st.info('英文：%s'%item['next_sentence'])
-```
-streamlit对不同格式的内容展示，有丰富的组建，对于文本可以用`st.markdown`组建以及`st.text`和`st.write`展示。更多组建和功能可以参考官方文档：https://docs.streamlit.io
-
-至此，一个完整的demo展示就完成了。效果图如下：
-
-
-
-完整的代码可以参考：`Fengshenbang-LM/fengshen/examples/FastDemo/YuyuanQA.py`
diff --git a/spaces/HaloMaster/chinesesummary/fengshen/examples/wenzhong_qa/finetune_wenzhong.py b/spaces/HaloMaster/chinesesummary/fengshen/examples/wenzhong_qa/finetune_wenzhong.py
deleted file mode 100644
index bcdeda71fd2d2d70dd56148451ddf2d4946bf31c..0000000000000000000000000000000000000000
--- a/spaces/HaloMaster/chinesesummary/fengshen/examples/wenzhong_qa/finetune_wenzhong.py
+++ /dev/null
@@ -1,153 +0,0 @@
-# sys.path.append('./')
-import os
-import torch
-import argparse
-import pytorch_lightning as pl
-from pytorch_lightning.callbacks import ModelCheckpoint
-from pytorch_lightning import Trainer, loggers
-from transformers.optimization import get_linear_schedule_with_warmup
-from transformers import GPT2LMHeadModel
-from fengshen.data.task_dataloader.medicalQADataset import GPT2QADataModel
-
-
-class GPT2FinetuneMedicalQAModelCheckpoint:
- @staticmethod
- def add_argparse_args(parent_args):
- parser = parent_args.add_argument_group('BaseModel')
-
- parser.add_argument('--monitor', default='train_loss', type=str)
- parser.add_argument('--mode', default='min', type=str)
- parser.add_argument('--dirpath', default='./ckpt/', type=str)
- parser.add_argument(
- '--filename', default='model-{epoch:02d}-{train_loss:.4f}', type=str)
- parser.add_argument('--save_last', action='store_true', default=True)
- parser.add_argument('--save_top_k', default=3, type=float)
- parser.add_argument('--every_n_train_steps', default=100, type=float)
- parser.add_argument('--save_weights_only', default=True, type=bool)
-
- return parent_args
-
- def __init__(self, args):
- self.callbacks = ModelCheckpoint(monitor=args.monitor,
- save_top_k=args.save_top_k,
- mode=args.mode,
- every_n_train_steps=args.every_n_train_steps,
- save_weights_only=args.save_weights_only,
- dirpath=args.dirpath,
- filename=args.filename,
- save_last=args.save_last)
-
-
-class GPT2FinetuneMedicalQA(pl.LightningModule):
-
- @staticmethod
- def add_model_specific_args(parent_args):
- parser = parent_args.add_argument_group('BaseModel')
- parser.add_argument('--learning_rate', default=1e-4, type=float)
- parser.add_argument('--weight_decay', default=0.1, type=float)
- parser.add_argument('--warmup', default=0.01, type=float)
- return parent_args
-
- def __init__(self, args, num_data):
- super().__init__()
- self.args = args
- self.num_data = num_data
- print('num_data:', num_data)
- self.model = GPT2LMHeadModel.from_pretrained(args.pretrained_model_path)
-
- def setup(self, stage) -> None:
- if stage == 'fit':
- num_gpus = self.trainer.gpus if self.trainer.gpus is not None else 0
- self.total_step = int(self.trainer.max_epochs * self.num_data
- / (max(1, num_gpus) * self.trainer.accumulate_grad_batches))
- print('Total training step:', self.total_step)
-
- def training_step(self, batch, batch_idx):
- output = self.model(
- input_ids=batch['input_ids'], attention_mask=batch['attention_mask'], labels=batch['labels'])
- # output = self.model(input_ids=batch['input_ids'], labels=batch['labels'])
- # acc = self.comput_metrix(output.logits, batch['labels'])
- self.log('train_loss', output.loss)
- return output.loss
-
- def comput_metrix(self, logits, labels):
- y_pred = torch.argmax(logits, dim=-1)
- y_pred = y_pred.view(size=(-1,))
- y_true = labels.view(size=(-1,)).float()
- corr = torch.eq(y_pred, y_true)
- acc = torch.sum(corr.float()) / labels.size()[0]
- return acc
-
- def validation_step(self, batch, batch_idx):
- output = self.model(
- input_ids=batch['input_ids'], attention_mask=batch['attention_mask'], labels=batch['labels'])
- # output = self.model(input_ids=batch['input_ids'], labels=batch['labels'])
- # acc = self.comput_metrix(output.logits, batch['labels'])
- self.log('val_loss', output.loss)
- # self.log('val_acc', acc)
-
- def configure_optimizers(self):
- no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight']
- paras = list(
- filter(lambda p: p[1].requires_grad, self.named_parameters()))
- paras = [{
- 'params':
- [p for n, p in paras if not any(nd in n for nd in no_decay)],
- 'weight_decay': self.args.weight_decay
- }, {
- 'params': [p for n, p in paras if any(nd in n for nd in no_decay)],
- 'weight_decay': 0.0
- }]
- optimizer = torch.optim.AdamW(paras, lr=self.args.learning_rate)
- scheduler = get_linear_schedule_with_warmup(
- optimizer, int(self.total_step * self.args.warmup),
- self.total_step)
-
- return [{
- 'optimizer': optimizer,
- 'lr_scheduler': {
- 'scheduler': scheduler,
- 'interval': 'step',
- 'frequency': 1
- }
- }]
-
-
-def main():
- total_parser = argparse.ArgumentParser("QA Task")
- total_parser.add_argument('--do_eval_only', action='store_true', default=False)
- total_parser.add_argument('--pretrained_model_path', default='google/mt5-small', type=str)
- total_parser.add_argument('--output_save_path', default='./predict.json', type=str)
- # * Args for data preprocessing
- total_parser = GPT2QADataModel.add_data_specific_args(total_parser)
- # * Args for training
- total_parser = Trainer.add_argparse_args(total_parser)
- total_parser = GPT2FinetuneMedicalQAModelCheckpoint.add_argparse_args(total_parser)
- total_parser = GPT2FinetuneMedicalQA.add_model_specific_args(total_parser)
- # * Args for base model
- args = total_parser.parse_args()
-
- data_model = GPT2QADataModel(args)
- if not args.do_eval_only:
- model = GPT2FinetuneMedicalQA(args, len(data_model.train_dataloader()))
- checkpoint_callback = GPT2FinetuneMedicalQAModelCheckpoint(args).callbacks
- logger = loggers.TensorBoardLogger(save_dir=os.path.join(
- args.default_root_dir, 'log/'), name='WenZhong')
- trainer = Trainer.from_argparse_args(args,
- logger=logger,
- callbacks=[checkpoint_callback]
- )
- trainer.fit(model, data_model)
-
-
-if __name__ == '__main__':
- main()
- # test()
-
-'''
-# python examples/mt5_summary.py --gpus=1 --test_data=test_public.jsonl
-# --default_root_dir=/cognitive_comp/ganruyi/fengshen/mt5_summary/eval
-# --do_eval_only
-# --resume_from_checkpoint=/cognitive_comp/ganruyi/fengshen/mt5_summary/ckpt/model-epoch=01-train_loss=1.9166.ckpt
-# --strategy=ddp
-'''
diff --git a/spaces/HaloMaster/chinesesummary/fengshen/models/longformer/__init__.py b/spaces/HaloMaster/chinesesummary/fengshen/models/longformer/__init__.py
deleted file mode 100644
index 8c068ccdcd2a786128a6a90032fea2ff74d3ea0f..0000000000000000000000000000000000000000
--- a/spaces/HaloMaster/chinesesummary/fengshen/models/longformer/__init__.py
+++ /dev/null
@@ -1,55 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The IDEA Authors. All rights reserved.
-
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-
-# http://www.apache.org/licenses/LICENSE-2.0
-
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from typing import TYPE_CHECKING
-
-from transformers.file_utils import _LazyModule, is_torch_available
-
-
-_import_structure = {
- "configuration_longformer": ["LongformerConfig"],
- "tokenization_longformer": ["LongformerTokenizer"],
-}
-
-if is_torch_available():
- _import_structure["modeling_longformer"] = [
- "LongformerModel",
- "LongformerForMaskedLM",
- "LongformerForMultipleChoice",
- "LongformerPreTrainedModel",
- "LongformerForQuestionAnswering",
- "LongformerForSequenceClassification",
- "LongformerForTokenClassification",
- ]
-
-
-if TYPE_CHECKING:
- from .configuration_longformer import LongformerConfig
- from .tokenization_longformer import LongformerTokenizer
-
- if is_torch_available():
- from .modeling_longformer import (
- LongformerModel,
- LongformerForMaskedLM,
- LongformerForMultipleChoice,
- LongformerPreTrainedModel,
- LongformerForQuestionAnswering,
- LongformerForSequenceClassification,
- LongformerForTokenClassification,
- )
-else:
- import sys
-
- sys.modules[__name__] = _LazyModule(__name__, globals()["__file__"], _import_structure)
diff --git a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/backtranslation/prepare-de-monolingual.sh b/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/backtranslation/prepare-de-monolingual.sh
deleted file mode 100644
index 5e67b2b3bcf27d3436031453e796e58a0ae79ec4..0000000000000000000000000000000000000000
--- a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/backtranslation/prepare-de-monolingual.sh
+++ /dev/null
@@ -1,98 +0,0 @@
-#!/bin/bash
-
-SCRIPTS=mosesdecoder/scripts
-TOKENIZER=$SCRIPTS/tokenizer/tokenizer.perl
-NORM_PUNC=$SCRIPTS/tokenizer/normalize-punctuation.perl
-REM_NON_PRINT_CHAR=$SCRIPTS/tokenizer/remove-non-printing-char.perl
-BPEROOT=subword-nmt/subword_nmt
-
-
-BPE_CODE=wmt18_en_de/code
-SUBSAMPLE_SIZE=25000000
-LANG=de
-
-
-OUTDIR=wmt18_${LANG}_mono
-orig=orig
-tmp=$OUTDIR/tmp
-mkdir -p $OUTDIR $tmp
-
-
-URLS=(
- "http://www.statmt.org/wmt14/training-monolingual-news-crawl/news.2007.de.shuffled.gz"
- "http://www.statmt.org/wmt14/training-monolingual-news-crawl/news.2008.de.shuffled.gz"
- "http://www.statmt.org/wmt14/training-monolingual-news-crawl/news.2009.de.shuffled.gz"
- "http://www.statmt.org/wmt14/training-monolingual-news-crawl/news.2010.de.shuffled.gz"
- "http://www.statmt.org/wmt14/training-monolingual-news-crawl/news.2011.de.shuffled.gz"
- "http://www.statmt.org/wmt14/training-monolingual-news-crawl/news.2012.de.shuffled.gz"
- "http://www.statmt.org/wmt14/training-monolingual-news-crawl/news.2013.de.shuffled.gz"
- "http://www.statmt.org/wmt15/training-monolingual-news-crawl-v2/news.2014.de.shuffled.v2.gz"
- "http://data.statmt.org/wmt16/translation-task/news.2015.de.shuffled.gz"
- "http://data.statmt.org/wmt17/translation-task/news.2016.de.shuffled.gz"
- "http://data.statmt.org/wmt18/translation-task/news.2017.de.shuffled.deduped.gz"
-)
-FILES=(
- "news.2007.de.shuffled.gz"
- "news.2008.de.shuffled.gz"
- "news.2009.de.shuffled.gz"
- "news.2010.de.shuffled.gz"
- "news.2011.de.shuffled.gz"
- "news.2012.de.shuffled.gz"
- "news.2013.de.shuffled.gz"
- "news.2014.de.shuffled.v2.gz"
- "news.2015.de.shuffled.gz"
- "news.2016.de.shuffled.gz"
- "news.2017.de.shuffled.deduped.gz"
-)
-
-
-cd $orig
-for ((i=0;i<${#URLS[@]};++i)); do
- file=${FILES[i]}
- if [ -f $file ]; then
- echo "$file already exists, skipping download"
- else
- url=${URLS[i]}
- wget "$url"
- fi
-done
-cd ..
-
-
-if [ -f $tmp/monolingual.${SUBSAMPLE_SIZE}.${LANG} ]; then
- echo "found monolingual sample, skipping shuffle/sample/tokenize"
-else
- gzip -c -d -k $(for FILE in "${FILES[@]}"; do echo $orig/$FILE; done) \
- | shuf -n $SUBSAMPLE_SIZE \
- | perl $NORM_PUNC $LANG \
- | perl $REM_NON_PRINT_CHAR \
- | perl $TOKENIZER -threads 8 -a -l $LANG \
- > $tmp/monolingual.${SUBSAMPLE_SIZE}.${LANG}
-fi
-
-
-if [ -f $tmp/bpe.monolingual.${SUBSAMPLE_SIZE}.${LANG} ]; then
- echo "found BPE monolingual sample, skipping BPE step"
-else
- python $BPEROOT/apply_bpe.py -c $BPE_CODE \
- < $tmp/monolingual.${SUBSAMPLE_SIZE}.${LANG} \
- > $tmp/bpe.monolingual.${SUBSAMPLE_SIZE}.${LANG}
-fi
-
-
-if [ -f $tmp/bpe.monolingual.dedup.${SUBSAMPLE_SIZE}.${LANG} ]; then
- echo "found deduplicated monolingual sample, skipping deduplication step"
-else
- python deduplicate_lines.py $tmp/bpe.monolingual.${SUBSAMPLE_SIZE}.${LANG} \
- > $tmp/bpe.monolingual.dedup.${SUBSAMPLE_SIZE}.${LANG}
-fi
-
-
-if [ -f $OUTDIR/bpe.monolingual.dedup.00.de ]; then
- echo "found sharded data, skipping sharding step"
-else
- split --lines 1000000 --numeric-suffixes \
- --additional-suffix .${LANG} \
- $tmp/bpe.monolingual.dedup.${SUBSAMPLE_SIZE}.${LANG} \
- $OUTDIR/bpe.monolingual.dedup.
-fi
diff --git a/spaces/Hexamind/swarms/dronemodel.py b/spaces/Hexamind/swarms/dronemodel.py
deleted file mode 100644
index caf99b95b5794071da29af9fbf8736875f94c27c..0000000000000000000000000000000000000000
--- a/spaces/Hexamind/swarms/dronemodel.py
+++ /dev/null
@@ -1,103 +0,0 @@
-from dataclasses import dataclass
-from scipy.integrate import odeint
-import numpy as np
-
-import param_
-
-
-@dataclass
-class DroneModel:
- """
- Creates a drone_model of a drone
- """
-
- def __init__(self, is_blue):
- self.drone_model = param_.DRONE_MODELS[param_.DRONE_MODEL[is_blue]]
-
- self.angle_to_neutralisation = self.drone_model['angle_to_neutralisation']
- self.distance_to_neutralisation = self.drone_model['distance_to_neutralisation']
- self.duration_to_neutralisation = self.drone_model['duration_to_neutralisation']
-
- self.Cxy = self.drone_model['Cxy']
- self.Cz = self.drone_model['Cz']
- self.mass = self.drone_model['mass']
-
- self.Fxy_ratio = self.drone_model['Fxy_ratio']
- self.Fz_min_ratio = self.drone_model['Fz_min_ratio']
- self.Fz_max_ratio = self.drone_model['Fz_max_ratio']
-
- self.weight_eq = self.mass * param_.g * (1 - self.Fz_min_ratio)
- self.Fz_plus = (self.Fz_max_ratio - 1) * self.mass * param_.g
- self.Fz_minus = (1 - self.Fz_min_ratio) * self.mass * param_.g
- self.Fxy = self.mass * param_.g * self.Fxy_ratio
-
- self.max_speed = np.sqrt(self.Fxy / self.Cxy)
- self.max_up_speed = np.sqrt(self.Fz_plus / self.Cz)
- self.max_down_speed = np.sqrt(self.Fz_minus / self.Cz)
- self.max_rot_speed = 2 * np.pi
-
- def get_trajectory(self, pos_xyz, speed_xyz, action: np.ndarray(3,), time_: np.ndarray(1,)) -> np.ndarray(3,):
- '''
- returns next position given the current position, speed and applied forces
- :param pos_xyz:
- :param speed_xyz:
- :param action:
- :param time_:
- :return:
- '''
-
- rho = action[0] # in 0, 1
- theta = 2*np.pi * action[1] # in 0, 2pi
- psy = np.pi * (action[2] - 0.5) # in -pi/2, pi/2
-
- fx = rho * np.cos(theta) * np.cos(psy) * self.Fxy
- fy = rho * np.sin(theta) * np.cos(psy) * self.Fxy
- fz = rho * np.sin(psy) * (self.Fz_plus if 0 < psy else self.Fz_minus)
-
- pos_speed = np.hstack((pos_xyz, speed_xyz))
-
- result_ = odeint(
- lambda u, v: self.drone_dynamics(u, v, fx, fy, fz, self.Cxy, self.Cz, self.mass),
- pos_speed,
- time_,
- Dfun=lambda u, v: self.fulljac(u, v, self.Cxy, self.Cz, self.mass)
- )
- x, y, z, dx, dy, dz = result_.T
-
- return np.array([x, y, z], dtype='float32'), np.array([dx, dy, dz], dtype='float32')
-
- def drone_dynamics(self, pos_speed, time_, f_x, f_y, f_z, Cxy, Cz, m):
- x, y, z, dx, dy, dz = pos_speed
- return [dx,
- dy,
- dz,
- 1/m * (f_x - Cxy * dx * np.sqrt(dx**2 + dy**2 + dz**2)),
- 1/m * (f_y - Cxy * dy * np.sqrt(dx**2 + dy**2 + dz**2)),
- 1/m * (f_z - Cz * dz * np.sqrt(dx**2 + dy**2 + dz**2))]
-
- def fulljac(self, pos_speed, time_, Cxy, Cz, m) -> np.ndarray((6, 6), ):
- '''
- returns the Jacobian of the differential equation of the trajectory
- :param pos_speed:
- :param time_:
- :param Cxy:
- :param Cz:
- :param m:
- :return:
- '''
-
- x, y, z, dx, dy, dz = pos_speed
- J = np.zeros((6, 6))
- J[0, 3] = 1
- J[1, 4] = 1
- J[2, 5] = 1
- J[3, 3] = -Cxy/m * ((np.sqrt(dx**2 + dy**2 + dz**2)) + dx**2 / np.sqrt(dx**2 + dy**2 + dz**2))
- J[3, 4] = -Cxy/m * (dx * dy / np.sqrt(dx**2 + dy**2 + dz**2))
- J[3, 5] = -Cxy/m * (dx * dz / np.sqrt(dx**2 + dy**2 + dz**2))
- J[4, 4] = -Cxy/m * ((np.sqrt(dx**2 + dy**2 + dz**2)) + dy**2 / np.sqrt(dx**2 + dy**2 + dz**2))
- J[4, 3] = -Cxy/m * (dy * dx / np.sqrt(dx**2 + dy**2 + dz**2))
- J[4, 5] = -Cxy/m * (dy * dz / np.sqrt(dx**2 + dy**2 + dz**2))
- J[5, 5] = -Cz/m * ((np.sqrt(dx**2 + dy**2 + dz**2)) + dz**2 / np.sqrt(dx**2 + dy**2 + dz**2))
- J[5, 3] = -Cz/m * (dz * dx / np.sqrt(dx**2 + dy**2 + dz**2))
- J[5, 4] = -Cz/m * (dz * dy / np.sqrt(dx**2 + dy**2 + dz**2))
- return J
diff --git a/spaces/HighCWu/GPEN/retinaface/facemodels/retinaface.py b/spaces/HighCWu/GPEN/retinaface/facemodels/retinaface.py
deleted file mode 100644
index b7092a2bc2f35d06ce99d25473bce913ef3fd8e7..0000000000000000000000000000000000000000
--- a/spaces/HighCWu/GPEN/retinaface/facemodels/retinaface.py
+++ /dev/null
@@ -1,127 +0,0 @@
-import torch
-import torch.nn as nn
-import torchvision.models.detection.backbone_utils as backbone_utils
-import torchvision.models._utils as _utils
-import torch.nn.functional as F
-from collections import OrderedDict
-
-from facemodels.net import MobileNetV1 as MobileNetV1
-from facemodels.net import FPN as FPN
-from facemodels.net import SSH as SSH
-
-
-
-class ClassHead(nn.Module):
- def __init__(self,inchannels=512,num_anchors=3):
- super(ClassHead,self).__init__()
- self.num_anchors = num_anchors
- self.conv1x1 = nn.Conv2d(inchannels,self.num_anchors*2,kernel_size=(1,1),stride=1,padding=0)
-
- def forward(self,x):
- out = self.conv1x1(x)
- out = out.permute(0,2,3,1).contiguous()
-
- return out.view(out.shape[0], -1, 2)
-
-class BboxHead(nn.Module):
- def __init__(self,inchannels=512,num_anchors=3):
- super(BboxHead,self).__init__()
- self.conv1x1 = nn.Conv2d(inchannels,num_anchors*4,kernel_size=(1,1),stride=1,padding=0)
-
- def forward(self,x):
- out = self.conv1x1(x)
- out = out.permute(0,2,3,1).contiguous()
-
- return out.view(out.shape[0], -1, 4)
-
-class LandmarkHead(nn.Module):
- def __init__(self,inchannels=512,num_anchors=3):
- super(LandmarkHead,self).__init__()
- self.conv1x1 = nn.Conv2d(inchannels,num_anchors*10,kernel_size=(1,1),stride=1,padding=0)
-
- def forward(self,x):
- out = self.conv1x1(x)
- out = out.permute(0,2,3,1).contiguous()
-
- return out.view(out.shape[0], -1, 10)
-
-class RetinaFace(nn.Module):
- def __init__(self, cfg = None, phase = 'train'):
- """
- :param cfg: Network related settings.
- :param phase: train or test.
- """
- super(RetinaFace,self).__init__()
- self.phase = phase
- backbone = None
- if cfg['name'] == 'mobilenet0.25':
- backbone = MobileNetV1()
- if cfg['pretrain']:
- checkpoint = torch.load("./weights/mobilenetV1X0.25_pretrain.tar", map_location=torch.device('cpu'))
- from collections import OrderedDict
- new_state_dict = OrderedDict()
- for k, v in checkpoint['state_dict'].items():
- name = k[7:] # remove module.
- new_state_dict[name] = v
- # load params
- backbone.load_state_dict(new_state_dict)
- elif cfg['name'] == 'Resnet50':
- import torchvision.models as models
- backbone = models.resnet50(pretrained=cfg['pretrain'])
-
- self.body = _utils.IntermediateLayerGetter(backbone, cfg['return_layers'])
- in_channels_stage2 = cfg['in_channel']
- in_channels_list = [
- in_channels_stage2 * 2,
- in_channels_stage2 * 4,
- in_channels_stage2 * 8,
- ]
- out_channels = cfg['out_channel']
- self.fpn = FPN(in_channels_list,out_channels)
- self.ssh1 = SSH(out_channels, out_channels)
- self.ssh2 = SSH(out_channels, out_channels)
- self.ssh3 = SSH(out_channels, out_channels)
-
- self.ClassHead = self._make_class_head(fpn_num=3, inchannels=cfg['out_channel'])
- self.BboxHead = self._make_bbox_head(fpn_num=3, inchannels=cfg['out_channel'])
- self.LandmarkHead = self._make_landmark_head(fpn_num=3, inchannels=cfg['out_channel'])
-
- def _make_class_head(self,fpn_num=3,inchannels=64,anchor_num=2):
- classhead = nn.ModuleList()
- for i in range(fpn_num):
- classhead.append(ClassHead(inchannels,anchor_num))
- return classhead
-
- def _make_bbox_head(self,fpn_num=3,inchannels=64,anchor_num=2):
- bboxhead = nn.ModuleList()
- for i in range(fpn_num):
- bboxhead.append(BboxHead(inchannels,anchor_num))
- return bboxhead
-
- def _make_landmark_head(self,fpn_num=3,inchannels=64,anchor_num=2):
- landmarkhead = nn.ModuleList()
- for i in range(fpn_num):
- landmarkhead.append(LandmarkHead(inchannels,anchor_num))
- return landmarkhead
-
- def forward(self,inputs):
- out = self.body(inputs)
-
- # FPN
- fpn = self.fpn(out)
-
- # SSH
- feature1 = self.ssh1(fpn[0])
- feature2 = self.ssh2(fpn[1])
- feature3 = self.ssh3(fpn[2])
- features = [feature1, feature2, feature3]
-
- bbox_regressions = torch.cat([self.BboxHead[i](feature) for i, feature in enumerate(features)], dim=1)
- classifications = torch.cat([self.ClassHead[i](feature) for i, feature in enumerate(features)],dim=1)
- ldm_regressions = torch.cat([self.LandmarkHead[i](feature) for i, feature in enumerate(features)], dim=1)
-
- if self.phase == 'train':
- output = (bbox_regressions, classifications, ldm_regressions)
- else:
- output = (bbox_regressions, F.softmax(classifications, dim=-1), ldm_regressions)
- return output
\ No newline at end of file
diff --git a/spaces/HighCWu/Style2Paints-4-Gradio/decompositioner.py b/spaces/HighCWu/Style2Paints-4-Gradio/decompositioner.py
deleted file mode 100644
index f54236f341d97d241ef1050bd28c8d00012d1a3e..0000000000000000000000000000000000000000
--- a/spaces/HighCWu/Style2Paints-4-Gradio/decompositioner.py
+++ /dev/null
@@ -1,185 +0,0 @@
-import os
-import numpy as np
-from scipy.spatial import ConvexHull
-from sklearn.cluster import MiniBatchKMeans
-from tricks import *
-import cv2
-
-
-ksd = 8
-mbc = MiniBatchKMeans(ksd)
-
-
-def get_theme(img):
- images = np.reshape(cv2.resize(img, (256, 256)), (256 * 256, 3))
- hull = ConvexHull(images)
- return hull.points[hull.vertices]
-
-
-def simplify_points(points, img):
- labels = mbc.fit(points)
- new_points = []
- all_center = np.mean(labels.cluster_centers_, axis=0)
- distances = np.sum((points - all_center) ** 2, axis=1) ** 0.5
-
- for idx in range(ksd):
- candidates = points[labels.labels_ == idx]
- scores = distances[labels.labels_ == idx]
- best_id = np.argmax(scores)
- new_points.append(candidates[best_id])
-
- new_points.sort(key=np.sum, reverse=True)
-
- new_points = np.stack(new_points, axis=0)
- return new_points.clip(0, 255).astype(np.uint8)
-
-
-def get_ini_layers(miku, points):
- results = []
- final_target = miku.astype(np.float32)
- bg = np.zeros_like(final_target, dtype=np.float32) + points[0]
- results.append(np.concatenate([bg, np.zeros_like(bg, dtype=np.float32) + 255], axis=2)[:, :, 0:4])
- current_result = bg.copy()
- for layer_index in range(1, ksd):
- current_base = current_result.astype(np.float32)
- current_color = np.zeros_like(final_target, dtype=np.float32) + points[layer_index]
- overall_direction = final_target - current_base
- avaliable_direction = current_color - current_base
- current_alpha = np.sum(overall_direction * avaliable_direction, axis=2, keepdims=True) / np.sum(
- avaliable_direction * avaliable_direction, axis=2, keepdims=True)
- current_alpha = current_alpha.clip(0, 1)
- current_result = (current_color * current_alpha + current_base * (1 - current_alpha)).clip(0, 255)
- results.append(np.concatenate([current_color, current_alpha * 255.0], axis=2))
- return results
-
-
-def make_reconstruction(layers):
- bg = np.zeros_like(layers[0], dtype=np.float32)[:, :, 0:3] + 255
- for item in layers:
- current_alpha = item[:, :, 3:4] / 255.0
- bg = item[:, :, 0:3] * current_alpha + bg * (1 - current_alpha)
- return bg
-
-
-def improve_layers(layers, miku):
- reconstruction = make_reconstruction(layers)
- b = miku - reconstruction
- new_layers = []
- for item in layers:
- new_item = item.copy()
- new_item[:, :, 0:3] = (new_item[:, :, 0:3] + b).clip(0, 255)
- new_layers.append(new_item)
- return new_layers
-
-
-def cluster_all(labeled_array, num_features):
- xs = [[] for _ in range(num_features)]
- ys = [[] for _ in range(num_features)]
- M = labeled_array.shape[0]
- N = labeled_array.shape[1]
- for x in range(M):
- for y in range(N):
- i = labeled_array[x, y]
- xs[i].append(x)
- ys[i].append(y)
- result = []
- for _ in range(num_features):
- result.append((np.array(xs[_]), np.array(ys[_])))
- return result
-
-
-def meder(x):
- y = x.copy()
- y = cv2.medianBlur(y, 5)
- y = cv2.medianBlur(y, 5)
- y = cv2.medianBlur(y, 3)
- y = cv2.medianBlur(y, 3)
- return y
-
-
-def re_med(s_2048):
-
- sample_2048 = s_2048.astype(np.float32)
- sample_1024 = cv2.pyrDown(sample_2048)
- sample_512 = cv2.pyrDown(sample_1024)
- sample_256 = cv2.pyrDown(sample_512)
-
- gradient_2048 = sample_2048 - cv2.pyrUp(sample_1024)
- gradient_1024 = sample_1024 - cv2.pyrUp(sample_512)
- gradient_512 = sample_512 - cv2.pyrUp(sample_256)
-
- rec_256 = meder(sample_256)
- rec_512 = cv2.pyrUp(rec_256) + meder(gradient_512)
- rec_1024 = cv2.pyrUp(rec_512) + meder(gradient_1024)
- rec_2048 = cv2.pyrUp(rec_1024) + meder(gradient_2048)
- return rec_2048
-
-
-def process_ctx(sketch, solid, render):
- solid = solid.astype(np.float32)
- sketch = d_resize(cv2.cvtColor(sketch, cv2.COLOR_GRAY2RGB), solid.shape).astype(np.float32)
- render = d_resize(render, solid.shape).astype(np.float32)
- alpha = sketch / 255.0
- all_diff = render - solid
- all_lines = render.copy()
- all_lines = cv2.erode(all_lines, np.ones((3,3), np.uint8)) * 0.618
- all_diff = re_med(all_diff)
- all_lines = re_med(all_lines)
- recon = solid + all_diff
- recon = recon * alpha + all_lines * (1 - alpha)
- recon2 = (solid + all_diff) * alpha + re_med(solid) * (1 - alpha)
- recon3 = reason_blending(recon2, sketch)
- return recon.clip(0, 255).astype(np.uint8), recon2.clip(0, 255).astype(np.uint8), recon3.clip(0, 255).astype(np.uint8)
-
-
-def process_psd(sketch, solid, render, path='./'):
- recon = process_ctx(sketch, solid, render)
- points = get_theme(solid)
- points = simplify_points(points, solid)
- compositions = get_ini_layers(solid, points)
- compositions = improve_layers(compositions, solid)
- for _ in range(ksd):
- cv2.imwrite(path + str(_ + 1) + '.color.png', compositions[_].clip(0, 255).astype(np.uint8))
- solid = make_reconstruction(compositions).clip(0, 255).astype(np.uint8)
- os.makedirs(path, exist_ok=True)
- alpha = 1 - sketch.astype(np.float32) / 255.0
- now = solid
- now = (now.astype(np.float32) + sketch.astype(np.float32) - 255.0).clip(0, 255)
- sketch = 255 + now - solid
- cv2.imwrite(path + '9.sketch.png', sketch.clip(0, 255).astype(np.uint8))
- all_diff = recon.astype(np.float32) - now
- all_light = all_diff.copy()
- all_shadow = - all_diff.copy()
- all_light[all_light < 0] = 0
- all_shadow[all_shadow < 0] = 0
- sketch_color = all_light * alpha
- light = all_light * (1 - alpha)
- all_shadow = 255 - all_shadow
- cv2.imwrite(path + '10.sketch_color.png', sketch_color.clip(0, 255).astype(np.uint8))
- cv2.imwrite(path + '11.light.png', light.clip(0, 255).astype(np.uint8))
- cv2.imwrite(path + '12.shadow.png', all_shadow.clip(0, 255).astype(np.uint8))
- return recon
-
-
-def process_albedo(albedo, composition, sketch):
- DEL = albedo.astype(np.float32)
- HSV = cv2.cvtColor(albedo, cv2.COLOR_RGB2HSV).astype(np.float32)
- YUV = cv2.cvtColor(albedo, cv2.COLOR_RGB2YUV).astype(np.float32)
- solid = composition.astype(np.float32)
- light = sketch[:, :, None].astype(np.float32)
-
- DEL = DEL * light / 255.0 + solid * (1 - light / 255.0)
- HSV[:, :, 2:3] = np.minimum(HSV[:, :, 2:3], light)
- YUV[:, :, 0:1] = np.minimum(YUV[:, :, 0:1], light)
-
- DEL = DEL.clip(0, 255).astype(np.uint8)
- HSV = HSV.clip(0, 255).astype(np.uint8)
- YUV = YUV.clip(0, 255).astype(np.uint8)
-
- return cv2.cvtColor(HSV, cv2.COLOR_HSV2RGB), cv2.cvtColor(YUV, cv2.COLOR_YUV2RGB), DEL
-
-
-def process_overlay(composition, sketch):
- RGB = composition.astype(np.float32)
- alpha = sketch[:, :, None].astype(np.float32) / 255.0
- return (RGB * alpha).clip(0, 255).astype(np.uint8)
diff --git a/spaces/HighCWu/anime-colorization-with-hint/gradio-modified/gradio/templates/frontend/assets/module.d8037460.js b/spaces/HighCWu/anime-colorization-with-hint/gradio-modified/gradio/templates/frontend/assets/module.d8037460.js
deleted file mode 100644
index 8d5e84b3696a9ef1b576f84f8a09e2600aaa9d02..0000000000000000000000000000000000000000
--- a/spaces/HighCWu/anime-colorization-with-hint/gradio-modified/gradio/templates/frontend/assets/module.d8037460.js
+++ /dev/null
@@ -1,2 +0,0 @@
-import{c as i}from"./module.e2741a44.js";const c=i({characterize:({call:e})=>()=>e("characterize"),encode:({call:e})=>(r,n)=>e("encode",{recordingId:r,timeslice:n}),record:({call:e})=>async(r,n,o)=>{await e("record",{recordingId:r,sampleRate:n,typedArrays:o},o.map(({buffer:a})=>a))}}),u=e=>{const r=new Worker(e);return c(r)},l=`(()=>{var e={775:function(e,t,r){!function(e,t,r,n){"use strict";function o(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}var s=o(t),a=o(r),i=o(n),u=function(e,t){return void 0===t?e:t.reduce((function(e,t){if("capitalize"===t){var r=e.charAt(0).toUpperCase(),n=e.slice(1);return"".concat(r).concat(n)}return"dashify"===t?a.default(e):"prependIndefiniteArticle"===t?"".concat(i.default(e)," ").concat(e):e}),e)},c=function(e){var t=e.name+e.modifiers.map((function(e){return"\\\\.".concat(e,"\\\\(\\\\)")})).join("");return new RegExp("\\\\$\\\\{".concat(t,"}"),"g")},l=function(e,t){for(var r=/\\\${([^.}]+)((\\.[^(]+\\(\\))*)}/g,n=[],o=r.exec(e);null!==o;){var a={modifiers:[],name:o[1]};if(void 0!==o[3])for(var i=/\\.[^(]+\\(\\)/g,l=i.exec(o[2]);null!==l;)a.modifiers.push(l[0].slice(1,-2)),l=i.exec(o[2]);n.push(a),o=r.exec(e)}var d=n.reduce((function(e,r){return e.map((function(e){return"string"==typeof e?e.split(c(r)).reduce((function(e,n,o){return 0===o?[n]:r.name in t?[].concat(s.default(e),[u(t[r.name],r.modifiers),n]):[].concat(s.default(e),[function(e){return u(e[r.name],r.modifiers)},n])}),[]):[e]})).reduce((function(e,t){return[].concat(s.default(e),s.default(t))}),[])}),[e]);return function(e){return d.reduce((function(t,r){return[].concat(s.default(t),"string"==typeof r?[r]:[r(e)])}),[]).join("")}},d=function(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},r=void 0===e.code?void 0:l(e.code,t),n=void 0===e.message?void 0:l(e.message,t);function o(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},o=arguments.length>1?arguments[1]:void 0,s=void 0===o&&(t instanceof Error||void 0!==t.code&&"Exception"===t.code.slice(-9))?{cause:t,missingParameters:{}}:{cause:o,missingParameters:t},a=s.cause,i=s.missingParameters,u=void 0===n?new Error:new Error(n(i));return null!==a&&(u.cause=a),void 0!==r&&(u.code=r(i)),void 0!==e.status&&(u.status=e.status),u}return o};e.compile=d,Object.defineProperty(e,"__esModule",{value:!0})}(t,r(106),r(881),r(507))},881:e=>{"use strict";e.exports=(e,t)=>{if("string"!=typeof e)throw new TypeError("expected a string");return e.trim().replace(/([a-z])([A-Z])/g,"$1-$2").replace(/\\W/g,(e=>/[\xC0-\u017E]/.test(e)?e:"-")).replace(/^-+|-+$/g,"").replace(/-{2,}/g,(e=>t&&t.condense?"-":e)).toLowerCase()}},107:function(e,t){!function(e){"use strict";var t=function(e){return function(t){var r=e(t);return t.add(r),r}},r=function(e){return function(t,r){return e.set(t,r),r}},n=void 0===Number.MAX_SAFE_INTEGER?9007199254740991:Number.MAX_SAFE_INTEGER,o=536870912,s=2*o,a=function(e,t){return function(r){var a=t.get(r),i=void 0===a?r.size:an)throw new Error("Congratulations, you created a collection of unique numbers which uses all available integers!");for(;r.has(i);)i=Math.floor(Math.random()*n);return e(r,i)}},i=new WeakMap,u=r(i),c=a(u,i),l=t(c);e.addUniqueNumber=l,e.generateUniqueNumber=c,Object.defineProperty(e,"__esModule",{value:!0})}(t)},507:e=>{var t=function(e){var t,r,n=/\\w+/.exec(e);if(!n)return"an";var o=(r=n[0]).toLowerCase(),s=["honest","hour","hono"];for(t in s)if(0==o.indexOf(s[t]))return"an";if(1==o.length)return"aedhilmnorsx".indexOf(o)>=0?"an":"a";if(r.match(/(?!FJO|[HLMNS]Y.|RY[EO]|SQU|(F[LR]?|[HL]|MN?|N|RH?|S[CHKLMNPTVW]?|X(YL)?)[AEIOU])[FHLMNRSX][A-Z]/))return"an";var a=[/^e[uw]/,/^onc?e\\b/,/^uni([^nmd]|mo)/,/^u[bcfhjkqrst][aeiou]/];for(t=0;t=0?"an":"a":"aeiou".indexOf(o[0])>=0||o.match(/^y(b[lor]|cl[ea]|fere|gg|p[ios]|rou|tt)/)?"an":"a"};void 0!==e.exports?e.exports=t:window.indefiniteArticle=t},768:e=>{e.exports=function(e,t){(null==t||t>e.length)&&(t=e.length);for(var r=0,n=new Array(t);r{var n=r(768);e.exports=function(e){if(Array.isArray(e))return n(e)},e.exports.__esModule=!0,e.exports.default=e.exports},642:e=>{e.exports=function(e){if("undefined"!=typeof Symbol&&null!=e[Symbol.iterator]||null!=e["@@iterator"])return Array.from(e)},e.exports.__esModule=!0,e.exports.default=e.exports},344:e=>{e.exports=function(){throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")},e.exports.__esModule=!0,e.exports.default=e.exports},106:(e,t,r)=>{var n=r(907),o=r(642),s=r(906),a=r(344);e.exports=function(e){return n(e)||o(e)||s(e)||a()},e.exports.__esModule=!0,e.exports.default=e.exports},906:(e,t,r)=>{var n=r(768);e.exports=function(e,t){if(e){if("string"==typeof e)return n(e,t);var r=Object.prototype.toString.call(e).slice(8,-1);return"Object"===r&&e.constructor&&(r=e.constructor.name),"Map"===r||"Set"===r?Array.from(e):"Arguments"===r||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r)?n(e,t):void 0}},e.exports.__esModule=!0,e.exports.default=e.exports}},t={};function r(n){var o=t[n];if(void 0!==o)return o.exports;var s=t[n]={exports:{}};return e[n].call(s.exports,s,s.exports,r),s.exports}(()=>{"use strict";var e=r(775);const t=-32603,n=-32602,o=-32601,s=(0,e.compile)({message:'The requested method called "\${method}" is not supported.',status:o}),a=(0,e.compile)({message:'The handler of the method called "\${method}" returned no required result.',status:t}),i=(0,e.compile)({message:'The handler of the method called "\${method}" returned an unexpected result.',status:t}),u=(0,e.compile)({message:'The specified parameter called "portId" with the given value "\${portId}" does not identify a port connected to this worker.',status:n}),c=(e,t)=>async r=>{let{data:{id:n,method:o,params:u}}=r;const c=t[o];try{if(void 0===c)throw s({method:o});const t=void 0===u?c():c(u);if(void 0===t)throw a({method:o});const r=t instanceof Promise?await t:t;if(null===n){if(void 0!==r.result)throw i({method:o})}else{if(void 0===r.result)throw i({method:o});const{result:t,transferables:s=[]}=r;e.postMessage({id:n,result:t},s)}}catch(t){const{message:r,status:o=-32603}=t;e.postMessage({error:{code:o,message:r},id:n})}};var l=r(107);const d=new Map,f=(e,t,r)=>({...t,connect:r=>{let{port:n}=r;n.start();const o=e(n,t),s=(0,l.generateUniqueNumber)(d);return d.set(s,(()=>{o(),n.close(),d.delete(s)})),{result:s}},disconnect:e=>{let{portId:t}=e;const r=d.get(t);if(void 0===r)throw u({portId:t.toString()});return r(),{result:null}},isSupported:async()=>{if(await new Promise((e=>{const t=new ArrayBuffer(0),{port1:r,port2:n}=new MessageChannel;r.onmessage=t=>{let{data:r}=t;return e(null!==r)},n.postMessage(t,[t])}))){const e=r();return{result:e instanceof Promise?await e:e}}return{result:!1}}}),p=function(e,t){let r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:()=>!0;const n=f(p,t,r),o=c(e,n);return e.addEventListener("message",o),()=>e.removeEventListener("message",o)},m=e=>e.reduce(((e,t)=>e+t.length),0),h=(e,t)=>{const r=[];let n=0;e:for(;nt){const o=n-t;r.forEach(((t,r)=>{const n=t.pop(),s=n.length-o;t.push(n.subarray(0,s)),e[r].unshift(n.subarray(s))}))}return r},v=new Map,g=(e=>(t,r,n)=>{const o=e.get(t);if(void 0===o){const o={channelDataArrays:n.map((e=>[e])),isComplete:!0,sampleRate:r};return e.set(t,o),o}return o.channelDataArrays.forEach(((e,t)=>e.push(n[t]))),o})(v),x=((e,t)=>(r,n,o,s)=>{const a=o>>3,i="subsequent"===n?0:44,u=r.length,c=e(r[0]),l=new ArrayBuffer(c*u*a+i),d=new DataView(l);return"subsequent"!==n&&t(d,o,u,"complete"===n?c:Number.POSITIVE_INFINITY,s),r.forEach(((e,t)=>{let r=i+t*a;e.forEach((e=>{const t=e.length;for(let n=0;n{const s=t>>3,a=Math.min(n*r*s,4294967251);e.setUint32(0,1380533830),e.setUint32(4,a+36,!0),e.setUint32(8,1463899717),e.setUint32(12,1718449184),e.setUint32(16,16,!0),e.setUint16(20,1,!0),e.setUint16(22,r,!0),e.setUint32(24,o,!0),e.setUint32(28,o*r*s,!0),e.setUint16(32,r*s,!0),e.setUint16(34,t,!0),e.setUint32(36,1684108385),e.setUint32(40,a,!0)})),w=new Map;p(self,{characterize:()=>({result:/^audio\\/wav$/}),encode:e=>{let{recordingId:t,timeslice:r}=e;const n=w.get(t);void 0!==n&&(w.delete(t),n.reject(new Error("Another request was made to initiate an encoding.")));const o=v.get(t);if(null!==r){if(void 0===o||m(o.channelDataArrays[0])*(1e3/o.sampleRate){w.set(t,{reject:n,resolve:e,timeslice:r})}));const e=h(o.channelDataArrays,Math.ceil(r*(o.sampleRate/1e3))),n=x(e,o.isComplete?"initial":"subsequent",16,o.sampleRate);return o.isComplete=!1,{result:n,transferables:n}}if(void 0!==o){const e=x(o.channelDataArrays,o.isComplete?"complete":"subsequent",16,o.sampleRate);return v.delete(t),{result:e,transferables:e}}return{result:[],transferables:[]}},record:e=>{let{recordingId:t,sampleRate:r,typedArrays:n}=e;const o=g(t,r,n),s=w.get(t);if(void 0!==s&&m(o.channelDataArrays[0])*(1e3/r)>=s.timeslice){const e=h(o.channelDataArrays,Math.ceil(s.timeslice*(r/1e3))),n=x(e,o.isComplete?"initial":"subsequent",16,r);o.isComplete=!1,w.delete(t),s.resolve({result:n,transferables:n})}return{result:null}}})})()})();`,d=new Blob([l],{type:"application/javascript; charset=utf-8"}),s=URL.createObjectURL(d),t=u(s),p=t.characterize,m=t.connect,h=t.disconnect,v=t.encode,g=t.isSupported,x=t.record;URL.revokeObjectURL(s);export{p as characterize,m as connect,h as disconnect,v as encode,g as isSupported,x as record};
-//# sourceMappingURL=module.d8037460.js.map
diff --git a/spaces/Hila/RobustViT/robustness_dataset.py b/spaces/Hila/RobustViT/robustness_dataset.py
deleted file mode 100644
index e067332e680e9707587dfc4ac509e2b9af5c17bd..0000000000000000000000000000000000000000
--- a/spaces/Hila/RobustViT/robustness_dataset.py
+++ /dev/null
@@ -1,66 +0,0 @@
-import json
-from torch.utils import data
-from torchvision.datasets import ImageFolder
-import torch
-import os
-from PIL import Image
-import numpy as np
-import argparse
-from tqdm import tqdm
-from munkres import Munkres
-import multiprocessing
-from multiprocessing import Process, Manager
-import collections
-import torchvision.transforms as transforms
-import torchvision.transforms.functional as TF
-import random
-import torchvision
-import cv2
-from label_str_to_imagenet_classes import label_str_to_imagenet_classes
-
-torch.manual_seed(0)
-
-ImageItem = collections.namedtuple('ImageItem', ('image_name', 'tag'))
-normalize = transforms.Normalize(mean=[0.5, 0.5, 0.5],
- std=[0.5, 0.5, 0.5])
-
-transform = transforms.Compose([
- transforms.Resize(256),
- transforms.CenterCrop(224),
- transforms.ToTensor(),
- normalize,
-])
-
-class RobustnessDataset(ImageFolder):
- def __init__(self, imagenet_path, imagenet_classes_path='imagenet_classes.json', isV2=False, isSI=False):
- self._isV2 = isV2
- self._isSI = isSI
- self._imagenet_path = imagenet_path
- with open(imagenet_classes_path, 'r') as f:
- self._imagenet_classes = json.load(f)
- self._tag_list = [tag for tag in os.listdir(self._imagenet_path)]
- self._all_images = []
- for tag in self._tag_list:
- base_dir = os.path.join(self._imagenet_path, tag)
- for i, file in enumerate(os.listdir(base_dir)):
- self._all_images.append(ImageItem(file, tag))
-
-
- def __getitem__(self, item):
- image_item = self._all_images[item]
- image_path = os.path.join(self._imagenet_path, image_item.tag, image_item.image_name)
- image = Image.open(image_path)
- image = image.convert('RGB')
- image = transform(image)
-
- if self._isV2:
- class_name = int(image_item.tag)
- elif self._isSI:
- class_name = int(label_str_to_imagenet_classes[image_item.tag])
- else:
- class_name = int(self._imagenet_classes[image_item.tag])
-
- return image, class_name
-
- def __len__(self):
- return len(self._all_images)
\ No newline at end of file
diff --git a/spaces/ICML2022/OFA/fairseq/examples/speech_to_text/data_utils.py b/spaces/ICML2022/OFA/fairseq/examples/speech_to_text/data_utils.py
deleted file mode 100644
index 41afac0bf8f6d70e06bee1a34e220ab396ec247d..0000000000000000000000000000000000000000
--- a/spaces/ICML2022/OFA/fairseq/examples/speech_to_text/data_utils.py
+++ /dev/null
@@ -1,382 +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 csv
-from pathlib import Path
-import zipfile
-from functools import reduce
-from multiprocessing import cpu_count
-from typing import Any, Dict, List, Optional, Union
-import io
-
-import numpy as np
-import pandas as pd
-import sentencepiece as sp
-from fairseq.data.audio.audio_utils import (
- convert_waveform, _get_kaldi_fbank, _get_torchaudio_fbank, is_npy_data,
- is_sf_audio_data
-)
-import torch
-import soundfile as sf
-from tqdm import tqdm
-
-
-UNK_TOKEN, UNK_TOKEN_ID = "", 3
-BOS_TOKEN, BOS_TOKEN_ID = "", 0
-EOS_TOKEN, EOS_TOKEN_ID = "", 2
-PAD_TOKEN, PAD_TOKEN_ID = "", 1
-
-
-def gen_vocab(
- input_path: Path, output_path_prefix: Path, model_type="bpe",
- vocab_size=1000, special_symbols: Optional[List[str]] = None
-):
- # Train SentencePiece Model
- arguments = [
- f"--input={input_path.as_posix()}",
- f"--model_prefix={output_path_prefix.as_posix()}",
- f"--model_type={model_type}",
- f"--vocab_size={vocab_size}",
- "--character_coverage=1.0",
- f"--num_threads={cpu_count()}",
- f"--unk_id={UNK_TOKEN_ID}",
- f"--bos_id={BOS_TOKEN_ID}",
- f"--eos_id={EOS_TOKEN_ID}",
- f"--pad_id={PAD_TOKEN_ID}",
- ]
- if special_symbols is not None:
- _special_symbols = ",".join(special_symbols)
- arguments.append(f"--user_defined_symbols={_special_symbols}")
- sp.SentencePieceTrainer.Train(" ".join(arguments))
- # Export fairseq dictionary
- spm = sp.SentencePieceProcessor()
- spm.Load(output_path_prefix.as_posix() + ".model")
- vocab = {i: spm.IdToPiece(i) for i in range(spm.GetPieceSize())}
- assert (
- vocab.get(UNK_TOKEN_ID) == UNK_TOKEN
- and vocab.get(PAD_TOKEN_ID) == PAD_TOKEN
- and vocab.get(BOS_TOKEN_ID) == BOS_TOKEN
- and vocab.get(EOS_TOKEN_ID) == EOS_TOKEN
- )
- vocab = {
- i: s
- for i, s in vocab.items()
- if s not in {UNK_TOKEN, BOS_TOKEN, EOS_TOKEN, PAD_TOKEN}
- }
- with open(output_path_prefix.as_posix() + ".txt", "w") as f_out:
- for _, s in sorted(vocab.items(), key=lambda x: x[0]):
- f_out.write(f"{s} 1\n")
-
-
-def extract_fbank_features(
- waveform: torch.FloatTensor,
- sample_rate: int,
- output_path: Optional[Path] = None,
- n_mel_bins: int = 80,
- overwrite: bool = False,
-):
- if output_path is not None and output_path.is_file() and not overwrite:
- return
-
- _waveform = convert_waveform(waveform, sample_rate, to_mono=True)
- # Kaldi compliance: 16-bit signed integers
- _waveform = _waveform * (2 ** 15)
- _waveform = _waveform.numpy()
-
- features = _get_kaldi_fbank(_waveform, sample_rate, n_mel_bins)
- if features is None:
- features = _get_torchaudio_fbank(_waveform, sample_rate, n_mel_bins)
- if features is None:
- raise ImportError(
- "Please install pyKaldi or torchaudio to enable fbank feature extraction"
- )
-
- if output_path is not None:
- np.save(output_path.as_posix(), features)
- return features
-
-
-def create_zip(data_root: Path, zip_path: Path):
- paths = list(data_root.glob("*.npy"))
- with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_STORED) as f:
- for path in tqdm(paths):
- f.write(path, arcname=path.name)
-
-
-def get_zip_manifest(
- zip_path: Path, zip_root: Optional[Path] = None, is_audio=False
-):
- _zip_path = Path.joinpath(zip_root or Path(""), zip_path)
- with zipfile.ZipFile(_zip_path, mode="r") as f:
- info = f.infolist()
- paths, lengths = {}, {}
- for i in tqdm(info):
- utt_id = Path(i.filename).stem
- offset, file_size = i.header_offset + 30 + len(i.filename), i.file_size
- paths[utt_id] = f"{zip_path.as_posix()}:{offset}:{file_size}"
- with open(_zip_path, "rb") as f:
- f.seek(offset)
- byte_data = f.read(file_size)
- assert len(byte_data) > 1
- if is_audio:
- assert is_sf_audio_data(byte_data), i
- else:
- assert is_npy_data(byte_data), i
- byte_data_fp = io.BytesIO(byte_data)
- if is_audio:
- lengths[utt_id] = sf.info(byte_data_fp).frames
- else:
- lengths[utt_id] = np.load(byte_data_fp).shape[0]
- return paths, lengths
-
-
-def gen_config_yaml(
- manifest_root: Path,
- spm_filename: Optional[str] = None,
- vocab_name: Optional[str] = None,
- yaml_filename: str = "config.yaml",
- specaugment_policy: Optional[str] = "lb",
- prepend_tgt_lang_tag: bool = False,
- sampling_alpha: Optional[float] = None,
- input_channels: Optional[int] = 1,
- input_feat_per_channel: Optional[int] = 80,
- audio_root: str = "",
- cmvn_type: str = "utterance",
- gcmvn_path: Optional[Path] = None,
- extra=None
-):
- manifest_root = manifest_root.absolute()
- writer = S2TDataConfigWriter(manifest_root / yaml_filename)
- assert spm_filename is not None or vocab_name is not None
- vocab_name = spm_filename.replace(".model", ".txt") if vocab_name is None \
- else vocab_name
- writer.set_vocab_filename(vocab_name)
- if input_channels is not None:
- writer.set_input_channels(input_channels)
- if input_feat_per_channel is not None:
- writer.set_input_feat_per_channel(input_feat_per_channel)
- specaugment_setters = {
- "lb": writer.set_specaugment_lb_policy,
- "ld": writer.set_specaugment_ld_policy,
- "sm": writer.set_specaugment_sm_policy,
- "ss": writer.set_specaugment_ss_policy,
- }
- specaugment_setter = specaugment_setters.get(specaugment_policy, None)
- if specaugment_setter is not None:
- specaugment_setter()
- if spm_filename is not None:
- writer.set_bpe_tokenizer(
- {
- "bpe": "sentencepiece",
- "sentencepiece_model": (manifest_root / spm_filename).as_posix(),
- }
- )
- if prepend_tgt_lang_tag:
- writer.set_prepend_tgt_lang_tag(True)
- if sampling_alpha is not None:
- writer.set_sampling_alpha(sampling_alpha)
-
- if cmvn_type not in ["global", "utterance"]:
- raise NotImplementedError
-
- if specaugment_policy is not None:
- writer.set_feature_transforms(
- "_train", [f"{cmvn_type}_cmvn", "specaugment"]
- )
- writer.set_feature_transforms("*", [f"{cmvn_type}_cmvn"])
-
- if cmvn_type == "global":
- if gcmvn_path is None:
- raise ValueError("Please provide path of global cmvn file.")
- else:
- writer.set_global_cmvn(gcmvn_path.as_posix())
-
- if len(audio_root) > 0:
- writer.set_audio_root(audio_root)
-
- if extra is not None:
- writer.set_extra(extra)
- writer.flush()
-
-
-def load_df_from_tsv(path: Union[str, Path]) -> pd.DataFrame:
- _path = path if isinstance(path, str) else path.as_posix()
- return pd.read_csv(
- _path,
- sep="\t",
- header=0,
- encoding="utf-8",
- escapechar="\\",
- quoting=csv.QUOTE_NONE,
- na_filter=False,
- )
-
-
-def save_df_to_tsv(dataframe, path: Union[str, Path]):
- _path = path if isinstance(path, str) else path.as_posix()
- dataframe.to_csv(
- _path,
- sep="\t",
- header=True,
- index=False,
- encoding="utf-8",
- escapechar="\\",
- quoting=csv.QUOTE_NONE,
- )
-
-
-def load_tsv_to_dicts(path: Union[str, Path]) -> List[dict]:
- with open(path, "r") as f:
- reader = csv.DictReader(
- f,
- delimiter="\t",
- quotechar=None,
- doublequote=False,
- lineterminator="\n",
- quoting=csv.QUOTE_NONE,
- )
- rows = [dict(e) for e in reader]
- return rows
-
-
-def filter_manifest_df(
- df, is_train_split=False, extra_filters=None, min_n_frames=5, max_n_frames=3000
-):
- filters = {
- "no speech": df["audio"] == "",
- f"short speech (<{min_n_frames} frames)": df["n_frames"] < min_n_frames,
- "empty sentence": df["tgt_text"] == "",
- }
- if is_train_split:
- filters[f"long speech (>{max_n_frames} frames)"] = df["n_frames"] > max_n_frames
- if extra_filters is not None:
- filters.update(extra_filters)
- invalid = reduce(lambda x, y: x | y, filters.values())
- valid = ~invalid
- print(
- "| "
- + ", ".join(f"{n}: {f.sum()}" for n, f in filters.items())
- + f", total {invalid.sum()} filtered, {valid.sum()} remained."
- )
- return df[valid]
-
-
-def cal_gcmvn_stats(features_list):
- features = np.concatenate(features_list)
- square_sums = (features ** 2).sum(axis=0)
- mean = features.mean(axis=0)
- features = np.subtract(features, mean)
- var = square_sums / features.shape[0] - mean ** 2
- std = np.sqrt(np.maximum(var, 1e-8))
- return {"mean": mean.astype("float32"), "std": std.astype("float32")}
-
-
-class S2TDataConfigWriter(object):
- DEFAULT_VOCAB_FILENAME = "dict.txt"
- DEFAULT_INPUT_FEAT_PER_CHANNEL = 80
- DEFAULT_INPUT_CHANNELS = 1
-
- def __init__(self, yaml_path: Path):
- try:
- import yaml
- except ImportError:
- print("Please install PyYAML for S2T data config YAML files")
- self.yaml = yaml
- self.yaml_path = yaml_path
- self.config = {}
-
- def flush(self):
- with open(self.yaml_path, "w") as f:
- self.yaml.dump(self.config, f)
-
- def set_audio_root(self, audio_root=""):
- self.config["audio_root"] = audio_root
-
- def set_vocab_filename(self, vocab_filename: str = "dict.txt"):
- self.config["vocab_filename"] = vocab_filename
-
- def set_specaugment(
- self,
- time_wrap_w: int,
- freq_mask_n: int,
- freq_mask_f: int,
- time_mask_n: int,
- time_mask_t: int,
- time_mask_p: float,
- ):
- self.config["specaugment"] = {
- "time_wrap_W": time_wrap_w,
- "freq_mask_N": freq_mask_n,
- "freq_mask_F": freq_mask_f,
- "time_mask_N": time_mask_n,
- "time_mask_T": time_mask_t,
- "time_mask_p": time_mask_p,
- }
-
- def set_specaugment_lb_policy(self):
- self.set_specaugment(
- time_wrap_w=0,
- freq_mask_n=1,
- freq_mask_f=27,
- time_mask_n=1,
- time_mask_t=100,
- time_mask_p=1.0,
- )
-
- def set_specaugment_ld_policy(self):
- self.set_specaugment(
- time_wrap_w=0,
- freq_mask_n=2,
- freq_mask_f=27,
- time_mask_n=2,
- time_mask_t=100,
- time_mask_p=1.0,
- )
-
- def set_specaugment_sm_policy(self):
- self.set_specaugment(
- time_wrap_w=0,
- freq_mask_n=2,
- freq_mask_f=15,
- time_mask_n=2,
- time_mask_t=70,
- time_mask_p=0.2,
- )
-
- def set_specaugment_ss_policy(self):
- self.set_specaugment(
- time_wrap_w=0,
- freq_mask_n=2,
- freq_mask_f=27,
- time_mask_n=2,
- time_mask_t=70,
- time_mask_p=0.2,
- )
-
- def set_input_channels(self, input_channels: int = 1):
- self.config["input_channels"] = input_channels
-
- def set_input_feat_per_channel(self, input_feat_per_channel: int = 80):
- self.config["input_feat_per_channel"] = input_feat_per_channel
-
- def set_bpe_tokenizer(self, bpe_tokenizer: Dict[str, Any]):
- self.config["bpe_tokenizer"] = bpe_tokenizer
-
- def set_global_cmvn(self, stats_npz_path: str):
- self.config["global_cmvn"] = {"stats_npz_path": stats_npz_path}
-
- def set_feature_transforms(self, split: str, transforms: List[str]):
- if "transforms" not in self.config:
- self.config["transforms"] = {}
- self.config["transforms"][split] = transforms
-
- def set_prepend_tgt_lang_tag(self, flag: bool = True):
- self.config["prepend_tgt_lang_tag"] = flag
-
- def set_sampling_alpha(self, sampling_alpha: float = 1.0):
- self.config["sampling_alpha"] = sampling_alpha
-
- def set_extra(self, data):
- self.config.update(data)
diff --git a/spaces/Illumotion/Koboldcpp/include/CL/cl_ext_intel.h b/spaces/Illumotion/Koboldcpp/include/CL/cl_ext_intel.h
deleted file mode 100644
index a7ae87a3400ffb0d3f3411dc0f4a3a330fcccf70..0000000000000000000000000000000000000000
--- a/spaces/Illumotion/Koboldcpp/include/CL/cl_ext_intel.h
+++ /dev/null
@@ -1,19 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008-2020 The Khronos Group Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- ******************************************************************************/
-
-#include
-#pragma message("The Intel extensions have been moved into cl_ext.h. Please include cl_ext.h directly.")
diff --git a/spaces/JohnSmith9982/ChuanhuChatGPT/assets/custom.css b/spaces/JohnSmith9982/ChuanhuChatGPT/assets/custom.css
deleted file mode 100644
index 22108488886cfc8d7772214dd9b83727b3fca6a3..0000000000000000000000000000000000000000
--- a/spaces/JohnSmith9982/ChuanhuChatGPT/assets/custom.css
+++ /dev/null
@@ -1,468 +0,0 @@
-:root {
- --chatbot-color-light: #000000;
- --chatbot-color-dark: #FFFFFF;
- --chatbot-background-color-light: #F3F3F3;
- --chatbot-background-color-dark: #121111;
- --message-user-background-color-light: #95EC69;
- --message-user-background-color-dark: #26B561;
- --message-bot-background-color-light: #FFFFFF;
- --message-bot-background-color-dark: #2C2C2C;
-}
-
-#app_title {
- font-weight: var(--prose-header-text-weight);
- font-size: var(--text-xxl);
- line-height: 1.3;
- text-align: left;
- margin-top: 6px;
- white-space: nowrap;
-}
-#description {
- text-align: center;
- margin: 32px 0 4px 0;
-}
-
-/* gradio的页脚信息 */
-footer {
- /* display: none !important; */
- margin-top: .2em !important;
- font-size: 85%;
-}
-#footer {
- text-align: center;
-}
-#footer div {
- display: inline-block;
-}
-#footer .versions{
- font-size: 85%;
- opacity: 0.60;
-}
-
-#float_display {
- position: absolute;
- max-height: 30px;
-}
-/* user_info */
-#user_info {
- white-space: nowrap;
- position: absolute; left: 8em; top: .2em;
- z-index: var(--layer-2);
- box-shadow: var(--block-shadow);
- border: none; border-radius: var(--block-label-radius);
- background: var(--color-accent);
- padding: var(--block-label-padding);
- font-size: var(--block-label-text-size); line-height: var(--line-sm);
- width: auto; min-height: 30px!important;
- opacity: 1;
- transition: opacity 0.3s ease-in-out;
-}
-#user_info .wrap {
- opacity: 0;
-}
-#user_info p {
- color: white;
- font-weight: var(--block-label-text-weight);
-}
-#user_info.hideK {
- opacity: 0;
- transition: opacity 1s ease-in-out;
-}
-
-/* status_display */
-#status_display {
- display: flex;
- min-height: 2em;
- align-items: flex-end;
- justify-content: flex-end;
-}
-#status_display p {
- font-size: .85em;
- font-family: ui-monospace, "SF Mono", "SFMono-Regular", "Menlo", "Consolas", "Liberation Mono", "Microsoft Yahei UI", "Microsoft Yahei", monospace;
- /* Windows下中文的monospace会fallback为新宋体，实在太丑，这里折中使用微软雅黑 */
- color: var(--body-text-color-subdued);
-}
-
-#status_display {
- transition: all 0.6s;
-}
-#chuanhu_chatbot {
- transition: height 0.3s ease;
-}
-
-/* usage_display */
-.insert_block {
- position: relative;
- margin: 0;
- padding: .5em 1em;
- box-shadow: var(--block-shadow);
- border-width: var(--block-border-width);
- border-color: var(--block-border-color);
- border-radius: var(--block-radius);
- background: var(--block-background-fill);
- width: 100%;
- line-height: var(--line-sm);
- min-height: 2em;
-}
-#usage_display p, #usage_display span {
- margin: 0;
- font-size: .85em;
- color: var(--body-text-color-subdued);
-}
-.progress-bar {
- background-color: var(--input-background-fill);;
- margin: .5em 0 !important;
- height: 20px;
- border-radius: 10px;
- overflow: hidden;
-}
-.progress {
- background-color: var(--block-title-background-fill);
- height: 100%;
- border-radius: 10px;
- text-align: right;
- transition: width 0.5s ease-in-out;
-}
-.progress-text {
- /* color: white; */
- color: var(--color-accent) !important;
- font-size: 1em !important;
- font-weight: bold;
- padding-right: 10px;
- line-height: 20px;
-}
-
-.apSwitch {
- top: 2px;
- display: inline-block;
- height: 24px;
- position: relative;
- width: 48px;
- border-radius: 12px;
-}
-.apSwitch input {
- display: none !important;
-}
-.apSlider {
- background-color: var(--neutral-200);
- bottom: 0;
- cursor: pointer;
- left: 0;
- position: absolute;
- right: 0;
- top: 0;
- transition: .4s;
- font-size: 18px;
- border-radius: 12px;
-}
-.apSlider::before {
- bottom: -1.5px;
- left: 1px;
- position: absolute;
- transition: .4s;
- content: "🌞";
-}
-input:checked + .apSlider {
- background-color: var(--primary-600);
-}
-input:checked + .apSlider::before {
- transform: translateX(23px);
- content:"🌚";
-}
-
-/* Override Slider Styles (for webkit browsers like Safari and Chrome)
- * 好希望这份提案能早日实现 https://github.com/w3c/csswg-drafts/issues/4410
- * 进度滑块在各个平台还是太不统一了
- */
-input[type="range"] {
- -webkit-appearance: none;
- height: 4px;
- background: var(--input-background-fill);
- border-radius: 5px;
- background-image: linear-gradient(var(--primary-500),var(--primary-500));
- background-size: 0% 100%;
- background-repeat: no-repeat;
-}
-input[type="range"]::-webkit-slider-thumb {
- -webkit-appearance: none;
- height: 20px;
- width: 20px;
- border-radius: 50%;
- border: solid 0.5px #ddd;
- background-color: white;
- cursor: ew-resize;
- box-shadow: var(--input-shadow);
- transition: background-color .1s ease;
-}
-input[type="range"]::-webkit-slider-thumb:hover {
- background: var(--neutral-50);
-}
-input[type=range]::-webkit-slider-runnable-track {
- -webkit-appearance: none;
- box-shadow: none;
- border: none;
- background: transparent;
-}
-
-#submit_btn, #cancel_btn {
- height: 42px !important;
-}
-#submit_btn::before {
- content: url("data:image/svg+xml, %3Csvg width='21px' height='20px' viewBox='0 0 21 20' version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink'%3E %3Cg id='page' stroke='none' stroke-width='1' fill='none' fill-rule='evenodd'%3E %3Cg id='send' transform='translate(0.435849, 0.088463)' fill='%23FFFFFF' fill-rule='nonzero'%3E %3Cpath d='M0.579148261,0.0428666046 C0.301105539,-0.0961547561 -0.036517765,0.122307382 0.0032026237,0.420210298 L1.4927172,18.1553639 C1.5125774,18.4334066 1.79062012,18.5922882 2.04880264,18.4929872 L8.24518329,15.8913017 L11.6412765,19.7441794 C11.8597387,19.9825018 12.2370824,19.8832008 12.3165231,19.5852979 L13.9450591,13.4882182 L19.7839562,11.0255541 C20.0619989,10.8865327 20.0818591,10.4694687 19.7839562,10.3105871 L0.579148261,0.0428666046 Z M11.6138902,17.0883151 L9.85385903,14.7195502 L0.718169621,0.618812241 L12.69945,12.9346347 L11.6138902,17.0883151 Z' id='shape'%3E%3C/path%3E %3C/g%3E %3C/g%3E %3C/svg%3E");
- height: 21px;
-}
-#cancel_btn::before {
- content: url("data:image/svg+xml,%3Csvg width='21px' height='21px' viewBox='0 0 21 21' version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink'%3E %3Cg id='pg' stroke='none' stroke-width='1' fill='none' fill-rule='evenodd'%3E %3Cpath d='M10.2072007,20.088463 C11.5727865,20.088463 12.8594566,19.8259823 14.067211,19.3010209 C15.2749653,18.7760595 16.3386126,18.0538087 17.2581528,17.1342685 C18.177693,16.2147282 18.8982283,15.1527965 19.4197586,13.9484733 C19.9412889,12.7441501 20.202054,11.4557644 20.202054,10.0833163 C20.202054,8.71773046 19.9395733,7.43106036 19.4146119,6.22330603 C18.8896505,5.01555169 18.1673997,3.95018885 17.2478595,3.0272175 C16.3283192,2.10424615 15.2646719,1.3837109 14.0569176,0.865611739 C12.8491633,0.34751258 11.5624932,0.088463 10.1969073,0.088463 C8.83132146,0.088463 7.54636692,0.34751258 6.34204371,0.865611739 C5.1377205,1.3837109 4.07407321,2.10424615 3.15110186,3.0272175 C2.22813051,3.95018885 1.5058797,5.01555169 0.984349419,6.22330603 C0.46281914,7.43106036 0.202054,8.71773046 0.202054,10.0833163 C0.202054,11.4557644 0.4645347,12.7441501 0.9894961,13.9484733 C1.5144575,15.1527965 2.23670831,16.2147282 3.15624854,17.1342685 C4.07578877,18.0538087 5.1377205,18.7760595 6.34204371,19.3010209 C7.54636692,19.8259823 8.83475258,20.088463 10.2072007,20.088463 Z M10.2072007,18.2562448 C9.07493099,18.2562448 8.01471483,18.0452309 7.0265522,17.6232031 C6.03838956,17.2011753 5.17031614,16.6161693 4.42233192,15.8681851 C3.6743477,15.1202009 3.09105726,14.2521274 2.67246059,13.2639648 C2.25386392,12.2758022 2.04456558,11.215586 2.04456558,10.0833163 C2.04456558,8.95104663 2.25386392,7.89083047 2.67246059,6.90266784 C3.09105726,5.9145052 3.6743477,5.04643178 4.42233192,4.29844756 C5.17031614,3.55046334 6.036674,2.9671729 7.02140552,2.54857623 C8.00613703,2.12997956 9.06463763,1.92068122 10.1969073,1.92068122 C11.329177,1.92068122 12.3911087,2.12997956 13.3827025,2.54857623 C14.3742962,2.9671729 15.2440852,3.55046334 15.9920694,4.29844756 C16.7400537,5.04643178 17.3233441,5.9145052 17.7419408,6.90266784 C18.1605374,7.89083047 18.3698358,8.95104663 18.3698358,10.0833163 C18.3698358,11.215586 18.1605374,12.2758022 17.7419408,13.2639648 C17.3233441,14.2521274 16.7400537,15.1202009 15.9920694,15.8681851 C15.2440852,16.6161693 14.3760118,17.2011753 13.3878492,17.6232031 C12.3996865,18.0452309 11.3394704,18.2562448 10.2072007,18.2562448 Z M7.65444721,13.6242324 L12.7496608,13.6242324 C13.0584616,13.6242324 13.3003556,13.5384544 13.4753427,13.3668984 C13.6503299,13.1953424 13.7378234,12.9585951 13.7378234,12.6566565 L13.7378234,7.49968276 C13.7378234,7.19774418 13.6503299,6.96099688 13.4753427,6.78944087 C13.3003556,6.61788486 13.0584616,6.53210685 12.7496608,6.53210685 L7.65444721,6.53210685 C7.33878414,6.53210685 7.09345904,6.61788486 6.91847191,6.78944087 C6.74348478,6.96099688 6.65599121,7.19774418 6.65599121,7.49968276 L6.65599121,12.6566565 C6.65599121,12.9585951 6.74348478,13.1953424 6.91847191,13.3668984 C7.09345904,13.5384544 7.33878414,13.6242324 7.65444721,13.6242324 Z' id='shape' fill='%23FF3B30' fill-rule='nonzero'%3E%3C/path%3E %3C/g%3E %3C/svg%3E");
- height: 21px;
-}
-/* list */
-ol:not(.options), ul:not(.options) {
- padding-inline-start: 2em !important;
-}
-
-/* 亮色（默认） */
-#chuanhu_chatbot {
- background-color: var(--chatbot-background-color-light) !important;
- color: var(--chatbot-color-light) !important;
-}
-[data-testid = "bot"] {
- background-color: var(--message-bot-background-color-light) !important;
-}
-[data-testid = "user"] {
- background-color: var(--message-user-background-color-light) !important;
-}
-/* 暗色 */
-.dark #chuanhu_chatbot {
- background-color: var(--chatbot-background-color-dark) !important;
- color: var(--chatbot-color-dark) !important;
-}
-.dark [data-testid = "bot"] {
- background-color: var(--message-bot-background-color-dark) !important;
-}
-.dark [data-testid = "user"] {
- background-color: var(--message-user-background-color-dark) !important;
-}
-
-/* 屏幕宽度大于等于500px的设备 */
-/* update on 2023.4.8: 高度的细致调整已写入JavaScript */
-@media screen and (min-width: 500px) {
- #chuanhu_chatbot {
- height: calc(100vh - 200px);
- }
- #chuanhu_chatbot .wrap {
- max-height: calc(100vh - 200px - var(--line-sm)*1rem - 2*var(--block-label-margin) );
- }
-}
-/* 屏幕宽度小于500px的设备 */
-@media screen and (max-width: 499px) {
- #chuanhu_chatbot {
- height: calc(100vh - 140px);
- }
- #chuanhu_chatbot .wrap {
- max-height: calc(100vh - 140px - var(--line-sm)*1rem - 2*var(--block-label-margin) );
- }
- [data-testid = "bot"] {
- max-width: 95% !important;
- }
- #app_title h1{
- letter-spacing: -1px; font-size: 22px;
- }
-}
-#chuanhu_chatbot .wrap {
- overflow-x: hidden;
-}
-/* 对话气泡 */
-.message {
- border-radius: var(--radius-xl) !important;
- border: none;
- padding: var(--spacing-xl) !important;
- font-size: var(--text-md) !important;
- line-height: var(--line-md) !important;
- min-height: calc(var(--text-md)*var(--line-md) + 2*var(--spacing-xl));
- min-width: calc(var(--text-md)*var(--line-md) + 2*var(--spacing-xl));
-}
-[data-testid = "bot"] {
- max-width: 85%;
- border-bottom-left-radius: 0 !important;
-}
-[data-testid = "user"] {
- max-width: 85%;
- width: auto !important;
- border-bottom-right-radius: 0 !important;
-}
-
-.message.user p {
- white-space: pre-wrap;
-}
-.message .user-message {
- display: block;
- padding: 0 !important;
- white-space: pre-wrap;
-}
-
-.message .md-message p {
- margin-top: 0.6em !important;
- margin-bottom: 0.6em !important;
-}
-.message .md-message p:first-child { margin-top: 0 !important; }
-.message .md-message p:last-of-type { margin-bottom: 0 !important; }
-
-.message .md-message {
- display: block;
- padding: 0 !important;
-}
-.message .raw-message p {
- margin:0 !important;
-}
-.message .raw-message {
- display: block;
- padding: 0 !important;
- white-space: pre-wrap;
-}
-.raw-message.hideM, .md-message.hideM {
- display: none;
-}
-
-/* custom buttons */
-.chuanhu-btn {
- border-radius: 5px;
- /* background-color: #E6E6E6 !important; */
- color: rgba(120, 120, 120, 0.64) !important;
- padding: 4px !important;
- position: absolute;
- right: -22px;
- cursor: pointer !important;
- transition: color .2s ease, background-color .2s ease;
-}
-.chuanhu-btn:hover {
- background-color: rgba(167, 167, 167, 0.25) !important;
- color: unset !important;
-}
-.chuanhu-btn:active {
- background-color: rgba(167, 167, 167, 0.5) !important;
-}
-.chuanhu-btn:focus {
- outline: none;
-}
-.copy-bot-btn {
- /* top: 18px; */
- bottom: 0;
-}
-.toggle-md-btn {
- /* top: 0; */
- bottom: 20px;
-}
-.copy-code-btn {
- position: relative;
- float: right;
- font-size: 1em;
- cursor: pointer;
-}
-
-.message-wrap>div img{
- border-radius: 10px !important;
-}
-
-/* history message */
-.wrap>.history-message {
- padding: 10px !important;
-}
-.history-message {
- /* padding: 0 !important; */
- opacity: 80%;
- display: flex;
- flex-direction: column;
-}
-.history-message>.history-message {
- padding: 0 !important;
-}
-.history-message>.message-wrap {
- padding: 0 !important;
- margin-bottom: 16px;
-}
-.history-message>.message {
- margin-bottom: 16px;
-}
-.wrap>.history-message::after {
- content: "";
- display: block;
- height: 2px;
- background-color: var(--body-text-color-subdued);
- margin-bottom: 10px;
- margin-top: -10px;
- clear: both;
-}
-.wrap>.history-message>:last-child::after {
- content: "仅供查看";
- display: block;
- text-align: center;
- color: var(--body-text-color-subdued);
- font-size: 0.8em;
-}
-
-/* 表格 */
-table {
- margin: 1em 0;
- border-collapse: collapse;
- empty-cells: show;
-}
-td,th {
- border: 1.2px solid var(--border-color-primary) !important;
- padding: 0.2em;
-}
-thead {
- background-color: rgba(175,184,193,0.2);
-}
-thead th {
- padding: .5em .2em;
-}
-/* 行内代码 */
-.message :not(pre) code {
- display: inline;
- white-space: break-spaces;
- font-family: var(--font-mono);
- border-radius: 6px;
- margin: 0 2px 0 2px;
- padding: .2em .4em .1em .4em;
- background-color: rgba(175,184,193,0.2);
-}
-/* 代码块 */
-.message pre,
-.message pre[class*=language-] {
- color: #fff;
- overflow-x: auto;
- overflow-y: hidden;
- margin: .8em 1em 1em 0em !important;
- padding: var(--spacing-xl) 1.2em !important;
- border-radius: var(--radius-lg) !important;
-}
-.message pre code,
-.message pre code[class*=language-] {
- color: #fff;
- padding: 0;
- margin: 0;
- background-color: unset;
- text-shadow: none;
- font-family: var(--font-mono);
-}
-/* 覆盖 gradio 丑陋的复制按钮样式 */
-pre button[title="copy"] {
- border-radius: 5px;
- transition: background-color .2s ease;
-}
-pre button[title="copy"]:hover {
- background-color: #333232;
-}
-pre button .check {
- color: #fff !important;
- background: var(--neutral-950) !important;
-}
-
-/* 覆盖prism.css */
-.language-css .token.string,
-.style .token.string,
-.token.entity,
-.token.operator,
-.token.url {
- background: none !important;
-}
diff --git a/spaces/JohnSmith9982/ChuanhuChatGPT/modules/models/Google_PaLM.py b/spaces/JohnSmith9982/ChuanhuChatGPT/modules/models/Google_PaLM.py
deleted file mode 100644
index 79ca042e228b25546600e4258a0b75790e25bb52..0000000000000000000000000000000000000000
--- a/spaces/JohnSmith9982/ChuanhuChatGPT/modules/models/Google_PaLM.py
+++ /dev/null
@@ -1,26 +0,0 @@
-from .base_model import BaseLLMModel
-import google.generativeai as palm
-
-class Google_PaLM_Client(BaseLLMModel):
- def __init__(self, model_name, api_key, user_name="") -> None:
- super().__init__(model_name=model_name, user=user_name)
- self.api_key = api_key
-
- def _get_palm_style_input(self):
- new_history = []
- for item in self.history:
- if item["role"] == "user":
- new_history.append({'author': '1', 'content': item["content"]})
- else:
- new_history.append({'author': '0', 'content': item["content"]})
- return new_history
-
- def get_answer_at_once(self):
- palm.configure(api_key=self.api_key)
- messages = self._get_palm_style_input()
- response = palm.chat(context=self.system_prompt, messages=messages, temperature=self.temperature, top_p=self.top_p)
- if response.last is not None:
- return response.last, len(response.last)
- else:
- reasons = '\n\n'.join(reason['reason'].name for reason in response.filters)
- return "由于下面的原因，Google 拒绝返回 PaLM 的回答：\n\n" + reasons, 0
\ No newline at end of file
diff --git a/spaces/KonradSzafer/HF-QA-Demo/tests/discord_bot/__init__.py b/spaces/KonradSzafer/HF-QA-Demo/tests/discord_bot/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/KyanChen/RSPrompter/mmdet/engine/runner/__init__.py b/spaces/KyanChen/RSPrompter/mmdet/engine/runner/__init__.py
deleted file mode 100644
index e8bcce4448e48e2d64354ba6770f9f426fb3d869..0000000000000000000000000000000000000000
--- a/spaces/KyanChen/RSPrompter/mmdet/engine/runner/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from .loops import TeacherStudentValLoop
-
-__all__ = ['TeacherStudentValLoop']
diff --git a/spaces/KyanChen/RSPrompter/mmdet/models/detectors/trident_faster_rcnn.py b/spaces/KyanChen/RSPrompter/mmdet/models/detectors/trident_faster_rcnn.py
deleted file mode 100644
index 4244925beaebea820f836b41ab5463f5f499f4d0..0000000000000000000000000000000000000000
--- a/spaces/KyanChen/RSPrompter/mmdet/models/detectors/trident_faster_rcnn.py
+++ /dev/null
@@ -1,81 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from torch import Tensor
-
-from mmdet.registry import MODELS
-from mmdet.structures import SampleList
-from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
-from .faster_rcnn import FasterRCNN
-
-
-@MODELS.register_module()
-class TridentFasterRCNN(FasterRCNN):
- """Implementation of `TridentNet `_"""
-
- def __init__(self,
- backbone: ConfigType,
- rpn_head: ConfigType,
- roi_head: ConfigType,
- train_cfg: ConfigType,
- test_cfg: ConfigType,
- neck: OptConfigType = None,
- data_preprocessor: OptConfigType = None,
- init_cfg: OptMultiConfig = None) -> None:
-
- super().__init__(
- backbone=backbone,
- neck=neck,
- rpn_head=rpn_head,
- roi_head=roi_head,
- train_cfg=train_cfg,
- test_cfg=test_cfg,
- data_preprocessor=data_preprocessor,
- init_cfg=init_cfg)
- assert self.backbone.num_branch == self.roi_head.num_branch
- assert self.backbone.test_branch_idx == self.roi_head.test_branch_idx
- self.num_branch = self.backbone.num_branch
- self.test_branch_idx = self.backbone.test_branch_idx
-
- def _forward(self, batch_inputs: Tensor,
- batch_data_samples: SampleList) -> tuple:
- """copy the ``batch_data_samples`` to fit multi-branch."""
- num_branch = self.num_branch \
- if self.training or self.test_branch_idx == -1 else 1
- trident_data_samples = batch_data_samples * num_branch
- return super()._forward(
- batch_inputs=batch_inputs, batch_data_samples=trident_data_samples)
-
- def loss(self, batch_inputs: Tensor,
- batch_data_samples: SampleList) -> dict:
- """copy the ``batch_data_samples`` to fit multi-branch."""
- num_branch = self.num_branch \
- if self.training or self.test_branch_idx == -1 else 1
- trident_data_samples = batch_data_samples * num_branch
- return super().loss(
- batch_inputs=batch_inputs, batch_data_samples=trident_data_samples)
-
- def predict(self,
- batch_inputs: Tensor,
- batch_data_samples: SampleList,
- rescale: bool = True) -> SampleList:
- """copy the ``batch_data_samples`` to fit multi-branch."""
- num_branch = self.num_branch \
- if self.training or self.test_branch_idx == -1 else 1
- trident_data_samples = batch_data_samples * num_branch
- return super().predict(
- batch_inputs=batch_inputs,
- batch_data_samples=trident_data_samples,
- rescale=rescale)
-
- # TODO need to refactor
- def aug_test(self, imgs, img_metas, rescale=False):
- """Test with augmentations.
-
- If rescale is False, then returned bboxes and masks will fit the scale
- of imgs[0].
- """
- x = self.extract_feats(imgs)
- num_branch = (self.num_branch if self.test_branch_idx == -1 else 1)
- trident_img_metas = [img_metas * num_branch for img_metas in img_metas]
- proposal_list = self.rpn_head.aug_test_rpn(x, trident_img_metas)
- return self.roi_head.aug_test(
- x, proposal_list, img_metas, rescale=rescale)
diff --git a/spaces/KyanChen/RSPrompter/mmpl/evaluation/metrics/builder.py b/spaces/KyanChen/RSPrompter/mmpl/evaluation/metrics/builder.py
deleted file mode 100644
index bd55df759561b73656a71941e67f9c033d900dd7..0000000000000000000000000000000000000000
--- a/spaces/KyanChen/RSPrompter/mmpl/evaluation/metrics/builder.py
+++ /dev/null
@@ -1,34 +0,0 @@
-import copy
-import inspect
-from typing import List, Union
-
-import torch
-import torch.nn as nn
-import lightning
-import torchmetrics
-import torchmetrics.detection
-
-from mmengine.config import Config, ConfigDict
-from mmpl.registry import METRICS
-
-
-def register_pl_metrics() -> List[str]:
- """Register loggers in ``lightning.pytorch.loggers`` to the ``LOGGERS`` registry.
-
- Returns:
- List[str]: A list of registered optimizers' name.
- """
- pl_metrics = []
- for modules in [torchmetrics, torchmetrics.detection]:
- for module_name in dir(modules):
- if module_name.startswith('__'):
- continue
- _metric = getattr(modules, module_name)
- if inspect.isclass(_metric):
- METRICS.register_module(module=_metric)
- pl_metrics.append(module_name)
- return pl_metrics
-
-
-PL_METRICS = register_pl_metrics()
-
diff --git a/spaces/KyanChen/RSPrompter/mmpl/utils/typing_utils.py b/spaces/KyanChen/RSPrompter/mmpl/utils/typing_utils.py
deleted file mode 100644
index 6caf6de53274594e139dbe7c1973c747229bf010..0000000000000000000000000000000000000000
--- a/spaces/KyanChen/RSPrompter/mmpl/utils/typing_utils.py
+++ /dev/null
@@ -1,22 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-"""Collecting some commonly used type hint in mmdetection."""
-from typing import List, Optional, Sequence, Tuple, Union
-
-from mmengine.config import ConfigDict
-from mmengine.structures import InstanceData, PixelData
-
-# TODO: Need to avoid circular import with assigner and sampler
-# Type hint of config data
-ConfigType = Union[ConfigDict, dict]
-OptConfigType = Optional[ConfigType]
-# Type hint of one or more config data
-MultiConfig = Union[ConfigType, List[ConfigType]]
-OptMultiConfig = Optional[MultiConfig]
-
-InstanceList = List[InstanceData]
-OptInstanceList = Optional[InstanceList]
-
-PixelList = List[PixelData]
-OptPixelList = Optional[PixelList]
-
-RangeType = Sequence[Tuple[int, int]]
diff --git a/spaces/LabAlproITS/CyberDAS-FE/main.py b/spaces/LabAlproITS/CyberDAS-FE/main.py
deleted file mode 100644
index a4005077331080ef19a0ac5118f31d8b322bff5d..0000000000000000000000000000000000000000
--- a/spaces/LabAlproITS/CyberDAS-FE/main.py
+++ /dev/null
@@ -1,40 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-
-from fastapi import FastAPI, Form, Depends, Request
-from fastapi.templating import Jinja2Templates
-from pydantic import BaseModel
-import pickle
-import json
-
-app = FastAPI()
-
-# Menentukan direktori templates
-templates = Jinja2Templates(directory="templates")
-
-class Msg(BaseModel):
- msg: str
-
-
-class Req(BaseModel):
- age: int
- sex: int
- smoker: int
- bmi: float
- children: int
- region: int
-
-
-@app.get("/welcomeMessage")
-async def welcome():
- return {"message": "Hello World. Welcome to FastAPI!"}
-
-@app.get("/")
-async def root(request: Request):
- return templates.TemplateResponse(
- "index.html",
- {
- "request": request,
- "insurance_cost": 0,
- }
- )
diff --git a/spaces/Laihiujin/OneFormer/README.md b/spaces/Laihiujin/OneFormer/README.md
deleted file mode 100644
index 0adcc679d28eb3ec75ab7b60ed753f6e17795106..0000000000000000000000000000000000000000
--- a/spaces/Laihiujin/OneFormer/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: OneFormer
-emoji: 🎗️
-colorFrom: red
-colorTo: blue
-sdk: docker
-app_port: 7860
-pinned: false
-license: mit
-duplicated_from: shi-labs/OneFormer
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/Makiing/coolb-in-gtest/cloudflare/worker.js b/spaces/Makiing/coolb-in-gtest/cloudflare/worker.js
deleted file mode 100644
index e0debd750615f1329b2c72fbce73e1b9291f7137..0000000000000000000000000000000000000000
--- a/spaces/Makiing/coolb-in-gtest/cloudflare/worker.js
+++ /dev/null
@@ -1,18 +0,0 @@
-const TRAGET_HOST='hf4all-bingo.hf.space' // 请将此域名改成你自己的，域名信息在设置》站点域名查看。
-
-export default {
- async fetch(request) {
- const uri = new URL(request.url);
- if (uri.protocol === 'http:') {
- uri.protocol = 'https:';
- return new Response('', {
- status: 301,
- headers: {
- location: uri.toString(),
- },
- })
- }
- uri.host = TRAGET_HOST
- return fetch(new Request(uri.toString(), request));
- },
-};
diff --git a/spaces/Makiing/coolb-in-gtest/src/app/layout.tsx b/spaces/Makiing/coolb-in-gtest/src/app/layout.tsx
deleted file mode 100644
index 8b5122759987177b8dc4e4356d1d06cea25c15ea..0000000000000000000000000000000000000000
--- a/spaces/Makiing/coolb-in-gtest/src/app/layout.tsx
+++ /dev/null
@@ -1,47 +0,0 @@
-import { Metadata } from 'next'
-import { Toaster } from 'react-hot-toast'
-import { TailwindIndicator } from '@/components/tailwind-indicator'
-import { Providers } from '@/components/providers'
-import { Header } from '@/components/header'
-
-import '@/app/globals.scss'
-
-
-export const metadata: Metadata = {
- title: {
- default: 'Bing AI Chatbot',
- template: `%s - Bing AI Chatbot`
- },
- description: 'Bing AI Chatbot Web App.',
- themeColor: [
- { media: '(prefers-color-scheme: light)', color: 'white' },
- { media: '(prefers-color-scheme: dark)', color: 'dark' }
- ],
- icons: {
- icon: '/favicon.ico',
- shortcut: '../assets/images/logo.svg',
- apple: '../assets/images/logo.svg'
- }
-}
-
-interface RootLayoutProps {
- children: React.ReactNode
-}
-
-export default function RootLayout({ children }: RootLayoutProps) {
- return (
-
-
-
-
-
- {/* @ts-ignore */}
-
- {children}
-
-
-
-
-
- )
-}
diff --git a/spaces/MarcusSu1216/XingTong/app.py b/spaces/MarcusSu1216/XingTong/app.py
deleted file mode 100644
index 8310b81340923a9aaea9ee5aba1d6e7811859097..0000000000000000000000000000000000000000
--- a/spaces/MarcusSu1216/XingTong/app.py
+++ /dev/null
@@ -1,75 +0,0 @@
-import io
-import os
-
-os.system("wget -P hubert/ https://huggingface.co/spaces/MarcusSu1216/XingTong/blob/main/hubert/checkpoint_best_legacy_500.pt")
-import gradio as gr
-import librosa
-import numpy as np
-import soundfile
-from inference.infer_tool import Svc
-import logging
-
-logging.getLogger('numba').setLevel(logging.WARNING)
-logging.getLogger('markdown_it').setLevel(logging.WARNING)
-logging.getLogger('urllib3').setLevel(logging.WARNING)
-logging.getLogger('matplotlib').setLevel(logging.WARNING)
-
-model = Svc("logs/44k/G_99200.pth", "configs/config.json", cluster_model_path="logs/44k/kmeans_10000.pt")
-
-def vc_fn(sid, input_audio, vc_transform, auto_f0,cluster_ratio, noise_scale):
- if input_audio is None:
- return "You need to upload an audio", None
- sampling_rate, audio = input_audio
- # print(audio.shape,sampling_rate)
- duration = audio.shape[0] / sampling_rate
- if duration > 100:
- return "请上传小于100s的音频，需要转换长音频请本地进行转换", None
- audio = (audio / np.iinfo(audio.dtype).max).astype(np.float32)
- if len(audio.shape) > 1:
- audio = librosa.to_mono(audio.transpose(1, 0))
- if sampling_rate != 16000:
- audio = librosa.resample(audio, orig_sr=sampling_rate, target_sr=16000)
- print(audio.shape)
- out_wav_path = "temp.wav"
- soundfile.write(out_wav_path, audio, 16000, format="wav")
- print( cluster_ratio, auto_f0, noise_scale)
- out_audio, out_sr = model.infer(sid, vc_transform, out_wav_path,
- cluster_infer_ratio=cluster_ratio,
- auto_predict_f0=auto_f0,
- noice_scale=noise_scale
- )
- return "转换成功", (44100, out_audio.numpy())
-
-
-app = gr.Blocks()
-with app:
- with gr.Tabs():
- with gr.TabItem("介绍"):
- gr.Markdown(value="""
- 星瞳_Official的语音在线合成，基于so-vits-svc-4.0生成。\n
-
- 使用须知：\n
- 1、请使用伴奏和声去除干净的人声素材，时长小于100秒，格式为mp3或wav。\n
- 2、去除伴奏推荐使用UVR5软件，B站上有详细教程。\n
- 3、条件不支持推荐使用以下几个去伴奏的网站：\n
- https://vocalremover.org/zh/\n
- https://tuanziai.com/vocal-remover/upload\n
- https://www.lalal.ai/zh-hans/\n
- 4、在线版服务器为2核16G免费版，转换效率较慢请耐心等待。\n
- 5、使用此模型请标注作者：一闪一闪小星瞳，以及该项目地址。\n
- 6、有问题可以在B站私聊我反馈：https://space.bilibili.com/38523418\n
- 7、语音模型转换出的音频请勿用于商业化。
- """)
- spks = list(model.spk2id.keys())
- sid = gr.Dropdown(label="音色", choices=["XT4.0"], value="XT4.0")
- vc_input3 = gr.Audio(label="上传音频（长度建议小于100秒）")
- vc_transform = gr.Number(label="变调（整数，可以正负，半音数量，升高八度就是12）", value=0)
- cluster_ratio = gr.Number(label="聚类模型混合比例，0-1之间，默认为0不启用聚类，能提升音色相似度，但会导致咬字下降（如果使用建议0.5左右）", value=0)
- auto_f0 = gr.Checkbox(label="自动f0预测，配合聚类模型f0预测效果更好,会导致变调功能失效（仅限转换语音，歌声不要勾选此项会究极跑调）", value=False)
- noise_scale = gr.Number(label="noise_scale 建议不要动，会影响音质，玄学参数", value=0.4)
- vc_submit = gr.Button("转换", variant="primary")
- vc_output1 = gr.Textbox(label="Output Message")
- vc_output2 = gr.Audio(label="Output Audio")
- vc_submit.click(vc_fn, [sid, vc_input3, vc_transform,auto_f0,cluster_ratio, noise_scale], [vc_output1, vc_output2])
-
- app.launch()
diff --git a/spaces/Mellow-ai/PhotoAI_Mellow/rembg/sessions/u2net.py b/spaces/Mellow-ai/PhotoAI_Mellow/rembg/sessions/u2net.py
deleted file mode 100644
index 4144a10e8b4bfa7a19e480dd955923d800931540..0000000000000000000000000000000000000000
--- a/spaces/Mellow-ai/PhotoAI_Mellow/rembg/sessions/u2net.py
+++ /dev/null
@@ -1,49 +0,0 @@
-import os
-from typing import List
-
-import numpy as np
-import pooch
-from PIL import Image
-from PIL.Image import Image as PILImage
-
-from .base import BaseSession
-
-
-class U2netSession(BaseSession):
- def predict(self, img: PILImage, *args, **kwargs) -> List[PILImage]:
- ort_outs = self.inner_session.run(
- None,
- self.normalize(
- img, (0.485, 0.456, 0.406), (0.229, 0.224, 0.225), (320, 320)
- ),
- )
-
- pred = ort_outs[0][:, 0, :, :]
-
- ma = np.max(pred)
- mi = np.min(pred)
-
- pred = (pred - mi) / (ma - mi)
- pred = np.squeeze(pred)
-
- mask = Image.fromarray((pred * 255).astype("uint8"), mode="L")
- mask = mask.resize(img.size, Image.LANCZOS)
-
- return [mask]
-
- @classmethod
- def download_models(cls, *args, **kwargs):
- fname = f"{cls.name()}.onnx"
- pooch.retrieve(
- "https://github.com/danielgatis/rembg/releases/download/v0.0.0/u2net.onnx",
- "md5:60024c5c889badc19c04ad937298a77b",
- fname=fname,
- path=cls.u2net_home(),
- progressbar=True,
- )
-
- return os.path.join(cls.u2net_home(), fname)
-
- @classmethod
- def name(cls, *args, **kwargs):
- return "u2net"
diff --git a/spaces/MonkeyDBoa/AvengersDetector/README.md b/spaces/MonkeyDBoa/AvengersDetector/README.md
deleted file mode 100644
index 867385765abfad0d8dfc95ab0b4be4d30f429578..0000000000000000000000000000000000000000
--- a/spaces/MonkeyDBoa/AvengersDetector/README.md
+++ /dev/null
@@ -1,37 +0,0 @@
----
-title: AvengersDetector
-emoji: ⚡
-colorFrom: green
-colorTo: pink
-sdk: gradio
-app_file: app.py
-pinned: false
----
-
-# Configuration
-
-`title`: _string_
-Display title for the Space
-
-`emoji`: _string_
-Space emoji (emoji-only character allowed)
-
-`colorFrom`: _string_
-Color for Thumbnail gradient (red, yellow, green, blue, indigo, purple, pink, gray)
-
-`colorTo`: _string_
-Color for Thumbnail gradient (red, yellow, green, blue, indigo, purple, pink, gray)
-
-`sdk`: _string_
-Can be either `gradio`, `streamlit`, or `static`
-
-`sdk_version` : _string_
-Only applicable for `streamlit` SDK.
-See [doc](https://hf.co/docs/hub/spaces) for more info on supported versions.
-
-`app_file`: _string_
-Path to your main application file (which contains either `gradio` or `streamlit` Python code, or `static` html code).
-Path is relative to the root of the repository.
-
-`pinned`: _boolean_
-Whether the Space stays on top of your list.
diff --git a/spaces/NCTCMumbai/NCTC/models/official/benchmark/models/resnet_cifar_main.py b/spaces/NCTCMumbai/NCTC/models/official/benchmark/models/resnet_cifar_main.py
deleted file mode 100644
index 4a02fec8b96e25228e6e0467d646c26995f944fc..0000000000000000000000000000000000000000
--- a/spaces/NCTCMumbai/NCTC/models/official/benchmark/models/resnet_cifar_main.py
+++ /dev/null
@@ -1,284 +0,0 @@
-# Copyright 2018 The TensorFlow Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ==============================================================================
-"""Runs a ResNet model on the Cifar-10 dataset."""
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-from absl import app
-from absl import flags
-from absl import logging
-import numpy as np
-import tensorflow as tf
-from official.benchmark.models import cifar_preprocessing
-from official.benchmark.models import resnet_cifar_model
-from official.benchmark.models import synthetic_util
-from official.utils.flags import core as flags_core
-from official.utils.misc import distribution_utils
-from official.utils.misc import keras_utils
-from official.vision.image_classification.resnet import common
-
-
-LR_SCHEDULE = [ # (multiplier, epoch to start) tuples
- (0.1, 91), (0.01, 136), (0.001, 182)
-]
-
-
-def learning_rate_schedule(current_epoch,
- current_batch,
- batches_per_epoch,
- batch_size):
- """Handles linear scaling rule and LR decay.
-
- Scale learning rate at epoch boundaries provided in LR_SCHEDULE by the
- provided scaling factor.
-
- Args:
- current_epoch: integer, current epoch indexed from 0.
- current_batch: integer, current batch in the current epoch, indexed from 0.
- batches_per_epoch: integer, number of steps in an epoch.
- batch_size: integer, total batch sized.
-
- Returns:
- Adjusted learning rate.
- """
- del current_batch, batches_per_epoch # not used
- initial_learning_rate = common.BASE_LEARNING_RATE * batch_size / 128
- learning_rate = initial_learning_rate
- for mult, start_epoch in LR_SCHEDULE:
- if current_epoch >= start_epoch:
- learning_rate = initial_learning_rate * mult
- else:
- break
- return learning_rate
-
-
-class LearningRateBatchScheduler(tf.keras.callbacks.Callback):
- """Callback to update learning rate on every batch (not epoch boundaries).
-
- N.B. Only support Keras optimizers, not TF optimizers.
-
- Attributes:
- schedule: a function that takes an epoch index and a batch index as input
- (both integer, indexed from 0) and returns a new learning rate as
- output (float).
- """
-
- def __init__(self, schedule, batch_size, steps_per_epoch):
- super(LearningRateBatchScheduler, self).__init__()
- self.schedule = schedule
- self.steps_per_epoch = steps_per_epoch
- self.batch_size = batch_size
- self.epochs = -1
- self.prev_lr = -1
-
- def on_epoch_begin(self, epoch, logs=None):
- if not hasattr(self.model.optimizer, 'learning_rate'):
- raise ValueError('Optimizer must have a "learning_rate" attribute.')
- self.epochs += 1
-
- def on_batch_begin(self, batch, logs=None):
- """Executes before step begins."""
- lr = self.schedule(self.epochs,
- batch,
- self.steps_per_epoch,
- self.batch_size)
- if not isinstance(lr, (float, np.float32, np.float64)):
- raise ValueError('The output of the "schedule" function should be float.')
- if lr != self.prev_lr:
- self.model.optimizer.learning_rate = lr # lr should be a float here
- self.prev_lr = lr
- logging.debug(
- 'Epoch %05d Batch %05d: LearningRateBatchScheduler '
- 'change learning rate to %s.', self.epochs, batch, lr)
-
-
-def run(flags_obj):
- """Run ResNet Cifar-10 training and eval loop using native Keras APIs.
-
- Args:
- flags_obj: An object containing parsed flag values.
-
- Raises:
- ValueError: If fp16 is passed as it is not currently supported.
-
- Returns:
- Dictionary of training and eval stats.
- """
- keras_utils.set_session_config(
- enable_xla=flags_obj.enable_xla)
-
- # Execute flag override logic for better model performance
- if flags_obj.tf_gpu_thread_mode:
- keras_utils.set_gpu_thread_mode_and_count(
- per_gpu_thread_count=flags_obj.per_gpu_thread_count,
- gpu_thread_mode=flags_obj.tf_gpu_thread_mode,
- num_gpus=flags_obj.num_gpus,
- datasets_num_private_threads=flags_obj.datasets_num_private_threads)
- common.set_cudnn_batchnorm_mode()
-
- dtype = flags_core.get_tf_dtype(flags_obj)
- if dtype == 'fp16':
- raise ValueError('dtype fp16 is not supported in Keras. Use the default '
- 'value(fp32).')
-
- data_format = flags_obj.data_format
- if data_format is None:
- data_format = ('channels_first' if tf.config.list_physical_devices('GPU')
- else 'channels_last')
- tf.keras.backend.set_image_data_format(data_format)
-
- strategy = distribution_utils.get_distribution_strategy(
- distribution_strategy=flags_obj.distribution_strategy,
- num_gpus=flags_obj.num_gpus,
- all_reduce_alg=flags_obj.all_reduce_alg,
- num_packs=flags_obj.num_packs)
-
- if strategy:
- # flags_obj.enable_get_next_as_optional controls whether enabling
- # get_next_as_optional behavior in DistributedIterator. If true, last
- # partial batch can be supported.
- strategy.extended.experimental_enable_get_next_as_optional = (
- flags_obj.enable_get_next_as_optional
- )
-
- strategy_scope = distribution_utils.get_strategy_scope(strategy)
-
- if flags_obj.use_synthetic_data:
- synthetic_util.set_up_synthetic_data()
- input_fn = common.get_synth_input_fn(
- height=cifar_preprocessing.HEIGHT,
- width=cifar_preprocessing.WIDTH,
- num_channels=cifar_preprocessing.NUM_CHANNELS,
- num_classes=cifar_preprocessing.NUM_CLASSES,
- dtype=flags_core.get_tf_dtype(flags_obj),
- drop_remainder=True)
- else:
- synthetic_util.undo_set_up_synthetic_data()
- input_fn = cifar_preprocessing.input_fn
-
- train_input_dataset = input_fn(
- is_training=True,
- data_dir=flags_obj.data_dir,
- batch_size=flags_obj.batch_size,
- parse_record_fn=cifar_preprocessing.parse_record,
- datasets_num_private_threads=flags_obj.datasets_num_private_threads,
- dtype=dtype,
- # Setting drop_remainder to avoid the partial batch logic in normalization
- # layer, which triggers tf.where and leads to extra memory copy of input
- # sizes between host and GPU.
- drop_remainder=(not flags_obj.enable_get_next_as_optional))
-
- eval_input_dataset = None
- if not flags_obj.skip_eval:
- eval_input_dataset = input_fn(
- is_training=False,
- data_dir=flags_obj.data_dir,
- batch_size=flags_obj.batch_size,
- parse_record_fn=cifar_preprocessing.parse_record)
-
- steps_per_epoch = (
- cifar_preprocessing.NUM_IMAGES['train'] // flags_obj.batch_size)
- lr_schedule = 0.1
- if flags_obj.use_tensor_lr:
- initial_learning_rate = common.BASE_LEARNING_RATE * flags_obj.batch_size / 128
- lr_schedule = tf.keras.optimizers.schedules.PiecewiseConstantDecay(
- boundaries=list(p[1] * steps_per_epoch for p in LR_SCHEDULE),
- values=[initial_learning_rate] +
- list(p[0] * initial_learning_rate for p in LR_SCHEDULE))
-
- with strategy_scope:
- optimizer = common.get_optimizer(lr_schedule)
- model = resnet_cifar_model.resnet56(classes=cifar_preprocessing.NUM_CLASSES)
- model.compile(
- loss='sparse_categorical_crossentropy',
- optimizer=optimizer,
- metrics=(['sparse_categorical_accuracy']
- if flags_obj.report_accuracy_metrics else None),
- run_eagerly=flags_obj.run_eagerly)
-
- train_epochs = flags_obj.train_epochs
-
- callbacks = common.get_callbacks()
-
- if not flags_obj.use_tensor_lr:
- lr_callback = LearningRateBatchScheduler(
- schedule=learning_rate_schedule,
- batch_size=flags_obj.batch_size,
- steps_per_epoch=steps_per_epoch)
- callbacks.append(lr_callback)
-
- # if mutliple epochs, ignore the train_steps flag.
- if train_epochs <= 1 and flags_obj.train_steps:
- steps_per_epoch = min(flags_obj.train_steps, steps_per_epoch)
- train_epochs = 1
-
- num_eval_steps = (cifar_preprocessing.NUM_IMAGES['validation'] //
- flags_obj.batch_size)
-
- validation_data = eval_input_dataset
- if flags_obj.skip_eval:
- if flags_obj.set_learning_phase_to_train:
- # TODO(haoyuzhang): Understand slowdown of setting learning phase when
- # not using distribution strategy.
- tf.keras.backend.set_learning_phase(1)
- num_eval_steps = None
- validation_data = None
-
- if not strategy and flags_obj.explicit_gpu_placement:
- # TODO(b/135607227): Add device scope automatically in Keras training loop
- # when not using distribition strategy.
- no_dist_strat_device = tf.device('/device:GPU:0')
- no_dist_strat_device.__enter__()
-
- history = model.fit(train_input_dataset,
- epochs=train_epochs,
- steps_per_epoch=steps_per_epoch,
- callbacks=callbacks,
- validation_steps=num_eval_steps,
- validation_data=validation_data,
- validation_freq=flags_obj.epochs_between_evals,
- verbose=2)
- eval_output = None
- if not flags_obj.skip_eval:
- eval_output = model.evaluate(eval_input_dataset,
- steps=num_eval_steps,
- verbose=2)
-
- if not strategy and flags_obj.explicit_gpu_placement:
- no_dist_strat_device.__exit__()
-
- stats = common.build_stats(history, eval_output, callbacks)
- return stats
-
-
-def define_cifar_flags():
- common.define_keras_flags(dynamic_loss_scale=False)
-
- flags_core.set_defaults(data_dir='/tmp/cifar10_data/cifar-10-batches-bin',
- model_dir='/tmp/cifar10_model',
- epochs_between_evals=10,
- batch_size=128)
-
-
-def main(_):
- return run(flags.FLAGS)
-
-
-if __name__ == '__main__':
- logging.set_verbosity(logging.INFO)
- define_cifar_flags()
- app.run(main)
diff --git a/spaces/Nesip/meta-llama-Llama-2-70b-chat-hf/app.py b/spaces/Nesip/meta-llama-Llama-2-70b-chat-hf/app.py
deleted file mode 100644
index a461703287a9bda9c93cfdfbb94d4c3cf90aaba9..0000000000000000000000000000000000000000
--- a/spaces/Nesip/meta-llama-Llama-2-70b-chat-hf/app.py
+++ /dev/null
@@ -1,3 +0,0 @@
-import gradio as gr
-
-gr.Interface.load("models/meta-llama/Llama-2-70b-chat-hf").launch()
\ No newline at end of file
diff --git a/spaces/Nick1/rvc-models/lib/infer_pack/modules/F0Predictor/HarvestF0Predictor.py b/spaces/Nick1/rvc-models/lib/infer_pack/modules/F0Predictor/HarvestF0Predictor.py
deleted file mode 100644
index b412ba2814e114ca7bb00b6fd6ef217f63d788a3..0000000000000000000000000000000000000000
--- a/spaces/Nick1/rvc-models/lib/infer_pack/modules/F0Predictor/HarvestF0Predictor.py
+++ /dev/null
@@ -1,86 +0,0 @@
-from lib.infer_pack.modules.F0Predictor.F0Predictor import F0Predictor
-import pyworld
-import numpy as np
-
-
-class HarvestF0Predictor(F0Predictor):
- def __init__(self, hop_length=512, f0_min=50, f0_max=1100, sampling_rate=44100):
- self.hop_length = hop_length
- self.f0_min = f0_min
- self.f0_max = f0_max
- self.sampling_rate = sampling_rate
-
- def interpolate_f0(self, f0):
- """
- 对F0进行插值处理
- """
-
- data = np.reshape(f0, (f0.size, 1))
-
- vuv_vector = np.zeros((data.size, 1), dtype=np.float32)
- vuv_vector[data > 0.0] = 1.0
- vuv_vector[data <= 0.0] = 0.0
-
- ip_data = data
-
- frame_number = data.size
- last_value = 0.0
- for i in range(frame_number):
- if data[i] <= 0.0:
- j = i + 1
- for j in range(i + 1, frame_number):
- if data[j] > 0.0:
- break
- if j < frame_number - 1:
- if last_value > 0.0:
- step = (data[j] - data[i - 1]) / float(j - i)
- for k in range(i, j):
- ip_data[k] = data[i - 1] + step * (k - i + 1)
- else:
- for k in range(i, j):
- ip_data[k] = data[j]
- else:
- for k in range(i, frame_number):
- ip_data[k] = last_value
- else:
- ip_data[i] = data[i] # 这里可能存在一个没有必要的拷贝
- last_value = data[i]
-
- return ip_data[:, 0], vuv_vector[:, 0]
-
- def resize_f0(self, x, target_len):
- source = np.array(x)
- source[source < 0.001] = np.nan
- target = np.interp(
- np.arange(0, len(source) * target_len, len(source)) / target_len,
- np.arange(0, len(source)),
- source,
- )
- res = np.nan_to_num(target)
- return res
-
- def compute_f0(self, wav, p_len=None):
- if p_len is None:
- p_len = wav.shape[0] // self.hop_length
- f0, t = pyworld.harvest(
- wav.astype(np.double),
- fs=self.hop_length,
- f0_ceil=self.f0_max,
- f0_floor=self.f0_min,
- frame_period=1000 * self.hop_length / self.sampling_rate,
- )
- f0 = pyworld.stonemask(wav.astype(np.double), f0, t, self.fs)
- return self.interpolate_f0(self.resize_f0(f0, p_len))[0]
-
- def compute_f0_uv(self, wav, p_len=None):
- if p_len is None:
- p_len = wav.shape[0] // self.hop_length
- f0, t = pyworld.harvest(
- wav.astype(np.double),
- fs=self.sampling_rate,
- f0_floor=self.f0_min,
- f0_ceil=self.f0_max,
- frame_period=1000 * self.hop_length / self.sampling_rate,
- )
- f0 = pyworld.stonemask(wav.astype(np.double), f0, t, self.sampling_rate)
- return self.interpolate_f0(self.resize_f0(f0, p_len))
diff --git a/spaces/Nultx/VITS-TTS/text/sanskrit.py b/spaces/Nultx/VITS-TTS/text/sanskrit.py
deleted file mode 100644
index 0223aaac384a2f850f5bc20651fc18eb964607d0..0000000000000000000000000000000000000000
--- a/spaces/Nultx/VITS-TTS/text/sanskrit.py
+++ /dev/null
@@ -1,62 +0,0 @@
-import re
-from indic_transliteration import sanscript
-
-
-# List of (iast, ipa) pairs:
-_iast_to_ipa = [(re.compile('%s' % x[0]), x[1]) for x in [
- ('a', 'ə'),
- ('ā', 'aː'),
- ('ī', 'iː'),
- ('ū', 'uː'),
- ('ṛ', 'ɹ`'),
- ('ṝ', 'ɹ`ː'),
- ('ḷ', 'l`'),
- ('ḹ', 'l`ː'),
- ('e', 'eː'),
- ('o', 'oː'),
- ('k', 'k⁼'),
- ('k⁼h', 'kʰ'),
- ('g', 'g⁼'),
- ('g⁼h', 'gʰ'),
- ('ṅ', 'ŋ'),
- ('c', 'ʧ⁼'),
- ('ʧ⁼h', 'ʧʰ'),
- ('j', 'ʥ⁼'),
- ('ʥ⁼h', 'ʥʰ'),
- ('ñ', 'n^'),
- ('ṭ', 't`⁼'),
- ('t`⁼h', 't`ʰ'),
- ('ḍ', 'd`⁼'),
- ('d`⁼h', 'd`ʰ'),
- ('ṇ', 'n`'),
- ('t', 't⁼'),
- ('t⁼h', 'tʰ'),
- ('d', 'd⁼'),
- ('d⁼h', 'dʰ'),
- ('p', 'p⁼'),
- ('p⁼h', 'pʰ'),
- ('b', 'b⁼'),
- ('b⁼h', 'bʰ'),
- ('y', 'j'),
- ('ś', 'ʃ'),
- ('ṣ', 's`'),
- ('r', 'ɾ'),
- ('l̤', 'l`'),
- ('h', 'ɦ'),
- ("'", ''),
- ('~', '^'),
- ('ṃ', '^')
-]]
-
-
-def devanagari_to_ipa(text):
- text = text.replace('ॐ', 'ओम्')
- text = re.sub(r'\s*।\s*$', '.', text)
- text = re.sub(r'\s*।\s*', ', ', text)
- text = re.sub(r'\s*॥', '.', text)
- text = sanscript.transliterate(text, sanscript.DEVANAGARI, sanscript.IAST)
- for regex, replacement in _iast_to_ipa:
- text = re.sub(regex, replacement, text)
- text = re.sub('(.)[`ː]*ḥ', lambda x: x.group(0)
- [:-1]+'h'+x.group(1)+'*', text)
- return text
diff --git a/spaces/OAOA/DifFace/facelib/detection/yolov5face/utils/extract_ckpt.py b/spaces/OAOA/DifFace/facelib/detection/yolov5face/utils/extract_ckpt.py
deleted file mode 100644
index 4b8b631348f2d0cdea4e5a3594bb59f3e8f34a0f..0000000000000000000000000000000000000000
--- a/spaces/OAOA/DifFace/facelib/detection/yolov5face/utils/extract_ckpt.py
+++ /dev/null
@@ -1,5 +0,0 @@
-import torch
-import sys
-sys.path.insert(0,'./facelib/detection/yolov5face')
-model = torch.load('facelib/detection/yolov5face/yolov5n-face.pt', map_location='cpu')['model']
-torch.save(model.state_dict(),'weights/facelib/yolov5n-face.pth')
\ No newline at end of file
diff --git a/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/examples/truncated_bptt/__init__.py b/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/examples/truncated_bptt/__init__.py
deleted file mode 100644
index eee484d427a68828462469d133144a8d7c052c40..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/examples/truncated_bptt/__init__.py
+++ /dev/null
@@ -1,6 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-from . import transformer_xl_model, truncated_bptt_lm_task # noqa
diff --git a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/fairseq/models/lightconv.py b/spaces/OFA-Sys/OFA-Image_Caption/fairseq/fairseq/models/lightconv.py
deleted file mode 100644
index 4edfe359379bc2445c1ae1ada04bd34ca4a32798..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/fairseq/models/lightconv.py
+++ /dev/null
@@ -1,1019 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import math
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from fairseq import utils
-from fairseq.models import (
- FairseqEncoder,
- FairseqEncoderDecoderModel,
- FairseqIncrementalDecoder,
- register_model,
- register_model_architecture,
-)
-from fairseq.modules import (
- AdaptiveSoftmax,
- DynamicConv,
- FairseqDropout,
- LayerNorm,
- LightweightConv,
- MultiheadAttention,
- PositionalEmbedding,
-)
-from fairseq.utils import safe_hasattr
-
-
-@register_model("lightconv")
-class LightConvModel(FairseqEncoderDecoderModel):
- """
- LightConv and DynamicConv model from `"Pay Less Attention with Lightweight and Dynamic Convolutions" (Wu, et al, 2019)
- `_.
- To use LightConv please set ``--encoder-conv-type lightweight --decoder-conv-type lightweight``
- To use DynamicConv please set ``--encoder-conv-type dynamic --decoder-conv-type dynamic``
-
- Args:
- encoder (LightConvEncoder): the encoder
- decoder (LightConvDecoder): the decoder
-
- The LightConv model provides the following named architectures and
- command-line arguments:
-
- .. argparse::
- :ref: fairseq.models.lightconv_parser
- :prog:
- """
-
- @classmethod
- def hub_models(cls):
- # fmt: off
-
- def moses_subword(path):
- return {
- 'path': path,
- 'tokenizer': 'moses',
- 'bpe': 'subword_nmt',
- }
-
- return {
- 'lightconv.no_glu.iwslt14.de-en': moses_subword('https://dl.fbaipublicfiles.com/fairseq/models/dynamicconv/iwslt14.de-en.lightconv.tar.gz'),
- 'dynamicconv.no_glu.iwslt14.de-en': moses_subword('https://dl.fbaipublicfiles.com/fairseq/models/dynamicconv/iwslt14.de-en.dynamicconv.tar.gz'),
- 'lightconv.no_glu.wmt16.en-de': moses_subword('https://dl.fbaipublicfiles.com/fairseq/models/dynamicconv/wmt16.en-de.joined-dict.lightconv.tar.gz'),
- 'dynamicconv.no_glu.wmt16.en-de': moses_subword('https://dl.fbaipublicfiles.com/fairseq/models/dynamicconv/wmt16.en-de.joined-dict.dynamicconv.tar.gz'),
- 'lightconv.glu.wmt16.en-de': moses_subword('https://dl.fbaipublicfiles.com/fairseq/models/dynamicconv/wmt16.en-de.joined-dict.lightconv-glu.tar.gz'),
- 'dynamicconv.glu.wmt16.en-de': moses_subword('https://dl.fbaipublicfiles.com/fairseq/models/dynamicconv/wmt16.en-de.joined-dict.dynamicconv-glu.tar.gz'),
- 'lightconv.glu.wmt17.en-de': moses_subword('https://dl.fbaipublicfiles.com/fairseq/models/dynamicconv/wmt16.en-de.joined-dict.lightconv-glu.tar.gz'),
- 'dynamicconv.glu.wmt17.en-de': moses_subword('https://dl.fbaipublicfiles.com/fairseq/models/dynamicconv/wmt16.en-de.joined-dict.dynamicconv-glu.tar.gz'),
- 'lightconv.glu.wmt14.en-fr': moses_subword('https://dl.fbaipublicfiles.com/fairseq/models/dynamicconv/wmt14.en-fr.joined-dict.lightconv-glu.tar.gz'),
- 'dynamicconv.glu.wmt14.en-fr': moses_subword('https://dl.fbaipublicfiles.com/fairseq/models/dynamicconv/wmt14.en-fr.joined-dict.dynamicconv-glu.tar.gz'),
- 'lightconv.glu.wmt17.zh-en': moses_subword('https://dl.fbaipublicfiles.com/fairseq/models/dynamicconv/wmt17.zh-en.lightconv-glu.tar.gz'),
- 'dynamicconv.glu.wmt17.zh-en': moses_subword('https://dl.fbaipublicfiles.com/fairseq/models/dynamicconv/wmt17.zh-en.dynamicconv-glu.tar.gz'),
- }
- # fmt: on
-
- def __init__(self, encoder, decoder):
- super().__init__(encoder, decoder)
-
- @staticmethod
- def add_args(parser):
- """Add model-specific arguments to the parser."""
- parser.add_argument(
- "--dropout", type=float, metavar="D", help="dropout probability"
- )
- parser.add_argument(
- "--attention-dropout",
- type=float,
- metavar="D",
- help="dropout probability for attention weights",
- )
- parser.add_argument(
- "--relu-dropout",
- type=float,
- metavar="D",
- help="dropout probability after ReLU in FFN",
- )
- parser.add_argument(
- "--input-dropout",
- type=float,
- metavar="D",
- help="dropout probability of the inputs",
- )
- parser.add_argument(
- "--encoder-embed-path",
- type=str,
- metavar="STR",
- help="path to pre-trained encoder embedding",
- )
- parser.add_argument(
- "--encoder-embed-dim",
- type=int,
- metavar="N",
- help="encoder embedding dimension",
- )
- parser.add_argument(
- "--encoder-conv-dim",
- type=int,
- metavar="N",
- help="encoder embedding dimension",
- )
- parser.add_argument(
- "--encoder-ffn-embed-dim",
- type=int,
- metavar="N",
- help="encoder embedding dimension for FFN",
- )
- parser.add_argument(
- "--encoder-layers", type=int, metavar="N", help="num encoder layers"
- )
- parser.add_argument(
- "--encoder-attention-heads",
- type=int,
- metavar="N",
- help="num encoder attention heads or LightConv/DynamicConv heads",
- )
- parser.add_argument(
- "--encoder-normalize-before",
- action="store_true",
- help="apply layernorm before each encoder block",
- )
- parser.add_argument(
- "--encoder-learned-pos",
- action="store_true",
- help="use learned positional embeddings in the encoder",
- )
- parser.add_argument(
- "--decoder-embed-path",
- type=str,
- metavar="STR",
- help="path to pre-trained decoder embedding",
- )
- parser.add_argument(
- "--decoder-embed-dim",
- type=int,
- metavar="N",
- help="decoder embedding dimension",
- )
- parser.add_argument(
- "--decoder-conv-dim",
- type=int,
- metavar="N",
- help="decoder embedding dimension",
- )
- parser.add_argument(
- "--decoder-ffn-embed-dim",
- type=int,
- metavar="N",
- help="decoder embedding dimension for FFN",
- )
- parser.add_argument(
- "--decoder-layers", type=int, metavar="N", help="num decoder layers"
- )
- parser.add_argument(
- "--decoder-attention-heads",
- type=int,
- metavar="N",
- help="num decoder attention heads or LightConv/DynamicConv heads",
- )
- parser.add_argument(
- "--decoder-learned-pos",
- action="store_true",
- help="use learned positional embeddings in the decoder",
- )
- parser.add_argument(
- "--decoder-normalize-before",
- action="store_true",
- help="apply layernorm before each decoder block",
- )
- parser.add_argument(
- "--share-decoder-input-output-embed",
- action="store_true",
- help="share decoder input and output embeddings",
- )
- parser.add_argument(
- "--share-all-embeddings",
- action="store_true",
- help="share encoder, decoder and output embeddings"
- " (requires shared dictionary and embed dim)",
- )
- parser.add_argument(
- "--adaptive-softmax-cutoff",
- metavar="EXPR",
- help="comma separated list of adaptive softmax cutoff points. "
- "Must be used with adaptive_loss criterion",
- ),
- parser.add_argument(
- "--adaptive-softmax-dropout",
- type=float,
- metavar="D",
- help="sets adaptive softmax dropout for the tail projections",
- )
-
- """LightConv and DynamicConv arguments"""
- parser.add_argument(
- "--encoder-kernel-size-list",
- type=lambda x: utils.eval_str_list(x, int),
- help='list of kernel size (default: "[3,7,15,31,31,31,31]")',
- )
- parser.add_argument(
- "--decoder-kernel-size-list",
- type=lambda x: utils.eval_str_list(x, int),
- help='list of kernel size (default: "[3,7,15,31,31,31]")',
- )
- parser.add_argument(
- "--encoder-glu", type=utils.eval_bool, help="glu after in proj"
- )
- parser.add_argument(
- "--decoder-glu", type=utils.eval_bool, help="glu after in proj"
- )
- parser.add_argument(
- "--encoder-conv-type",
- default="dynamic",
- type=str,
- choices=["dynamic", "lightweight"],
- help="type of convolution",
- )
- parser.add_argument(
- "--decoder-conv-type",
- default="dynamic",
- type=str,
- choices=["dynamic", "lightweight"],
- help="type of convolution",
- )
- parser.add_argument("--weight-softmax", default=True, type=utils.eval_bool)
- parser.add_argument(
- "--weight-dropout",
- type=float,
- metavar="D",
- help="dropout probability for conv weights",
- )
-
- @classmethod
- def build_model(cls, args, task):
- """Build a new model instance."""
-
- # make sure all arguments are present in older models
- base_architecture(args)
-
- if not safe_hasattr(args, "max_source_positions"):
- args.max_source_positions = 1024
- if not safe_hasattr(args, "max_target_positions"):
- args.max_target_positions = 1024
-
- src_dict, tgt_dict = task.source_dictionary, task.target_dictionary
-
- def build_embedding(dictionary, embed_dim, path=None):
- num_embeddings = len(dictionary)
- padding_idx = dictionary.pad()
- emb = Embedding(num_embeddings, embed_dim, padding_idx)
- # if provided, load from preloaded dictionaries
- if path:
- embed_dict = utils.parse_embedding(path)
- utils.load_embedding(embed_dict, dictionary, emb)
- return emb
-
- if args.share_all_embeddings:
- if src_dict != tgt_dict:
- raise RuntimeError(
- "--share-all-embeddings requires a joined dictionary"
- )
- if args.encoder_embed_dim != args.decoder_embed_dim:
- raise RuntimeError(
- "--share-all-embeddings requires --encoder-embed-dim to match --decoder-embed-dim"
- )
- if args.decoder_embed_path and (
- args.decoder_embed_path != args.encoder_embed_path
- ):
- raise RuntimeError(
- "--share-all-embeddings not compatible with --decoder-embed-path"
- )
- encoder_embed_tokens = build_embedding(
- src_dict, args.encoder_embed_dim, args.encoder_embed_path
- )
- decoder_embed_tokens = encoder_embed_tokens
- args.share_decoder_input_output_embed = True
- else:
- encoder_embed_tokens = build_embedding(
- src_dict, args.encoder_embed_dim, args.encoder_embed_path
- )
- decoder_embed_tokens = build_embedding(
- tgt_dict, args.decoder_embed_dim, args.decoder_embed_path
- )
-
- encoder = LightConvEncoder(args, src_dict, encoder_embed_tokens)
- decoder = LightConvDecoder(args, tgt_dict, decoder_embed_tokens)
- return LightConvModel(encoder, decoder)
-
-
-class LightConvEncoder(FairseqEncoder):
- """
- LightConv encoder consisting of *args.encoder_layers* layers. Each layer
- is a :class:`LightConvEncoderLayer`.
-
- Args:
- args (argparse.Namespace): parsed command-line arguments
- dictionary (~fairseq.data.Dictionary): encoding dictionary
- embed_tokens (torch.nn.Embedding): input embedding
- """
-
- def __init__(self, args, dictionary, embed_tokens):
- super().__init__(dictionary)
- self.dropout_module = FairseqDropout(
- args.dropout, module_name=self.__class__.__name__
- )
-
- embed_dim = embed_tokens.embedding_dim
- self.padding_idx = embed_tokens.padding_idx
- self.max_source_positions = args.max_source_positions
-
- self.embed_tokens = embed_tokens
- self.embed_scale = math.sqrt(embed_dim)
- self.embed_positions = (
- PositionalEmbedding(
- args.max_source_positions,
- embed_dim,
- self.padding_idx,
- learned=args.encoder_learned_pos,
- )
- if not args.no_token_positional_embeddings
- else None
- )
-
- self.layers = nn.ModuleList([])
- self.layers.extend(
- [
- LightConvEncoderLayer(
- args, kernel_size=args.encoder_kernel_size_list[i]
- )
- for i in range(args.encoder_layers)
- ]
- )
- self.register_buffer("version", torch.Tensor([2]))
- self.normalize = args.encoder_normalize_before
- if self.normalize:
- self.layer_norm = LayerNorm(embed_dim)
-
- def forward(self, src_tokens, **unused):
- """
- Args:
- src_tokens (LongTensor): tokens in the source language of shape
- `(batch, src_len)`
-
- Returns:
- dict:
- - **encoder_out** (Tensor): the last encoder layer's output of
- shape `(src_len, batch, embed_dim)`
- - **encoder_padding_mask** (ByteTensor): the positions of
- padding elements of shape `(batch, src_len)`
- """
- # embed tokens and positions
- x = self.embed_scale * self.embed_tokens(src_tokens)
- if self.embed_positions is not None:
- x += self.embed_positions(src_tokens)
- x = self.dropout_module(x)
-
- # B x T x C -> T x B x C
- x = x.transpose(0, 1)
-
- # compute padding mask
- encoder_padding_mask = src_tokens.eq(self.padding_idx)
- if not encoder_padding_mask.any():
- encoder_padding_mask = None
-
- # encoder layers
- for layer in self.layers:
- x = layer(x, encoder_padding_mask)
-
- if self.normalize:
- x = self.layer_norm(x)
-
- return {
- "encoder_out": x, # T x B x C
- "encoder_padding_mask": encoder_padding_mask, # B x T
- }
-
- def reorder_encoder_out(self, encoder_out, new_order):
- """
- Reorder encoder output according to *new_order*.
-
- Args:
- encoder_out: output from the ``forward()`` method
- new_order (LongTensor): desired order
-
- Returns:
- *encoder_out* rearranged according to *new_order*
- """
- if encoder_out["encoder_out"] is not None:
- encoder_out["encoder_out"] = encoder_out["encoder_out"].index_select(
- 1, new_order
- )
- if encoder_out["encoder_padding_mask"] is not None:
- encoder_out["encoder_padding_mask"] = encoder_out[
- "encoder_padding_mask"
- ].index_select(0, new_order)
- return encoder_out
-
- def max_positions(self):
- """Maximum input length supported by the encoder."""
- if self.embed_positions is None:
- return self.max_source_positions
- return min(self.max_source_positions, self.embed_positions.max_positions)
-
-
-class LightConvDecoder(FairseqIncrementalDecoder):
- """
- LightConv decoder consisting of *args.decoder_layers* layers. Each layer
- is a :class:`LightConvDecoderLayer`.
-
- Args:
- args (argparse.Namespace): parsed command-line arguments
- dictionary (~fairseq.data.Dictionary): decoding dictionary
- embed_tokens (torch.nn.Embedding): output embedding
- no_encoder_attn (bool, optional): whether to attend to encoder outputs.
- Default: ``False``
- """
-
- def __init__(
- self, args, dictionary, embed_tokens, no_encoder_attn=False, final_norm=True
- ):
- super().__init__(dictionary)
- self.dropout_module = FairseqDropout(
- args.dropout, module_name=self.__class__.__name__
- )
- self.share_input_output_embed = args.share_decoder_input_output_embed
-
- input_embed_dim = embed_tokens.embedding_dim
- embed_dim = args.decoder_embed_dim
- output_embed_dim = args.decoder_output_dim
-
- padding_idx = embed_tokens.padding_idx
- self.max_target_positions = args.max_target_positions
-
- self.embed_tokens = embed_tokens
- self.embed_scale = math.sqrt(embed_dim) # todo: try with input_embed_dim
-
- self.project_in_dim = (
- Linear(input_embed_dim, embed_dim, bias=False)
- if embed_dim != input_embed_dim
- else None
- )
-
- self.embed_positions = (
- PositionalEmbedding(
- args.max_target_positions,
- embed_dim,
- padding_idx,
- learned=args.decoder_learned_pos,
- )
- if not args.no_token_positional_embeddings
- else None
- )
-
- self.layers = nn.ModuleList([])
- self.layers.extend(
- [
- LightConvDecoderLayer(
- args, no_encoder_attn, kernel_size=args.decoder_kernel_size_list[i]
- )
- for i in range(args.decoder_layers)
- ]
- )
-
- self.adaptive_softmax = None
-
- self.project_out_dim = (
- Linear(embed_dim, output_embed_dim, bias=False)
- if embed_dim != output_embed_dim and not args.tie_adaptive_weights
- else None
- )
-
- if args.adaptive_softmax_cutoff is not None:
- self.adaptive_softmax = AdaptiveSoftmax(
- len(dictionary),
- output_embed_dim,
- utils.eval_str_list(args.adaptive_softmax_cutoff, type=int),
- dropout=args.adaptive_softmax_dropout,
- adaptive_inputs=embed_tokens if args.tie_adaptive_weights else None,
- factor=args.adaptive_softmax_factor,
- tie_proj=args.tie_adaptive_proj,
- )
- elif not self.share_input_output_embed:
- self.embed_out = nn.Parameter(
- torch.Tensor(len(dictionary), output_embed_dim)
- )
- nn.init.normal_(self.embed_out, mean=0, std=output_embed_dim ** -0.5)
- self.register_buffer("version", torch.Tensor([2]))
- self.normalize = args.decoder_normalize_before and final_norm
- if self.normalize:
- self.layer_norm = LayerNorm(embed_dim)
-
- def forward(
- self, prev_output_tokens, encoder_out=None, incremental_state=None, **kwargs
- ):
- """
- Args:
- prev_output_tokens (LongTensor): previous decoder outputs of shape
- `(batch, tgt_len)`, for teacher forcing
- encoder_out (Tensor, optional): output from the encoder, used for
- encoder-side attention
- incremental_state (dict): dictionary used for storing state during
- :ref:`Incremental decoding`
-
- Returns:
- tuple:
- - the last decoder layer's output of shape `(batch, tgt_len,
- vocab)`
- - the last decoder layer's attention weights of shape `(batch,
- tgt_len, src_len)`
- """
- # embed positions
- positions = (
- self.embed_positions(
- prev_output_tokens,
- incremental_state=incremental_state,
- )
- if self.embed_positions is not None
- else None
- )
-
- if incremental_state is not None:
- prev_output_tokens = prev_output_tokens[:, -1:]
- if positions is not None:
- positions = positions[:, -1:]
-
- # embed tokens and positions
- x = self.embed_scale * self.embed_tokens(prev_output_tokens)
-
- if self.project_in_dim is not None:
- x = self.project_in_dim(x)
-
- if positions is not None:
- x += positions
- x = self.dropout_module(x)
-
- # B x T x C -> T x B x C
- x = x.transpose(0, 1)
- attn = None
-
- inner_states = [x]
-
- # decoder layers
- for layer in self.layers:
- x, attn = layer(
- x,
- encoder_out["encoder_out"] if encoder_out is not None else None,
- encoder_out["encoder_padding_mask"]
- if encoder_out is not None
- else None,
- incremental_state,
- )
- inner_states.append(x)
-
- if self.normalize:
- x = self.layer_norm(x)
-
- # T x B x C -> B x T x C
- x = x.transpose(0, 1)
-
- if self.project_out_dim is not None:
- x = self.project_out_dim(x)
-
- if self.adaptive_softmax is None:
- # project back to size of vocabulary
- if self.share_input_output_embed:
- x = F.linear(x, self.embed_tokens.weight)
- else:
- x = F.linear(x, self.embed_out)
-
- return x, {"attn": attn, "inner_states": inner_states}
-
- def max_positions(self):
- """Maximum output length supported by the decoder."""
- if self.embed_positions is None:
- return self.max_target_positions
- return min(self.max_target_positions, self.embed_positions.max_positions)
-
- def buffered_future_mask(self, tensor):
- dim = tensor.size(0)
- if (
- not hasattr(self, "_future_mask")
- or self._future_mask is None
- or self._future_mask.device != tensor.device
- ):
- self._future_mask = torch.triu(
- utils.fill_with_neg_inf(tensor.new(dim, dim)), 1
- )
- if self._future_mask.size(0) < dim:
- self._future_mask = torch.triu(
- utils.fill_with_neg_inf(self._future_mask.resize_(dim, dim)), 1
- )
- return self._future_mask[:dim, :dim]
-
-
-class LightConvEncoderLayer(nn.Module):
- """Encoder layer block.
-
- Args:
- args (argparse.Namespace): parsed command-line arguments
- kernel_size: kernel size of the convolution
- """
-
- def __init__(self, args, kernel_size=0):
- super().__init__()
- self.embed_dim = args.encoder_embed_dim
- self.conv_dim = args.encoder_conv_dim
- padding_l = (
- kernel_size // 2
- if kernel_size % 2 == 1
- else ((kernel_size - 1) // 2, kernel_size // 2)
- )
-
- if args.encoder_glu:
- self.linear1 = Linear(self.embed_dim, 2 * self.conv_dim)
- self.act = nn.GLU()
- else:
- self.linear1 = Linear(self.embed_dim, self.conv_dim)
- self.act = None
- if args.encoder_conv_type == "lightweight":
- self.conv = LightweightConv(
- self.conv_dim,
- kernel_size,
- padding_l=padding_l,
- weight_softmax=args.weight_softmax,
- num_heads=args.encoder_attention_heads,
- weight_dropout=args.weight_dropout,
- )
- elif args.encoder_conv_type == "dynamic":
- self.conv = DynamicConv(
- self.conv_dim,
- kernel_size,
- padding_l=padding_l,
- weight_softmax=args.weight_softmax,
- num_heads=args.encoder_attention_heads,
- weight_dropout=args.weight_dropout,
- )
- else:
- raise NotImplementedError
- self.linear2 = Linear(self.conv_dim, self.embed_dim)
-
- self.dropout_module = FairseqDropout(
- args.dropout, module_name=self.__class__.__name__
- )
- self.relu_dropout_module = FairseqDropout(
- args.relu_dropout, module_name=self.__class__.__name__
- )
- self.input_dropout_module = FairseqDropout(
- args.input_dropout, module_name=self.__class__.__name__
- )
- self.normalize_before = args.encoder_normalize_before
- self.fc1 = Linear(self.embed_dim, args.encoder_ffn_embed_dim)
- self.fc2 = Linear(args.encoder_ffn_embed_dim, self.embed_dim)
- self.layer_norms = nn.ModuleList([LayerNorm(self.embed_dim) for _ in range(2)])
-
- def forward(self, x, encoder_padding_mask):
- """
- Args:
- x (Tensor): input to the layer of shape `(seq_len, batch, embed_dim)`
- encoder_padding_mask (ByteTensor): binary ByteTensor of shape
- `(batch, src_len)` where padding elements are indicated by ``1``.
-
- Returns:
- encoded output of shape `(batch, src_len, embed_dim)`
- """
- residual = x
- x = self.maybe_layer_norm(0, x, before=True)
- x = self.input_dropout_module(x)
- x = self.linear1(x)
- if self.act is not None:
- x = self.act(x)
- if encoder_padding_mask is not None:
- x = x.masked_fill(encoder_padding_mask.transpose(0, 1).unsqueeze(2), 0)
- x = self.conv(x)
- x = self.linear2(x)
- x = self.dropout_module(x)
- x = residual + x
- x = self.maybe_layer_norm(0, x, after=True)
-
- residual = x
- x = self.maybe_layer_norm(1, x, before=True)
- x = F.relu(self.fc1(x))
- x = self.relu_dropout_module(x)
- x = self.fc2(x)
- x = self.dropout_module(x)
- x = residual + x
- x = self.maybe_layer_norm(1, x, after=True)
- return x
-
- def maybe_layer_norm(self, i, x, before=False, after=False):
- assert before ^ after
- if after ^ self.normalize_before:
- return self.layer_norms[i](x)
- else:
- return x
-
- def extra_repr(self):
- return (
- "dropout={}, relu_dropout={}, input_dropout={}, normalize_before={}".format(
- self.dropout_module.p,
- self.relu_dropout_module.p,
- self.input_dropout_module.p,
- self.normalize_before,
- )
- )
-
-
-class LightConvDecoderLayer(nn.Module):
- """Decoder layer block.
-
- Args:
- args (argparse.Namespace): parsed command-line arguments
- no_encoder_attn (bool, optional): whether to attend to encoder outputs.
- Default: ``False``
- kernel_size: kernel size of the convolution
- """
-
- def __init__(self, args, no_encoder_attn=False, kernel_size=0):
- super().__init__()
- self.embed_dim = args.decoder_embed_dim
- self.conv_dim = args.decoder_conv_dim
- if args.decoder_glu:
- self.linear1 = Linear(self.embed_dim, 2 * self.conv_dim)
- self.act = nn.GLU()
- else:
- self.linear1 = Linear(self.embed_dim, self.conv_dim)
- self.act = None
- if args.decoder_conv_type == "lightweight":
- self.conv = LightweightConv(
- self.conv_dim,
- kernel_size,
- padding_l=kernel_size - 1,
- weight_softmax=args.weight_softmax,
- num_heads=args.decoder_attention_heads,
- weight_dropout=args.weight_dropout,
- )
- elif args.decoder_conv_type == "dynamic":
- self.conv = DynamicConv(
- self.conv_dim,
- kernel_size,
- padding_l=kernel_size - 1,
- weight_softmax=args.weight_softmax,
- num_heads=args.decoder_attention_heads,
- weight_dropout=args.weight_dropout,
- )
- else:
- raise NotImplementedError
- self.linear2 = Linear(self.conv_dim, self.embed_dim)
-
- self.dropout_module = FairseqDropout(
- args.dropout, module_name=self.__class__.__name__
- )
- self.relu_dropout_module = FairseqDropout(
- args.relu_dropout, module_name=self.__class__.__name__
- )
- self.input_dropout_module = FairseqDropout(
- args.input_dropout, module_name=self.__class__.__name__
- )
- self.normalize_before = args.decoder_normalize_before
-
- self.conv_layer_norm = LayerNorm(self.embed_dim)
-
- if no_encoder_attn:
- self.encoder_attn = None
- self.encoder_attn_layer_norm = None
- else:
- self.encoder_attn = MultiheadAttention(
- self.embed_dim,
- args.decoder_attention_heads,
- dropout=args.attention_dropout,
- encoder_decoder_attention=True,
- )
- self.encoder_attn_layer_norm = LayerNorm(self.embed_dim)
-
- self.fc1 = Linear(self.embed_dim, args.decoder_ffn_embed_dim)
- self.fc2 = Linear(args.decoder_ffn_embed_dim, self.embed_dim)
-
- self.final_layer_norm = LayerNorm(self.embed_dim)
- self.need_attn = True
-
- def forward(
- self,
- x,
- encoder_out,
- encoder_padding_mask,
- incremental_state,
- prev_conv_state=None,
- prev_attn_state=None,
- conv_mask=None,
- conv_padding_mask=None,
- ):
- """
- Args:
- x (Tensor): input to the layer of shape `(seq_len, batch, embed_dim)`
- encoder_padding_mask (ByteTensor): binary ByteTensor of shape
- `(batch, src_len)` where padding elements are indicated by ``1``.
-
- Returns:
- encoded output of shape `(batch, src_len, embed_dim)`
- """
- residual = x
- x = self.maybe_layer_norm(self.conv_layer_norm, x, before=True)
- if prev_conv_state is not None:
- if incremental_state is None:
- incremental_state = {}
- self.conv._set_input_buffer(incremental_state, prev_conv_state)
- x = self.input_dropout_module(x)
- x = self.linear1(x)
- if self.act is not None:
- x = self.act(x)
- x = self.conv(x, incremental_state=incremental_state)
- x = self.linear2(x)
- x = self.dropout_module(x)
- x = residual + x
- x = self.maybe_layer_norm(self.conv_layer_norm, x, after=True)
-
- attn = None
- if self.encoder_attn is not None:
- residual = x
- x = self.maybe_layer_norm(self.encoder_attn_layer_norm, x, before=True)
- if prev_attn_state is not None:
- if incremental_state is None:
- incremental_state = {}
- prev_key, prev_value = prev_attn_state
- saved_state = {"prev_key": prev_key, "prev_value": prev_value}
- self.encoder_attn._set_input_buffer(incremental_state, saved_state)
- x, attn = self.encoder_attn(
- query=x,
- key=encoder_out,
- value=encoder_out,
- key_padding_mask=encoder_padding_mask,
- incremental_state=incremental_state,
- static_kv=True,
- need_weights=(not self.training and self.need_attn),
- )
- x = self.dropout_module(x)
- x = residual + x
- x = self.maybe_layer_norm(self.encoder_attn_layer_norm, x, after=True)
-
- residual = x
- x = self.maybe_layer_norm(self.final_layer_norm, x, before=True)
- x = F.relu(self.fc1(x))
- x = self.relu_dropout_module(x)
- x = self.fc2(x)
- x = self.dropout_module(x)
- x = residual + x
- x = self.maybe_layer_norm(self.final_layer_norm, x, after=True)
- return x, attn
-
- def maybe_layer_norm(self, layer_norm, x, before=False, after=False):
- assert before ^ after
- if after ^ self.normalize_before:
- return layer_norm(x)
- else:
- return x
-
- def make_generation_fast_(self, need_attn=False, **kwargs):
- self.need_attn = need_attn
-
- def extra_repr(self):
- return (
- "dropout={}, relu_dropout={}, input_dropout={}, normalize_before={}".format(
- self.dropout_module.p,
- self.relu_dropout_module.p,
- self.input_dropout_module.p,
- self.normalize_before,
- )
- )
-
-
-def Embedding(num_embeddings, embedding_dim, padding_idx):
- m = nn.Embedding(num_embeddings, embedding_dim, padding_idx=padding_idx)
- nn.init.normal_(m.weight, mean=0, std=embedding_dim ** -0.5)
- nn.init.constant_(m.weight[padding_idx], 0)
- return m
-
-
-def Linear(in_features, out_features, bias=True):
- m = nn.Linear(in_features, out_features, bias)
- nn.init.xavier_uniform_(m.weight)
- if bias:
- nn.init.constant_(m.bias, 0.0)
- return m
-
-
-@register_model_architecture("lightconv", "lightconv")
-def base_architecture(args):
- args.encoder_embed_path = getattr(args, "encoder_embed_path", None)
- args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 512)
- args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 2048)
- args.encoder_layers = getattr(args, "encoder_layers", 7)
- args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 8)
- args.encoder_normalize_before = getattr(args, "encoder_normalize_before", False)
- args.encoder_learned_pos = getattr(args, "encoder_learned_pos", False)
- args.decoder_embed_path = getattr(args, "decoder_embed_path", None)
- args.decoder_embed_dim = getattr(args, "decoder_embed_dim", args.encoder_embed_dim)
- args.decoder_ffn_embed_dim = getattr(
- args, "decoder_ffn_embed_dim", args.encoder_ffn_embed_dim
- )
- args.decoder_layers = getattr(args, "decoder_layers", 6)
- args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 8)
- args.decoder_normalize_before = getattr(args, "decoder_normalize_before", False)
- args.decoder_learned_pos = getattr(args, "decoder_learned_pos", False)
- args.attention_dropout = getattr(args, "attention_dropout", 0.0)
- args.relu_dropout = getattr(args, "relu_dropout", 0.0)
- args.dropout = getattr(args, "dropout", 0.1)
- args.adaptive_softmax_cutoff = getattr(args, "adaptive_softmax_cutoff", None)
- args.adaptive_softmax_dropout = getattr(args, "adaptive_softmax_dropout", 0)
- args.share_decoder_input_output_embed = getattr(
- args, "share_decoder_input_output_embed", False
- )
- args.share_all_embeddings = getattr(args, "share_all_embeddings", False)
- args.no_token_positional_embeddings = getattr(
- args, "no_token_positional_embeddings", False
- )
-
- args.decoder_output_dim = getattr(
- args, "decoder_output_dim", args.decoder_embed_dim
- )
- args.decoder_input_dim = getattr(args, "decoder_input_dim", args.decoder_embed_dim)
-
- args.encoder_conv_dim = getattr(args, "encoder_conv_dim", args.encoder_embed_dim)
- args.decoder_conv_dim = getattr(args, "decoder_conv_dim", args.decoder_embed_dim)
-
- args.encoder_kernel_size_list = getattr(
- args, "encoder_kernel_size_list", [3, 7, 15, 31, 31, 31, 31]
- )
- args.decoder_kernel_size_list = getattr(
- args, "decoder_kernel_size_list", [3, 7, 15, 31, 31, 31]
- )
- if len(args.encoder_kernel_size_list) == 1:
- args.encoder_kernel_size_list = (
- args.encoder_kernel_size_list * args.encoder_layers
- )
- if len(args.decoder_kernel_size_list) == 1:
- args.decoder_kernel_size_list = (
- args.decoder_kernel_size_list * args.decoder_layers
- )
- assert (
- len(args.encoder_kernel_size_list) == args.encoder_layers
- ), "encoder_kernel_size_list doesn't match encoder_layers"
- assert (
- len(args.decoder_kernel_size_list) == args.decoder_layers
- ), "decoder_kernel_size_list doesn't match decoder_layers"
- args.encoder_glu = getattr(args, "encoder_glu", True)
- args.decoder_glu = getattr(args, "decoder_glu", True)
- args.input_dropout = getattr(args, "input_dropout", 0.1)
- args.weight_dropout = getattr(args, "weight_dropout", args.attention_dropout)
-
-
-@register_model_architecture("lightconv", "lightconv_iwslt_de_en")
-def lightconv_iwslt_de_en(args):
- args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 512)
- args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 1024)
- args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 4)
- args.encoder_layers = getattr(args, "encoder_layers", 7)
- args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 512)
- args.decoder_ffn_embed_dim = getattr(args, "decoder_ffn_embed_dim", 1024)
- args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 4)
- args.decoder_layers = getattr(args, "decoder_layers", 6)
- args.attention_dropout = getattr(args, "attention_dropout", 0.1)
- args.weight_dropout = getattr(args, "weight_dropout", 0.1)
- args.encoder_glu = getattr(args, "encoder_glu", False)
- args.decoder_glu = getattr(args, "decoder_glu", False)
- args.input_dropout = getattr(args, "input_dropout", 0.0)
- base_architecture(args)
-
-
-@register_model_architecture("lightconv", "lightconv_wmt_en_de")
-def lightconv_wmt_en_de(args):
- base_architecture(args)
-
-
-@register_model_architecture("lightconv", "lightconv_wmt_en_de_big")
-def lightconv_wmt_en_de_big(args):
- args.attention_dropout = getattr(args, "attention_dropout", 0.1)
- args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 1024)
- args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 4096)
- args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 16)
- args.encoder_normalize_before = getattr(args, "encoder_normalize_before", False)
- args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 1024)
- args.decoder_ffn_embed_dim = getattr(args, "decoder_ffn_embed_dim", 4096)
- args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 16)
- args.dropout = getattr(args, "dropout", 0.3)
- base_architecture(args)
-
-
-@register_model_architecture("lightconv", "lightconv_wmt_en_fr_big")
-def lightconv_wmt_en_fr_big(args):
- args.dropout = getattr(args, "dropout", 0.1)
- lightconv_wmt_en_de_big(args)
-
-
-@register_model_architecture("lightconv", "lightconv_wmt_zh_en_big")
-def lightconv_wmt_zh_en_big(args):
- args.dropout = getattr(args, "dropout", 0.2)
- args.attention_dropout = getattr(args, "attention_dropout", 0.2)
- args.weight_dropout = getattr(args, "weight_dropout", 0.2)
- lightconv_wmt_en_de_big(args)
diff --git a/spaces/OFA-Sys/OFA-Image_Caption/utils/cider/pyciderevalcap/ciderD/ciderD.py b/spaces/OFA-Sys/OFA-Image_Caption/utils/cider/pyciderevalcap/ciderD/ciderD.py
deleted file mode 100644
index 280f9890312a76b54695b2a8c456c5d52a87e186..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Image_Caption/utils/cider/pyciderevalcap/ciderD/ciderD.py
+++ /dev/null
@@ -1,58 +0,0 @@
-# Filename: ciderD.py
-#
-# Description: Describes the class to compute the CIDEr-D (Consensus-Based Image Description Evaluation) Metric
-# by Vedantam, Zitnick, and Parikh (http://arxiv.org/abs/1411.5726)
-#
-# Creation Date: Sun Feb 8 14:16:54 2015
-#
-# Authors: Ramakrishna Vedantam and Tsung-Yi Lin
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-from .ciderD_scorer import CiderScorer
-import pdb
-
-class CiderD:
- """
- Main Class to compute the CIDEr metric
-
- """
- def __init__(self, n=4, sigma=6.0, df="corpus"):
- # set cider to sum over 1 to 4-grams
- self._n = n
- # set the standard deviation parameter for gaussian penalty
- self._sigma = sigma
- # set which where to compute document frequencies from
- self._df = df
- self.cider_scorer = CiderScorer(n=self._n, df_mode=self._df)
-
- def compute_score(self, gts, res):
- """
- Main function to compute CIDEr score
- :param hypo_for_image (dict) : dictionary with key and value
- ref_for_image (dict) : dictionary with key and value
- :return: cider (float) : computed CIDEr score for the corpus
- """
-
- # clear all the previous hypos and refs
- tmp_cider_scorer = self.cider_scorer.copy_empty()
- tmp_cider_scorer.clear()
- for res_id in res:
-
- hypo = res_id['caption']
- ref = gts[res_id['image_id']]
-
- # Sanity check.
- assert(type(hypo) is list)
- assert(len(hypo) == 1)
- assert(type(ref) is list)
- assert(len(ref) > 0)
- tmp_cider_scorer += (hypo[0], ref)
-
- (score, scores) = tmp_cider_scorer.compute_score()
-
- return score, scores
-
- def method(self):
- return "CIDEr-D"
diff --git a/spaces/OFA-Sys/OFA-vqa/fairseq/fairseq/optim/lr_scheduler/pass_through.py b/spaces/OFA-Sys/OFA-vqa/fairseq/fairseq/optim/lr_scheduler/pass_through.py
deleted file mode 100644
index 2f93db328c1de9b268e8ee1c0c1cad558fd089aa..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-vqa/fairseq/fairseq/optim/lr_scheduler/pass_through.py
+++ /dev/null
@@ -1,39 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-from dataclasses import dataclass
-
-from fairseq.dataclass import FairseqDataclass
-from fairseq.optim.lr_scheduler import FairseqLRScheduler, register_lr_scheduler
-
-
-@dataclass
-class PassThroughScheduleConfig(FairseqDataclass):
- pass
-
-
-@register_lr_scheduler("pass_through", dataclass=PassThroughScheduleConfig)
-class PassThroughScheduleSchedule(FairseqLRScheduler):
- """Delegate lr scheduling to the optimizer."""
-
- def __init__(self, cfg: PassThroughScheduleConfig, optimizer):
- super().__init__(cfg, optimizer)
- assert (
- hasattr(optimizer, "lr_scheduler") and optimizer.lr_scheduler is not None
- ), "Pass-through schedule can only be used with optimizers with their own schedulers"
-
- def state_dict(self):
- return self.optimizer.lr_scheduler.state_dict()
-
- def load_state_dict(self, state_dict):
- self.optimizer.lr_scheduler.load_state_dict(state_dict)
-
- def step_begin_epoch(self, epoch):
- """Update the learning rate at the beginning of the given epoch."""
- return self.optimizer.lr_scheduler.step_begin_epoch(epoch)
-
- def step_update(self, num_updates):
- """Update the learning rate after each update."""
- return self.optimizer.lr_scheduler.step_update(num_updates)
diff --git a/spaces/OpenDILabCommunity/DI-sheep/DI-sheep/ui/src/themes/mhl/index.tsx b/spaces/OpenDILabCommunity/DI-sheep/DI-sheep/ui/src/themes/mhl/index.tsx
deleted file mode 100644
index c69add7504c51f88d9b865e106b2b775bc642fa4..0000000000000000000000000000000000000000
--- a/spaces/OpenDILabCommunity/DI-sheep/DI-sheep/ui/src/themes/mhl/index.tsx
+++ /dev/null
@@ -1,26 +0,0 @@
-import React from 'react';
-import { Theme } from '../interface';
-import { DefaultSoundNames, defaultSounds } from '../default';
-
-const imagesUrls = import.meta.glob('./images/*.png', {
- import: 'default',
- eager: true,
-});
-
-const mhls = Object.entries(imagesUrls).map(([key, value]) => ({
- name: key.slice(9, -4),
- // eslint-disable-next-line @typescript-eslint/ban-ts-comment
- // @ts-ignore
- content: ,
-}));
-
-export const mhlTheme: Theme = {
- name: 'kitten',
- icons: mhls.map(({ name, content }) => ({
- name,
- content,
- clickSound: 'button-click',
- tripleSound: 'triple',
- })),
- sounds: defaultSounds,
-};
diff --git a/spaces/OpenGVLab/InternGPT/iGPT/models/grit_src/third_party/CenterNet2/detectron2/modeling/roi_heads/__init__.py b/spaces/OpenGVLab/InternGPT/iGPT/models/grit_src/third_party/CenterNet2/detectron2/modeling/roi_heads/__init__.py
deleted file mode 100644
index d13e9c57235b982f3e0645bc316de2b75755dfda..0000000000000000000000000000000000000000
--- a/spaces/OpenGVLab/InternGPT/iGPT/models/grit_src/third_party/CenterNet2/detectron2/modeling/roi_heads/__init__.py
+++ /dev/null
@@ -1,29 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-from .box_head import ROI_BOX_HEAD_REGISTRY, build_box_head, FastRCNNConvFCHead
-from .keypoint_head import (
- ROI_KEYPOINT_HEAD_REGISTRY,
- build_keypoint_head,
- BaseKeypointRCNNHead,
- KRCNNConvDeconvUpsampleHead,
-)
-from .mask_head import (
- ROI_MASK_HEAD_REGISTRY,
- build_mask_head,
- BaseMaskRCNNHead,
- MaskRCNNConvUpsampleHead,
-)
-from .roi_heads import (
- ROI_HEADS_REGISTRY,
- ROIHeads,
- Res5ROIHeads,
- StandardROIHeads,
- build_roi_heads,
- select_foreground_proposals,
-)
-from .cascade_rcnn import CascadeROIHeads
-from .rotated_fast_rcnn import RROIHeads
-from .fast_rcnn import FastRCNNOutputLayers
-
-from . import cascade_rcnn # isort:skip
-
-__all__ = list(globals().keys())
diff --git a/spaces/OptimalScale/Robin-33b/lmflow/utils/__init__.py b/spaces/OptimalScale/Robin-33b/lmflow/utils/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/OthmaneJ/transcribe-distil-wav2vec2/README.md b/spaces/OthmaneJ/transcribe-distil-wav2vec2/README.md
deleted file mode 100644
index cf1bbff05ef4f6abacc515a9059d09f1f9243509..0000000000000000000000000000000000000000
--- a/spaces/OthmaneJ/transcribe-distil-wav2vec2/README.md
+++ /dev/null
@@ -1,37 +0,0 @@
----
-title: Transcribe Distil Wav2vec2
-emoji: 🐠
-colorFrom: red
-colorTo: blue
-sdk: gradio
-app_file: app.py
-pinned: false
----
-
-# Configuration
-
-`title`: _string_
-Display title for the Space
-
-`emoji`: _string_
-Space emoji (emoji-only character allowed)
-
-`colorFrom`: _string_
-Color for Thumbnail gradient (red, yellow, green, blue, indigo, purple, pink, gray)
-
-`colorTo`: _string_
-Color for Thumbnail gradient (red, yellow, green, blue, indigo, purple, pink, gray)
-
-`sdk`: _string_
-Can be either `gradio` or `streamlit`
-
-`sdk_version` : _string_
-Only applicable for `streamlit` SDK.
-See [doc](https://hf.co/docs/hub/spaces) for more info on supported versions.
-
-`app_file`: _string_
-Path to your main application file (which contains either `gradio` or `streamlit` Python code).
-Path is relative to the root of the repository.
-
-`pinned`: _boolean_
-Whether the Space stays on top of your list.
diff --git a/spaces/PAIR/Text2Video-Zero/annotator/uniformer/mmcv/video/processing.py b/spaces/PAIR/Text2Video-Zero/annotator/uniformer/mmcv/video/processing.py
deleted file mode 100644
index 3d90b96e0823d5f116755e7f498d25d17017224a..0000000000000000000000000000000000000000
--- a/spaces/PAIR/Text2Video-Zero/annotator/uniformer/mmcv/video/processing.py
+++ /dev/null
@@ -1,160 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import os
-import os.path as osp
-import subprocess
-import tempfile
-
-from annotator.uniformer.mmcv.utils import requires_executable
-
-
-@requires_executable('ffmpeg')
-def convert_video(in_file,
- out_file,
- print_cmd=False,
- pre_options='',
- **kwargs):
- """Convert a video with ffmpeg.
-
- This provides a general api to ffmpeg, the executed command is::
-
- `ffmpeg -y -i `
-
- Options(kwargs) are mapped to ffmpeg commands with the following rules:
-
- - key=val: "-key val"
- - key=True: "-key"
- - key=False: ""
-
- Args:
- in_file (str): Input video filename.
- out_file (str): Output video filename.
- pre_options (str): Options appears before "-i ".
- print_cmd (bool): Whether to print the final ffmpeg command.
- """
- options = []
- for k, v in kwargs.items():
- if isinstance(v, bool):
- if v:
- options.append(f'-{k}')
- elif k == 'log_level':
- assert v in [
- 'quiet', 'panic', 'fatal', 'error', 'warning', 'info',
- 'verbose', 'debug', 'trace'
- ]
- options.append(f'-loglevel {v}')
- else:
- options.append(f'-{k} {v}')
- cmd = f'ffmpeg -y {pre_options} -i {in_file} {" ".join(options)} ' \
- f'{out_file}'
- if print_cmd:
- print(cmd)
- subprocess.call(cmd, shell=True)
-
-
-@requires_executable('ffmpeg')
-def resize_video(in_file,
- out_file,
- size=None,
- ratio=None,
- keep_ar=False,
- log_level='info',
- print_cmd=False):
- """Resize a video.
-
- Args:
- in_file (str): Input video filename.
- out_file (str): Output video filename.
- size (tuple): Expected size (w, h), eg, (320, 240) or (320, -1).
- ratio (tuple or float): Expected resize ratio, (2, 0.5) means
- (w*2, h*0.5).
- keep_ar (bool): Whether to keep original aspect ratio.
- log_level (str): Logging level of ffmpeg.
- print_cmd (bool): Whether to print the final ffmpeg command.
- """
- if size is None and ratio is None:
- raise ValueError('expected size or ratio must be specified')
- if size is not None and ratio is not None:
- raise ValueError('size and ratio cannot be specified at the same time')
- options = {'log_level': log_level}
- if size:
- if not keep_ar:
- options['vf'] = f'scale={size[0]}:{size[1]}'
- else:
- options['vf'] = f'scale=w={size[0]}:h={size[1]}:' \
- 'force_original_aspect_ratio=decrease'
- else:
- if not isinstance(ratio, tuple):
- ratio = (ratio, ratio)
- options['vf'] = f'scale="trunc(iw*{ratio[0]}):trunc(ih*{ratio[1]})"'
- convert_video(in_file, out_file, print_cmd, **options)
-
-
-@requires_executable('ffmpeg')
-def cut_video(in_file,
- out_file,
- start=None,
- end=None,
- vcodec=None,
- acodec=None,
- log_level='info',
- print_cmd=False):
- """Cut a clip from a video.
-
- Args:
- in_file (str): Input video filename.
- out_file (str): Output video filename.
- start (None or float): Start time (in seconds).
- end (None or float): End time (in seconds).
- vcodec (None or str): Output video codec, None for unchanged.
- acodec (None or str): Output audio codec, None for unchanged.
- log_level (str): Logging level of ffmpeg.
- print_cmd (bool): Whether to print the final ffmpeg command.
- """
- options = {'log_level': log_level}
- if vcodec is None:
- options['vcodec'] = 'copy'
- if acodec is None:
- options['acodec'] = 'copy'
- if start:
- options['ss'] = start
- else:
- start = 0
- if end:
- options['t'] = end - start
- convert_video(in_file, out_file, print_cmd, **options)
-
-
-@requires_executable('ffmpeg')
-def concat_video(video_list,
- out_file,
- vcodec=None,
- acodec=None,
- log_level='info',
- print_cmd=False):
- """Concatenate multiple videos into a single one.
-
- Args:
- video_list (list): A list of video filenames
- out_file (str): Output video filename
- vcodec (None or str): Output video codec, None for unchanged
- acodec (None or str): Output audio codec, None for unchanged
- log_level (str): Logging level of ffmpeg.
- print_cmd (bool): Whether to print the final ffmpeg command.
- """
- tmp_filehandler, tmp_filename = tempfile.mkstemp(suffix='.txt', text=True)
- with open(tmp_filename, 'w') as f:
- for filename in video_list:
- f.write(f'file {osp.abspath(filename)}\n')
- options = {'log_level': log_level}
- if vcodec is None:
- options['vcodec'] = 'copy'
- if acodec is None:
- options['acodec'] = 'copy'
- convert_video(
- tmp_filename,
- out_file,
- print_cmd,
- pre_options='-f concat -safe 0',
- **options)
- os.close(tmp_filehandler)
- os.remove(tmp_filename)
diff --git a/spaces/PKUWilliamYang/VToonify/vtoonify/model/raft/core/extractor.py b/spaces/PKUWilliamYang/VToonify/vtoonify/model/raft/core/extractor.py
deleted file mode 100644
index 9a9c759d1243d4694e8656c2f6f8a37e53edd009..0000000000000000000000000000000000000000
--- a/spaces/PKUWilliamYang/VToonify/vtoonify/model/raft/core/extractor.py
+++ /dev/null
@@ -1,267 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-
-class ResidualBlock(nn.Module):
- def __init__(self, in_planes, planes, norm_fn='group', stride=1):
- super(ResidualBlock, self).__init__()
-
- self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=3, padding=1, stride=stride)
- self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, padding=1)
- self.relu = nn.ReLU(inplace=True)
-
- num_groups = planes // 8
-
- if norm_fn == 'group':
- self.norm1 = nn.GroupNorm(num_groups=num_groups, num_channels=planes)
- self.norm2 = nn.GroupNorm(num_groups=num_groups, num_channels=planes)
- if not stride == 1:
- self.norm3 = nn.GroupNorm(num_groups=num_groups, num_channels=planes)
-
- elif norm_fn == 'batch':
- self.norm1 = nn.BatchNorm2d(planes)
- self.norm2 = nn.BatchNorm2d(planes)
- if not stride == 1:
- self.norm3 = nn.BatchNorm2d(planes)
-
- elif norm_fn == 'instance':
- self.norm1 = nn.InstanceNorm2d(planes)
- self.norm2 = nn.InstanceNorm2d(planes)
- if not stride == 1:
- self.norm3 = nn.InstanceNorm2d(planes)
-
- elif norm_fn == 'none':
- self.norm1 = nn.Sequential()
- self.norm2 = nn.Sequential()
- if not stride == 1:
- self.norm3 = nn.Sequential()
-
- if stride == 1:
- self.downsample = None
-
- else:
- self.downsample = nn.Sequential(
- nn.Conv2d(in_planes, planes, kernel_size=1, stride=stride), self.norm3)
-
-
- def forward(self, x):
- y = x
- y = self.relu(self.norm1(self.conv1(y)))
- y = self.relu(self.norm2(self.conv2(y)))
-
- if self.downsample is not None:
- x = self.downsample(x)
-
- return self.relu(x+y)
-
-
-
-class BottleneckBlock(nn.Module):
- def __init__(self, in_planes, planes, norm_fn='group', stride=1):
- super(BottleneckBlock, self).__init__()
-
- self.conv1 = nn.Conv2d(in_planes, planes//4, kernel_size=1, padding=0)
- self.conv2 = nn.Conv2d(planes//4, planes//4, kernel_size=3, padding=1, stride=stride)
- self.conv3 = nn.Conv2d(planes//4, planes, kernel_size=1, padding=0)
- self.relu = nn.ReLU(inplace=True)
-
- num_groups = planes // 8
-
- if norm_fn == 'group':
- self.norm1 = nn.GroupNorm(num_groups=num_groups, num_channels=planes//4)
- self.norm2 = nn.GroupNorm(num_groups=num_groups, num_channels=planes//4)
- self.norm3 = nn.GroupNorm(num_groups=num_groups, num_channels=planes)
- if not stride == 1:
- self.norm4 = nn.GroupNorm(num_groups=num_groups, num_channels=planes)
-
- elif norm_fn == 'batch':
- self.norm1 = nn.BatchNorm2d(planes//4)
- self.norm2 = nn.BatchNorm2d(planes//4)
- self.norm3 = nn.BatchNorm2d(planes)
- if not stride == 1:
- self.norm4 = nn.BatchNorm2d(planes)
-
- elif norm_fn == 'instance':
- self.norm1 = nn.InstanceNorm2d(planes//4)
- self.norm2 = nn.InstanceNorm2d(planes//4)
- self.norm3 = nn.InstanceNorm2d(planes)
- if not stride == 1:
- self.norm4 = nn.InstanceNorm2d(planes)
-
- elif norm_fn == 'none':
- self.norm1 = nn.Sequential()
- self.norm2 = nn.Sequential()
- self.norm3 = nn.Sequential()
- if not stride == 1:
- self.norm4 = nn.Sequential()
-
- if stride == 1:
- self.downsample = None
-
- else:
- self.downsample = nn.Sequential(
- nn.Conv2d(in_planes, planes, kernel_size=1, stride=stride), self.norm4)
-
-
- def forward(self, x):
- y = x
- y = self.relu(self.norm1(self.conv1(y)))
- y = self.relu(self.norm2(self.conv2(y)))
- y = self.relu(self.norm3(self.conv3(y)))
-
- if self.downsample is not None:
- x = self.downsample(x)
-
- return self.relu(x+y)
-
-class BasicEncoder(nn.Module):
- def __init__(self, output_dim=128, norm_fn='batch', dropout=0.0):
- super(BasicEncoder, self).__init__()
- self.norm_fn = norm_fn
-
- if self.norm_fn == 'group':
- self.norm1 = nn.GroupNorm(num_groups=8, num_channels=64)
-
- elif self.norm_fn == 'batch':
- self.norm1 = nn.BatchNorm2d(64)
-
- elif self.norm_fn == 'instance':
- self.norm1 = nn.InstanceNorm2d(64)
-
- elif self.norm_fn == 'none':
- self.norm1 = nn.Sequential()
-
- self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3)
- self.relu1 = nn.ReLU(inplace=True)
-
- self.in_planes = 64
- self.layer1 = self._make_layer(64, stride=1)
- self.layer2 = self._make_layer(96, stride=2)
- self.layer3 = self._make_layer(128, stride=2)
-
- # output convolution
- self.conv2 = nn.Conv2d(128, output_dim, kernel_size=1)
-
- self.dropout = None
- if dropout > 0:
- self.dropout = nn.Dropout2d(p=dropout)
-
- for m in self.modules():
- if isinstance(m, nn.Conv2d):
- nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
- elif isinstance(m, (nn.BatchNorm2d, nn.InstanceNorm2d, nn.GroupNorm)):
- if m.weight is not None:
- nn.init.constant_(m.weight, 1)
- if m.bias is not None:
- nn.init.constant_(m.bias, 0)
-
- def _make_layer(self, dim, stride=1):
- layer1 = ResidualBlock(self.in_planes, dim, self.norm_fn, stride=stride)
- layer2 = ResidualBlock(dim, dim, self.norm_fn, stride=1)
- layers = (layer1, layer2)
-
- self.in_planes = dim
- return nn.Sequential(*layers)
-
-
- def forward(self, x):
-
- # if input is list, combine batch dimension
- is_list = isinstance(x, tuple) or isinstance(x, list)
- if is_list:
- batch_dim = x[0].shape[0]
- x = torch.cat(x, dim=0)
-
- x = self.conv1(x)
- x = self.norm1(x)
- x = self.relu1(x)
-
- x = self.layer1(x)
- x = self.layer2(x)
- x = self.layer3(x)
-
- x = self.conv2(x)
-
- if self.training and self.dropout is not None:
- x = self.dropout(x)
-
- if is_list:
- x = torch.split(x, [batch_dim, batch_dim], dim=0)
-
- return x
-
-
-class SmallEncoder(nn.Module):
- def __init__(self, output_dim=128, norm_fn='batch', dropout=0.0):
- super(SmallEncoder, self).__init__()
- self.norm_fn = norm_fn
-
- if self.norm_fn == 'group':
- self.norm1 = nn.GroupNorm(num_groups=8, num_channels=32)
-
- elif self.norm_fn == 'batch':
- self.norm1 = nn.BatchNorm2d(32)
-
- elif self.norm_fn == 'instance':
- self.norm1 = nn.InstanceNorm2d(32)
-
- elif self.norm_fn == 'none':
- self.norm1 = nn.Sequential()
-
- self.conv1 = nn.Conv2d(3, 32, kernel_size=7, stride=2, padding=3)
- self.relu1 = nn.ReLU(inplace=True)
-
- self.in_planes = 32
- self.layer1 = self._make_layer(32, stride=1)
- self.layer2 = self._make_layer(64, stride=2)
- self.layer3 = self._make_layer(96, stride=2)
-
- self.dropout = None
- if dropout > 0:
- self.dropout = nn.Dropout2d(p=dropout)
-
- self.conv2 = nn.Conv2d(96, output_dim, kernel_size=1)
-
- for m in self.modules():
- if isinstance(m, nn.Conv2d):
- nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
- elif isinstance(m, (nn.BatchNorm2d, nn.InstanceNorm2d, nn.GroupNorm)):
- if m.weight is not None:
- nn.init.constant_(m.weight, 1)
- if m.bias is not None:
- nn.init.constant_(m.bias, 0)
-
- def _make_layer(self, dim, stride=1):
- layer1 = BottleneckBlock(self.in_planes, dim, self.norm_fn, stride=stride)
- layer2 = BottleneckBlock(dim, dim, self.norm_fn, stride=1)
- layers = (layer1, layer2)
-
- self.in_planes = dim
- return nn.Sequential(*layers)
-
-
- def forward(self, x):
-
- # if input is list, combine batch dimension
- is_list = isinstance(x, tuple) or isinstance(x, list)
- if is_list:
- batch_dim = x[0].shape[0]
- x = torch.cat(x, dim=0)
-
- x = self.conv1(x)
- x = self.norm1(x)
- x = self.relu1(x)
-
- x = self.layer1(x)
- x = self.layer2(x)
- x = self.layer3(x)
- x = self.conv2(x)
-
- if self.training and self.dropout is not None:
- x = self.dropout(x)
-
- if is_list:
- x = torch.split(x, [batch_dim, batch_dim], dim=0)
-
- return x
diff --git a/spaces/Pattr/DrumClassification/lilypond-2.24.2/lib/lilypond/2.24.2/ccache/lily/font-encodings.go b/spaces/Pattr/DrumClassification/lilypond-2.24.2/lib/lilypond/2.24.2/ccache/lily/font-encodings.go
deleted file mode 100644
index 825c989540a5a15236795b85e29fdce7b8f4af7e..0000000000000000000000000000000000000000
Binary files a/spaces/Pattr/DrumClassification/lilypond-2.24.2/lib/lilypond/2.24.2/ccache/lily/font-encodings.go and /dev/null differ
diff --git a/spaces/Proxdigestpills1/README/README.md b/spaces/Proxdigestpills1/README/README.md
deleted file mode 100644
index 123b6fe172b61efe12ce67aee1e4830d3c1dbd91..0000000000000000000000000000000000000000
--- a/spaces/Proxdigestpills1/README/README.md
+++ /dev/null
@@ -1,163 +0,0 @@
-[.png)](https://www.glitco.com/get-pro-x-digest)
-
-What is Pro X Digest?
-=====================
-
-Pro X Digest is a digestive health supplement featuring a blend of enzymes, probiotics, and other ingredients to support healthy digestion.
-
-Millions of people are diagnosed with a digestive disorder each year. As you get older, your risk of developing a digestive disorder increases.
-
-Pro X Digest claims to help by using a blend of natural ingredients to target the root cause of digestive discomfort. The blend of enzymes and probiotics can make it easier to break down food, helping your body digest everything you eat.
-
-Pro X Digest is made in the United States in an FDA-registered, GMP-certified facility. The manufacturer is based in West Jordan, Utah.
-
-**Pro X Digest Benefits**
--------------------------
-
-Pro X Digest contains a blend of digestive enzymes and probiotics to support healthy digestion, immunity, and overall health and wellness.
-
-### **[Here are some of the benefits of Pro X Digest, according to the official website:](https://www.glitco.com/get-pro-x-digest)**
-
- All natural way to help with your digestive system
-
- Keep your digestive system healthy and regular
-
- Natural digestive enzymes to break down proteins, fats, oils, and carbs
-
- Natural probiotics to support good bacteria, immune function, and overall gut health
-
- Backed by 60 day moneyback guarantee
-
- Made in the United States in FDA-registered, GMP-certified facility
-
-Order your supply of Pro X Digest now and start enjoying the benefits!
-
-**How Does Pro X Digest Work?**
--------------------------------
-
-Pro X Digest works using a blend of two main categories of ingredients: digestive enzymes and probiotics. The two ingredients work in different ways to support good digestion.
-
-Digestive enzymes, for example, help to break down the food you eat and extract its nutritional value. If you don’t have sufficient levels of digestive enzymes, then your body struggles to break down certain foods.
-
-Many people feel bloated after a protein-rich meal or protein shake, for example. This could be due to a lack of protease, a digestive enzyme to help break down protein. Others feel bloated or uncomfortable after dairy products, which could be caused by a lack of the lactase enzyme, which helps to break down the lactose protein in dairy.
-
-In addition to digestive enzymes, Pro X Digest contains probiotics, or good gut bacteria to help your gut flourish. A healthy gut is filled with billions of living bacteria that contribute to immunity, food breakdown, and overall gut wellness. People with poor gut health tend to have a less diverse gut microbiome than others. People with strong gut health tend to have thriving levels of billions of probiotic bacteria.
-
-Overall, Pro X Digest contains a blend of proven ingredients to target digestion in multiple ways. There are 3 probiotic strains, 7 digestive enzymes, and 1 fungi to help support digestive health and overall digestive balance.
-
-### **[Also Read: What Do You Mean by Gut Health Or Probiotic Supplements?](https://www.glitco.com/get-pro-x-digest)**
-
-**Pro X Digest Ingredients**
-----------------------------
-
-Pro X Digest contains a blend of two categories of ingredients: digestive enzymes and probiotic supplements.
-
-Digestive enzymes help to break down the foods you eat, while probiotics help your gut maintain a healthy balance overall. Enzymes can help extract nutrients, while probiotics can support immunity, weight loss, energy, metabolism, and other features linked to digestion.
-
-All three probiotics in Pro X Digest are part of the Lactobacillus family, including L. acidophilus, L. casei, and L. plantarum.
-
-Here are all of the ingredients in Pro X Digest and how they work, according to the manufacture:
-
-### [**Click here to order while supplies last!**](https://www.glitco.com/get-pro-x-digest)
-
-**Lactobacillus Acidophilus:** Lactobacillus acidophilus promotes the growth of good bacteria and helps treat digestive disorders, according to the manufacturer. Common digestive disorders include irritable bowel syndrome (IBS) or indigestion. Some also have poor probiotic balance because of Crohn’s disease, celiac disease, lactose intolerance, or other conditions. Although L. acidophilus can’t help with all of these, it’s found in many probiotic supplements and prized for its effects on overall gut balance.
-
-**Lactobacillus Casei:** Lactobacillus casei is a common probiotic found in your digestive tract. Like other probiotics, L. casei is considered friendly because it plays a valuable role in digestion and immunity. One study found L. casei increased the activity of natural killer (NK) cells, for example, while other studies have linked L. casei to general digestive health and discomfort.
-
-**Lactobacillus Plantarum:** The third probiotic strain in Pro X Digest and the third member of the Lactobacillus family, L. plantarum can improve cognitive function and help with gut immunity, according to the manufacturer. Over 70% of your immune system is found in your gut. If your gut bacteria are imbalanced, then your body’s immune system may struggle to defend itself. You need a balanced gut and thriving microflora to maintain good immunity, and Lactobacillus plantarum could help with that.
-
-**Bromelain**: Bromelain is a digestive enzyme found in pineapple. Many nutritional supplements contain bromelain from pineapple for its effects on digestion and the overall breakdown of food. Studies have linked bromelain to a range of effects – from weight loss to immune function. Today, many people take bromelain supplements daily for overall health and wellness.
-
-**Papain**: Papain is a digestive enzyme similar to bromelain. However, instead of coming from pineapple, papain comes from papaya. Papain can break down food for better digestion while helping to relieve bloating, constipation, and gas, according to the makers of Pro X Digest.
-
-**Aspergillus Oryzae:** Aspergillus oryzae is a fungus or mold used in food manufacturing in East Asia. It’s particularly common in fermented foods in Japan and China, for example. The makers of Pro X Digest added this unique ingredient to the formula to improve cognitive function and aid gut immunity. According to the manufacturer, the mold can support brain health and gut immunity, working in a similar way to probiotics.
-
-**Protease**: Pro X Digest contains protease, an enzyme designed to break down proteins. If you feel bloated or uncomfortable after eating protein, then you may need more protease. Pro X Digest can help your body break down protein, process its nutritional value, and absorb the maximum amount of protein from your foods.
-
-**Lipase**: Pro X Digest contains lipase, an enzyme to break down fats and oils. Many people feel bloated after eating a meal high in fats and oils. Pro X Digest can help by giving you a strong dose of lipase. Your body normally makes lipase in your pancreas. However, your salivary (spit) glands and stomach also produce lipase. As food enters your mouth, travels through your stomach, and enters your digestive tract, lipase helps to break down food along the way. As Mount Sinai explains, studies show lipase supplements can help reduce bloating, gas, and fullness after large meals.
-
-**Amylase**: Pro X Digest contains amylase, an enzyme to break down carbs. Like lipase and protease, amylase is designed to help your body process a specific type of ingredient: carbs. Your body produces amylase from its pancreas and salivary glands. Like lipase, amylase helps to break down food as it travels from your mouth throughout your digestive tract. Some people undergo amylase testing if unsure about the cause of their digestive problems.
-
-**Lactase:** Pro X Digest contains lactase, an enzyme that breaks down dairy. Some people naturally have less lactase than others, making it difficult to digest the lactose, or milk sugars, in dairy foods and beverages. Pro X Digest can help by breaking down these milk sugars to help you digest milk products more efficiently. Even if you don’t consume dairy, lactase can contribute to overall digestive comfort.
-
-**Alpha Galactosidase:** Pro X Digest contains alpha galactosidase, an enzyme involved in the metabolism of glycolipids, a specific type of fat that may contribute to digestive discomfort. A 2007 study showed alpha galactosidase supplementation led to a significant reduction in gas after a large meal.
-
-The makers of Pro X Digest claim all ingredients are tested by third-party labs to verify purity and potency. The company also assembles all ingredients together in the United States at an FDA-registered, GMP-certified facility.
-
-**[(Limited Supply) Order Pro X Digest Before Supplies Run Out!!](https://www.glitco.com/get-pro-x-digest)**
-
-Scientific Evidence for Pro X Digest
-------------------------------------
-
-As proof Pro X Digest works, the company cites several studies linking each of the ingredients to various health effects. We’ll review some of that scientific evidence below to validate the claims made on the **[Pro X Digest website.](https://www.npmjs.com/package/pro-x-digest-buy-official-site)**
-
-Pro X Digest contains alpha galactosidase, a digestive enzyme linked to health and wellness. In a 2000 study, researchers found the enzyme could play a valuable role in enzyme therapy. By taking alpha galactosidase enzymes from healthy adults and giving them to patients with enzyme deficiency, researchers found they could restore normal levels of enzymes. Alpha galactosidase appears to be particularly important for breaking down carbs.
-
-Lactobacillus casei has a long history of use as a probiotic supplement and overall digestive aid. In a 2019 study published in Nutrients, researchers found Lactobacillus casei could be beneficial for modulating gut microbiota. Researchers found people who took a L. casei supplement – like Pro X Digest – tended to have higher levels of L. casei in their system after taking the supplement, and those higher levels were linked to lower rates of diarrhea and other digestive issues.
-
-Lactobacillus acidophilus is backed by similar studies. A 2020 study found Lactobacillus acidophilus could help manage gastrointestinal disorders. Researchers found ample evidence L. acidophilus could help with acute diarrhea, chronic diarrhea, antibiotic-associated digestive problems, and even immune problems linked to the gut, among other benefits.
-
-As the National Center for Complementary and Integrative Health explains, bromelain is a group of enzymes found in the fruit and stem of the pineapple plant. Today, some take bromelain to reduce pain and swelling. Others take it for digestive problems. Some early studies have linked bromelain to promising digestive effects, although we need more research to conclusively make this connection.
-
-Aspergillus oryzae is one of the more unique ingredients in Pro X Digest. You can find plenty of digestive enzyme supplements and probiotic formulas online. However, aspergillus oryzae fills a more unique role. Also known as koji mold, A. oryzae is commonly used in food manufacturing. A 1999 study found the ingredient was commonly used in sake, miso, and soy sauce production in Japan, for example, describing its role as “pivotal” in food manufacturing. According to the makers of Pro X Digest, this same koji mold has powerful effects on cognition and digestion.
-
-Overall, Pro X Digest contains a blend of science-backed digestive enzymes and probiotics designed to support gut health in multiple ways. Although we don’t know specific dose or concentration information, Pro X Digest could work to support gut health by breaking down food, boosting immunity, and helping your digestive system function like normal.
-
-**[Place your order today by clicking here before stock runs out! >>>](https://www.glitco.com/get-pro-x-digest)**
-
-**How to Take Pro X Digest**
-----------------------------
-
-The makers of Pro X Digest recommend taking one capsule of Pro X Digest twice a day. Or, for best results, take it 20 to 30 minutes before a meal:
-
- Take 1 capsule (1 serving) of Pro X Digest 2 times per day
-
- For best results, take Pro X Digest 20 to 30 minutes before a meal
-
-Pro X Digest Pricing
---------------------
-
-Pro X Digest is normally priced at $199 per bottle. As part of a 2023 promotion, however, the manufacturer has reduced the price to just $59 per bottle. You can save even more money by ordering multiple bottles, which drops the price to $39 per bottle and comes bundled with free bonuses.
-
-[.png)](https://www.glitco.com/get-pro-x-digest)
-
-### **Here’s how pricing works when ordering online today:**
-
- 1 Bottle: $59 + Shipping
-
- 3 Bottles: $147 ($49 Per Bottle) + 1 Free Bonus + Shipping
-
- 6 Bottles: $234 ($39 Per Bottle) + 1 Free Bonus + Free Shipping
-
-#### **Order Pro X Digest Right Here At The Best Prices!!**
-
-Each bottle contains a 30 day supply of Pro X Digest, or 30 servings. You take one serving daily to help with digestion.
-
-Pro X Digest Refund Policy
---------------------------
-
-Pro X Digest comes with a 60 day moneyback guarantee. You can request a refund on your purchase within 60 days with no questions asked if you’re unhappy with the supplement for any reason.
-
-**Returns Address: Health Heroes 8152 S. Welby Park Dr Ste B, West Jordan, UT 84088**
-
-**About Health Heroes**
------------------------
-
-Pro X Digest is made in the United States in an FDA-registered, GMP-certified facility by a Utah-based company named Health Heroes. The company manufactures the supplement using natural ingredients.
-
-**You can contact the makers of Pro X Digest and the company’s customer service team via the following:**
-
- Email: [support@proxdigest.com](https://www.glitco.com/get-pro-x-digest)
-
- Phone: 702-859-3292
-
- Registered Address: Health Heroes 8152 S. Welby Park Dr Ste B, West Jordan, UT 84088
-
-**Final Word**
---------------
-
-Pro X Digest is a digestive health supplement available exclusively online. Made by a West Jordan, Utah-based company, Pro X Digest features a blend of digestive enzymes and probiotics to support gut health.
-
-Millions of Americans deal with bloating and digestive discomfort after meals. In many cases, these problems are linked to low digestive enzyme levels or poor probiotic balance. Pro X Digest aims to solve both of these issues.
-
-To learn more about Pro X Digest and how it works or to buy the digestive health supplement today, **[visit the official website.](https://www.glitco.com/get-pro-x-digest)**
\ No newline at end of file
diff --git a/spaces/Raghav001/Experiment/README.md b/spaces/Raghav001/Experiment/README.md
deleted file mode 100644
index e055b5bb6296ba8cee13d0d5f89ae23c87b9a390..0000000000000000000000000000000000000000
--- a/spaces/Raghav001/Experiment/README.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-title: ChatPDF
-emoji: 💻
-colorFrom: gray
-colorTo: yellow
-sdk: gradio
-sdk_version: 3.20.0
-app_file: app.py
-pinned: false
-license: apache-2.0
-duplicated_from: Raghav001/DocTalk
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/Rami/validate_chat_utd/README.md b/spaces/Rami/validate_chat_utd/README.md
deleted file mode 100644
index c80ed2fa95b5cf379345a87e4a8f9da0c9a99857..0000000000000000000000000000000000000000
--- a/spaces/Rami/validate_chat_utd/README.md
+++ /dev/null
@@ -1,11 +0,0 @@
----
-title: Validate Chat Utd
-emoji: 🌍
-colorFrom: green
-colorTo: yellow
-sdk: docker
-pinned: false
-license: openrail
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pip/_vendor/pygments/formatters/svg.py b/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pip/_vendor/pygments/formatters/svg.py
deleted file mode 100644
index 075150a4b586d668c1666513fbf90463cdbb11ab..0000000000000000000000000000000000000000
--- a/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pip/_vendor/pygments/formatters/svg.py
+++ /dev/null
@@ -1,188 +0,0 @@
-"""
- pygments.formatters.svg
- ~~~~~~~~~~~~~~~~~~~~~~~
-
- Formatter for SVG output.
-
- :copyright: Copyright 2006-2022 by the Pygments team, see AUTHORS.
- :license: BSD, see LICENSE for details.
-"""
-
-from pip._vendor.pygments.formatter import Formatter
-from pip._vendor.pygments.token import Comment
-from pip._vendor.pygments.util import get_bool_opt, get_int_opt
-
-__all__ = ['SvgFormatter']
-
-
-def escape_html(text):
- """Escape &, <, > as well as single and double quotes for HTML."""
- return text.replace('&', '&'). \
- replace('<', '<'). \
- replace('>', '>'). \
- replace('"', '"'). \
- replace("'", ''')
-
-
-class2style = {}
-
-class SvgFormatter(Formatter):
- """
- Format tokens as an SVG graphics file. This formatter is still experimental.
- Each line of code is a ```` element with explicit ``x`` and ``y``
- coordinates containing ```` elements with the individual token styles.
-
- By default, this formatter outputs a full SVG document including doctype
- declaration and the ``' or ''
- value = escape_html(value)
- if self.spacehack:
- value = value.expandtabs().replace(' ', ' ')
- parts = value.split('\n')
- for part in parts[:-1]:
- outfile.write(tspan + part + tspanend)
- y += self.ystep
- outfile.write('\n')
- if self.linenos and counter % counter_step == 0:
- outfile.write('%s' %
- (x+self.linenowidth,y,counter_style,counter))
-
- counter += 1
- outfile.write('' % (line_x,y))
- outfile.write(tspan + parts[-1] + tspanend)
- outfile.write('')
-
- if not self.nowrap:
- outfile.write('\n')
-
- def _get_style(self, tokentype):
- if tokentype in self._stylecache:
- return self._stylecache[tokentype]
- otokentype = tokentype
- while not self.style.styles_token(tokentype):
- tokentype = tokentype.parent
- value = self.style.style_for_token(tokentype)
- result = ''
- if value['color']:
- result = ' fill="#' + value['color'] + '"'
- if value['bold']:
- result += ' font-weight="bold"'
- if value['italic']:
- result += ' font-style="italic"'
- self._stylecache[otokentype] = result
- return result
diff --git a/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pip/_vendor/rich/style.py b/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pip/_vendor/rich/style.py
deleted file mode 100644
index b2e8aff71f50d0d308e3bcb206508912738029ad..0000000000000000000000000000000000000000
--- a/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pip/_vendor/rich/style.py
+++ /dev/null
@@ -1,771 +0,0 @@
-import sys
-from functools import lru_cache
-from marshal import dumps, loads
-from random import randint
-from typing import Any, Dict, Iterable, List, Optional, Type, Union, cast
-
-from . import errors
-from .color import Color, ColorParseError, ColorSystem, blend_rgb
-from .repr import Result, rich_repr
-from .terminal_theme import DEFAULT_TERMINAL_THEME, TerminalTheme
-
-# Style instances and style definitions are often interchangeable
-StyleType = Union[str, "Style"]
-
-
-class _Bit:
- """A descriptor to get/set a style attribute bit."""
-
- __slots__ = ["bit"]
-
- def __init__(self, bit_no: int) -> None:
- self.bit = 1 << bit_no
-
- def __get__(self, obj: "Style", objtype: Type["Style"]) -> Optional[bool]:
- if obj._set_attributes & self.bit:
- return obj._attributes & self.bit != 0
- return None
-
-
-@rich_repr
-class Style:
- """A terminal style.
-
- A terminal style consists of a color (`color`), a background color (`bgcolor`), and a number of attributes, such
- as bold, italic etc. The attributes have 3 states: they can either be on
- (``True``), off (``False``), or not set (``None``).
-
- Args:
- color (Union[Color, str], optional): Color of terminal text. Defaults to None.
- bgcolor (Union[Color, str], optional): Color of terminal background. Defaults to None.
- bold (bool, optional): Enable bold text. Defaults to None.
- dim (bool, optional): Enable dim text. Defaults to None.
- italic (bool, optional): Enable italic text. Defaults to None.
- underline (bool, optional): Enable underlined text. Defaults to None.
- blink (bool, optional): Enabled blinking text. Defaults to None.
- blink2 (bool, optional): Enable fast blinking text. Defaults to None.
- reverse (bool, optional): Enabled reverse text. Defaults to None.
- conceal (bool, optional): Enable concealed text. Defaults to None.
- strike (bool, optional): Enable strikethrough text. Defaults to None.
- underline2 (bool, optional): Enable doubly underlined text. Defaults to None.
- frame (bool, optional): Enable framed text. Defaults to None.
- encircle (bool, optional): Enable encircled text. Defaults to None.
- overline (bool, optional): Enable overlined text. Defaults to None.
- link (str, link): Link URL. Defaults to None.
-
- """
-
- _color: Optional[Color]
- _bgcolor: Optional[Color]
- _attributes: int
- _set_attributes: int
- _hash: Optional[int]
- _null: bool
- _meta: Optional[bytes]
-
- __slots__ = [
- "_color",
- "_bgcolor",
- "_attributes",
- "_set_attributes",
- "_link",
- "_link_id",
- "_ansi",
- "_style_definition",
- "_hash",
- "_null",
- "_meta",
- ]
-
- # maps bits on to SGR parameter
- _style_map = {
- 0: "1",
- 1: "2",
- 2: "3",
- 3: "4",
- 4: "5",
- 5: "6",
- 6: "7",
- 7: "8",
- 8: "9",
- 9: "21",
- 10: "51",
- 11: "52",
- 12: "53",
- }
-
- STYLE_ATTRIBUTES = {
- "dim": "dim",
- "d": "dim",
- "bold": "bold",
- "b": "bold",
- "italic": "italic",
- "i": "italic",
- "underline": "underline",
- "u": "underline",
- "blink": "blink",
- "blink2": "blink2",
- "reverse": "reverse",
- "r": "reverse",
- "conceal": "conceal",
- "c": "conceal",
- "strike": "strike",
- "s": "strike",
- "underline2": "underline2",
- "uu": "underline2",
- "frame": "frame",
- "encircle": "encircle",
- "overline": "overline",
- "o": "overline",
- }
-
- def __init__(
- self,
- *,
- color: Optional[Union[Color, str]] = None,
- bgcolor: Optional[Union[Color, str]] = None,
- bold: Optional[bool] = None,
- dim: Optional[bool] = None,
- italic: Optional[bool] = None,
- underline: Optional[bool] = None,
- blink: Optional[bool] = None,
- blink2: Optional[bool] = None,
- reverse: Optional[bool] = None,
- conceal: Optional[bool] = None,
- strike: Optional[bool] = None,
- underline2: Optional[bool] = None,
- frame: Optional[bool] = None,
- encircle: Optional[bool] = None,
- overline: Optional[bool] = None,
- link: Optional[str] = None,
- meta: Optional[Dict[str, Any]] = None,
- ):
- self._ansi: Optional[str] = None
- self._style_definition: Optional[str] = None
-
- def _make_color(color: Union[Color, str]) -> Color:
- return color if isinstance(color, Color) else Color.parse(color)
-
- self._color = None if color is None else _make_color(color)
- self._bgcolor = None if bgcolor is None else _make_color(bgcolor)
- self._set_attributes = sum(
- (
- bold is not None,
- dim is not None and 2,
- italic is not None and 4,
- underline is not None and 8,
- blink is not None and 16,
- blink2 is not None and 32,
- reverse is not None and 64,
- conceal is not None and 128,
- strike is not None and 256,
- underline2 is not None and 512,
- frame is not None and 1024,
- encircle is not None and 2048,
- overline is not None and 4096,
- )
- )
- self._attributes = (
- sum(
- (
- bold and 1 or 0,
- dim and 2 or 0,
- italic and 4 or 0,
- underline and 8 or 0,
- blink and 16 or 0,
- blink2 and 32 or 0,
- reverse and 64 or 0,
- conceal and 128 or 0,
- strike and 256 or 0,
- underline2 and 512 or 0,
- frame and 1024 or 0,
- encircle and 2048 or 0,
- overline and 4096 or 0,
- )
- )
- if self._set_attributes
- else 0
- )
-
- self._link = link
- self._link_id = f"{randint(0, 999999)}" if link else ""
- self._meta = None if meta is None else dumps(meta)
- self._hash: Optional[int] = None
- self._null = not (self._set_attributes or color or bgcolor or link or meta)
-
- @classmethod
- def null(cls) -> "Style":
- """Create an 'null' style, equivalent to Style(), but more performant."""
- return NULL_STYLE
-
- @classmethod
- def from_color(
- cls, color: Optional[Color] = None, bgcolor: Optional[Color] = None
- ) -> "Style":
- """Create a new style with colors and no attributes.
-
- Returns:
- color (Optional[Color]): A (foreground) color, or None for no color. Defaults to None.
- bgcolor (Optional[Color]): A (background) color, or None for no color. Defaults to None.
- """
- style: Style = cls.__new__(Style)
- style._ansi = None
- style._style_definition = None
- style._color = color
- style._bgcolor = bgcolor
- style._set_attributes = 0
- style._attributes = 0
- style._link = None
- style._link_id = ""
- style._meta = None
- style._null = not (color or bgcolor)
- style._hash = None
- return style
-
- @classmethod
- def from_meta(cls, meta: Optional[Dict[str, Any]]) -> "Style":
- """Create a new style with meta data.
-
- Returns:
- meta (Optional[Dict[str, Any]]): A dictionary of meta data. Defaults to None.
- """
- style: Style = cls.__new__(Style)
- style._ansi = None
- style._style_definition = None
- style._color = None
- style._bgcolor = None
- style._set_attributes = 0
- style._attributes = 0
- style._link = None
- style._link_id = ""
- style._meta = dumps(meta)
- style._hash = None
- style._null = not (meta)
- return style
-
- @classmethod
- def on(cls, meta: Optional[Dict[str, Any]] = None, **handlers: Any) -> "Style":
- """Create a blank style with meta information.
-
- Example:
- style = Style.on(click=self.on_click)
-
- Args:
- meta (Optional[Dict[str, Any]], optional): An optional dict of meta information.
- **handlers (Any): Keyword arguments are translated in to handlers.
-
- Returns:
- Style: A Style with meta information attached.
- """
- meta = {} if meta is None else meta
- meta.update({f"@{key}": value for key, value in handlers.items()})
- return cls.from_meta(meta)
-
- bold = _Bit(0)
- dim = _Bit(1)
- italic = _Bit(2)
- underline = _Bit(3)
- blink = _Bit(4)
- blink2 = _Bit(5)
- reverse = _Bit(6)
- conceal = _Bit(7)
- strike = _Bit(8)
- underline2 = _Bit(9)
- frame = _Bit(10)
- encircle = _Bit(11)
- overline = _Bit(12)
-
- @property
- def link_id(self) -> str:
- """Get a link id, used in ansi code for links."""
- return self._link_id
-
- def __str__(self) -> str:
- """Re-generate style definition from attributes."""
- if self._style_definition is None:
- attributes: List[str] = []
- append = attributes.append
- bits = self._set_attributes
- if bits & 0b0000000001111:
- if bits & 1:
- append("bold" if self.bold else "not bold")
- if bits & (1 << 1):
- append("dim" if self.dim else "not dim")
- if bits & (1 << 2):
- append("italic" if self.italic else "not italic")
- if bits & (1 << 3):
- append("underline" if self.underline else "not underline")
- if bits & 0b0000111110000:
- if bits & (1 << 4):
- append("blink" if self.blink else "not blink")
- if bits & (1 << 5):
- append("blink2" if self.blink2 else "not blink2")
- if bits & (1 << 6):
- append("reverse" if self.reverse else "not reverse")
- if bits & (1 << 7):
- append("conceal" if self.conceal else "not conceal")
- if bits & (1 << 8):
- append("strike" if self.strike else "not strike")
- if bits & 0b1111000000000:
- if bits & (1 << 9):
- append("underline2" if self.underline2 else "not underline2")
- if bits & (1 << 10):
- append("frame" if self.frame else "not frame")
- if bits & (1 << 11):
- append("encircle" if self.encircle else "not encircle")
- if bits & (1 << 12):
- append("overline" if self.overline else "not overline")
- if self._color is not None:
- append(self._color.name)
- if self._bgcolor is not None:
- append("on")
- append(self._bgcolor.name)
- if self._link:
- append("link")
- append(self._link)
- self._style_definition = " ".join(attributes) or "none"
- return self._style_definition
-
- def __bool__(self) -> bool:
- """A Style is false if it has no attributes, colors, or links."""
- return not self._null
-
- def _make_ansi_codes(self, color_system: ColorSystem) -> str:
- """Generate ANSI codes for this style.
-
- Args:
- color_system (ColorSystem): Color system.
-
- Returns:
- str: String containing codes.
- """
-
- if self._ansi is None:
- sgr: List[str] = []
- append = sgr.append
- _style_map = self._style_map
- attributes = self._attributes & self._set_attributes
- if attributes:
- if attributes & 1:
- append(_style_map[0])
- if attributes & 2:
- append(_style_map[1])
- if attributes & 4:
- append(_style_map[2])
- if attributes & 8:
- append(_style_map[3])
- if attributes & 0b0000111110000:
- for bit in range(4, 9):
- if attributes & (1 << bit):
- append(_style_map[bit])
- if attributes & 0b1111000000000:
- for bit in range(9, 13):
- if attributes & (1 << bit):
- append(_style_map[bit])
- if self._color is not None:
- sgr.extend(self._color.downgrade(color_system).get_ansi_codes())
- if self._bgcolor is not None:
- sgr.extend(
- self._bgcolor.downgrade(color_system).get_ansi_codes(
- foreground=False
- )
- )
- self._ansi = ";".join(sgr)
- return self._ansi
-
- @classmethod
- @lru_cache(maxsize=1024)
- def normalize(cls, style: str) -> str:
- """Normalize a style definition so that styles with the same effect have the same string
- representation.
-
- Args:
- style (str): A style definition.
-
- Returns:
- str: Normal form of style definition.
- """
- try:
- return str(cls.parse(style))
- except errors.StyleSyntaxError:
- return style.strip().lower()
-
- @classmethod
- def pick_first(cls, *values: Optional[StyleType]) -> StyleType:
- """Pick first non-None style."""
- for value in values:
- if value is not None:
- return value
- raise ValueError("expected at least one non-None style")
-
- def __rich_repr__(self) -> Result:
- yield "color", self.color, None
- yield "bgcolor", self.bgcolor, None
- yield "bold", self.bold, None,
- yield "dim", self.dim, None,
- yield "italic", self.italic, None
- yield "underline", self.underline, None,
- yield "blink", self.blink, None
- yield "blink2", self.blink2, None
- yield "reverse", self.reverse, None
- yield "conceal", self.conceal, None
- yield "strike", self.strike, None
- yield "underline2", self.underline2, None
- yield "frame", self.frame, None
- yield "encircle", self.encircle, None
- yield "link", self.link, None
- if self._meta:
- yield "meta", self.meta
-
- def __eq__(self, other: Any) -> bool:
- if not isinstance(other, Style):
- return NotImplemented
- return self.__hash__() == other.__hash__()
-
- def __ne__(self, other: Any) -> bool:
- if not isinstance(other, Style):
- return NotImplemented
- return self.__hash__() != other.__hash__()
-
- def __hash__(self) -> int:
- if self._hash is not None:
- return self._hash
- self._hash = hash(
- (
- self._color,
- self._bgcolor,
- self._attributes,
- self._set_attributes,
- self._link,
- self._meta,
- )
- )
- return self._hash
-
- @property
- def color(self) -> Optional[Color]:
- """The foreground color or None if it is not set."""
- return self._color
-
- @property
- def bgcolor(self) -> Optional[Color]:
- """The background color or None if it is not set."""
- return self._bgcolor
-
- @property
- def link(self) -> Optional[str]:
- """Link text, if set."""
- return self._link
-
- @property
- def transparent_background(self) -> bool:
- """Check if the style specified a transparent background."""
- return self.bgcolor is None or self.bgcolor.is_default
-
- @property
- def background_style(self) -> "Style":
- """A Style with background only."""
- return Style(bgcolor=self.bgcolor)
-
- @property
- def meta(self) -> Dict[str, Any]:
- """Get meta information (can not be changed after construction)."""
- return {} if self._meta is None else cast(Dict[str, Any], loads(self._meta))
-
- @property
- def without_color(self) -> "Style":
- """Get a copy of the style with color removed."""
- if self._null:
- return NULL_STYLE
- style: Style = self.__new__(Style)
- style._ansi = None
- style._style_definition = None
- style._color = None
- style._bgcolor = None
- style._attributes = self._attributes
- style._set_attributes = self._set_attributes
- style._link = self._link
- style._link_id = f"{randint(0, 999999)}" if self._link else ""
- style._null = False
- style._meta = None
- style._hash = None
- return style
-
- @classmethod
- @lru_cache(maxsize=4096)
- def parse(cls, style_definition: str) -> "Style":
- """Parse a style definition.
-
- Args:
- style_definition (str): A string containing a style.
-
- Raises:
- errors.StyleSyntaxError: If the style definition syntax is invalid.
-
- Returns:
- `Style`: A Style instance.
- """
- if style_definition.strip() == "none" or not style_definition:
- return cls.null()
-
- STYLE_ATTRIBUTES = cls.STYLE_ATTRIBUTES
- color: Optional[str] = None
- bgcolor: Optional[str] = None
- attributes: Dict[str, Optional[Any]] = {}
- link: Optional[str] = None
-
- words = iter(style_definition.split())
- for original_word in words:
- word = original_word.lower()
- if word == "on":
- word = next(words, "")
- if not word:
- raise errors.StyleSyntaxError("color expected after 'on'")
- try:
- Color.parse(word) is None
- except ColorParseError as error:
- raise errors.StyleSyntaxError(
- f"unable to parse {word!r} as background color; {error}"
- ) from None
- bgcolor = word
-
- elif word == "not":
- word = next(words, "")
- attribute = STYLE_ATTRIBUTES.get(word)
- if attribute is None:
- raise errors.StyleSyntaxError(
- f"expected style attribute after 'not', found {word!r}"
- )
- attributes[attribute] = False
-
- elif word == "link":
- word = next(words, "")
- if not word:
- raise errors.StyleSyntaxError("URL expected after 'link'")
- link = word
-
- elif word in STYLE_ATTRIBUTES:
- attributes[STYLE_ATTRIBUTES[word]] = True
-
- else:
- try:
- Color.parse(word)
- except ColorParseError as error:
- raise errors.StyleSyntaxError(
- f"unable to parse {word!r} as color; {error}"
- ) from None
- color = word
- style = Style(color=color, bgcolor=bgcolor, link=link, **attributes)
- return style
-
- @lru_cache(maxsize=1024)
- def get_html_style(self, theme: Optional[TerminalTheme] = None) -> str:
- """Get a CSS style rule."""
- theme = theme or DEFAULT_TERMINAL_THEME
- css: List[str] = []
- append = css.append
-
- color = self.color
- bgcolor = self.bgcolor
- if self.reverse:
- color, bgcolor = bgcolor, color
- if self.dim:
- foreground_color = (
- theme.foreground_color if color is None else color.get_truecolor(theme)
- )
- color = Color.from_triplet(
- blend_rgb(foreground_color, theme.background_color, 0.5)
- )
- if color is not None:
- theme_color = color.get_truecolor(theme)
- append(f"color: {theme_color.hex}")
- append(f"text-decoration-color: {theme_color.hex}")
- if bgcolor is not None:
- theme_color = bgcolor.get_truecolor(theme, foreground=False)
- append(f"background-color: {theme_color.hex}")
- if self.bold:
- append("font-weight: bold")
- if self.italic:
- append("font-style: italic")
- if self.underline:
- append("text-decoration: underline")
- if self.strike:
- append("text-decoration: line-through")
- if self.overline:
- append("text-decoration: overline")
- return "; ".join(css)
-
- @classmethod
- def combine(cls, styles: Iterable["Style"]) -> "Style":
- """Combine styles and get result.
-
- Args:
- styles (Iterable[Style]): Styles to combine.
-
- Returns:
- Style: A new style instance.
- """
- iter_styles = iter(styles)
- return sum(iter_styles, next(iter_styles))
-
- @classmethod
- def chain(cls, *styles: "Style") -> "Style":
- """Combine styles from positional argument in to a single style.
-
- Args:
- *styles (Iterable[Style]): Styles to combine.
-
- Returns:
- Style: A new style instance.
- """
- iter_styles = iter(styles)
- return sum(iter_styles, next(iter_styles))
-
- def copy(self) -> "Style":
- """Get a copy of this style.
-
- Returns:
- Style: A new Style instance with identical attributes.
- """
- if self._null:
- return NULL_STYLE
- style: Style = self.__new__(Style)
- style._ansi = self._ansi
- style._style_definition = self._style_definition
- style._color = self._color
- style._bgcolor = self._bgcolor
- style._attributes = self._attributes
- style._set_attributes = self._set_attributes
- style._link = self._link
- style._link_id = f"{randint(0, 999999)}" if self._link else ""
- style._hash = self._hash
- style._null = False
- style._meta = self._meta
- return style
-
- def update_link(self, link: Optional[str] = None) -> "Style":
- """Get a copy with a different value for link.
-
- Args:
- link (str, optional): New value for link. Defaults to None.
-
- Returns:
- Style: A new Style instance.
- """
- style: Style = self.__new__(Style)
- style._ansi = self._ansi
- style._style_definition = self._style_definition
- style._color = self._color
- style._bgcolor = self._bgcolor
- style._attributes = self._attributes
- style._set_attributes = self._set_attributes
- style._link = link
- style._link_id = f"{randint(0, 999999)}" if link else ""
- style._hash = None
- style._null = False
- style._meta = self._meta
- return style
-
- def render(
- self,
- text: str = "",
- *,
- color_system: Optional[ColorSystem] = ColorSystem.TRUECOLOR,
- legacy_windows: bool = False,
- ) -> str:
- """Render the ANSI codes for the style.
-
- Args:
- text (str, optional): A string to style. Defaults to "".
- color_system (Optional[ColorSystem], optional): Color system to render to. Defaults to ColorSystem.TRUECOLOR.
-
- Returns:
- str: A string containing ANSI style codes.
- """
- if not text or color_system is None:
- return text
- attrs = self._ansi or self._make_ansi_codes(color_system)
- rendered = f"\x1b[{attrs}m{text}\x1b[0m" if attrs else text
- if self._link and not legacy_windows:
- rendered = (
- f"\x1b]8;id={self._link_id};{self._link}\x1b\\{rendered}\x1b]8;;\x1b\\"
- )
- return rendered
-
- def test(self, text: Optional[str] = None) -> None:
- """Write text with style directly to terminal.
-
- This method is for testing purposes only.
-
- Args:
- text (Optional[str], optional): Text to style or None for style name.
-
- """
- text = text or str(self)
- sys.stdout.write(f"{self.render(text)}\n")
-
- @lru_cache(maxsize=1024)
- def _add(self, style: Optional["Style"]) -> "Style":
- if style is None or style._null:
- return self
- if self._null:
- return style
- new_style: Style = self.__new__(Style)
- new_style._ansi = None
- new_style._style_definition = None
- new_style._color = style._color or self._color
- new_style._bgcolor = style._bgcolor or self._bgcolor
- new_style._attributes = (self._attributes & ~style._set_attributes) | (
- style._attributes & style._set_attributes
- )
- new_style._set_attributes = self._set_attributes | style._set_attributes
- new_style._link = style._link or self._link
- new_style._link_id = style._link_id or self._link_id
- new_style._null = style._null
- if self._meta and style._meta:
- new_style._meta = dumps({**self.meta, **style.meta})
- else:
- new_style._meta = self._meta or style._meta
- new_style._hash = None
- return new_style
-
- def __add__(self, style: Optional["Style"]) -> "Style":
- combined_style = self._add(style)
- return combined_style.copy() if combined_style.link else combined_style
-
-
-NULL_STYLE = Style()
-
-
-class StyleStack:
- """A stack of styles."""
-
- __slots__ = ["_stack"]
-
- def __init__(self, default_style: "Style") -> None:
- self._stack: List[Style] = [default_style]
-
- def __repr__(self) -> str:
- return f""
-
- @property
- def current(self) -> Style:
- """Get the Style at the top of the stack."""
- return self._stack[-1]
-
- def push(self, style: Style) -> None:
- """Push a new style on to the stack.
-
- Args:
- style (Style): New style to combine with current style.
- """
- self._stack.append(self._stack[-1] + style)
-
- def pop(self) -> Style:
- """Pop last style and discard.
-
- Returns:
- Style: New current style (also available as stack.current)
- """
- self._stack.pop()
- return self._stack[-1]
diff --git a/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pip/_vendor/urllib3/util/proxy.py b/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pip/_vendor/urllib3/util/proxy.py
deleted file mode 100644
index 2199cc7b7f004009493d032720c36d6568f9d89e..0000000000000000000000000000000000000000
--- a/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pip/_vendor/urllib3/util/proxy.py
+++ /dev/null
@@ -1,57 +0,0 @@
-from .ssl_ import create_urllib3_context, resolve_cert_reqs, resolve_ssl_version
-
-
-def connection_requires_http_tunnel(
- proxy_url=None, proxy_config=None, destination_scheme=None
-):
- """
- Returns True if the connection requires an HTTP CONNECT through the proxy.
-
- :param URL proxy_url:
- URL of the proxy.
- :param ProxyConfig proxy_config:
- Proxy configuration from poolmanager.py
- :param str destination_scheme:
- The scheme of the destination. (i.e https, http, etc)
- """
- # If we're not using a proxy, no way to use a tunnel.
- if proxy_url is None:
- return False
-
- # HTTP destinations never require tunneling, we always forward.
- if destination_scheme == "http":
- return False
-
- # Support for forwarding with HTTPS proxies and HTTPS destinations.
- if (
- proxy_url.scheme == "https"
- and proxy_config
- and proxy_config.use_forwarding_for_https
- ):
- return False
-
- # Otherwise always use a tunnel.
- return True
-
-
-def create_proxy_ssl_context(
- ssl_version, cert_reqs, ca_certs=None, ca_cert_dir=None, ca_cert_data=None
-):
- """
- Generates a default proxy ssl context if one hasn't been provided by the
- user.
- """
- ssl_context = create_urllib3_context(
- ssl_version=resolve_ssl_version(ssl_version),
- cert_reqs=resolve_cert_reqs(cert_reqs),
- )
-
- if (
- not ca_certs
- and not ca_cert_dir
- and not ca_cert_data
- and hasattr(ssl_context, "load_default_certs")
- ):
- ssl_context.load_default_certs()
-
- return ssl_context
diff --git a/spaces/Redgon/bingo/src/app/page.tsx b/spaces/Redgon/bingo/src/app/page.tsx
deleted file mode 100644
index 0dff3431b098ce4fe282cc83fc87a93a28a43090..0000000000000000000000000000000000000000
--- a/spaces/Redgon/bingo/src/app/page.tsx
+++ /dev/null
@@ -1,15 +0,0 @@
-import dynamic from 'next/dynamic'
-
-const DynamicComponentWithNoSSR = dynamic(
- () => import('../components/chat'),
- { ssr: false }
-)
-
-export default function IndexPage() {
- return (
- <>
-
-
-
- )
-}
diff --git a/spaces/Reha2704/VToonify/vtoonify/model/stylegan/op_gpu/upfirdn2d.cpp b/spaces/Reha2704/VToonify/vtoonify/model/stylegan/op_gpu/upfirdn2d.cpp
deleted file mode 100644
index 73928ece8150f847d98af65a95685a29fcceecde..0000000000000000000000000000000000000000
--- a/spaces/Reha2704/VToonify/vtoonify/model/stylegan/op_gpu/upfirdn2d.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-#include
-#include
-
-torch::Tensor upfirdn2d_op(const torch::Tensor &input,
- const torch::Tensor &kernel, int up_x, int up_y,
- int down_x, int down_y, int pad_x0, int pad_x1,
- int pad_y0, int pad_y1);
-
-#define CHECK_CUDA(x) \
- TORCH_CHECK(x.type().is_cuda(), #x " must be a CUDA tensor")
-#define CHECK_CONTIGUOUS(x) \
- TORCH_CHECK(x.is_contiguous(), #x " must be contiguous")
-#define CHECK_INPUT(x) \
- CHECK_CUDA(x); \
- CHECK_CONTIGUOUS(x)
-
-torch::Tensor upfirdn2d(const torch::Tensor &input, const torch::Tensor &kernel,
- int up_x, int up_y, int down_x, int down_y, int pad_x0,
- int pad_x1, int pad_y0, int pad_y1) {
- CHECK_INPUT(input);
- CHECK_INPUT(kernel);
-
- at::DeviceGuard guard(input.device());
-
- return upfirdn2d_op(input, kernel, up_x, up_y, down_x, down_y, pad_x0, pad_x1,
- pad_y0, pad_y1);
-}
-
-PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
- m.def("upfirdn2d", &upfirdn2d, "upfirdn2d (CUDA)");
-}
\ No newline at end of file
diff --git a/spaces/Robert001/UniControl-Demo/annotator/uniformer_base/mmcv/runner/hooks/logger/text.py b/spaces/Robert001/UniControl-Demo/annotator/uniformer_base/mmcv/runner/hooks/logger/text.py
deleted file mode 100644
index 87b1a3eca9595a130121526f8b4c29915387ab35..0000000000000000000000000000000000000000
--- a/spaces/Robert001/UniControl-Demo/annotator/uniformer_base/mmcv/runner/hooks/logger/text.py
+++ /dev/null
@@ -1,256 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import datetime
-import os
-import os.path as osp
-from collections import OrderedDict
-
-import torch
-import torch.distributed as dist
-
-import annotator.uniformer.mmcv as mmcv
-from annotator.uniformer.mmcv.fileio.file_client import FileClient
-from annotator.uniformer.mmcv.utils import is_tuple_of, scandir
-from ..hook import HOOKS
-from .base import LoggerHook
-
-
-@HOOKS.register_module()
-class TextLoggerHook(LoggerHook):
- """Logger hook in text.
-
- In this logger hook, the information will be printed on terminal and
- saved in json file.
-
- Args:
- by_epoch (bool, optional): Whether EpochBasedRunner is used.
- Default: True.
- interval (int, optional): Logging interval (every k iterations).
- Default: 10.
- ignore_last (bool, optional): Ignore the log of last iterations in each
- epoch if less than :attr:`interval`. Default: True.
- reset_flag (bool, optional): Whether to clear the output buffer after
- logging. Default: False.
- interval_exp_name (int, optional): Logging interval for experiment
- name. This feature is to help users conveniently get the experiment
- information from screen or log file. Default: 1000.
- out_dir (str, optional): Logs are saved in ``runner.work_dir`` default.
- If ``out_dir`` is specified, logs will be copied to a new directory
- which is the concatenation of ``out_dir`` and the last level
- directory of ``runner.work_dir``. Default: None.
- `New in version 1.3.16.`
- out_suffix (str or tuple[str], optional): Those filenames ending with
- ``out_suffix`` will be copied to ``out_dir``.
- Default: ('.log.json', '.log', '.py').
- `New in version 1.3.16.`
- keep_local (bool, optional): Whether to keep local log when
- :attr:`out_dir` is specified. If False, the local log will be
- removed. Default: True.
- `New in version 1.3.16.`
- file_client_args (dict, optional): Arguments to instantiate a
- FileClient. See :class:`mmcv.fileio.FileClient` for details.
- Default: None.
- `New in version 1.3.16.`
- """
-
- def __init__(self,
- by_epoch=True,
- interval=10,
- ignore_last=True,
- reset_flag=False,
- interval_exp_name=1000,
- out_dir=None,
- out_suffix=('.log.json', '.log', '.py'),
- keep_local=True,
- file_client_args=None):
- super(TextLoggerHook, self).__init__(interval, ignore_last, reset_flag,
- by_epoch)
- self.by_epoch = by_epoch
- self.time_sec_tot = 0
- self.interval_exp_name = interval_exp_name
-
- if out_dir is None and file_client_args is not None:
- raise ValueError(
- 'file_client_args should be "None" when `out_dir` is not'
- 'specified.')
- self.out_dir = out_dir
-
- if not (out_dir is None or isinstance(out_dir, str)
- or is_tuple_of(out_dir, str)):
- raise TypeError('out_dir should be "None" or string or tuple of '
- 'string, but got {out_dir}')
- self.out_suffix = out_suffix
-
- self.keep_local = keep_local
- self.file_client_args = file_client_args
- if self.out_dir is not None:
- self.file_client = FileClient.infer_client(file_client_args,
- self.out_dir)
-
- def before_run(self, runner):
- super(TextLoggerHook, self).before_run(runner)
-
- if self.out_dir is not None:
- self.file_client = FileClient.infer_client(self.file_client_args,
- self.out_dir)
- # The final `self.out_dir` is the concatenation of `self.out_dir`
- # and the last level directory of `runner.work_dir`
- basename = osp.basename(runner.work_dir.rstrip(osp.sep))
- self.out_dir = self.file_client.join_path(self.out_dir, basename)
- runner.logger.info(
- (f'Text logs will be saved to {self.out_dir} by '
- f'{self.file_client.name} after the training process.'))
-
- self.start_iter = runner.iter
- self.json_log_path = osp.join(runner.work_dir,
- f'{runner.timestamp}.log.json')
- if runner.meta is not None:
- self._dump_log(runner.meta, runner)
-
- def _get_max_memory(self, runner):
- device = getattr(runner.model, 'output_device', None)
- mem = torch.cuda.max_memory_allocated(device=device)
- mem_mb = torch.tensor([mem / (1024 * 1024)],
- dtype=torch.int,
- device=device)
- if runner.world_size > 1:
- dist.reduce(mem_mb, 0, op=dist.ReduceOp.MAX)
- return mem_mb.item()
-
- def _log_info(self, log_dict, runner):
- # print exp name for users to distinguish experiments
- # at every ``interval_exp_name`` iterations and the end of each epoch
- if runner.meta is not None and 'exp_name' in runner.meta:
- if (self.every_n_iters(runner, self.interval_exp_name)) or (
- self.by_epoch and self.end_of_epoch(runner)):
- exp_info = f'Exp name: {runner.meta["exp_name"]}'
- runner.logger.info(exp_info)
-
- if log_dict['mode'] == 'train':
- if isinstance(log_dict['lr'], dict):
- lr_str = []
- for k, val in log_dict['lr'].items():
- lr_str.append(f'lr_{k}: {val:.3e}')
- lr_str = ' '.join(lr_str)
- else:
- lr_str = f'lr: {log_dict["lr"]:.3e}'
-
- # by epoch: Epoch [4][100/1000]
- # by iter: Iter [100/100000]
- if self.by_epoch:
- log_str = f'Epoch [{log_dict["epoch"]}]' \
- f'[{log_dict["iter"]}/{len(runner.data_loader)}]\t'
- else:
- log_str = f'Iter [{log_dict["iter"]}/{runner.max_iters}]\t'
- log_str += f'{lr_str}, '
-
- if 'time' in log_dict.keys():
- self.time_sec_tot += (log_dict['time'] * self.interval)
- time_sec_avg = self.time_sec_tot / (
- runner.iter - self.start_iter + 1)
- eta_sec = time_sec_avg * (runner.max_iters - runner.iter - 1)
- eta_str = str(datetime.timedelta(seconds=int(eta_sec)))
- log_str += f'eta: {eta_str}, '
- log_str += f'time: {log_dict["time"]:.3f}, ' \
- f'data_time: {log_dict["data_time"]:.3f}, '
- # statistic memory
- if torch.cuda.is_available():
- log_str += f'memory: {log_dict["memory"]}, '
- else:
- # val/test time
- # here 1000 is the length of the val dataloader
- # by epoch: Epoch[val] [4][1000]
- # by iter: Iter[val] [1000]
- if self.by_epoch:
- log_str = f'Epoch({log_dict["mode"]}) ' \
- f'[{log_dict["epoch"]}][{log_dict["iter"]}]\t'
- else:
- log_str = f'Iter({log_dict["mode"]}) [{log_dict["iter"]}]\t'
-
- log_items = []
- for name, val in log_dict.items():
- # TODO: resolve this hack
- # these items have been in log_str
- if name in [
- 'mode', 'Epoch', 'iter', 'lr', 'time', 'data_time',
- 'memory', 'epoch'
- ]:
- continue
- if isinstance(val, float):
- val = f'{val:.4f}'
- log_items.append(f'{name}: {val}')
- log_str += ', '.join(log_items)
-
- runner.logger.info(log_str)
-
- def _dump_log(self, log_dict, runner):
- # dump log in json format
- json_log = OrderedDict()
- for k, v in log_dict.items():
- json_log[k] = self._round_float(v)
- # only append log at last line
- if runner.rank == 0:
- with open(self.json_log_path, 'a+') as f:
- mmcv.dump(json_log, f, file_format='json')
- f.write('\n')
-
- def _round_float(self, items):
- if isinstance(items, list):
- return [self._round_float(item) for item in items]
- elif isinstance(items, float):
- return round(items, 5)
- else:
- return items
-
- def log(self, runner):
- if 'eval_iter_num' in runner.log_buffer.output:
- # this doesn't modify runner.iter and is regardless of by_epoch
- cur_iter = runner.log_buffer.output.pop('eval_iter_num')
- else:
- cur_iter = self.get_iter(runner, inner_iter=True)
-
- log_dict = OrderedDict(
- mode=self.get_mode(runner),
- epoch=self.get_epoch(runner),
- iter=cur_iter)
-
- # only record lr of the first param group
- cur_lr = runner.current_lr()
- if isinstance(cur_lr, list):
- log_dict['lr'] = cur_lr[0]
- else:
- assert isinstance(cur_lr, dict)
- log_dict['lr'] = {}
- for k, lr_ in cur_lr.items():
- assert isinstance(lr_, list)
- log_dict['lr'].update({k: lr_[0]})
-
- if 'time' in runner.log_buffer.output:
- # statistic memory
- if torch.cuda.is_available():
- log_dict['memory'] = self._get_max_memory(runner)
-
- log_dict = dict(log_dict, **runner.log_buffer.output)
-
- self._log_info(log_dict, runner)
- self._dump_log(log_dict, runner)
- return log_dict
-
- def after_run(self, runner):
- # copy or upload logs to self.out_dir
- if self.out_dir is not None:
- for filename in scandir(runner.work_dir, self.out_suffix, True):
- local_filepath = osp.join(runner.work_dir, filename)
- out_filepath = self.file_client.join_path(
- self.out_dir, filename)
- with open(local_filepath, 'r') as f:
- self.file_client.put_text(f.read(), out_filepath)
-
- runner.logger.info(
- (f'The file {local_filepath} has been uploaded to '
- f'{out_filepath}.'))
-
- if not self.keep_local:
- os.remove(local_filepath)
- runner.logger.info(
- (f'{local_filepath} was removed due to the '
- '`self.keep_local=False`'))
diff --git a/spaces/Robo2000/ClinicalTerminologyAISearch-GR/README.md b/spaces/Robo2000/ClinicalTerminologyAISearch-GR/README.md
deleted file mode 100644
index 178e216824738a81d70c12235b2b95e2082df9e0..0000000000000000000000000000000000000000
--- a/spaces/Robo2000/ClinicalTerminologyAISearch-GR/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: ClinicalTerminologyAISearch
-emoji: 🐠
-colorFrom: red
-colorTo: yellow
-sdk: gradio
-sdk_version: 3.9.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/Salesforce/EDICT/my_half_diffusers/models/unet_2d_condition.py b/spaces/Salesforce/EDICT/my_half_diffusers/models/unet_2d_condition.py
deleted file mode 100644
index 8546ea4c475ead158f9ae16a0c391c1267d6a4ec..0000000000000000000000000000000000000000
--- a/spaces/Salesforce/EDICT/my_half_diffusers/models/unet_2d_condition.py
+++ /dev/null
@@ -1,273 +0,0 @@
-from dataclasses import dataclass
-from typing import Optional, Tuple, Union
-
-import torch
-import torch.nn as nn
-
-from ..configuration_utils import ConfigMixin, register_to_config
-from ..modeling_utils import ModelMixin
-from ..utils import BaseOutput
-from .embeddings import TimestepEmbedding, Timesteps
-from .unet_blocks import UNetMidBlock2DCrossAttn, get_down_block, get_up_block
-
-
-@dataclass
-class UNet2DConditionOutput(BaseOutput):
- """
- Args:
- sample (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
- Hidden states conditioned on `encoder_hidden_states` input. Output of last layer of model.
- """
-
- sample: torch.FloatTensor
-
-
-class UNet2DConditionModel(ModelMixin, ConfigMixin):
- r"""
- UNet2DConditionModel is a conditional 2D UNet model that takes in a noisy sample, conditional state, and a timestep
- and returns sample shaped output.
-
- This model inherits from [`ModelMixin`]. Check the superclass documentation for the generic methods the library
- implements for all the model (such as downloading or saving, etc.)
-
- Parameters:
- sample_size (`int`, *optional*): The size of the input sample.
- in_channels (`int`, *optional*, defaults to 4): The number of channels in the input sample.
- out_channels (`int`, *optional*, defaults to 4): The number of channels in the output.
- center_input_sample (`bool`, *optional*, defaults to `False`): Whether to center the input sample.
- flip_sin_to_cos (`bool`, *optional*, defaults to `False`):
- Whether to flip the sin to cos in the time embedding.
- freq_shift (`int`, *optional*, defaults to 0): The frequency shift to apply to the time embedding.
- down_block_types (`Tuple[str]`, *optional*, defaults to `("CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "DownBlock2D")`):
- The tuple of downsample blocks to use.
- up_block_types (`Tuple[str]`, *optional*, defaults to `("UpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D",)`):
- The tuple of upsample blocks to use.
- block_out_channels (`Tuple[int]`, *optional*, defaults to `(320, 640, 1280, 1280)`):
- The tuple of output channels for each block.
- layers_per_block (`int`, *optional*, defaults to 2): The number of layers per block.
- downsample_padding (`int`, *optional*, defaults to 1): The padding to use for the downsampling convolution.
- mid_block_scale_factor (`float`, *optional*, defaults to 1.0): The scale factor to use for the mid block.
- act_fn (`str`, *optional*, defaults to `"silu"`): The activation function to use.
- norm_num_groups (`int`, *optional*, defaults to 32): The number of groups to use for the normalization.
- norm_eps (`float`, *optional*, defaults to 1e-5): The epsilon to use for the normalization.
- cross_attention_dim (`int`, *optional*, defaults to 1280): The dimension of the cross attention features.
- attention_head_dim (`int`, *optional*, defaults to 8): The dimension of the attention heads.
- """
-
- @register_to_config
- def __init__(
- self,
- sample_size: Optional[int] = None,
- in_channels: int = 4,
- out_channels: int = 4,
- center_input_sample: bool = False,
- flip_sin_to_cos: bool = True,
- freq_shift: int = 0,
- down_block_types: Tuple[str] = (
- "CrossAttnDownBlock2D",
- "CrossAttnDownBlock2D",
- "CrossAttnDownBlock2D",
- "DownBlock2D",
- ),
- up_block_types: Tuple[str] = ("UpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D"),
- block_out_channels: Tuple[int] = (320, 640, 1280, 1280),
- layers_per_block: int = 2,
- downsample_padding: int = 1,
- mid_block_scale_factor: float = 1,
- act_fn: str = "silu",
- norm_num_groups: int = 32,
- norm_eps: float = 1e-5,
- cross_attention_dim: int = 1280,
- attention_head_dim: int = 8,
- ):
- super().__init__()
-
- self.sample_size = sample_size
- time_embed_dim = block_out_channels[0] * 4
-
- # input
- self.conv_in = nn.Conv2d(in_channels, block_out_channels[0], kernel_size=3, padding=(1, 1))
-
- # time
- self.time_proj = Timesteps(block_out_channels[0], flip_sin_to_cos, freq_shift)
- timestep_input_dim = block_out_channels[0]
-
- self.time_embedding = TimestepEmbedding(timestep_input_dim, time_embed_dim)
-
- self.down_blocks = nn.ModuleList([])
- self.mid_block = None
- self.up_blocks = nn.ModuleList([])
-
- # down
- output_channel = block_out_channels[0]
- for i, down_block_type in enumerate(down_block_types):
- input_channel = output_channel
- output_channel = block_out_channels[i]
- is_final_block = i == len(block_out_channels) - 1
-
- down_block = get_down_block(
- down_block_type,
- num_layers=layers_per_block,
- in_channels=input_channel,
- out_channels=output_channel,
- temb_channels=time_embed_dim,
- add_downsample=not is_final_block,
- resnet_eps=norm_eps,
- resnet_act_fn=act_fn,
- cross_attention_dim=cross_attention_dim,
- attn_num_head_channels=attention_head_dim,
- downsample_padding=downsample_padding,
- )
- self.down_blocks.append(down_block)
-
- # mid
- self.mid_block = UNetMidBlock2DCrossAttn(
- in_channels=block_out_channels[-1],
- temb_channels=time_embed_dim,
- resnet_eps=norm_eps,
- resnet_act_fn=act_fn,
- output_scale_factor=mid_block_scale_factor,
- resnet_time_scale_shift="default",
- cross_attention_dim=cross_attention_dim,
- attn_num_head_channels=attention_head_dim,
- resnet_groups=norm_num_groups,
- )
-
- # up
- reversed_block_out_channels = list(reversed(block_out_channels))
- output_channel = reversed_block_out_channels[0]
- for i, up_block_type in enumerate(up_block_types):
- prev_output_channel = output_channel
- output_channel = reversed_block_out_channels[i]
- input_channel = reversed_block_out_channels[min(i + 1, len(block_out_channels) - 1)]
-
- is_final_block = i == len(block_out_channels) - 1
-
- up_block = get_up_block(
- up_block_type,
- num_layers=layers_per_block + 1,
- in_channels=input_channel,
- out_channels=output_channel,
- prev_output_channel=prev_output_channel,
- temb_channels=time_embed_dim,
- add_upsample=not is_final_block,
- resnet_eps=norm_eps,
- resnet_act_fn=act_fn,
- cross_attention_dim=cross_attention_dim,
- attn_num_head_channels=attention_head_dim,
- )
- self.up_blocks.append(up_block)
- prev_output_channel = output_channel
-
- # out
- self.conv_norm_out = nn.GroupNorm(num_channels=block_out_channels[0], num_groups=norm_num_groups, eps=norm_eps)
- self.conv_act = nn.SiLU()
- self.conv_out = nn.Conv2d(block_out_channels[0], out_channels, 3, padding=1)
-
- def set_attention_slice(self, slice_size):
- if slice_size is not None and self.config.attention_head_dim % slice_size != 0:
- raise ValueError(
- f"Make sure slice_size {slice_size} is a divisor of "
- f"the number of heads used in cross_attention {self.config.attention_head_dim}"
- )
- if slice_size is not None and slice_size > self.config.attention_head_dim:
- raise ValueError(
- f"Chunk_size {slice_size} has to be smaller or equal to "
- f"the number of heads used in cross_attention {self.config.attention_head_dim}"
- )
-
- for block in self.down_blocks:
- if hasattr(block, "attentions") and block.attentions is not None:
- block.set_attention_slice(slice_size)
-
- self.mid_block.set_attention_slice(slice_size)
-
- for block in self.up_blocks:
- if hasattr(block, "attentions") and block.attentions is not None:
- block.set_attention_slice(slice_size)
-
- def forward(
- self,
- sample: torch.FloatTensor,
- timestep: Union[torch.Tensor, float, int],
- encoder_hidden_states: torch.Tensor,
- return_dict: bool = True,
- ) -> Union[UNet2DConditionOutput, Tuple]:
- """r
- Args:
- sample (`torch.FloatTensor`): (batch, channel, height, width) noisy inputs tensor
- timestep (`torch.FloatTensor` or `float` or `int): (batch) timesteps
- encoder_hidden_states (`torch.FloatTensor`): (batch, channel, height, width) encoder hidden states
- return_dict (`bool`, *optional*, defaults to `True`):
- Whether or not to return a [`models.unet_2d_condition.UNet2DConditionOutput`] instead of a plain tuple.
-
- Returns:
- [`~models.unet_2d_condition.UNet2DConditionOutput`] or `tuple`:
- [`~models.unet_2d_condition.UNet2DConditionOutput`] if `return_dict` is True, otherwise a `tuple`. When
- returning a tuple, the first element is the sample tensor.
- """
- # 0. center input if necessary
- if self.config.center_input_sample:
- sample = 2 * sample - 1.0
-
- # 1. time
- timesteps = timestep
- if not torch.is_tensor(timesteps):
- timesteps = torch.tensor([timesteps], dtype=torch.long, device=sample.device)
- elif torch.is_tensor(timesteps) and len(timesteps.shape) == 0:
- timesteps = timesteps.to(dtype=torch.float16)
- timesteps = timesteps[None].to(device=sample.device)
-
- # broadcast to batch dimension in a way that's compatible with ONNX/Core ML
- timesteps = timesteps.expand(sample.shape[0])
-
- t_emb = self.time_proj(timesteps)
- # print(t_emb.dtype)
- t_emb = t_emb.to(sample.dtype).to(sample.device)
- emb = self.time_embedding(t_emb)
-
- # 2. pre-process
- sample = self.conv_in(sample)
-
- # 3. down
- down_block_res_samples = (sample,)
- for downsample_block in self.down_blocks:
- if hasattr(downsample_block, "attentions") and downsample_block.attentions is not None:
- # print(sample.dtype, emb.dtype, encoder_hidden_states.dtype)
- sample, res_samples = downsample_block(
- hidden_states=sample, temb=emb, encoder_hidden_states=encoder_hidden_states
- )
- else:
- sample, res_samples = downsample_block(hidden_states=sample, temb=emb)
-
- down_block_res_samples += res_samples
-
- # 4. mid
- sample = self.mid_block(sample, emb, encoder_hidden_states=encoder_hidden_states)
-
- # 5. up
- for upsample_block in self.up_blocks:
- res_samples = down_block_res_samples[-len(upsample_block.resnets) :]
- down_block_res_samples = down_block_res_samples[: -len(upsample_block.resnets)]
-
- if hasattr(upsample_block, "attentions") and upsample_block.attentions is not None:
- sample = upsample_block(
- hidden_states=sample,
- temb=emb,
- res_hidden_states_tuple=res_samples,
- encoder_hidden_states=encoder_hidden_states,
- )
- else:
- sample = upsample_block(hidden_states=sample, temb=emb, res_hidden_states_tuple=res_samples)
-
- # 6. post-process
- # make sure hidden states is in float32
- # when running in half-precision
- sample = self.conv_norm_out(sample).type(sample.dtype)
- sample = self.conv_act(sample)
- sample = self.conv_out(sample)
-
- if not return_dict:
- return (sample,)
-
- return UNet2DConditionOutput(sample=sample)
diff --git a/spaces/ServerX/PorcoDiaz/go-applio-manager-recode.bat b/spaces/ServerX/PorcoDiaz/go-applio-manager-recode.bat
deleted file mode 100644
index 91b8acfc0c69a356fd5b1d77650b2cd728b1072b..0000000000000000000000000000000000000000
--- a/spaces/ServerX/PorcoDiaz/go-applio-manager-recode.bat
+++ /dev/null
@@ -1,322 +0,0 @@
-@echo off
-title Applio Installer
-
-::: _ _ _____ _
-::: /\ | (_) | __ \ | |
-::: / \ _ __ _ __ | |_ ___ | |__) |___ ___ ___ __| | ___
-::: / /\ \ | '_ \| '_ \| | |/ _ \ | _ // _ \/ __/ _ \ / _` |/ _ \
-::: / ____ \| |_) | |_) | | | (_) | | | \ \ __/ (_| (_) | (_| | __/
-::: /_/ \_\ .__/| .__/|_|_|\___/ |_| \_\___|\___\___/ \__,_|\___|
-::: | | | |
-::: |_| |_|
-:::
-:::
-
-setlocal
-set "branch=applio-recode"
-set "runtime=runtime-recode"
-set "repoUrl=https://github.com/IAHispano/Applio-RVC-Fork/archive/refs/heads/%branch%.zip"
-set "fixesFolder=fixes"
-set "localFixesPy=local_fixes.py"
-set "principal=%cd%"
-set "URL_BASE=https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main"
-set "URL_EXTRA=https://huggingface.co/IAHispano/applio/resolve/main"
-
-:menu
-for /f "delims=: tokens=*" %%A in ('findstr /b ":::" "%~f0"') do @echo(%%A
-
-echo [1] Reinstall Applio
-echo [2] Update Applio
-echo [3] Update Applio + Runtime
-echo.
-
-set /p choice=Select an option:
-set choice=%choice: =%
-
-if "%choice%"=="1" (
- cls
- echo Starting Applio Reinstaller...
- echo.
- goto reinstaller
- pause
- cls
- goto menu
-
-)
-
-if "%choice%"=="2" (
- cls
- echo Starting Applio Updater...
- echo.
- goto updater
- pause
- cls
- goto menu
-)
-
-if "%choice%"=="3" (
- cls
- echo Updating Applio + Runtime...
- echo.
- goto updaterRuntime
- pause
- cls
- goto menu
-
-)
-
-cls
-echo Invalid option. Please enter a number from 1 to 3.
-echo.
-echo Press 'Enter' to access the main menu...
-pause>nul
-cls
-goto menu
-
-:reinstaller
-
-echo WARNING: Remember to install Microsoft C++ Build Tools, Redistributable, Python, and Git before continuing.
-echo.
-echo Step-by-step guide: https://rentry.org/appliolocal
-echo Build Tools: https://aka.ms/vs/17/release/vs_BuildTools.exe
-echo Redistributable: https://aka.ms/vs/17/release/vc_redist.x64.exe
-echo Git: https://github.com/git-for-windows/git/releases/download/v2.42.0.windows.2/Git-2.42.0.2-64-bit.exe
-echo Python: Add this route to the windows enviroment variables the user path variable: %principal%\runtime\Scripts
-echo.
-pause
-cls
-
-echo Downloading ZIP file...
-powershell -command "& { Invoke-WebRequest -Uri '%repoUrl%' -OutFile '%principal%\repo.zip' }"
-echo.
-
-echo Extracting ZIP file...
-powershell -command "& { Add-Type -AssemblyName System.IO.Compression.FileSystem ; [System.IO.Compression.ZipFile]::ExtractToDirectory('%principal%\repo.zip', '%principal%') }"
-echo.
-
-echo Copying folder and file structure from subdirectory to main directory...
-robocopy "%principal%\Applio-RVC-Fork-%branch%" "%principal%" /E
-echo.
-
-echo Deleting contents of subdirectory (files and folders)...
-rmdir "%principal%\Applio-RVC-Fork-%branch%" /S /Q
-echo.
-
-echo Cleaning up...
-del "%principal%\repo.zip"
-echo.
-cls
-
-echo Proceeding to download the models...
-echo.
-
-echo WARNING: At this point, it's recommended to disable antivirus or firewall, as errors might occur when downloading pretrained models.
-pause
-cls
-
-echo Downloading models in the assets folder...
-cd "assets"
-echo.
-echo Downloading the "pretrained" folder...
-cd "pretrained"
-curl -LJO "%URL_BASE%/pretrained/D32k.pth"
-curl -LJO "%URL_BASE%/pretrained/D40k.pth"
-curl -LJO "%URL_BASE%/pretrained/D48k.pth"
-curl -LJO "%URL_BASE%/pretrained/G32k.pth"
-curl -LJO "%URL_BASE%/pretrained/G40k.pth"
-curl -LJO "%URL_BASE%/pretrained/G48k.pth"
-curl -LJO "%URL_BASE%/pretrained/f0D32k.pth"
-curl -LJO "%URL_BASE%/pretrained/f0D40k.pth"
-curl -LJO "%URL_BASE%/pretrained/f0D48k.pth"
-curl -LJO "%URL_BASE%/pretrained/f0G32k.pth"
-curl -LJO "%URL_BASE%/pretrained/f0G40k.pth"
-curl -LJO "%URL_BASE%/pretrained/f0G48k.pth"
-cd ".."
-echo.
-cls
-
-echo Downloading the "pretrained_v2" folder...
-cd "pretrained_v2"
-curl -LJO "%URL_BASE%/pretrained_v2/D32k.pth"
-curl -LJO "%URL_BASE%/pretrained_v2/D40k.pth"
-curl -LJO "%URL_BASE%/pretrained_v2/D48k.pth"
-curl -LJO "%URL_BASE%/pretrained_v2/G32k.pth"
-curl -LJO "%URL_BASE%/pretrained_v2/G40k.pth"
-curl -LJO "%URL_BASE%/pretrained_v2/G48k.pth"
-curl -LJO "%URL_BASE%/pretrained_v2/f0D32k.pth"
-curl -LJO "%URL_BASE%/pretrained_v2/f0D40k.pth"
-curl -LJO "%URL_BASE%/pretrained_v2/f0D48k.pth"
-curl -LJO "%URL_BASE%/pretrained_v2/f0G32k.pth"
-curl -LJO "%URL_BASE%/pretrained_v2/f0G40k.pth"
-curl -LJO "%URL_BASE%/pretrained_v2/f0G48k.pth"
-cd ".."
-echo.
-cls
-
-echo Downloading the hubert_base.pt file...
-cd "hubert"
-curl -LJO "%URL_BASE%/hubert_base.pt"
-cd ".."
-echo.
-cls
-
-
-echo Downloading the rmvpe.pt file...
-cd "rmvpe"
-curl -LJO "%URL_BASE%/rmvpe.pt"
-echo.
-cls
-
-echo Downloading the rmvpe.onnx file...
-curl -LJO "%URL_BASE%/rmvpe.onnx"
-cd ".."
-cd ".."
-echo.
-cls
-
-echo Downloading the rest of the large files
-
-echo Downloading the "uvr5_weights" folder...
-cd "uvr5_weights"
-curl -LJO "%URL_BASE%/uvr5_weights/HP2_all_vocals.pth"
-curl -LJO "%URL_BASE%/uvr5_weights/HP3_all_vocals.pth"
-curl -LJO "%URL_BASE%/uvr5_weights/HP5_only_main_vocal.pth"
-curl -LJO "%URL_BASE%/uvr5_weights/VR-DeEchoAggressive.pth"
-curl -LJO "%URL_BASE%/uvr5_weights/VR-DeEchoDeReverb.pth"
-curl -LJO "%URL_BASE%/uvr5_weights/VR-DeEchoNormal.pth"
-cd ".."
-echo.
-cls
-
-echo Downloading the ffmpeg.exe file...
-curl -LJO "%URL_BASE%/ffmpeg.exe"
-echo.
-cls
-
-echo Downloading the ffprobe.exe file...
-curl -LJO "%URL_BASE%/ffprobe.exe"
-echo.
-cls
-
-echo Downloading the runtime.zip file...
-curl -LJO "%URL_EXTRA%/%runtime%.zip"
-echo.
-cls
-
-echo Extracting the runtime.zip file, this might take a while...
-powershell -Command "Expand-Archive -Path '%runtime%.zip' -DestinationPath '.'"
-del %runtime%.zip
-echo.
-cls
-
-echo Downloads completed!
-echo.
-
-echo Checking if the local_fixes.py file exists in the Fixes folder...
-if exist "%fixesFolder%\%localFixesPy%" (
- echo Running the file...
- runtime\python.exe "%fixesFolder%\%localFixesPy%"
-) else (
- echo The "%localFixesPy%" file was not found in the "Fixes" folder.
-)
-echo.
-
-echo Fixes Applied!
-echo.
-
-echo Applio has been reinstalled!
-echo.
-echo Press 'Enter' to access the main menu...
-pause>nul
-cls
-goto menu
-
-
-:updater
-
-echo Downloading the ZIP file...
-powershell -command "& { Invoke-WebRequest -Uri '%repoUrl%' -OutFile '%principal%\repo.zip' }"
-echo.
-
-echo Extracting ZIP file...
-powershell -command "& { Add-Type -AssemblyName System.IO.Compression.FileSystem ; [System.IO.Compression.ZipFile]::ExtractToDirectory('%principal%\repo.zip', '%principal%') }"
-echo.
-
-echo Copying folder and file structure from subdirectory to main directory...
-robocopy "%principal%\Applio-RVC-Fork-%branch%" "%principal%" /E
-echo.
-
-echo Deleting contents of the subdirectory (files and folders)...
-rmdir "%principal%\Applio-RVC-Fork-%branch%" /S /Q
-echo.
-
-echo Cleaning up...
-del "%principal%\repo.zip"
-echo.
-cls
-
-echo Verifying if the local_fixes.py file exists in the Fixes folder...
-if exist "%fixesFolder%\%localFixesPy%" (
- echo Running the file...
- runtime\python.exe "%fixesFolder%\%localFixesPy%"
-) else (
- echo The file "%localFixesPy%" was not found in the "Fixes" folder.
-)
-echo.
-
-echo Applio has been updated!
-echo.
-echo Press 'Enter' to access the main menu...
-pause>nul
-cls
-goto menu
-
-
-:updaterRuntime
-
-echo Downloading the ZIP file...
-powershell -command "& { Invoke-WebRequest -Uri '%repoUrl%' -OutFile '%principal%\repo.zip' }"
-echo.
-
-echo Extracting ZIP file...
-powershell -command "& { Add-Type -AssemblyName System.IO.Compression.FileSystem ; [System.IO.Compression.ZipFile]::ExtractToDirectory('%principal%\repo.zip', '%principal%') }"
-echo.
-
-echo Copying folder and file structure from subdirectory to main directory...
-robocopy "%principal%\Applio-RVC-Fork-%branch%" "%principal%" /E
-echo.
-
-echo Deleting contents of the subdirectory (files and folders)...
-rmdir "%principal%\Applio-RVC-Fork-%branch%" /S /Q
-echo.
-
-echo Cleaning up...
-del "%principal%\repo.zip"
-echo.
-cls
-
-echo Downloading the runtime.zip file...
-curl -LJO "%URL_EXTRA%/%runtime%.zip"
-echo.
-cls
-echo Extracting the runtime.zip file, this might take a while...
-powershell -Command "Expand-Archive -Path '%runtime%.zip' -DestinationPath '.'"
-del runtime.zip
-echo.
-cls
-
-echo Verifying if the local_fixes.py file exists in the Fixes folder...
-if exist "%fixesFolder%\%localFixesPy%" (
- echo Running the file...
- runtime\python.exe "%fixesFolder%\%localFixesPy%"
-) else (
- echo The file "%localFixesPy%" was not found in the "Fixes" folder.
-)
-echo.
-
-echo Applio has been updated!
-echo.
-echo Press 'Enter' to access the main menu...
-pause>nul
-cls
-goto menu
diff --git a/spaces/ShadowDominator/sentence-sentiment-analysis/app.py b/spaces/ShadowDominator/sentence-sentiment-analysis/app.py
deleted file mode 100644
index 54d30896615c6e1aa41fe1510c29bb7c2e95af5f..0000000000000000000000000000000000000000
--- a/spaces/ShadowDominator/sentence-sentiment-analysis/app.py
+++ /dev/null
@@ -1,40 +0,0 @@
-import gradio as gr
-import torch
-from transformers import AutoTokenizer, AutoModelForSequenceClassification
-
-tokenizer_sentence_analysis = AutoTokenizer.from_pretrained("finiteautomata/bertweet-base-sentiment-analysis")
-model_sentence_analysis = AutoModelForSequenceClassification.from_pretrained("finiteautomata/bertweet-base-sentiment-analysis")
-paragraph = """
-I woke up this morning feeling refreshed and excited for the day ahead.
-I had a great night's sleep, and I was looking forward to spending time with my family and friends.
-I went for a walk in the park, and I enjoyed the beautiful weather. I also stopped by my favorite coffee shop and got a delicious cup of coffee.
-I felt so happy and content, and I knew that it was going to be a great day.
-
-"""
-def sentence_sentiment_model(text, tokenizer, model):
- inputs = tokenizer(text, padding=True, truncation=True, return_tensors="pt")
- with torch.no_grad():
- result = model(inputs['input_ids'], attention_mask=inputs['attention_mask'])
- logits = result.logits.detach()
- probs = torch.softmax(logits, dim=1)
- pos_prob = probs[0][2].item()
- neu_prob = probs[0][1].item()
- neg_prob = probs[0][0].item()
- return {'Positive': [round(float(pos_prob), 2)],"Neutural":[round(float(neu_prob), 2)], 'Negative': [round(float(neg_prob), 2)]}
-
-def sentence_sentiment(text):
- result = sentence_sentiment_model(text,tokenizer_sentence_analysis,model_sentence_analysis)
- return result
-
-with gr.Blocks(title="Sentence",css="footer {visibility: hidden}") as demo:
- with gr.Row():
- with gr.Column():
- gr.Markdown("## Sentence sentiment")
- with gr.Row():
- with gr.Column():
- inputs = gr.TextArea(label="sentence",value=paragraph,interactive=True)
- btn = gr.Button(value="RUN")
- with gr.Column():
- output = gr.Label(label="output")
- btn.click(fn=sentence_sentiment,inputs=[inputs],outputs=[output])
-demo.launch()
\ No newline at end of file
diff --git a/spaces/Shakeb100/GroomingGenie_AI/clipseg/training.py b/spaces/Shakeb100/GroomingGenie_AI/clipseg/training.py
deleted file mode 100644
index ce12cf443f37e2520658614e15d0e64eb554b7f1..0000000000000000000000000000000000000000
--- a/spaces/Shakeb100/GroomingGenie_AI/clipseg/training.py
+++ /dev/null
@@ -1,266 +0,0 @@
-import torch
-import inspect
-import json
-import yaml
-import math
-import os
-import sys
-
-from general_utils import log
-
-import numpy as np
-from functools import partial
-from os.path import expanduser, join, isfile, basename
-
-from torch.cuda.amp import autocast, GradScaler
-from torch.optim.lr_scheduler import LambdaLR
-from contextlib import nullcontext
-from torch.utils.data import DataLoader
-
-from general_utils import TrainingLogger, get_attribute, filter_args, log, training_config_from_cli_args
-
-
-def cosine_warmup_lr(i, warmup=10, max_iter=90):
- """ Cosine LR with Warmup """
- if i < warmup:
- return (i+1)/(warmup+1)
- else:
- return 0.5 + 0.5*math.cos(math.pi*(((i-warmup)/(max_iter- warmup))))
-
-
-def validate(model, dataset, config):
- data_loader = torch.utils.data.DataLoader(dataset, batch_size=4, shuffle=False)
-
- metric_class, use_metric = config.val_metric_class, config.use_val_metric
- loss_fn = get_attribute(config.loss)
-
- model.eval()
- model.cuda()
-
- if metric_class is not None:
- metric = get_attribute(metric_class)()
-
- with torch.no_grad():
-
- i, losses = 0, []
- for data_x, data_y in data_loader:
-
- data_x = [x.cuda() if isinstance(x, torch.Tensor) else x for x in data_x]
- data_y = [x.cuda() if isinstance(x, torch.Tensor) else x for x in data_y]
-
- prompts = model.sample_prompts(data_x[1], prompt_list=('a photo of a {}',))
- pred, visual_q, _, _ = model(data_x[0], prompts, return_features=True)
-
- if metric_class is not None:
- metric.add([pred], data_y)
-
- # pred = model(data_x[0], prompts)
- # loss = loss_fn(pred[0], data_y[0])
- loss = loss_fn(pred, data_y[0])
- losses += [float(loss)]
-
- i += 1
-
- if config.val_max_iterations is not None and i > config.val_max_iterations:
- break
-
- if use_metric is None:
- return np.mean(losses), {}, False
- else:
- metric_scores = {m: s for m, s in zip(metric.names(), metric.value())} if metric is not None else {}
- return np.mean(losses), metric_scores, True
-
-
-def main():
-
- config = training_config_from_cli_args()
-
- val_interval, best_val_loss, best_val_score = config.val_interval, float('inf'), float('-inf')
-
- model_cls = get_attribute(config.model)
- _, model_args, _ = filter_args(config, inspect.signature(model_cls).parameters)
- model = model_cls(**model_args).cuda()
-
- dataset_cls = get_attribute(config.dataset)
- _, dataset_args, _ = filter_args(config, inspect.signature(dataset_cls).parameters)
-
- dataset = dataset_cls(**dataset_args)
-
- log.info(f'Train dataset {dataset.__class__.__name__} (length: {len(dataset)})')
-
- if val_interval is not None:
- dataset_val_args = {k[4:]: v for k,v in config.items() if k.startswith('val_') and k != 'val_interval'}
- _, dataset_val_args, _ = filter_args(dataset_val_args, inspect.signature(dataset_cls).parameters)
- print('val args', {**dataset_args, **{'split': 'val', 'aug': 0}, **dataset_val_args})
-
- dataset_val = dataset_cls(**{**dataset_args, **{'split': 'val', 'aug': 0}, **dataset_val_args})
-
- # optimizer
- opt_cls = get_attribute(config.optimizer)
- if config.optimize == 'torch.optim.SGD':
- opt_args = {'momentum': config.momentum if 'momentum' in config else 0}
- else:
- opt_args = {}
- opt = opt_cls(model.parameters(), lr=config.lr, **opt_args)
-
- if config.lr_scheduler == 'cosine':
- assert config.T_max is not None and config.eta_min is not None
- lr_scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(opt, config.T_max, config.eta_min)
- elif config.lr_scheduler == 'warmup_cosine':
- lr_scheduler = LambdaLR(opt, partial(cosine_warmup_lr, max_iter=(config.max_iterations), warmup=config.warmup))
- else:
- lr_scheduler = None
-
- batch_size, max_iterations = config.batch_size, config.max_iterations
-
- loss_fn = get_attribute(config.loss)
-
- if config.amp:
- log.info('Using AMP')
- autocast_fn = autocast
- scaler = GradScaler()
- else:
- autocast_fn, scaler = nullcontext, None
-
-
- save_only_trainable = True
- data_loader = DataLoader(dataset, batch_size=batch_size, num_workers=4)
-
- # disable config when hyperparam. opt. to avoid writing logs.
- tracker_config = config if not config.hyperparameter_optimization else None
-
- with TrainingLogger(log_dir=config.name, model=model, config=tracker_config) as logger:
-
- i = 0
- while True:
- for data_x, data_y in data_loader:
-
- # between caption and output feature.
- # 1. Sample random captions
- # 2. Check alignment with CLIP
-
- # randomly mix text and visual support conditionals
- if config.mix:
-
- assert config.mask.startswith('text_and')
-
- with autocast_fn():
- # data_x[1] = text label
- prompts = model.sample_prompts(data_x[1])
-
- # model.clip_model()
-
- text_cond = model.compute_conditional(prompts)
- if model.__class__.__name__ == 'CLIPDensePredTMasked':
- # when mask=='separate'
- visual_s_cond, _, _ = model.visual_forward_masked(data_x[2].cuda(), data_x[3].cuda())
- else:
- # data_x[2] = visual prompt
- visual_s_cond, _, _ = model.visual_forward(data_x[2].cuda())
-
- max_txt = config.mix_text_max if config.mix_text_max is not None else 1
- batch_size = text_cond.shape[0]
-
- # sample weights for each element in batch
- text_weights = torch.distributions.Uniform(config.mix_text_min, max_txt).sample((batch_size,))[:, None]
- text_weights = text_weights.cuda()
-
- if dataset.__class__.__name__ == 'PhraseCut':
- # give full weight to text where support_image is invalid
- visual_is_valid = data_x[4] if model.__class__.__name__ == 'CLIPDensePredTMasked' else data_x[3]
- text_weights = torch.max(text_weights[:,0], 1 - visual_is_valid.float().cuda()).unsqueeze(1)
-
- cond = text_cond * text_weights + visual_s_cond * (1 - text_weights)
-
- else:
- # no mix
-
- if model.__class__.__name__ == 'CLIPDensePredTMasked':
- # compute conditional vector using CLIP masking
- with autocast_fn():
- assert config.mask == 'separate'
- cond, _, _ = model.visual_forward_masked(data_x[1].cuda(), data_x[2].cuda())
- else:
- cond = data_x[1]
- if isinstance(cond, torch.Tensor):
- cond = cond.cuda()
-
- with autocast_fn():
- visual_q = None
-
- pred, visual_q, _, _ = model(data_x[0].cuda(), cond, return_features=True)
-
- loss = loss_fn(pred, data_y[0].cuda())
-
- if torch.isnan(loss) or torch.isinf(loss):
- # skip if loss is nan
- log.warning('Training stopped due to inf/nan loss.')
- sys.exit(-1)
-
- extra_loss = 0
- loss += extra_loss
-
- opt.zero_grad()
-
- if scaler is None:
- loss.backward()
- opt.step()
- else:
- scaler.scale(loss).backward()
- scaler.step(opt)
- scaler.update()
-
- if lr_scheduler is not None:
- lr_scheduler.step()
- if i % 2000 == 0:
- current_lr = [g['lr'] for g in opt.param_groups][0]
- log.info(f'current lr: {current_lr:.5f} ({len(opt.param_groups)} parameter groups)')
-
- logger.iter(i=i, loss=loss)
- i += 1
-
- if i >= max_iterations:
-
- if not isfile(join(logger.base_path, 'weights.pth')):
- # only write if no weights were already written
- logger.save_weights(only_trainable=save_only_trainable)
-
- sys.exit(0)
-
-
- if config.checkpoint_iterations is not None and i in config.checkpoint_iterations:
- logger.save_weights(only_trainable=save_only_trainable, weight_file=f'weights_{i}.pth')
-
-
- if val_interval is not None and i % val_interval == val_interval - 1:
-
- val_loss, val_scores, maximize = validate(model, dataset_val, config)
-
- if len(val_scores) > 0:
-
- score_str = f', scores: ' + ', '.join(f'{k}: {v}' for k, v in val_scores.items())
-
- if maximize and val_scores[config.use_val_metric] > best_val_score:
- logger.save_weights(only_trainable=save_only_trainable)
- best_val_score = val_scores[config.use_val_metric]
-
- elif not maximize and val_scores[config.use_val_metric] < best_val_score:
- logger.save_weights(only_trainable=save_only_trainable)
- best_val_score = val_scores[config.use_val_metric]
-
- else:
- score_str = ''
- # if no score is used, fall back to loss
- if val_loss < best_val_loss:
- logger.save_weights(only_trainable=save_only_trainable)
- best_val_loss = val_loss
-
- log.info(f'Validation loss: {val_loss}' + score_str)
- logger.iter(i=i, val_loss=val_loss, extra_loss=float(extra_loss), **val_scores)
- model.train()
-
- print('epoch complete')
-
-
-if __name__ == '__main__':
- main()
\ No newline at end of file
diff --git a/spaces/SuYuanS/AudioCraft_Plus/tests/models/test_multibanddiffusion.py b/spaces/SuYuanS/AudioCraft_Plus/tests/models/test_multibanddiffusion.py
deleted file mode 100644
index 2702a3cb5fe402bf96911dbc992d2749cb18a4c0..0000000000000000000000000000000000000000
--- a/spaces/SuYuanS/AudioCraft_Plus/tests/models/test_multibanddiffusion.py
+++ /dev/null
@@ -1,53 +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 random
-
-import numpy as np
-import torch
-from audiocraft.models.multibanddiffusion import MultiBandDiffusion, DiffusionProcess
-from audiocraft.models import EncodecModel, DiffusionUnet
-from audiocraft.modules import SEANetEncoder, SEANetDecoder
-from audiocraft.modules.diffusion_schedule import NoiseSchedule
-from audiocraft.quantization import DummyQuantizer
-
-
-class TestMBD:
-
- def _create_mbd(self,
- sample_rate: int,
- channels: int,
- n_filters: int = 3,
- n_residual_layers: int = 1,
- ratios: list = [5, 4, 3, 2],
- num_steps: int = 1000,
- codec_dim: int = 128,
- **kwargs):
- frame_rate = np.prod(ratios)
- encoder = SEANetEncoder(channels=channels, dimension=codec_dim, n_filters=n_filters,
- n_residual_layers=n_residual_layers, ratios=ratios)
- decoder = SEANetDecoder(channels=channels, dimension=codec_dim, n_filters=n_filters,
- n_residual_layers=n_residual_layers, ratios=ratios)
- quantizer = DummyQuantizer()
- compression_model = EncodecModel(encoder, decoder, quantizer, frame_rate=frame_rate,
- sample_rate=sample_rate, channels=channels, **kwargs)
- diffusion_model = DiffusionUnet(chin=channels, num_steps=num_steps, codec_dim=codec_dim)
- schedule = NoiseSchedule(device='cpu', num_steps=num_steps)
- DP = DiffusionProcess(model=diffusion_model, noise_schedule=schedule)
- mbd = MultiBandDiffusion(DPs=[DP], codec_model=compression_model)
- return mbd
-
- def test_model(self):
- random.seed(1234)
- sample_rate = 24_000
- channels = 1
- codec_dim = 128
- mbd = self._create_mbd(sample_rate=sample_rate, channels=channels, codec_dim=codec_dim)
- for _ in range(10):
- length = random.randrange(1, 10_000)
- x = torch.randn(2, channels, length)
- res = mbd.regenerate(x, sample_rate)
- assert res.shape == x.shape
diff --git a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/attrs/filters.py b/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/attrs/filters.py
deleted file mode 100644
index 52959005b088f0e5116c8b6acdbcc5937bbaacc8..0000000000000000000000000000000000000000
--- a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/attrs/filters.py
+++ /dev/null
@@ -1,3 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-from attr.filters import * # noqa
diff --git a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/chromadb/db/__init__.py b/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/chromadb/db/__init__.py
deleted file mode 100644
index d90e3db9a585e78c1c3418dc7a7dd05cd08eb332..0000000000000000000000000000000000000000
--- a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/chromadb/db/__init__.py
+++ /dev/null
@@ -1,142 +0,0 @@
-from abc import abstractmethod
-from typing import List, Sequence, Optional, Tuple
-from uuid import UUID
-import numpy.typing as npt
-from chromadb.api.types import (
- Embeddings,
- Documents,
- IDs,
- Metadatas,
- Metadata,
- Where,
- WhereDocument,
-)
-from chromadb.config import Component
-from overrides import override
-
-
-class DB(Component):
- @abstractmethod
- def create_collection(
- self,
- name: str,
- metadata: Optional[Metadata] = None,
- get_or_create: bool = False,
- ) -> Sequence: # type: ignore
- pass
-
- @abstractmethod
- def get_collection(self, name: str) -> Sequence: # type: ignore
- pass
-
- @abstractmethod
- def list_collections(self) -> Sequence: # type: ignore
- pass
-
- @abstractmethod
- def update_collection(
- self,
- id: UUID,
- new_name: Optional[str] = None,
- new_metadata: Optional[Metadata] = None,
- ) -> None:
- pass
-
- @abstractmethod
- def delete_collection(self, name: str) -> None:
- pass
-
- @abstractmethod
- def get_collection_uuid_from_name(self, collection_name: str) -> UUID:
- pass
-
- @abstractmethod
- def add(
- self,
- collection_uuid: UUID,
- embeddings: Embeddings,
- metadatas: Optional[Metadatas],
- documents: Optional[Documents],
- ids: List[str],
- ) -> List[UUID]:
- pass
-
- @abstractmethod
- def add_incremental(
- self, collection_uuid: UUID, ids: List[UUID], embeddings: Embeddings
- ) -> None:
- pass
-
- @abstractmethod
- def get(
- self,
- where: Where = {},
- collection_name: Optional[str] = None,
- collection_uuid: Optional[UUID] = None,
- ids: Optional[IDs] = None,
- sort: Optional[str] = None,
- limit: Optional[int] = None,
- offset: Optional[int] = None,
- where_document: WhereDocument = {},
- columns: Optional[List[str]] = None,
- ) -> Sequence: # type: ignore
- pass
-
- @abstractmethod
- def update(
- self,
- collection_uuid: UUID,
- ids: IDs,
- embeddings: Optional[Embeddings] = None,
- metadatas: Optional[Metadatas] = None,
- documents: Optional[Documents] = None,
- ) -> bool:
- pass
-
- @abstractmethod
- def count(self, collection_id: UUID) -> int:
- pass
-
- @abstractmethod
- def delete(
- self,
- where: Where = {},
- collection_uuid: Optional[UUID] = None,
- ids: Optional[IDs] = None,
- where_document: WhereDocument = {},
- ) -> List[str]:
- pass
-
- @abstractmethod
- @override
- def reset(self) -> None:
- pass
-
- @abstractmethod
- def get_nearest_neighbors(
- self,
- collection_uuid: UUID,
- where: Where = {},
- embeddings: Optional[Embeddings] = None,
- n_results: int = 10,
- where_document: WhereDocument = {},
- ) -> Tuple[List[List[UUID]], npt.NDArray]:
- pass
-
- @abstractmethod
- def get_by_ids(
- self, uuids: List[UUID], columns: Optional[List[str]] = None
- ) -> Sequence: # type: ignore
- pass
-
- @abstractmethod
- def raw_sql(self, raw_sql): # type: ignore
- pass
-
- @abstractmethod
- def create_index(self, collection_uuid: UUID): # type: ignore
- pass
-
- @abstractmethod
- def persist(self) -> None:
- pass
diff --git a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/comm/__init__.py b/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/comm/__init__.py
deleted file mode 100644
index eb8f9048b3ac9f81cbc6be23e977731c984c876a..0000000000000000000000000000000000000000
--- a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/comm/__init__.py
+++ /dev/null
@@ -1,50 +0,0 @@
-"""Comm package.
-
-Copyright (c) IPython Development Team.
-Distributed under the terms of the Modified BSD License.
-
-This package provides a way to register a Kernel Comm implementation, as per
-the Jupyter kernel protocol.
-It also provides a base Comm implementation and a default CommManager for the IPython case.
-"""
-
-from .base_comm import BaseComm, CommManager
-
-__version__ = "0.1.3"
-__all__ = [
- "create_comm",
- "get_comm_manager",
- "__version__",
-]
-
-_comm_manager = None
-
-
-class DummyComm(BaseComm):
- def publish_msg(self, msg_type, data=None, metadata=None, buffers=None, **keys):
- pass
-
-
-def _create_comm(*args, **kwargs):
- """Create a Comm.
-
- This method is intended to be replaced, so that it returns your Comm instance.
- """
- return DummyComm(*args, **kwargs)
-
-
-def _get_comm_manager():
- """Get the current Comm manager, creates one if there is none.
-
- This method is intended to be replaced if needed (if you want to manage multiple CommManagers).
- """
- global _comm_manager
-
- if _comm_manager is None:
- _comm_manager = CommManager()
-
- return _comm_manager
-
-
-create_comm = _create_comm
-get_comm_manager = _get_comm_manager
diff --git a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/debugpy/_vendored/pydevd/_pydev_bundle/_pydev_sys_patch.py b/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/debugpy/_vendored/pydevd/_pydev_bundle/_pydev_sys_patch.py
deleted file mode 100644
index f5067509f4207370dc868da943113695ec67926a..0000000000000000000000000000000000000000
--- a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/debugpy/_vendored/pydevd/_pydev_bundle/_pydev_sys_patch.py
+++ /dev/null
@@ -1,73 +0,0 @@
-import sys
-
-
-def patch_sys_module():
-
- def patched_exc_info(fun):
-
- def pydev_debugger_exc_info():
- type, value, traceback = fun()
- if type == ImportError:
- # we should not show frame added by plugin_import call
- if traceback and hasattr(traceback, "tb_next"):
- return type, value, traceback.tb_next
- return type, value, traceback
-
- return pydev_debugger_exc_info
-
- system_exc_info = sys.exc_info
- sys.exc_info = patched_exc_info(system_exc_info)
- if not hasattr(sys, "system_exc_info"):
- sys.system_exc_info = system_exc_info
-
-
-def patched_reload(orig_reload):
-
- def pydev_debugger_reload(module):
- orig_reload(module)
- if module.__name__ == "sys":
- # if sys module was reloaded we should patch it again
- patch_sys_module()
-
- return pydev_debugger_reload
-
-
-def patch_reload():
- import builtins # Py3
-
- if hasattr(builtins, "reload"):
- sys.builtin_orig_reload = builtins.reload
- builtins.reload = patched_reload(sys.builtin_orig_reload) # @UndefinedVariable
- try:
- import imp
- sys.imp_orig_reload = imp.reload
- imp.reload = patched_reload(sys.imp_orig_reload) # @UndefinedVariable
- except:
- pass
- else:
- try:
- import importlib
- sys.importlib_orig_reload = importlib.reload # @UndefinedVariable
- importlib.reload = patched_reload(sys.importlib_orig_reload) # @UndefinedVariable
- except:
- pass
-
- del builtins
-
-
-def cancel_patches_in_sys_module():
- sys.exc_info = sys.system_exc_info # @UndefinedVariable
- import builtins # Py3
-
- if hasattr(sys, "builtin_orig_reload"):
- builtins.reload = sys.builtin_orig_reload
-
- if hasattr(sys, "imp_orig_reload"):
- import imp
- imp.reload = sys.imp_orig_reload
-
- if hasattr(sys, "importlib_orig_reload"):
- import importlib
- importlib.reload = sys.importlib_orig_reload
-
- del builtins
diff --git a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/debugpy/_vendored/pydevd/pydevd.py b/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/debugpy/_vendored/pydevd/pydevd.py
deleted file mode 100644
index ae865b1614ad2fe26a07ed097edf741cabe4e3e4..0000000000000000000000000000000000000000
--- a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/debugpy/_vendored/pydevd/pydevd.py
+++ /dev/null
@@ -1,3489 +0,0 @@
-'''
-Entry point module (keep at root):
-
-This module starts the debugger.
-'''
-import sys # @NoMove
-if sys.version_info[:2] < (3, 6):
- raise RuntimeError('The PyDev.Debugger requires Python 3.6 onwards to be run. If you need to use an older Python version, use an older version of the debugger.')
-import os
-
-try:
- # Just empty packages to check if they're in the PYTHONPATH.
- import _pydev_bundle
-except ImportError:
- # On the first import of a pydevd module, add pydevd itself to the PYTHONPATH
- # if its dependencies cannot be imported.
- sys.path.append(os.path.dirname(os.path.abspath(__file__)))
- import _pydev_bundle
-
-# Import this first as it'll check for shadowed modules and will make sure that we import
-# things as needed for gevent.
-from _pydevd_bundle import pydevd_constants
-
-import atexit
-import dis
-import io
-from collections import defaultdict
-from contextlib import contextmanager
-from functools import partial
-import itertools
-import traceback
-import weakref
-import getpass as getpass_mod
-import functools
-
-import pydevd_file_utils
-from _pydev_bundle import pydev_imports, pydev_log
-from _pydev_bundle._pydev_filesystem_encoding import getfilesystemencoding
-from _pydev_bundle.pydev_is_thread_alive import is_thread_alive
-from _pydev_bundle.pydev_override import overrides
-from _pydev_bundle._pydev_saved_modules import threading, time, thread
-from _pydevd_bundle import pydevd_extension_utils, pydevd_frame_utils
-from _pydevd_bundle.pydevd_filtering import FilesFiltering, glob_matches_path
-from _pydevd_bundle import pydevd_io, pydevd_vm_type, pydevd_defaults
-from _pydevd_bundle import pydevd_utils
-from _pydevd_bundle import pydevd_runpy
-from _pydev_bundle.pydev_console_utils import DebugConsoleStdIn
-from _pydevd_bundle.pydevd_additional_thread_info import set_additional_thread_info
-from _pydevd_bundle.pydevd_breakpoints import ExceptionBreakpoint, get_exception_breakpoint
-from _pydevd_bundle.pydevd_comm_constants import (CMD_THREAD_SUSPEND, CMD_STEP_INTO, CMD_SET_BREAK,
- CMD_STEP_INTO_MY_CODE, CMD_STEP_OVER, CMD_SMART_STEP_INTO, CMD_RUN_TO_LINE,
- CMD_SET_NEXT_STATEMENT, CMD_STEP_RETURN, CMD_ADD_EXCEPTION_BREAK, CMD_STEP_RETURN_MY_CODE,
- CMD_STEP_OVER_MY_CODE, constant_to_str, CMD_STEP_INTO_COROUTINE)
-from _pydevd_bundle.pydevd_constants import (get_thread_id, get_current_thread_id,
- DebugInfoHolder, PYTHON_SUSPEND, STATE_SUSPEND, STATE_RUN, get_frame,
- clear_cached_thread_id, INTERACTIVE_MODE_AVAILABLE, SHOW_DEBUG_INFO_ENV, NULL,
- NO_FTRACE, IS_IRONPYTHON, JSON_PROTOCOL, IS_CPYTHON, HTTP_JSON_PROTOCOL, USE_CUSTOM_SYS_CURRENT_FRAMES_MAP, call_only_once,
- ForkSafeLock, IGNORE_BASENAMES_STARTING_WITH, EXCEPTION_TYPE_UNHANDLED, SUPPORT_GEVENT,
- PYDEVD_IPYTHON_COMPATIBLE_DEBUGGING, PYDEVD_IPYTHON_CONTEXT)
-from _pydevd_bundle.pydevd_defaults import PydevdCustomization # Note: import alias used on pydev_monkey.
-from _pydevd_bundle.pydevd_custom_frames import CustomFramesContainer, custom_frames_container_init
-from _pydevd_bundle.pydevd_dont_trace_files import DONT_TRACE, PYDEV_FILE, LIB_FILE, DONT_TRACE_DIRS
-from _pydevd_bundle.pydevd_extension_api import DebuggerEventHandler
-from _pydevd_bundle.pydevd_frame_utils import add_exception_to_frame, remove_exception_from_frame
-from _pydevd_bundle.pydevd_net_command_factory_xml import NetCommandFactory
-from _pydevd_bundle.pydevd_trace_dispatch import (
- trace_dispatch as _trace_dispatch, global_cache_skips, global_cache_frame_skips, fix_top_level_trace_and_get_trace_func, USING_CYTHON)
-from _pydevd_bundle.pydevd_utils import save_main_module, is_current_thread_main_thread, \
- import_attr_from_module
-from _pydevd_frame_eval.pydevd_frame_eval_main import (
- frame_eval_func, dummy_trace_dispatch, USING_FRAME_EVAL)
-import pydev_ipython # @UnusedImport
-from _pydevd_bundle.pydevd_source_mapping import SourceMapping
-from _pydevd_bundle.pydevd_concurrency_analyser.pydevd_concurrency_logger import ThreadingLogger, AsyncioLogger, send_concurrency_message, cur_time
-from _pydevd_bundle.pydevd_concurrency_analyser.pydevd_thread_wrappers import wrap_threads
-from pydevd_file_utils import get_abs_path_real_path_and_base_from_frame, NORM_PATHS_AND_BASE_CONTAINER
-from pydevd_file_utils import get_fullname, get_package_dir
-from os.path import abspath as os_path_abspath
-import pydevd_tracing
-from _pydevd_bundle.pydevd_comm import (InternalThreadCommand, InternalThreadCommandForAnyThread,
- create_server_socket, FSNotifyThread)
-from _pydevd_bundle.pydevd_comm import(InternalConsoleExec,
- _queue, ReaderThread, GetGlobalDebugger, get_global_debugger,
- set_global_debugger, WriterThread,
- start_client, start_server, InternalGetBreakpointException, InternalSendCurrExceptionTrace,
- InternalSendCurrExceptionTraceProceeded)
-from _pydevd_bundle.pydevd_daemon_thread import PyDBDaemonThread, mark_as_pydevd_daemon_thread
-from _pydevd_bundle.pydevd_process_net_command_json import PyDevJsonCommandProcessor
-from _pydevd_bundle.pydevd_process_net_command import process_net_command
-from _pydevd_bundle.pydevd_net_command import NetCommand, NULL_NET_COMMAND
-
-from _pydevd_bundle.pydevd_breakpoints import stop_on_unhandled_exception
-from _pydevd_bundle.pydevd_collect_bytecode_info import collect_try_except_info, collect_return_info, collect_try_except_info_from_source
-from _pydevd_bundle.pydevd_suspended_frames import SuspendedFramesManager
-from socket import SHUT_RDWR
-from _pydevd_bundle.pydevd_api import PyDevdAPI
-from _pydevd_bundle.pydevd_timeout import TimeoutTracker
-from _pydevd_bundle.pydevd_thread_lifecycle import suspend_all_threads, mark_thread_suspended
-
-pydevd_gevent_integration = None
-
-if SUPPORT_GEVENT:
- try:
- from _pydevd_bundle import pydevd_gevent_integration
- except:
- pydev_log.exception(
- 'pydevd: GEVENT_SUPPORT is set but gevent is not available in the environment.\n'
- 'Please unset GEVENT_SUPPORT from the environment variables or install gevent.')
- else:
- pydevd_gevent_integration.log_gevent_debug_info()
-
-if USE_CUSTOM_SYS_CURRENT_FRAMES_MAP:
- from _pydevd_bundle.pydevd_constants import constructed_tid_to_last_frame
-
-__version_info__ = (2, 9, 5)
-__version_info_str__ = []
-for v in __version_info__:
- __version_info_str__.append(str(v))
-
-__version__ = '.'.join(__version_info_str__)
-
-# IMPORTANT: pydevd_constants must be the 1st thing defined because it'll keep a reference to the original sys._getframe
-
-
-def install_breakpointhook(pydevd_breakpointhook=None):
- if pydevd_breakpointhook is None:
-
- def pydevd_breakpointhook(*args, **kwargs):
- hookname = os.getenv('PYTHONBREAKPOINT')
- if (
- hookname is not None
- and len(hookname) > 0
- and hasattr(sys, '__breakpointhook__')
- and sys.__breakpointhook__ != pydevd_breakpointhook
- ):
- sys.__breakpointhook__(*args, **kwargs)
- else:
- settrace(*args, **kwargs)
-
- if sys.version_info[0:2] >= (3, 7):
- # There are some choices on how to provide the breakpoint hook. Namely, we can provide a
- # PYTHONBREAKPOINT which provides the import path for a method to be executed or we
- # can override sys.breakpointhook.
- # pydevd overrides sys.breakpointhook instead of providing an environment variable because
- # it's possible that the debugger starts the user program but is not available in the
- # PYTHONPATH (and would thus fail to be imported if PYTHONBREAKPOINT was set to pydevd.settrace).
- # Note that the implementation still takes PYTHONBREAKPOINT in account (so, if it was provided
- # by someone else, it'd still work).
- sys.breakpointhook = pydevd_breakpointhook
- else:
- if sys.version_info[0] >= 3:
- import builtins as __builtin__ # Py3 noqa
- else:
- import __builtin__ # noqa
-
- # In older versions, breakpoint() isn't really available, so, install the hook directly
- # in the builtins.
- __builtin__.breakpoint = pydevd_breakpointhook
- sys.__breakpointhook__ = pydevd_breakpointhook
-
-
-# Install the breakpoint hook at import time.
-install_breakpointhook()
-
-from _pydevd_bundle.pydevd_plugin_utils import PluginManager
-
-threadingEnumerate = threading.enumerate
-threadingCurrentThread = threading.current_thread
-
-try:
- 'dummy'.encode('utf-8') # Added because otherwise Jython 2.2.1 wasn't finding the encoding (if it wasn't loaded in the main thread).
-except:
- pass
-
-_global_redirect_stdout_to_server = False
-_global_redirect_stderr_to_server = False
-
-file_system_encoding = getfilesystemencoding()
-
-_CACHE_FILE_TYPE = {}
-
-pydev_log.debug('Using GEVENT_SUPPORT: %s', pydevd_constants.SUPPORT_GEVENT)
-pydev_log.debug('Using GEVENT_SHOW_PAUSED_GREENLETS: %s', pydevd_constants.GEVENT_SHOW_PAUSED_GREENLETS)
-pydev_log.debug('pydevd __file__: %s', os.path.abspath(__file__))
-pydev_log.debug('Using PYDEVD_IPYTHON_COMPATIBLE_DEBUGGING: %s', pydevd_constants.PYDEVD_IPYTHON_COMPATIBLE_DEBUGGING)
-if pydevd_constants.PYDEVD_IPYTHON_COMPATIBLE_DEBUGGING:
- pydev_log.debug('PYDEVD_IPYTHON_CONTEXT: %s', pydevd_constants.PYDEVD_IPYTHON_CONTEXT)
-
-
-#=======================================================================================================================
-# PyDBCommandThread
-#=======================================================================================================================
-class PyDBCommandThread(PyDBDaemonThread):
-
- def __init__(self, py_db):
- PyDBDaemonThread.__init__(self, py_db)
- self._py_db_command_thread_event = py_db._py_db_command_thread_event
- self.name = 'pydevd.CommandThread'
-
- @overrides(PyDBDaemonThread._on_run)
- def _on_run(self):
- # Delay a bit this initialization to wait for the main program to start.
- self._py_db_command_thread_event.wait(0.3)
-
- if self._kill_received:
- return
-
- try:
- while not self._kill_received:
- try:
- self.py_db.process_internal_commands()
- except:
- pydev_log.info('Finishing debug communication...(2)')
- self._py_db_command_thread_event.clear()
- self._py_db_command_thread_event.wait(0.3)
- except:
- try:
- pydev_log.debug(sys.exc_info()[0])
- except:
- # In interpreter shutdown many things can go wrong (any module variables may
- # be None, streams can be closed, etc).
- pass
-
- # only got this error in interpreter shutdown
- # pydev_log.info('Finishing debug communication...(3)')
-
- @overrides(PyDBDaemonThread.do_kill_pydev_thread)
- def do_kill_pydev_thread(self):
- PyDBDaemonThread.do_kill_pydev_thread(self)
- # Set flag so that it can exit before the usual timeout.
- self._py_db_command_thread_event.set()
-
-
-#=======================================================================================================================
-# CheckAliveThread
-# Non-daemon thread: guarantees that all data is written even if program is finished
-#=======================================================================================================================
-class CheckAliveThread(PyDBDaemonThread):
-
- def __init__(self, py_db):
- PyDBDaemonThread.__init__(self, py_db)
- self.name = 'pydevd.CheckAliveThread'
- self.daemon = False
- self._wait_event = threading.Event()
-
- @overrides(PyDBDaemonThread._on_run)
- def _on_run(self):
- py_db = self.py_db
-
- def can_exit():
- with py_db._main_lock:
- # Note: it's important to get the lock besides checking that it's empty (this
- # means that we're not in the middle of some command processing).
- writer = py_db.writer
- writer_empty = writer is not None and writer.empty()
-
- return not py_db.has_user_threads_alive() and writer_empty
-
- try:
- while not self._kill_received:
- self._wait_event.wait(0.3)
- if can_exit():
- break
-
- py_db.check_output_redirect()
-
- if can_exit():
- pydev_log.debug("No threads alive, finishing debug session")
- py_db.dispose_and_kill_all_pydevd_threads()
- except:
- pydev_log.exception()
-
- def join(self, timeout=None):
- # If someone tries to join this thread, mark it to be killed.
- # This is the case for CherryPy when auto-reload is turned on.
- self.do_kill_pydev_thread()
- PyDBDaemonThread.join(self, timeout=timeout)
-
- @overrides(PyDBDaemonThread.do_kill_pydev_thread)
- def do_kill_pydev_thread(self):
- PyDBDaemonThread.do_kill_pydev_thread(self)
- # Set flag so that it can exit before the usual timeout.
- self._wait_event.set()
-
-
-class AbstractSingleNotificationBehavior(object):
- '''
- The basic usage should be:
-
- # Increment the request time for the suspend.
- single_notification_behavior.increment_suspend_time()
-
- # Notify that this is a pause request (when a pause, not a breakpoint).
- single_notification_behavior.on_pause()
-
- # Mark threads to be suspended.
- set_suspend(...)
-
- # On do_wait_suspend, use notify_thread_suspended:
- def do_wait_suspend(...):
- with single_notification_behavior.notify_thread_suspended(thread_id, thread, reason):
- ...
- '''
-
- __slots__ = [
- '_last_resume_notification_time',
- '_last_suspend_notification_time',
- '_lock',
- '_next_request_time',
- '_suspend_time_request',
- '_suspended_thread_id_to_thread',
- '_pause_requested',
- '_py_db',
- ]
-
- NOTIFY_OF_PAUSE_TIMEOUT = .5
-
- def __init__(self, py_db):
- self._py_db = weakref.ref(py_db)
- self._next_request_time = partial(next, itertools.count())
- self._last_suspend_notification_time = -1
- self._last_resume_notification_time = -1
- self._suspend_time_request = self._next_request_time()
- self._lock = thread.allocate_lock()
- self._suspended_thread_id_to_thread = {}
- self._pause_requested = False
-
- def send_suspend_notification(self, thread_id, thread, stop_reason):
- raise AssertionError('abstract: subclasses must override.')
-
- def send_resume_notification(self, thread_id):
- raise AssertionError('abstract: subclasses must override.')
-
- def increment_suspend_time(self):
- with self._lock:
- self._suspend_time_request = self._next_request_time()
-
- def on_pause(self):
- # Upon a pause, we should force sending new suspend notifications
- # if no notification is sent after some time and there's some thread already stopped.
- with self._lock:
- self._pause_requested = True
- global_suspend_time = self._suspend_time_request
- py_db = self._py_db()
- if py_db is not None:
- py_db.timeout_tracker.call_on_timeout(
- self.NOTIFY_OF_PAUSE_TIMEOUT,
- self._notify_after_timeout,
- kwargs={'global_suspend_time': global_suspend_time}
- )
-
- def _notify_after_timeout(self, global_suspend_time):
- with self._lock:
- if self._suspended_thread_id_to_thread:
- if global_suspend_time > self._last_suspend_notification_time:
- self._last_suspend_notification_time = global_suspend_time
- # Notify about any thread which is currently suspended.
- pydev_log.info('Sending suspend notification after timeout.')
- thread_id, thread = next(iter(self._suspended_thread_id_to_thread.items()))
- self.send_suspend_notification(thread_id, thread, CMD_THREAD_SUSPEND)
-
- def on_thread_suspend(self, thread_id, thread, stop_reason):
- with self._lock:
- pause_requested = self._pause_requested
- if pause_requested:
- # When a suspend notification is sent, reset the pause flag.
- self._pause_requested = False
-
- self._suspended_thread_id_to_thread[thread_id] = thread
-
- # CMD_THREAD_SUSPEND should always be a side-effect of a break, so, only
- # issue for a CMD_THREAD_SUSPEND if a pause is pending.
- if stop_reason != CMD_THREAD_SUSPEND or pause_requested:
- if self._suspend_time_request > self._last_suspend_notification_time:
- pydev_log.info('Sending suspend notification.')
- self._last_suspend_notification_time = self._suspend_time_request
- self.send_suspend_notification(thread_id, thread, stop_reason)
- else:
- pydev_log.info(
- 'Suspend not sent (it was already sent). Last suspend % <= Last resume %s',
- self._last_suspend_notification_time,
- self._last_resume_notification_time,
- )
- else:
- pydev_log.info(
- 'Suspend not sent because stop reason is thread suspend and pause was not requested.',
- )
-
- def on_thread_resume(self, thread_id, thread):
- # on resume (step, continue all):
- with self._lock:
- self._suspended_thread_id_to_thread.pop(thread_id)
- if self._last_resume_notification_time < self._last_suspend_notification_time:
- pydev_log.info('Sending resume notification.')
- self._last_resume_notification_time = self._last_suspend_notification_time
- self.send_resume_notification(thread_id)
- else:
- pydev_log.info(
- 'Resume not sent (it was already sent). Last resume %s >= Last suspend %s',
- self._last_resume_notification_time,
- self._last_suspend_notification_time,
- )
-
- @contextmanager
- def notify_thread_suspended(self, thread_id, thread, stop_reason):
- self.on_thread_suspend(thread_id, thread, stop_reason)
- try:
- yield # At this point the thread must be actually suspended.
- finally:
- self.on_thread_resume(thread_id, thread)
-
-
-class ThreadsSuspendedSingleNotification(AbstractSingleNotificationBehavior):
-
- __slots__ = AbstractSingleNotificationBehavior.__slots__ + [
- 'multi_threads_single_notification', '_callbacks', '_callbacks_lock']
-
- def __init__(self, py_db):
- AbstractSingleNotificationBehavior.__init__(self, py_db)
- # If True, pydevd will send a single notification when all threads are suspended/resumed.
- self.multi_threads_single_notification = False
- self._callbacks_lock = threading.Lock()
- self._callbacks = []
-
- def add_on_resumed_callback(self, callback):
- with self._callbacks_lock:
- self._callbacks.append(callback)
-
- @overrides(AbstractSingleNotificationBehavior.send_resume_notification)
- def send_resume_notification(self, thread_id):
- py_db = self._py_db()
- if py_db is not None:
- py_db.writer.add_command(py_db.cmd_factory.make_thread_resume_single_notification(thread_id))
-
- with self._callbacks_lock:
- callbacks = self._callbacks
- self._callbacks = []
-
- for callback in callbacks:
- callback()
-
- @overrides(AbstractSingleNotificationBehavior.send_suspend_notification)
- def send_suspend_notification(self, thread_id, thread, stop_reason):
- py_db = self._py_db()
- if py_db is not None:
- py_db.writer.add_command(
- py_db.cmd_factory.make_thread_suspend_single_notification(
- py_db, thread_id, thread, stop_reason))
-
- @overrides(AbstractSingleNotificationBehavior.notify_thread_suspended)
- @contextmanager
- def notify_thread_suspended(self, thread_id, thread, stop_reason):
- if self.multi_threads_single_notification:
- with AbstractSingleNotificationBehavior.notify_thread_suspended(self, thread_id, thread, stop_reason):
- yield
- else:
- yield
-
-
-class _Authentication(object):
-
- __slots__ = ['access_token', 'client_access_token', '_authenticated', '_wrong_attempts']
-
- def __init__(self):
- # A token to be send in the command line or through the settrace api -- when such token
- # is given, the first message sent to the IDE must pass the same token to authenticate.
- # Note that if a disconnect is sent, the same message must be resent to authenticate.
- self.access_token = None
-
- # This token is the one that the client requires to accept a connection from pydevd
- # (it's stored here and just passed back when required, it's not used internally
- # for anything else).
- self.client_access_token = None
-
- self._authenticated = None
-
- self._wrong_attempts = 0
-
- def is_authenticated(self):
- if self._authenticated is None:
- return self.access_token is None
- return self._authenticated
-
- def login(self, access_token):
- if self._wrong_attempts >= 10: # A user can fail to authenticate at most 10 times.
- return
-
- self._authenticated = access_token == self.access_token
- if not self._authenticated:
- self._wrong_attempts += 1
- else:
- self._wrong_attempts = 0
-
- def logout(self):
- self._authenticated = None
- self._wrong_attempts = 0
-
-
-class PyDB(object):
- """ Main debugging class
- Lots of stuff going on here:
-
- PyDB starts two threads on startup that connect to remote debugger (RDB)
- The threads continuously read & write commands to RDB.
- PyDB communicates with these threads through command queues.
- Every RDB command is processed by calling process_net_command.
- Every PyDB net command is sent to the net by posting NetCommand to WriterThread queue
-
- Some commands need to be executed on the right thread (suspend/resume & friends)
- These are placed on the internal command queue.
- """
-
- # Direct child pids which should not be terminated when terminating processes.
- # Note: class instance because it should outlive PyDB instances.
- dont_terminate_child_pids = set()
-
- def __init__(self, set_as_global=True):
- if set_as_global:
- pydevd_tracing.replace_sys_set_trace_func()
-
- self.authentication = _Authentication()
-
- self.reader = None
- self.writer = None
- self._fsnotify_thread = None
- self.created_pydb_daemon_threads = {}
- self._waiting_for_connection_thread = None
- self._on_configuration_done_event = threading.Event()
- self.check_alive_thread = None
- self.py_db_command_thread = None
- self.quitting = None
- self.cmd_factory = NetCommandFactory()
- self._cmd_queue = defaultdict(_queue.Queue) # Key is thread id or '*', value is Queue
- self.suspended_frames_manager = SuspendedFramesManager()
- self._files_filtering = FilesFiltering()
- self.timeout_tracker = TimeoutTracker(self)
-
- # Note: when the source mapping is changed we also have to clear the file types cache
- # (because if a given file is a part of the project or not may depend on it being
- # defined in the source mapping).
- self.source_mapping = SourceMapping(on_source_mapping_changed=self._clear_filters_caches)
-
- # Determines whether we should terminate child processes when asked to terminate.
- self.terminate_child_processes = True
-
- # Determines whether we should try to do a soft terminate (i.e.: interrupt the main
- # thread with a KeyboardInterrupt).
- self.terminate_keyboard_interrupt = False
-
- # Set to True after a keyboard interrupt is requested the first time.
- self.keyboard_interrupt_requested = False
-
- # These are the breakpoints received by the PyDevdAPI. They are meant to store
- # the breakpoints in the api -- its actual contents are managed by the api.
- self.api_received_breakpoints = {}
-
- # These are the breakpoints meant to be consumed during runtime.
- self.breakpoints = {}
- self.function_breakpoint_name_to_breakpoint = {}
-
- # Set communication protocol
- PyDevdAPI().set_protocol(self, 0, PydevdCustomization.DEFAULT_PROTOCOL)
-
- self.variable_presentation = PyDevdAPI.VariablePresentation()
-
- # mtime to be raised when breakpoints change
- self.mtime = 0
-
- self.file_to_id_to_line_breakpoint = {}
- self.file_to_id_to_plugin_breakpoint = {}
-
- # Note: breakpoints dict should not be mutated: a copy should be created
- # and later it should be assigned back (to prevent concurrency issues).
- self.break_on_uncaught_exceptions = {}
- self.break_on_caught_exceptions = {}
- self.break_on_user_uncaught_exceptions = {}
-
- self.ready_to_run = False
- self._main_lock = thread.allocate_lock()
- self._lock_running_thread_ids = thread.allocate_lock()
- self._lock_create_fs_notify = thread.allocate_lock()
- self._py_db_command_thread_event = threading.Event()
- if set_as_global:
- CustomFramesContainer._py_db_command_thread_event = self._py_db_command_thread_event
-
- self.pydb_disposed = False
- self._wait_for_threads_to_finish_called = False
- self._wait_for_threads_to_finish_called_lock = thread.allocate_lock()
- self._wait_for_threads_to_finish_called_event = threading.Event()
-
- self.terminate_requested = False
- self._disposed_lock = thread.allocate_lock()
- self.signature_factory = None
- self.SetTrace = pydevd_tracing.SetTrace
- self.skip_on_exceptions_thrown_in_same_context = False
- self.ignore_exceptions_thrown_in_lines_with_ignore_exception = True
-
- # Suspend debugger even if breakpoint condition raises an exception.
- # May be changed with CMD_PYDEVD_JSON_CONFIG.
- self.skip_suspend_on_breakpoint_exception = () # By default suspend on any Exception.
- self.skip_print_breakpoint_exception = () # By default print on any Exception.
-
- # By default user can step into properties getter/setter/deleter methods
- self.disable_property_trace = False
- self.disable_property_getter_trace = False
- self.disable_property_setter_trace = False
- self.disable_property_deleter_trace = False
-
- # this is a dict of thread ids pointing to thread ids. Whenever a command is passed to the java end that
- # acknowledges that a thread was created, the thread id should be passed here -- and if at some time we do not
- # find that thread alive anymore, we must remove it from this list and make the java side know that the thread
- # was killed.
- self._running_thread_ids = {}
- # Note: also access '_enable_thread_notifications' with '_lock_running_thread_ids'
- self._enable_thread_notifications = False
-
- self._set_breakpoints_with_id = False
-
- # This attribute holds the file-> lines which have an @IgnoreException.
- self.filename_to_lines_where_exceptions_are_ignored = {}
-
- # working with plugins (lazily initialized)
- self.plugin = None
- self.has_plugin_line_breaks = False
- self.has_plugin_exception_breaks = False
- self.thread_analyser = None
- self.asyncio_analyser = None
-
- # The GUI event loop that's going to run.
- # Possible values:
- # matplotlib - Whatever GUI backend matplotlib is using.
- # 'wx'/'qt'/'none'/... - GUI toolkits that have bulitin support. See pydevd_ipython/inputhook.py:24.
- # Other - A custom function that'll be imported and run.
- self._gui_event_loop = 'matplotlib'
- self._installed_gui_support = False
- self.gui_in_use = False
-
- # GUI event loop support in debugger
- self.activate_gui_function = None
-
- # matplotlib support in debugger and debug console
- self.mpl_hooks_in_debug_console = False
- self.mpl_modules_for_patching = {}
-
- self._filename_to_not_in_scope = {}
- self.first_breakpoint_reached = False
- self._exclude_filters_enabled = self._files_filtering.use_exclude_filters()
- self._is_libraries_filter_enabled = self._files_filtering.use_libraries_filter()
- self.is_files_filter_enabled = self._exclude_filters_enabled or self._is_libraries_filter_enabled
- self.show_return_values = False
- self.remove_return_values_flag = False
- self.redirect_output = False
- # Note that besides the `redirect_output` flag, we also need to consider that someone
- # else is already redirecting (i.e.: debugpy).
- self.is_output_redirected = False
-
- # this flag disables frame evaluation even if it's available
- self.use_frame_eval = True
-
- # If True, pydevd will send a single notification when all threads are suspended/resumed.
- self._threads_suspended_single_notification = ThreadsSuspendedSingleNotification(self)
-
- # If True a step command will do a step in one thread and will also resume all other threads.
- self.stepping_resumes_all_threads = False
-
- self._local_thread_trace_func = threading.local()
-
- self._server_socket_ready_event = threading.Event()
- self._server_socket_name = None
-
- # Bind many locals to the debugger because upon teardown those names may become None
- # in the namespace (and thus can't be relied upon unless the reference was previously
- # saved).
- if IS_IRONPYTHON:
-
- # A partial() cannot be used in IronPython for sys.settrace.
- def new_trace_dispatch(frame, event, arg):
- return _trace_dispatch(self, frame, event, arg)
-
- self.trace_dispatch = new_trace_dispatch
- else:
- self.trace_dispatch = partial(_trace_dispatch, self)
- self.fix_top_level_trace_and_get_trace_func = fix_top_level_trace_and_get_trace_func
- self.frame_eval_func = frame_eval_func
- self.dummy_trace_dispatch = dummy_trace_dispatch
-
- # Note: this is different from pydevd_constants.thread_get_ident because we want Jython
- # to be None here because it also doesn't have threading._active.
- try:
- self.threading_get_ident = threading.get_ident # Python 3
- self.threading_active = threading._active
- except:
- try:
- self.threading_get_ident = threading._get_ident # Python 2 noqa
- self.threading_active = threading._active
- except:
- self.threading_get_ident = None # Jython
- self.threading_active = None
- self.threading_current_thread = threading.currentThread
- self.set_additional_thread_info = set_additional_thread_info
- self.stop_on_unhandled_exception = stop_on_unhandled_exception
- self.collect_return_info = collect_return_info
- self.get_exception_breakpoint = get_exception_breakpoint
- self._dont_trace_get_file_type = DONT_TRACE.get
- self._dont_trace_dirs_get_file_type = DONT_TRACE_DIRS.get
- self.PYDEV_FILE = PYDEV_FILE
- self.LIB_FILE = LIB_FILE
-
- self._in_project_scope_cache = {}
- self._exclude_by_filter_cache = {}
- self._apply_filter_cache = {}
- self._ignore_system_exit_codes = set()
-
- # DAP related
- self._dap_messages_listeners = []
-
- if set_as_global:
- # Set as the global instance only after it's initialized.
- set_global_debugger(self)
-
- pydevd_defaults.on_pydb_init(self)
- # Stop the tracing as the last thing before the actual shutdown for a clean exit.
- atexit.register(stoptrace)
-
- def collect_try_except_info(self, code_obj):
- filename = code_obj.co_filename
- try:
- if os.path.exists(filename):
- pydev_log.debug('Collecting try..except info from source for %s', filename)
- try_except_infos = collect_try_except_info_from_source(filename)
- if try_except_infos:
- # Filter for the current function
- max_line = -1
- min_line = sys.maxsize
- for _, line in dis.findlinestarts(code_obj):
-
- if line > max_line:
- max_line = line
-
- if line < min_line:
- min_line = line
-
- try_except_infos = [x for x in try_except_infos if min_line <= x.try_line <= max_line]
- return try_except_infos
-
- except:
- pydev_log.exception('Error collecting try..except info from source (%s)', filename)
-
- pydev_log.debug('Collecting try..except info from bytecode for %s', filename)
- return collect_try_except_info(code_obj)
-
- def setup_auto_reload_watcher(self, enable_auto_reload, watch_dirs, poll_target_time, exclude_patterns, include_patterns):
- try:
- with self._lock_create_fs_notify:
-
- # When setting up, dispose of the previous one (if any).
- if self._fsnotify_thread is not None:
- self._fsnotify_thread.do_kill_pydev_thread()
- self._fsnotify_thread = None
-
- if not enable_auto_reload:
- return
-
- exclude_patterns = tuple(exclude_patterns)
- include_patterns = tuple(include_patterns)
-
- def accept_directory(absolute_filename, cache={}):
- try:
- return cache[absolute_filename]
- except:
- if absolute_filename and absolute_filename[-1] not in ('/', '\\'):
- # I.e.: for directories we always end with '/' or '\\' so that
- # we match exclusions such as "**/node_modules/**"
- absolute_filename += os.path.sep
-
- # First include what we want
- for include_pattern in include_patterns:
- if glob_matches_path(absolute_filename, include_pattern):
- cache[absolute_filename] = True
- return True
-
- # Then exclude what we don't want
- for exclude_pattern in exclude_patterns:
- if glob_matches_path(absolute_filename, exclude_pattern):
- cache[absolute_filename] = False
- return False
-
- # By default track all directories not excluded.
- cache[absolute_filename] = True
- return True
-
- def accept_file(absolute_filename, cache={}):
- try:
- return cache[absolute_filename]
- except:
- # First include what we want
- for include_pattern in include_patterns:
- if glob_matches_path(absolute_filename, include_pattern):
- cache[absolute_filename] = True
- return True
-
- # Then exclude what we don't want
- for exclude_pattern in exclude_patterns:
- if glob_matches_path(absolute_filename, exclude_pattern):
- cache[absolute_filename] = False
- return False
-
- # By default don't track files not included.
- cache[absolute_filename] = False
- return False
-
- self._fsnotify_thread = FSNotifyThread(self, PyDevdAPI(), watch_dirs)
- watcher = self._fsnotify_thread.watcher
- watcher.accept_directory = accept_directory
- watcher.accept_file = accept_file
-
- watcher.target_time_for_single_scan = poll_target_time
- watcher.target_time_for_notification = poll_target_time
- self._fsnotify_thread.start()
- except:
- pydev_log.exception('Error setting up auto-reload.')
-
- def get_arg_ppid(self):
- try:
- setup = SetupHolder.setup
- if setup:
- return int(setup.get('ppid', 0))
- except:
- pydev_log.exception('Error getting ppid.')
-
- return 0
-
- def wait_for_ready_to_run(self):
- while not self.ready_to_run:
- # busy wait until we receive run command
- self.process_internal_commands()
- self._py_db_command_thread_event.clear()
- self._py_db_command_thread_event.wait(0.1)
-
- def on_initialize(self):
- '''
- Note: only called when using the DAP (Debug Adapter Protocol).
- '''
- self._on_configuration_done_event.clear()
-
- def on_configuration_done(self):
- '''
- Note: only called when using the DAP (Debug Adapter Protocol).
- '''
- self._on_configuration_done_event.set()
- self._py_db_command_thread_event.set()
-
- def is_attached(self):
- return self._on_configuration_done_event.is_set()
-
- def on_disconnect(self):
- '''
- Note: only called when using the DAP (Debug Adapter Protocol).
- '''
- self.authentication.logout()
- self._on_configuration_done_event.clear()
-
- def set_ignore_system_exit_codes(self, ignore_system_exit_codes):
- assert isinstance(ignore_system_exit_codes, (list, tuple, set))
- self._ignore_system_exit_codes = set(ignore_system_exit_codes)
-
- def ignore_system_exit_code(self, system_exit_exc):
- if hasattr(system_exit_exc, 'code'):
- return system_exit_exc.code in self._ignore_system_exit_codes
- else:
- return system_exit_exc in self._ignore_system_exit_codes
-
- def block_until_configuration_done(self, cancel=None):
- if cancel is None:
- cancel = NULL
-
- while not cancel.is_set():
- if self._on_configuration_done_event.is_set():
- cancel.set() # Set cancel to prevent reuse
- return
-
- self.process_internal_commands()
- self._py_db_command_thread_event.clear()
- self._py_db_command_thread_event.wait(1 / 15.)
-
- def add_fake_frame(self, thread_id, frame_id, frame):
- self.suspended_frames_manager.add_fake_frame(thread_id, frame_id, frame)
-
- def handle_breakpoint_condition(self, info, pybreakpoint, new_frame):
- condition = pybreakpoint.condition
- try:
- if pybreakpoint.handle_hit_condition(new_frame):
- return True
-
- if not condition:
- return False
-
- return eval(condition, new_frame.f_globals, new_frame.f_locals)
- except Exception as e:
- if not isinstance(e, self.skip_print_breakpoint_exception):
- stack_trace = io.StringIO()
- etype, value, tb = sys.exc_info()
- traceback.print_exception(etype, value, tb.tb_next, file=stack_trace)
-
- msg = 'Error while evaluating expression in conditional breakpoint: %s\n%s' % (
- condition, stack_trace.getvalue())
- api = PyDevdAPI()
- api.send_error_message(self, msg)
-
- if not isinstance(e, self.skip_suspend_on_breakpoint_exception):
- try:
- # add exception_type and stacktrace into thread additional info
- etype, value, tb = sys.exc_info()
- error = ''.join(traceback.format_exception_only(etype, value))
- stack = traceback.extract_stack(f=tb.tb_frame.f_back)
-
- # On self.set_suspend(thread, CMD_SET_BREAK) this info will be
- # sent to the client.
- info.conditional_breakpoint_exception = \
- ('Condition:\n' + condition + '\n\nError:\n' + error, stack)
- except:
- pydev_log.exception()
- return True
-
- return False
-
- finally:
- etype, value, tb = None, None, None
-
- def handle_breakpoint_expression(self, pybreakpoint, info, new_frame):
- try:
- try:
- val = eval(pybreakpoint.expression, new_frame.f_globals, new_frame.f_locals)
- except:
- val = sys.exc_info()[1]
- finally:
- if val is not None:
- info.pydev_message = str(val)
-
- def _internal_get_file_type(self, abs_real_path_and_basename):
- basename = abs_real_path_and_basename[-1]
- if (
- basename.startswith(IGNORE_BASENAMES_STARTING_WITH) or
- abs_real_path_and_basename[0].startswith(IGNORE_BASENAMES_STARTING_WITH)
- ):
- # Note: these are the files that are completely ignored (they aren't shown to the user
- # as user nor library code as it's usually just noise in the frame stack).
- return self.PYDEV_FILE
- file_type = self._dont_trace_get_file_type(basename)
- if file_type is not None:
- return file_type
-
- if basename.startswith('__init__.py'):
- # i.e.: ignore the __init__ files inside pydevd (the other
- # files are ignored just by their name).
- abs_path = abs_real_path_and_basename[0]
- i = max(abs_path.rfind('/'), abs_path.rfind('\\'))
- if i:
- abs_path = abs_path[0:i]
- i = max(abs_path.rfind('/'), abs_path.rfind('\\'))
- if i:
- dirname = abs_path[i + 1:]
- # At this point, something as:
- # "my_path\_pydev_runfiles\__init__.py"
- # is now "_pydev_runfiles".
- return self._dont_trace_dirs_get_file_type(dirname)
- return None
-
- def dont_trace_external_files(self, abs_path):
- '''
- :param abs_path:
- The result from get_abs_path_real_path_and_base_from_file or
- get_abs_path_real_path_and_base_from_frame.
-
- :return
- True :
- If files should NOT be traced.
-
- False:
- If files should be traced.
- '''
- # By default all external files are traced. Note: this function is expected to
- # be changed for another function in PyDevdAPI.set_dont_trace_start_end_patterns.
- return False
-
- def get_file_type(self, frame, abs_real_path_and_basename=None, _cache_file_type=_CACHE_FILE_TYPE):
- '''
- :param abs_real_path_and_basename:
- The result from get_abs_path_real_path_and_base_from_file or
- get_abs_path_real_path_and_base_from_frame.
-
- :return
- _pydevd_bundle.pydevd_dont_trace_files.PYDEV_FILE:
- If it's a file internal to the debugger which shouldn't be
- traced nor shown to the user.
-
- _pydevd_bundle.pydevd_dont_trace_files.LIB_FILE:
- If it's a file in a library which shouldn't be traced.
-
- None:
- If it's a regular user file which should be traced.
- '''
- if abs_real_path_and_basename is None:
- try:
- # Make fast path faster!
- abs_real_path_and_basename = NORM_PATHS_AND_BASE_CONTAINER[frame.f_code.co_filename]
- except:
- abs_real_path_and_basename = get_abs_path_real_path_and_base_from_frame(frame)
-
- # Note 1: we have to take into account that we may have files as '', and that in
- # this case the cache key can't rely only on the filename. With the current cache, there's
- # still a potential miss if 2 functions which have exactly the same content are compiled
- # with '', but in practice as we only separate the one from python -c from the rest
- # this shouldn't be a problem in practice.
-
- # Note 2: firstlineno added to make misses faster in the first comparison.
-
- # Note 3: this cache key is repeated in pydevd_frame_evaluator.pyx:get_func_code_info (for
- # speedups).
- cache_key = (frame.f_code.co_firstlineno, abs_real_path_and_basename[0], frame.f_code)
- try:
- return _cache_file_type[cache_key]
- except:
- if abs_real_path_and_basename[0] == '':
-
- # Consider it an untraceable file unless there's no back frame (ignoring
- # internal files and runpy.py).
- f = frame.f_back
- while f is not None:
- if (self.get_file_type(f) != self.PYDEV_FILE and
- pydevd_file_utils.basename(f.f_code.co_filename) not in ('runpy.py', '')):
- # We found some back frame that's not internal, which means we must consider
- # this a library file.
- # This is done because we only want to trace files as if they don't
- # have any back frame (which is the case for python -c ...), for all other
- # cases we don't want to trace them because we can't show the source to the
- # user (at least for now...).
-
- # Note that we return as a LIB_FILE and not PYDEV_FILE because we still want
- # to show it in the stack.
- _cache_file_type[cache_key] = LIB_FILE
- return LIB_FILE
- f = f.f_back
- else:
- # This is a top-level file (used in python -c), so, trace it as usual... we
- # still won't be able to show the sources, but some tests require this to work.
- _cache_file_type[cache_key] = None
- return None
-
- file_type = self._internal_get_file_type(abs_real_path_and_basename)
- if file_type is None:
- if self.dont_trace_external_files(abs_real_path_and_basename[0]):
- file_type = PYDEV_FILE
-
- _cache_file_type[cache_key] = file_type
- return file_type
-
- def is_cache_file_type_empty(self):
- return not _CACHE_FILE_TYPE
-
- def get_cache_file_type(self, _cache=_CACHE_FILE_TYPE): # i.e.: Make it local.
- return _cache
-
- def get_thread_local_trace_func(self):
- try:
- thread_trace_func = self._local_thread_trace_func.thread_trace_func
- except AttributeError:
- thread_trace_func = self.trace_dispatch
- return thread_trace_func
-
- def enable_tracing(self, thread_trace_func=None, apply_to_all_threads=False):
- '''
- Enables tracing.
-
- If in regular mode (tracing), will set the tracing function to the tracing
- function for this thread -- by default it's `PyDB.trace_dispatch`, but after
- `PyDB.enable_tracing` is called with a `thread_trace_func`, the given function will
- be the default for the given thread.
-
- :param bool apply_to_all_threads:
- If True we'll set the tracing function in all threads, not only in the current thread.
- If False only the tracing for the current function should be changed.
- In general apply_to_all_threads should only be true if this is the first time
- this function is called on a multi-threaded program (either programmatically or attach
- to pid).
- '''
- if pydevd_gevent_integration is not None:
- pydevd_gevent_integration.enable_gevent_integration()
-
- if self.frame_eval_func is not None:
- self.frame_eval_func()
- pydevd_tracing.SetTrace(self.dummy_trace_dispatch)
-
- if IS_CPYTHON and apply_to_all_threads:
- pydevd_tracing.set_trace_to_threads(self.dummy_trace_dispatch)
- return
-
- if apply_to_all_threads:
- # If applying to all threads, don't use the local thread trace function.
- assert thread_trace_func is not None
- else:
- if thread_trace_func is None:
- thread_trace_func = self.get_thread_local_trace_func()
- else:
- self._local_thread_trace_func.thread_trace_func = thread_trace_func
-
- pydevd_tracing.SetTrace(thread_trace_func)
- if IS_CPYTHON and apply_to_all_threads:
- pydevd_tracing.set_trace_to_threads(thread_trace_func)
-
- def disable_tracing(self):
- pydevd_tracing.SetTrace(None)
-
- def on_breakpoints_changed(self, removed=False):
- '''
- When breakpoints change, we have to re-evaluate all the assumptions we've made so far.
- '''
- if not self.ready_to_run:
- # No need to do anything if we're still not running.
- return
-
- self.mtime += 1
- if not removed:
- # When removing breakpoints we can leave tracing as was, but if a breakpoint was added
- # we have to reset the tracing for the existing functions to be re-evaluated.
- self.set_tracing_for_untraced_contexts()
-
- def set_tracing_for_untraced_contexts(self):
- # Enable the tracing for existing threads (because there may be frames being executed that
- # are currently untraced).
-
- if IS_CPYTHON:
- # Note: use sys._current_frames instead of threading.enumerate() because this way
- # we also see C/C++ threads, not only the ones visible to the threading module.
- tid_to_frame = sys._current_frames()
-
- ignore_thread_ids = set(
- t.ident for t in threadingEnumerate()
- if getattr(t, 'is_pydev_daemon_thread', False) or getattr(t, 'pydev_do_not_trace', False)
- )
-
- for thread_id, frame in tid_to_frame.items():
- if thread_id not in ignore_thread_ids:
- self.set_trace_for_frame_and_parents(frame)
-
- else:
- try:
- threads = threadingEnumerate()
- for t in threads:
- if getattr(t, 'is_pydev_daemon_thread', False) or getattr(t, 'pydev_do_not_trace', False):
- continue
-
- additional_info = set_additional_thread_info(t)
- frame = additional_info.get_topmost_frame(t)
- try:
- if frame is not None:
- self.set_trace_for_frame_and_parents(frame)
- finally:
- frame = None
- finally:
- frame = None
- t = None
- threads = None
- additional_info = None
-
- @property
- def multi_threads_single_notification(self):
- return self._threads_suspended_single_notification.multi_threads_single_notification
-
- @multi_threads_single_notification.setter
- def multi_threads_single_notification(self, notify):
- self._threads_suspended_single_notification.multi_threads_single_notification = notify
-
- @property
- def threads_suspended_single_notification(self):
- return self._threads_suspended_single_notification
-
- def get_plugin_lazy_init(self):
- if self.plugin is None:
- self.plugin = PluginManager(self)
- return self.plugin
-
- def in_project_scope(self, frame, absolute_filename=None):
- '''
- Note: in general this method should not be used (apply_files_filter should be used
- in most cases as it also handles the project scope check).
-
- :param frame:
- The frame we want to check.
-
- :param absolute_filename:
- Must be the result from get_abs_path_real_path_and_base_from_frame(frame)[0] (can
- be used to speed this function a bit if it's already available to the caller, but
- in general it's not needed).
- '''
- try:
- if absolute_filename is None:
- try:
- # Make fast path faster!
- abs_real_path_and_basename = NORM_PATHS_AND_BASE_CONTAINER[frame.f_code.co_filename]
- except:
- abs_real_path_and_basename = get_abs_path_real_path_and_base_from_frame(frame)
-
- absolute_filename = abs_real_path_and_basename[0]
-
- cache_key = (frame.f_code.co_firstlineno, absolute_filename, frame.f_code)
-
- return self._in_project_scope_cache[cache_key]
- except KeyError:
- cache = self._in_project_scope_cache
- try:
- abs_real_path_and_basename # If we've gotten it previously, use it again.
- except NameError:
- abs_real_path_and_basename = get_abs_path_real_path_and_base_from_frame(frame)
-
- # pydevd files are never considered to be in the project scope.
- file_type = self.get_file_type(frame, abs_real_path_and_basename)
- if file_type == self.PYDEV_FILE:
- cache[cache_key] = False
-
- elif absolute_filename == '':
- # Special handling for ''
- if file_type == self.LIB_FILE:
- cache[cache_key] = False
- else:
- cache[cache_key] = True
-
- elif self.source_mapping.has_mapping_entry(absolute_filename):
- cache[cache_key] = True
-
- else:
- cache[cache_key] = self._files_filtering.in_project_roots(absolute_filename)
-
- return cache[cache_key]
-
- def in_project_roots_filename_uncached(self, absolute_filename):
- return self._files_filtering.in_project_roots(absolute_filename)
-
- def _clear_filters_caches(self):
- self._in_project_scope_cache.clear()
- self._exclude_by_filter_cache.clear()
- self._apply_filter_cache.clear()
- self._exclude_filters_enabled = self._files_filtering.use_exclude_filters()
- self._is_libraries_filter_enabled = self._files_filtering.use_libraries_filter()
- self.is_files_filter_enabled = self._exclude_filters_enabled or self._is_libraries_filter_enabled
-
- def clear_dont_trace_start_end_patterns_caches(self):
- # When start/end patterns are changed we must clear all caches which would be
- # affected by a change in get_file_type() and reset the tracing function
- # as places which were traced may no longer need to be traced and vice-versa.
- self.on_breakpoints_changed()
- _CACHE_FILE_TYPE.clear()
- self._clear_filters_caches()
- self._clear_skip_caches()
-
- def _exclude_by_filter(self, frame, absolute_filename):
- '''
- :return: True if it should be excluded, False if it should be included and None
- if no rule matched the given file.
-
- :note: it'll be normalized as needed inside of this method.
- '''
- cache_key = (absolute_filename, frame.f_code.co_name, frame.f_code.co_firstlineno)
- try:
- return self._exclude_by_filter_cache[cache_key]
- except KeyError:
- cache = self._exclude_by_filter_cache
-
- # pydevd files are always filtered out
- if self.get_file_type(frame) == self.PYDEV_FILE:
- cache[cache_key] = True
- else:
- module_name = None
- if self._files_filtering.require_module:
- module_name = frame.f_globals.get('__name__', '')
- cache[cache_key] = self._files_filtering.exclude_by_filter(absolute_filename, module_name)
-
- return cache[cache_key]
-
- def apply_files_filter(self, frame, original_filename, force_check_project_scope):
- '''
- Should only be called if `self.is_files_filter_enabled == True` or `force_check_project_scope == True`.
-
- Note that it covers both the filter by specific paths includes/excludes as well
- as the check which filters out libraries if not in the project scope.
-
- :param original_filename:
- Note can either be the original filename or the absolute version of that filename.
-
- :param force_check_project_scope:
- Check that the file is in the project scope even if the global setting
- is off.
-
- :return bool:
- True if it should be excluded when stepping and False if it should be
- included.
- '''
- cache_key = (frame.f_code.co_firstlineno, original_filename, force_check_project_scope, frame.f_code)
- try:
- return self._apply_filter_cache[cache_key]
- except KeyError:
- if self.plugin is not None and (self.has_plugin_line_breaks or self.has_plugin_exception_breaks):
- # If it's explicitly needed by some plugin, we can't skip it.
- if not self.plugin.can_skip(self, frame):
- pydev_log.debug_once('File traced (included by plugins): %s', original_filename)
- self._apply_filter_cache[cache_key] = False
- return False
-
- if self._exclude_filters_enabled:
- absolute_filename = pydevd_file_utils.absolute_path(original_filename)
- exclude_by_filter = self._exclude_by_filter(frame, absolute_filename)
- if exclude_by_filter is not None:
- if exclude_by_filter:
- # ignore files matching stepping filters
- pydev_log.debug_once('File not traced (excluded by filters): %s', original_filename)
-
- self._apply_filter_cache[cache_key] = True
- return True
- else:
- pydev_log.debug_once('File traced (explicitly included by filters): %s', original_filename)
-
- self._apply_filter_cache[cache_key] = False
- return False
-
- if (self._is_libraries_filter_enabled or force_check_project_scope) and not self.in_project_scope(frame):
- # ignore library files while stepping
- self._apply_filter_cache[cache_key] = True
- if force_check_project_scope:
- pydev_log.debug_once('File not traced (not in project): %s', original_filename)
- else:
- pydev_log.debug_once('File not traced (not in project - force_check_project_scope): %s', original_filename)
-
- return True
-
- if force_check_project_scope:
- pydev_log.debug_once('File traced: %s (force_check_project_scope)', original_filename)
- else:
- pydev_log.debug_once('File traced: %s', original_filename)
- self._apply_filter_cache[cache_key] = False
- return False
-
- def exclude_exception_by_filter(self, exception_breakpoint, trace):
- if not exception_breakpoint.ignore_libraries and not self._exclude_filters_enabled:
- return False
-
- if trace is None:
- return True
-
- ignore_libraries = exception_breakpoint.ignore_libraries
- exclude_filters_enabled = self._exclude_filters_enabled
-
- if (ignore_libraries and not self.in_project_scope(trace.tb_frame)) \
- or (exclude_filters_enabled and self._exclude_by_filter(
- trace.tb_frame,
- pydevd_file_utils.absolute_path(trace.tb_frame.f_code.co_filename))):
- return True
-
- return False
-
- def set_project_roots(self, project_roots):
- self._files_filtering.set_project_roots(project_roots)
- self._clear_skip_caches()
- self._clear_filters_caches()
-
- def set_exclude_filters(self, exclude_filters):
- self._files_filtering.set_exclude_filters(exclude_filters)
- self._clear_skip_caches()
- self._clear_filters_caches()
-
- def set_use_libraries_filter(self, use_libraries_filter):
- self._files_filtering.set_use_libraries_filter(use_libraries_filter)
- self._clear_skip_caches()
- self._clear_filters_caches()
-
- def get_use_libraries_filter(self):
- return self._files_filtering.use_libraries_filter()
-
- def get_require_module_for_filters(self):
- return self._files_filtering.require_module
-
- def has_user_threads_alive(self):
- for t in pydevd_utils.get_non_pydevd_threads():
- if isinstance(t, PyDBDaemonThread):
- pydev_log.error_once(
- 'Error in debugger: Found PyDBDaemonThread not marked with is_pydev_daemon_thread=True.\n')
-
- if is_thread_alive(t):
- if not t.daemon or hasattr(t, "__pydevd_main_thread"):
- return True
-
- return False
-
- def initialize_network(self, sock, terminate_on_socket_close=True):
- assert sock is not None
- try:
- sock.settimeout(None) # infinite, no timeouts from now on - jython does not have it
- except:
- pass
- curr_reader = getattr(self, 'reader', None)
- curr_writer = getattr(self, 'writer', None)
- if curr_reader:
- curr_reader.do_kill_pydev_thread()
- if curr_writer:
- curr_writer.do_kill_pydev_thread()
-
- self.writer = WriterThread(sock, self, terminate_on_socket_close=terminate_on_socket_close)
- self.reader = ReaderThread(
- sock,
- self,
- PyDevJsonCommandProcessor=PyDevJsonCommandProcessor,
- process_net_command=process_net_command,
- terminate_on_socket_close=terminate_on_socket_close
- )
- self.writer.start()
- self.reader.start()
-
- time.sleep(0.1) # give threads time to start
-
- def connect(self, host, port):
- if host:
- s = start_client(host, port)
- else:
- s = start_server(port)
-
- self.initialize_network(s)
-
- def create_wait_for_connection_thread(self):
- if self._waiting_for_connection_thread is not None:
- raise AssertionError('There is already another thread waiting for a connection.')
-
- self._server_socket_ready_event.clear()
- self._waiting_for_connection_thread = self._WaitForConnectionThread(self)
- self._waiting_for_connection_thread.start()
-
- def set_server_socket_ready(self):
- self._server_socket_ready_event.set()
-
- def wait_for_server_socket_ready(self):
- self._server_socket_ready_event.wait()
-
- @property
- def dap_messages_listeners(self):
- return self._dap_messages_listeners
-
- def add_dap_messages_listener(self, listener):
- self._dap_messages_listeners.append(listener)
-
- class _WaitForConnectionThread(PyDBDaemonThread):
-
- def __init__(self, py_db):
- PyDBDaemonThread.__init__(self, py_db)
- self._server_socket = None
-
- def run(self):
- host = SetupHolder.setup['client']
- port = SetupHolder.setup['port']
-
- self._server_socket = create_server_socket(host=host, port=port)
- self.py_db._server_socket_name = self._server_socket.getsockname()
- self.py_db.set_server_socket_ready()
-
- while not self._kill_received:
- try:
- s = self._server_socket
- if s is None:
- return
-
- s.listen(1)
- new_socket, _addr = s.accept()
- if self._kill_received:
- pydev_log.info("Connection (from wait_for_attach) accepted but ignored as kill was already received.")
- return
-
- pydev_log.info("Connection (from wait_for_attach) accepted.")
- reader = getattr(self.py_db, 'reader', None)
- if reader is not None:
- # This is needed if a new connection is done without the client properly
- # sending a disconnect for the previous connection.
- api = PyDevdAPI()
- api.request_disconnect(self.py_db, resume_threads=False)
-
- self.py_db.initialize_network(new_socket, terminate_on_socket_close=False)
-
- except:
- if DebugInfoHolder.DEBUG_TRACE_LEVEL > 0:
- pydev_log.exception()
- pydev_log.debug("Exiting _WaitForConnectionThread: %s\n", port)
-
- def do_kill_pydev_thread(self):
- PyDBDaemonThread.do_kill_pydev_thread(self)
- s = self._server_socket
- if s is not None:
- try:
- s.close()
- except:
- pass
- self._server_socket = None
-
- def get_internal_queue(self, thread_id):
- """ returns internal command queue for a given thread.
- if new queue is created, notify the RDB about it """
- if thread_id.startswith('__frame__'):
- thread_id = thread_id[thread_id.rfind('|') + 1:]
- return self._cmd_queue[thread_id]
-
- def post_method_as_internal_command(self, thread_id, method, *args, **kwargs):
- if thread_id == '*':
- internal_cmd = InternalThreadCommandForAnyThread(thread_id, method, *args, **kwargs)
- else:
- internal_cmd = InternalThreadCommand(thread_id, method, *args, **kwargs)
- self.post_internal_command(internal_cmd, thread_id)
- if thread_id == '*':
- # Notify so that the command is handled as soon as possible.
- self._py_db_command_thread_event.set()
-
- def post_internal_command(self, int_cmd, thread_id):
- """ if thread_id is *, post to the '*' queue"""
- queue = self.get_internal_queue(thread_id)
- queue.put(int_cmd)
-
- def enable_output_redirection(self, redirect_stdout, redirect_stderr):
- global _global_redirect_stdout_to_server
- global _global_redirect_stderr_to_server
-
- _global_redirect_stdout_to_server = redirect_stdout
- _global_redirect_stderr_to_server = redirect_stderr
- self.redirect_output = redirect_stdout or redirect_stderr
- if _global_redirect_stdout_to_server:
- _init_stdout_redirect()
- if _global_redirect_stderr_to_server:
- _init_stderr_redirect()
-
- def check_output_redirect(self):
- global _global_redirect_stdout_to_server
- global _global_redirect_stderr_to_server
-
- if _global_redirect_stdout_to_server:
- _init_stdout_redirect()
-
- if _global_redirect_stderr_to_server:
- _init_stderr_redirect()
-
- def init_matplotlib_in_debug_console(self):
- # import hook and patches for matplotlib support in debug console
- from _pydev_bundle.pydev_import_hook import import_hook_manager
- if is_current_thread_main_thread():
- for module in list(self.mpl_modules_for_patching):
- import_hook_manager.add_module_name(module, self.mpl_modules_for_patching.pop(module))
-
- def init_gui_support(self):
- if self._installed_gui_support:
- return
- self._installed_gui_support = True
-
- # enable_gui and enable_gui_function in activate_matplotlib should be called in main thread. Unlike integrated console,
- # in the debug console we have no interpreter instance with exec_queue, but we run this code in the main
- # thread and can call it directly.
- class _ReturnGuiLoopControlHelper:
- _return_control_osc = False
-
- def return_control():
- # Some of the input hooks (e.g. Qt4Agg) check return control without doing
- # a single operation, so we don't return True on every
- # call when the debug hook is in place to allow the GUI to run
- _ReturnGuiLoopControlHelper._return_control_osc = not _ReturnGuiLoopControlHelper._return_control_osc
- return _ReturnGuiLoopControlHelper._return_control_osc
-
- from pydev_ipython.inputhook import set_return_control_callback, enable_gui
-
- set_return_control_callback(return_control)
-
- if self._gui_event_loop == 'matplotlib':
- # prepare debugger for matplotlib integration with GUI event loop
- from pydev_ipython.matplotlibtools import activate_matplotlib, activate_pylab, activate_pyplot, do_enable_gui
-
- self.mpl_modules_for_patching = {"matplotlib": lambda: activate_matplotlib(do_enable_gui),
- "matplotlib.pyplot": activate_pyplot,
- "pylab": activate_pylab }
- else:
- self.activate_gui_function = enable_gui
-
- def _activate_gui_if_needed(self):
- if self.gui_in_use:
- return
-
- if len(self.mpl_modules_for_patching) > 0:
- if is_current_thread_main_thread(): # Note that we call only in the main thread.
- for module in list(self.mpl_modules_for_patching):
- if module in sys.modules:
- activate_function = self.mpl_modules_for_patching.pop(module, None)
- if activate_function is not None:
- activate_function()
- self.gui_in_use = True
-
- if self.activate_gui_function:
- if is_current_thread_main_thread(): # Only call enable_gui in the main thread.
- try:
- # First try to activate builtin GUI event loops.
- self.activate_gui_function(self._gui_event_loop)
- self.activate_gui_function = None
- self.gui_in_use = True
- except ValueError:
- # The user requested a custom GUI event loop, try to import it.
- from pydev_ipython.inputhook import set_inputhook
- try:
- inputhook_function = import_attr_from_module(self._gui_event_loop)
- set_inputhook(inputhook_function)
- self.gui_in_use = True
- except Exception as e:
- pydev_log.debug("Cannot activate custom GUI event loop {}: {}".format(self._gui_event_loop, e))
- finally:
- self.activate_gui_function = None
-
- def _call_input_hook(self):
- try:
- from pydev_ipython.inputhook import get_inputhook
- inputhook = get_inputhook()
- if inputhook:
- inputhook()
- except:
- pass
-
- def notify_skipped_step_in_because_of_filters(self, frame):
- self.writer.add_command(self.cmd_factory.make_skipped_step_in_because_of_filters(self, frame))
-
- def notify_thread_created(self, thread_id, thread, use_lock=True):
- if self.writer is None:
- # Protect about threads being created before the communication structure is in place
- # (note that they will appear later on anyways as pydevd does reconcile live/dead threads
- # when processing internal commands, albeit it may take longer and in general this should
- # not be usual as it's expected that the debugger is live before other threads are created).
- return
-
- with self._lock_running_thread_ids if use_lock else NULL:
- if not self._enable_thread_notifications:
- return
-
- if thread_id in self._running_thread_ids:
- return
-
- additional_info = set_additional_thread_info(thread)
- if additional_info.pydev_notify_kill:
- # After we notify it should be killed, make sure we don't notify it's alive (on a racing condition
- # this could happen as we may notify before the thread is stopped internally).
- return
-
- self._running_thread_ids[thread_id] = thread
-
- self.writer.add_command(self.cmd_factory.make_thread_created_message(thread))
-
- def notify_thread_not_alive(self, thread_id, use_lock=True):
- """ if thread is not alive, cancel trace_dispatch processing """
- if self.writer is None:
- return
-
- with self._lock_running_thread_ids if use_lock else NULL:
- if not self._enable_thread_notifications:
- return
-
- thread = self._running_thread_ids.pop(thread_id, None)
- if thread is None:
- return
-
- additional_info = set_additional_thread_info(thread)
- was_notified = additional_info.pydev_notify_kill
- if not was_notified:
- additional_info.pydev_notify_kill = True
-
- self.writer.add_command(self.cmd_factory.make_thread_killed_message(thread_id))
-
- def set_enable_thread_notifications(self, enable):
- with self._lock_running_thread_ids:
- if self._enable_thread_notifications != enable:
- self._enable_thread_notifications = enable
-
- if enable:
- # As it was previously disabled, we have to notify about existing threads again
- # (so, clear the cache related to that).
- self._running_thread_ids = {}
-
- def process_internal_commands(self):
- '''
- This function processes internal commands.
- '''
- # If this method is being called before the debugger is ready to run we should not notify
- # about threads and should only process commands sent to all threads.
- ready_to_run = self.ready_to_run
-
- dispose = False
- with self._main_lock:
- program_threads_alive = {}
- if ready_to_run:
- self.check_output_redirect()
-
- all_threads = threadingEnumerate()
- program_threads_dead = []
- with self._lock_running_thread_ids:
- reset_cache = not self._running_thread_ids
-
- for t in all_threads:
- if getattr(t, 'is_pydev_daemon_thread', False):
- pass # I.e.: skip the DummyThreads created from pydev daemon threads
- elif isinstance(t, PyDBDaemonThread):
- pydev_log.error_once('Error in debugger: Found PyDBDaemonThread not marked with is_pydev_daemon_thread=True.')
-
- elif is_thread_alive(t):
- if reset_cache:
- # Fix multiprocessing debug with breakpoints in both main and child processes
- # (https://youtrack.jetbrains.com/issue/PY-17092) When the new process is created, the main
- # thread in the new process already has the attribute 'pydevd_id', so the new thread doesn't
- # get new id with its process number and the debugger loses access to both threads.
- # Therefore we should update thread_id for every main thread in the new process.
- clear_cached_thread_id(t)
-
- thread_id = get_thread_id(t)
- program_threads_alive[thread_id] = t
-
- self.notify_thread_created(thread_id, t, use_lock=False)
-
- # Compute and notify about threads which are no longer alive.
- thread_ids = list(self._running_thread_ids.keys())
- for thread_id in thread_ids:
- if thread_id not in program_threads_alive:
- program_threads_dead.append(thread_id)
-
- for thread_id in program_threads_dead:
- self.notify_thread_not_alive(thread_id, use_lock=False)
-
- cmds_to_execute = []
-
- # Without self._lock_running_thread_ids
- if len(program_threads_alive) == 0 and ready_to_run:
- dispose = True
- else:
- # Actually process the commands now (make sure we don't have a lock for _lock_running_thread_ids
- # acquired at this point as it could lead to a deadlock if some command evaluated tried to
- # create a thread and wait for it -- which would try to notify about it getting that lock).
- curr_thread_id = get_current_thread_id(threadingCurrentThread())
- if ready_to_run:
- process_thread_ids = (curr_thread_id, '*')
- else:
- process_thread_ids = ('*',)
-
- for thread_id in process_thread_ids:
- queue = self.get_internal_queue(thread_id)
-
- # some commands must be processed by the thread itself... if that's the case,
- # we will re-add the commands to the queue after executing.
- cmds_to_add_back = []
-
- try:
- while True:
- int_cmd = queue.get(False)
-
- if not self.mpl_hooks_in_debug_console and isinstance(int_cmd, InternalConsoleExec) and not self.gui_in_use:
- # add import hooks for matplotlib patches if only debug console was started
- try:
- self.init_matplotlib_in_debug_console()
- self.gui_in_use = True
- except:
- pydev_log.debug("Matplotlib support in debug console failed", traceback.format_exc())
- self.mpl_hooks_in_debug_console = True
-
- if int_cmd.can_be_executed_by(curr_thread_id):
- cmds_to_execute.append(int_cmd)
- else:
- pydev_log.verbose("NOT processing internal command: %s ", int_cmd)
- cmds_to_add_back.append(int_cmd)
-
- except _queue.Empty: # @UndefinedVariable
- # this is how we exit
- for int_cmd in cmds_to_add_back:
- queue.put(int_cmd)
-
- if dispose:
- # Note: must be called without the main lock to avoid deadlocks.
- self.dispose_and_kill_all_pydevd_threads()
- else:
- # Actually execute the commands without the main lock!
- for int_cmd in cmds_to_execute:
- pydev_log.verbose("processing internal command: %s", int_cmd)
- try:
- int_cmd.do_it(self)
- except:
- pydev_log.exception('Error processing internal command.')
-
- def consolidate_breakpoints(self, canonical_normalized_filename, id_to_breakpoint, file_to_line_to_breakpoints):
- break_dict = {}
- for _breakpoint_id, pybreakpoint in id_to_breakpoint.items():
- break_dict[pybreakpoint.line] = pybreakpoint
-
- file_to_line_to_breakpoints[canonical_normalized_filename] = break_dict
- self._clear_skip_caches()
-
- def _clear_skip_caches(self):
- global_cache_skips.clear()
- global_cache_frame_skips.clear()
-
- def add_break_on_exception(
- self,
- exception,
- condition,
- expression,
- notify_on_handled_exceptions,
- notify_on_unhandled_exceptions,
- notify_on_user_unhandled_exceptions,
- notify_on_first_raise_only,
- ignore_libraries=False
- ):
- try:
- eb = ExceptionBreakpoint(
- exception,
- condition,
- expression,
- notify_on_handled_exceptions,
- notify_on_unhandled_exceptions,
- notify_on_user_unhandled_exceptions,
- notify_on_first_raise_only,
- ignore_libraries
- )
- except ImportError:
- pydev_log.critical("Error unable to add break on exception for: %s (exception could not be imported).", exception)
- return None
-
- if eb.notify_on_unhandled_exceptions:
- cp = self.break_on_uncaught_exceptions.copy()
- cp[exception] = eb
- pydev_log.info("Exceptions to hook on terminate: %s.", cp)
- self.break_on_uncaught_exceptions = cp
-
- if eb.notify_on_handled_exceptions:
- cp = self.break_on_caught_exceptions.copy()
- cp[exception] = eb
- pydev_log.info("Exceptions to hook always: %s.", cp)
- self.break_on_caught_exceptions = cp
-
- if eb.notify_on_user_unhandled_exceptions:
- cp = self.break_on_user_uncaught_exceptions.copy()
- cp[exception] = eb
- pydev_log.info("Exceptions to hook on user uncaught code: %s.", cp)
- self.break_on_user_uncaught_exceptions = cp
-
- return eb
-
- def set_suspend(self, thread, stop_reason, suspend_other_threads=False, is_pause=False, original_step_cmd=-1):
- '''
- :param thread:
- The thread which should be suspended.
-
- :param stop_reason:
- Reason why the thread was suspended.
-
- :param suspend_other_threads:
- Whether to force other threads to be suspended (i.e.: when hitting a breakpoint
- with a suspend all threads policy).
-
- :param is_pause:
- If this is a pause to suspend all threads, any thread can be considered as the 'main'
- thread paused.
-
- :param original_step_cmd:
- If given we may change the stop reason to this.
- '''
- self._threads_suspended_single_notification.increment_suspend_time()
- if is_pause:
- self._threads_suspended_single_notification.on_pause()
-
- info = mark_thread_suspended(thread, stop_reason, original_step_cmd=original_step_cmd)
-
- if is_pause:
- # Must set tracing after setting the state to suspend.
- frame = info.get_topmost_frame(thread)
- if frame is not None:
- try:
- self.set_trace_for_frame_and_parents(frame)
- finally:
- frame = None
-
- # If conditional breakpoint raises any exception during evaluation send the details to the client.
- if stop_reason == CMD_SET_BREAK and info.conditional_breakpoint_exception is not None:
- conditional_breakpoint_exception_tuple = info.conditional_breakpoint_exception
- info.conditional_breakpoint_exception = None
- self._send_breakpoint_condition_exception(thread, conditional_breakpoint_exception_tuple)
-
- if not suspend_other_threads and self.multi_threads_single_notification:
- # In the mode which gives a single notification when all threads are
- # stopped, stop all threads whenever a set_suspend is issued.
- suspend_other_threads = True
-
- if suspend_other_threads:
- # Suspend all except the current one (which we're currently suspending already).
- suspend_all_threads(self, except_thread=thread)
-
- def _send_breakpoint_condition_exception(self, thread, conditional_breakpoint_exception_tuple):
- """If conditional breakpoint raises an exception during evaluation
- send exception details to java
- """
- thread_id = get_thread_id(thread)
- # conditional_breakpoint_exception_tuple - should contain 2 values (exception_type, stacktrace)
- if conditional_breakpoint_exception_tuple and len(conditional_breakpoint_exception_tuple) == 2:
- exc_type, stacktrace = conditional_breakpoint_exception_tuple
- int_cmd = InternalGetBreakpointException(thread_id, exc_type, stacktrace)
- self.post_internal_command(int_cmd, thread_id)
-
- def send_caught_exception_stack(self, thread, arg, curr_frame_id):
- """Sends details on the exception which was caught (and where we stopped) to the java side.
-
- arg is: exception type, description, traceback object
- """
- thread_id = get_thread_id(thread)
- int_cmd = InternalSendCurrExceptionTrace(thread_id, arg, curr_frame_id)
- self.post_internal_command(int_cmd, thread_id)
-
- def send_caught_exception_stack_proceeded(self, thread):
- """Sends that some thread was resumed and is no longer showing an exception trace.
- """
- thread_id = get_thread_id(thread)
- int_cmd = InternalSendCurrExceptionTraceProceeded(thread_id)
- self.post_internal_command(int_cmd, thread_id)
- self.process_internal_commands()
-
- def send_process_created_message(self):
- """Sends a message that a new process has been created.
- """
- if self.writer is None or self.cmd_factory is None:
- return
- cmd = self.cmd_factory.make_process_created_message()
- self.writer.add_command(cmd)
-
- def send_process_about_to_be_replaced(self):
- """Sends a message that a new process has been created.
- """
- if self.writer is None or self.cmd_factory is None:
- return
- cmd = self.cmd_factory.make_process_about_to_be_replaced_message()
- if cmd is NULL_NET_COMMAND:
- return
-
- sent = [False]
-
- def after_sent(*args, **kwargs):
- sent[0] = True
-
- cmd.call_after_send(after_sent)
- self.writer.add_command(cmd)
-
- timeout = 5 # Wait up to 5 seconds
- initial_time = time.time()
- while not sent[0]:
- time.sleep(.05)
-
- if (time.time() - initial_time) > timeout:
- pydev_log.critical('pydevd: Sending message related to process being replaced timed-out after %s seconds', timeout)
- break
-
- def set_next_statement(self, frame, event, func_name, next_line):
- stop = False
- response_msg = ""
- old_line = frame.f_lineno
- if event == 'line' or event == 'exception':
- # If we're already in the correct context, we have to stop it now, because we can act only on
- # line events -- if a return was the next statement it wouldn't work (so, we have this code
- # repeated at pydevd_frame).
-
- curr_func_name = frame.f_code.co_name
-
- # global context is set with an empty name
- if curr_func_name in ('?', ''):
- curr_func_name = ''
-
- if func_name == '*' or curr_func_name == func_name:
- line = next_line
- frame.f_trace = self.trace_dispatch
- frame.f_lineno = line
- stop = True
- else:
- response_msg = "jump is available only within the bottom frame"
- return stop, old_line, response_msg
-
- def cancel_async_evaluation(self, thread_id, frame_id):
- with self._main_lock:
- try:
- all_threads = threadingEnumerate()
- for t in all_threads:
- if getattr(t, 'is_pydev_daemon_thread', False) and hasattr(t, 'cancel_event') and t.thread_id == thread_id and \
- t.frame_id == frame_id:
- t.cancel_event.set()
- except:
- pydev_log.exception()
-
- def find_frame(self, thread_id, frame_id):
- """ returns a frame on the thread that has a given frame_id """
- return self.suspended_frames_manager.find_frame(thread_id, frame_id)
-
- def do_wait_suspend(self, thread, frame, event, arg, exception_type=None): # @UnusedVariable
- """ busy waits until the thread state changes to RUN
- it expects thread's state as attributes of the thread.
- Upon running, processes any outstanding Stepping commands.
-
- :param exception_type:
- If pausing due to an exception, its type.
- """
- if USE_CUSTOM_SYS_CURRENT_FRAMES_MAP:
- constructed_tid_to_last_frame[thread.ident] = sys._getframe()
- self.process_internal_commands()
-
- thread_id = get_current_thread_id(thread)
-
- # print('do_wait_suspend %s %s %s %s %s %s (%s)' % (frame.f_lineno, frame.f_code.co_name, frame.f_code.co_filename, event, arg, constant_to_str(thread.additional_info.pydev_step_cmd), constant_to_str(thread.additional_info.pydev_original_step_cmd)))
- # print('--- stack ---')
- # print(traceback.print_stack(file=sys.stdout))
- # print('--- end stack ---')
-
- # Send the suspend message
- message = thread.additional_info.pydev_message
- suspend_type = thread.additional_info.trace_suspend_type
- thread.additional_info.trace_suspend_type = 'trace' # Reset to trace mode for next call.
- stop_reason = thread.stop_reason
-
- frames_list = None
-
- if arg is not None and event == 'exception':
- # arg must be the exception info (tuple(exc_type, exc, traceback))
- exc_type, exc_desc, trace_obj = arg
- if trace_obj is not None:
- frames_list = pydevd_frame_utils.create_frames_list_from_traceback(trace_obj, frame, exc_type, exc_desc, exception_type=exception_type)
-
- if frames_list is None:
- frames_list = pydevd_frame_utils.create_frames_list_from_frame(frame)
-
- if DebugInfoHolder.DEBUG_TRACE_LEVEL > 2:
- pydev_log.debug(
- 'PyDB.do_wait_suspend\nname: %s (line: %s)\n file: %s\n event: %s\n arg: %s\n step: %s (original step: %s)\n thread: %s, thread id: %s, id(thread): %s',
- frame.f_code.co_name,
- frame.f_lineno,
- frame.f_code.co_filename,
- event,
- arg,
- constant_to_str(thread.additional_info.pydev_step_cmd),
- constant_to_str(thread.additional_info.pydev_original_step_cmd),
- thread,
- thread_id,
- id(thread),
- )
- for f in frames_list:
- pydev_log.debug(' Stack: %s, %s, %s', f.f_code.co_filename, f.f_code.co_name, f.f_lineno)
-
- with self.suspended_frames_manager.track_frames(self) as frames_tracker:
- frames_tracker.track(thread_id, frames_list)
- cmd = frames_tracker.create_thread_suspend_command(thread_id, stop_reason, message, suspend_type)
- self.writer.add_command(cmd)
-
- with CustomFramesContainer.custom_frames_lock: # @UndefinedVariable
- from_this_thread = []
-
- for frame_custom_thread_id, custom_frame in CustomFramesContainer.custom_frames.items():
- if custom_frame.thread_id == thread.ident:
- frames_tracker.track(thread_id, pydevd_frame_utils.create_frames_list_from_frame(custom_frame.frame), frame_custom_thread_id=frame_custom_thread_id)
- # print('Frame created as thread: %s' % (frame_custom_thread_id,))
-
- self.writer.add_command(self.cmd_factory.make_custom_frame_created_message(
- frame_custom_thread_id, custom_frame.name))
-
- self.writer.add_command(
- frames_tracker.create_thread_suspend_command(frame_custom_thread_id, CMD_THREAD_SUSPEND, "", suspend_type))
-
- from_this_thread.append(frame_custom_thread_id)
-
- with self._threads_suspended_single_notification.notify_thread_suspended(thread_id, thread, stop_reason):
- keep_suspended = self._do_wait_suspend(thread, frame, event, arg, suspend_type, from_this_thread, frames_tracker)
-
- frames_list = None
-
- if keep_suspended:
- # This means that we should pause again after a set next statement.
- self._threads_suspended_single_notification.increment_suspend_time()
- self.do_wait_suspend(thread, frame, event, arg, exception_type)
- if DebugInfoHolder.DEBUG_TRACE_LEVEL > 2:
- pydev_log.debug('Leaving PyDB.do_wait_suspend: %s (%s) %s', thread, thread_id, id(thread))
-
- def _do_wait_suspend(self, thread, frame, event, arg, suspend_type, from_this_thread, frames_tracker):
- info = thread.additional_info
- info.step_in_initial_location = None
- keep_suspended = False
-
- with self._main_lock: # Use lock to check if suspended state changed
- activate_gui = info.pydev_state == STATE_SUSPEND and not self.pydb_disposed
-
- in_main_thread = is_current_thread_main_thread()
- if activate_gui and in_main_thread:
- # before every stop check if matplotlib modules were imported inside script code
- # or some GUI event loop needs to be activated
- self._activate_gui_if_needed()
-
- while True:
- with self._main_lock: # Use lock to check if suspended state changed
- if info.pydev_state != STATE_SUSPEND or (self.pydb_disposed and not self.terminate_requested):
- # Note: we can't exit here if terminate was requested while a breakpoint was hit.
- break
-
- if in_main_thread and self.gui_in_use:
- # call input hooks if only GUI is in use
- self._call_input_hook()
-
- self.process_internal_commands()
- time.sleep(0.01)
-
- self.cancel_async_evaluation(get_current_thread_id(thread), str(id(frame)))
-
- # process any stepping instructions
- if info.pydev_step_cmd in (CMD_STEP_INTO, CMD_STEP_INTO_MY_CODE):
- info.step_in_initial_location = (frame, frame.f_lineno)
- if frame.f_code.co_flags & 0x80: # CO_COROUTINE = 0x80
- # When in a coroutine we switch to CMD_STEP_INTO_COROUTINE.
- info.pydev_step_cmd = CMD_STEP_INTO_COROUTINE
- info.pydev_step_stop = frame
- self.set_trace_for_frame_and_parents(frame)
- else:
- info.pydev_step_stop = None
- self.set_trace_for_frame_and_parents(frame)
-
- elif info.pydev_step_cmd in (CMD_STEP_OVER, CMD_STEP_OVER_MY_CODE, CMD_SMART_STEP_INTO):
- info.pydev_step_stop = frame
- self.set_trace_for_frame_and_parents(frame)
-
- elif info.pydev_step_cmd == CMD_RUN_TO_LINE or info.pydev_step_cmd == CMD_SET_NEXT_STATEMENT:
- info.pydev_step_stop = None
- self.set_trace_for_frame_and_parents(frame)
- stop = False
- response_msg = ""
- try:
- stop, _old_line, response_msg = self.set_next_statement(frame, event, info.pydev_func_name, info.pydev_next_line)
- except ValueError as e:
- response_msg = "%s" % e
- finally:
- seq = info.pydev_message
- cmd = self.cmd_factory.make_set_next_stmnt_status_message(seq, stop, response_msg)
- self.writer.add_command(cmd)
- info.pydev_message = ''
-
- if stop:
- # Uninstall the current frames tracker before running it.
- frames_tracker.untrack_all()
- cmd = self.cmd_factory.make_thread_run_message(get_current_thread_id(thread), info.pydev_step_cmd)
- self.writer.add_command(cmd)
- info.pydev_state = STATE_SUSPEND
- thread.stop_reason = CMD_SET_NEXT_STATEMENT
- keep_suspended = True
-
- else:
- # Set next did not work...
- info.pydev_original_step_cmd = -1
- info.pydev_step_cmd = -1
- info.pydev_state = STATE_SUSPEND
- thread.stop_reason = CMD_THREAD_SUSPEND
- # return to the suspend state and wait for other command (without sending any
- # additional notification to the client).
- return self._do_wait_suspend(thread, frame, event, arg, suspend_type, from_this_thread, frames_tracker)
-
- elif info.pydev_step_cmd in (CMD_STEP_RETURN, CMD_STEP_RETURN_MY_CODE):
- back_frame = frame.f_back
- force_check_project_scope = info.pydev_step_cmd == CMD_STEP_RETURN_MY_CODE
-
- if force_check_project_scope or self.is_files_filter_enabled:
- while back_frame is not None:
- if self.apply_files_filter(back_frame, back_frame.f_code.co_filename, force_check_project_scope):
- frame = back_frame
- back_frame = back_frame.f_back
- else:
- break
-
- if back_frame is not None:
- # steps back to the same frame (in a return call it will stop in the 'back frame' for the user)
- info.pydev_step_stop = frame
- self.set_trace_for_frame_and_parents(frame)
- else:
- # No back frame?!? -- this happens in jython when we have some frame created from an awt event
- # (the previous frame would be the awt event, but this doesn't make part of 'jython', only 'java')
- # so, if we're doing a step return in this situation, it's the same as just making it run
- info.pydev_step_stop = None
- info.pydev_original_step_cmd = -1
- info.pydev_step_cmd = -1
- info.pydev_state = STATE_RUN
-
- if PYDEVD_IPYTHON_COMPATIBLE_DEBUGGING:
- info.pydev_use_scoped_step_frame = False
- if info.pydev_step_cmd in (
- CMD_STEP_OVER, CMD_STEP_OVER_MY_CODE,
- CMD_STEP_INTO, CMD_STEP_INTO_MY_CODE
- ):
- # i.e.: We're stepping: check if the stepping should be scoped (i.e.: in ipython
- # each line is executed separately in a new frame, in which case we need to consider
- # the next line as if it was still in the same frame).
- f = frame.f_back
- if f and f.f_code.co_name == PYDEVD_IPYTHON_CONTEXT[1]:
- f = f.f_back
- if f and f.f_code.co_name == PYDEVD_IPYTHON_CONTEXT[2]:
- info.pydev_use_scoped_step_frame = True
- pydev_log.info('Using (ipython) scoped stepping.')
- del f
-
- del frame
- cmd = self.cmd_factory.make_thread_run_message(get_current_thread_id(thread), info.pydev_step_cmd)
- self.writer.add_command(cmd)
-
- with CustomFramesContainer.custom_frames_lock:
- # The ones that remained on last_running must now be removed.
- for frame_id in from_this_thread:
- # print('Removing created frame: %s' % (frame_id,))
- self.writer.add_command(self.cmd_factory.make_thread_killed_message(frame_id))
-
- return keep_suspended
-
- def do_stop_on_unhandled_exception(self, thread, frame, frames_byid, arg):
- pydev_log.debug("We are stopping in unhandled exception.")
- try:
- add_exception_to_frame(frame, arg)
- self.send_caught_exception_stack(thread, arg, id(frame))
- try:
- self.set_suspend(thread, CMD_ADD_EXCEPTION_BREAK)
- self.do_wait_suspend(thread, frame, 'exception', arg, EXCEPTION_TYPE_UNHANDLED)
- except:
- self.send_caught_exception_stack_proceeded(thread)
- except:
- pydev_log.exception("We've got an error while stopping in unhandled exception: %s.", arg[0])
- finally:
- remove_exception_from_frame(frame)
- frame = None
-
- def set_trace_for_frame_and_parents(self, frame, **kwargs):
- disable = kwargs.pop('disable', False)
- assert not kwargs
-
- while frame is not None:
- # Don't change the tracing on debugger-related files
- file_type = self.get_file_type(frame)
-
- if file_type is None:
- if disable:
- pydev_log.debug('Disable tracing of frame: %s - %s', frame.f_code.co_filename, frame.f_code.co_name)
- if frame.f_trace is not None and frame.f_trace is not NO_FTRACE:
- frame.f_trace = NO_FTRACE
-
- elif frame.f_trace is not self.trace_dispatch:
- pydev_log.debug('Set tracing of frame: %s - %s', frame.f_code.co_filename, frame.f_code.co_name)
- frame.f_trace = self.trace_dispatch
- else:
- pydev_log.debug('SKIP set tracing of frame: %s - %s', frame.f_code.co_filename, frame.f_code.co_name)
-
- frame = frame.f_back
-
- del frame
-
- def _create_pydb_command_thread(self):
- curr_pydb_command_thread = self.py_db_command_thread
- if curr_pydb_command_thread is not None:
- curr_pydb_command_thread.do_kill_pydev_thread()
-
- new_pydb_command_thread = self.py_db_command_thread = PyDBCommandThread(self)
- new_pydb_command_thread.start()
-
- def _create_check_output_thread(self):
- curr_output_checker_thread = self.check_alive_thread
- if curr_output_checker_thread is not None:
- curr_output_checker_thread.do_kill_pydev_thread()
-
- check_alive_thread = self.check_alive_thread = CheckAliveThread(self)
- check_alive_thread.start()
-
- def start_auxiliary_daemon_threads(self):
- self._create_pydb_command_thread()
- self._create_check_output_thread()
-
- def __wait_for_threads_to_finish(self, timeout):
- try:
- with self._wait_for_threads_to_finish_called_lock:
- wait_for_threads_to_finish_called = self._wait_for_threads_to_finish_called
- self._wait_for_threads_to_finish_called = True
-
- if wait_for_threads_to_finish_called:
- # Make sure that we wait for the previous call to be finished.
- self._wait_for_threads_to_finish_called_event.wait(timeout=timeout)
- else:
- try:
-
- def get_pydb_daemon_threads_to_wait():
- pydb_daemon_threads = set(self.created_pydb_daemon_threads)
- pydb_daemon_threads.discard(self.check_alive_thread)
- pydb_daemon_threads.discard(threading.current_thread())
- return pydb_daemon_threads
-
- pydev_log.debug("PyDB.dispose_and_kill_all_pydevd_threads waiting for pydb daemon threads to finish")
- started_at = time.time()
- # Note: we wait for all except the check_alive_thread (which is not really a daemon
- # thread and it can call this method itself).
- while time.time() < started_at + timeout:
- if len(get_pydb_daemon_threads_to_wait()) == 0:
- break
- time.sleep(1 / 10.)
- else:
- thread_names = [t.name for t in get_pydb_daemon_threads_to_wait()]
- if thread_names:
- pydev_log.debug("The following pydb threads may not have finished correctly: %s",
- ', '.join(thread_names))
- finally:
- self._wait_for_threads_to_finish_called_event.set()
- except:
- pydev_log.exception()
-
- def dispose_and_kill_all_pydevd_threads(self, wait=True, timeout=.5):
- '''
- When this method is called we finish the debug session, terminate threads
- and if this was registered as the global instance, unregister it -- afterwards
- it should be possible to create a new instance and set as global to start
- a new debug session.
-
- :param bool wait:
- If True we'll wait for the threads to be actually finished before proceeding
- (based on the available timeout).
- Note that this must be thread-safe and if one thread is waiting the other thread should
- also wait.
- '''
- try:
- back_frame = sys._getframe().f_back
- pydev_log.debug(
- 'PyDB.dispose_and_kill_all_pydevd_threads (called from: File "%s", line %s, in %s)',
- back_frame.f_code.co_filename, back_frame.f_lineno, back_frame.f_code.co_name
- )
- back_frame = None
- with self._disposed_lock:
- disposed = self.pydb_disposed
- self.pydb_disposed = True
-
- if disposed:
- if wait:
- pydev_log.debug("PyDB.dispose_and_kill_all_pydevd_threads (already disposed - wait)")
- self.__wait_for_threads_to_finish(timeout)
- else:
- pydev_log.debug("PyDB.dispose_and_kill_all_pydevd_threads (already disposed - no wait)")
- return
-
- pydev_log.debug("PyDB.dispose_and_kill_all_pydevd_threads (first call)")
-
- # Wait until a time when there are no commands being processed to kill the threads.
- started_at = time.time()
- while time.time() < started_at + timeout:
- with self._main_lock:
- writer = self.writer
- if writer is None or writer.empty():
- pydev_log.debug("PyDB.dispose_and_kill_all_pydevd_threads no commands being processed.")
- break
- else:
- pydev_log.debug("PyDB.dispose_and_kill_all_pydevd_threads timed out waiting for writer to be empty.")
-
- pydb_daemon_threads = set(self.created_pydb_daemon_threads)
- for t in pydb_daemon_threads:
- if hasattr(t, 'do_kill_pydev_thread'):
- pydev_log.debug("PyDB.dispose_and_kill_all_pydevd_threads killing thread: %s", t)
- t.do_kill_pydev_thread()
-
- if wait:
- self.__wait_for_threads_to_finish(timeout)
- else:
- pydev_log.debug("PyDB.dispose_and_kill_all_pydevd_threads: no wait")
-
- py_db = get_global_debugger()
- if py_db is self:
- set_global_debugger(None)
- except:
- pydev_log.debug("PyDB.dispose_and_kill_all_pydevd_threads: exception")
- try:
- if DebugInfoHolder.DEBUG_TRACE_LEVEL >= 3:
- pydev_log.exception()
- except:
- pass
- finally:
- pydev_log.debug("PyDB.dispose_and_kill_all_pydevd_threads: finished")
-
- def prepare_to_run(self):
- ''' Shared code to prepare debugging by installing traces and registering threads '''
- self.patch_threads()
- self.start_auxiliary_daemon_threads()
-
- def patch_threads(self):
- try:
- # not available in jython!
- threading.settrace(self.trace_dispatch) # for all future threads
- except:
- pass
-
- from _pydev_bundle.pydev_monkey import patch_thread_modules
- patch_thread_modules()
-
- def run(self, file, globals=None, locals=None, is_module=False, set_trace=True):
- module_name = None
- entry_point_fn = ''
- if is_module:
- # When launching with `python -m `, python automatically adds
- # an empty path to the PYTHONPATH which resolves files in the current
- # directory, so, depending how pydevd itself is launched, we may need
- # to manually add such an entry to properly resolve modules in the
- # current directory (see: https://github.com/Microsoft/ptvsd/issues/1010).
- if '' not in sys.path:
- sys.path.insert(0, '')
- file, _, entry_point_fn = file.partition(':')
- module_name = file
- filename = get_fullname(file)
- if filename is None:
- mod_dir = get_package_dir(module_name)
- if mod_dir is None:
- sys.stderr.write("No module named %s\n" % file)
- return
- else:
- filename = get_fullname("%s.__main__" % module_name)
- if filename is None:
- sys.stderr.write("No module named %s\n" % file)
- return
- else:
- file = filename
- else:
- file = filename
- mod_dir = os.path.dirname(filename)
- main_py = os.path.join(mod_dir, '__main__.py')
- main_pyc = os.path.join(mod_dir, '__main__.pyc')
- if filename.endswith('__init__.pyc'):
- if os.path.exists(main_pyc):
- filename = main_pyc
- elif os.path.exists(main_py):
- filename = main_py
- elif filename.endswith('__init__.py'):
- if os.path.exists(main_pyc) and not os.path.exists(main_py):
- filename = main_pyc
- elif os.path.exists(main_py):
- filename = main_py
-
- sys.argv[0] = filename
-
- if os.path.isdir(file):
- new_target = os.path.join(file, '__main__.py')
- if os.path.isfile(new_target):
- file = new_target
-
- m = None
- if globals is None:
- m = save_main_module(file, 'pydevd')
- globals = m.__dict__
- try:
- globals['__builtins__'] = __builtins__
- except NameError:
- pass # Not there on Jython...
-
- if locals is None:
- locals = globals
-
- # Predefined (writable) attributes: __name__ is the module's name;
- # __doc__ is the module's documentation string, or None if unavailable;
- # __file__ is the pathname of the file from which the module was loaded,
- # if it was loaded from a file. The __file__ attribute is not present for
- # C modules that are statically linked into the interpreter; for extension modules
- # loaded dynamically from a shared library, it is the pathname of the shared library file.
-
- # I think this is an ugly hack, bug it works (seems to) for the bug that says that sys.path should be the same in
- # debug and run.
- if sys.path[0] != '' and m is not None and m.__file__.startswith(sys.path[0]):
- # print >> sys.stderr, 'Deleting: ', sys.path[0]
- del sys.path[0]
-
- if not is_module:
- # now, the local directory has to be added to the pythonpath
- # sys.path.insert(0, os.getcwd())
- # Changed: it's not the local directory, but the directory of the file launched
- # The file being run must be in the pythonpath (even if it was not before)
- sys.path.insert(0, os.path.split(os_path_abspath(file))[0])
-
- if set_trace:
- self.wait_for_ready_to_run()
-
- # call prepare_to_run when we already have all information about breakpoints
- self.prepare_to_run()
-
- t = threadingCurrentThread()
- thread_id = get_current_thread_id(t)
-
- if self.thread_analyser is not None:
- wrap_threads()
- self.thread_analyser.set_start_time(cur_time())
- send_concurrency_message("threading_event", 0, t.name, thread_id, "thread", "start", file, 1, None, parent=thread_id)
-
- if self.asyncio_analyser is not None:
- # we don't have main thread in asyncio graph, so we should add a fake event
- send_concurrency_message("asyncio_event", 0, "Task", "Task", "thread", "stop", file, 1, frame=None, parent=None)
-
- try:
- if INTERACTIVE_MODE_AVAILABLE:
- self.init_gui_support()
- except:
- pydev_log.exception("Matplotlib support in debugger failed")
-
- if hasattr(sys, 'exc_clear'):
- # we should clean exception information in Python 2, before user's code execution
- sys.exc_clear()
-
- # Notify that the main thread is created.
- self.notify_thread_created(thread_id, t)
-
- # Note: important: set the tracing right before calling _exec.
- if set_trace:
- self.enable_tracing()
-
- return self._exec(is_module, entry_point_fn, module_name, file, globals, locals)
-
- def _exec(self, is_module, entry_point_fn, module_name, file, globals, locals):
- '''
- This function should have frames tracked by unhandled exceptions (the `_exec` name is important).
- '''
- if not is_module:
- globals = pydevd_runpy.run_path(file, globals, '__main__')
- else:
- # treat ':' as a separator between module and entry point function
- # if there is no entry point we run we same as with -m switch. Otherwise we perform
- # an import and execute the entry point
- if entry_point_fn:
- mod = __import__(module_name, level=0, fromlist=[entry_point_fn], globals=globals, locals=locals)
- func = getattr(mod, entry_point_fn)
- func()
- else:
- # Run with the -m switch
- globals = pydevd_runpy._run_module_as_main(module_name, alter_argv=False)
- return globals
-
- def wait_for_commands(self, globals):
- self._activate_gui_if_needed()
-
- thread = threading.current_thread()
- from _pydevd_bundle import pydevd_frame_utils
- frame = pydevd_frame_utils.Frame(None, -1, pydevd_frame_utils.FCode("Console",
- os.path.abspath(os.path.dirname(__file__))), globals, globals)
- thread_id = get_current_thread_id(thread)
- self.add_fake_frame(thread_id, id(frame), frame)
-
- cmd = self.cmd_factory.make_show_console_message(self, thread_id, frame)
- if self.writer is not None:
- self.writer.add_command(cmd)
-
- while True:
- if self.gui_in_use:
- # call input hooks if only GUI is in use
- self._call_input_hook()
- self.process_internal_commands()
- time.sleep(0.01)
-
-
-class IDAPMessagesListener(object):
-
- def before_send(self, message_as_dict):
- '''
- Called just before a message is sent to the IDE.
-
- :type message_as_dict: dict
- '''
-
- def after_receive(self, message_as_dict):
- '''
- Called just after a message is received from the IDE.
-
- :type message_as_dict: dict
- '''
-
-
-def add_dap_messages_listener(dap_messages_listener):
- '''
- Adds a listener for the DAP (debug adapter protocol) messages.
-
- :type dap_messages_listener: IDAPMessagesListener
-
- :note: messages from the xml backend are not notified through this API.
-
- :note: the notifications are sent from threads and they are not synchronized (so,
- it's possible that a message is sent and received from different threads at the same time).
- '''
- py_db = get_global_debugger()
- if py_db is None:
- raise AssertionError('PyDB is still not setup.')
-
- py_db.add_dap_messages_listener(dap_messages_listener)
-
-
-def send_json_message(msg):
- '''
- API to send some custom json message.
-
- :param dict|pydevd_schema.BaseSchema msg:
- The custom message to be sent.
-
- :return bool:
- True if the message was added to the queue to be sent and False otherwise.
- '''
- py_db = get_global_debugger()
- if py_db is None:
- return False
-
- writer = py_db.writer
- if writer is None:
- return False
-
- cmd = NetCommand(-1, 0, msg, is_json=True)
- writer.add_command(cmd)
- return True
-
-
-def enable_qt_support(qt_support_mode):
- from _pydev_bundle import pydev_monkey_qt
- pydev_monkey_qt.patch_qt(qt_support_mode)
-
-
-def start_dump_threads_thread(filename_template, timeout, recurrent):
- '''
- Helper to dump threads after a timeout.
-
- :param filename_template:
- A template filename, such as 'c:/temp/thread_dump_%s.txt', where the %s will
- be replaced by the time for the dump.
- :param timeout:
- The timeout (in seconds) for the dump.
- :param recurrent:
- If True we'll keep on doing thread dumps.
- '''
- assert filename_template.count('%s') == 1, \
- 'Expected one %%s to appear in: %s' % (filename_template,)
-
- def _threads_on_timeout():
- try:
- while True:
- time.sleep(timeout)
- filename = filename_template % (time.time(),)
- try:
- os.makedirs(os.path.dirname(filename))
- except Exception:
- pass
- with open(filename, 'w') as stream:
- dump_threads(stream)
- if not recurrent:
- return
- except Exception:
- pydev_log.exception()
-
- t = threading.Thread(target=_threads_on_timeout)
- mark_as_pydevd_daemon_thread(t)
- t.start()
-
-
-def dump_threads(stream=None):
- '''
- Helper to dump thread info (default is printing to stderr).
- '''
- pydevd_utils.dump_threads(stream)
-
-
-def usage(doExit=0):
- sys.stdout.write('Usage:\n')
- sys.stdout.write('pydevd.py --port N [(--client hostname) | --server] --file executable [file_options]\n')
- if doExit:
- sys.exit(0)
-
-
-def _init_stdout_redirect():
- pydevd_io.redirect_stream_to_pydb_io_messages(std='stdout')
-
-
-def _init_stderr_redirect():
- pydevd_io.redirect_stream_to_pydb_io_messages(std='stderr')
-
-
-def _enable_attach(
- address,
- dont_trace_start_patterns=(),
- dont_trace_end_patterns=(),
- patch_multiprocessing=False,
- access_token=None,
- client_access_token=None,
- ):
- '''
- Starts accepting connections at the given host/port. The debugger will not be initialized nor
- configured, it'll only start accepting connections (and will have the tracing setup in this
- thread).
-
- Meant to be used with the DAP (Debug Adapter Protocol) with _wait_for_attach().
-
- :param address: (host, port)
- :type address: tuple(str, int)
- '''
- host = address[0]
- port = int(address[1])
-
- if SetupHolder.setup is not None:
- if port != SetupHolder.setup['port']:
- raise AssertionError('Unable to listen in port: %s (already listening in port: %s)' % (port, SetupHolder.setup['port']))
- settrace(
- host=host,
- port=port,
- suspend=False,
- wait_for_ready_to_run=False,
- block_until_connected=False,
- dont_trace_start_patterns=dont_trace_start_patterns,
- dont_trace_end_patterns=dont_trace_end_patterns,
- patch_multiprocessing=patch_multiprocessing,
- access_token=access_token,
- client_access_token=client_access_token,
- )
-
- py_db = get_global_debugger()
- py_db.wait_for_server_socket_ready()
- return py_db._server_socket_name
-
-
-def _wait_for_attach(cancel=None):
- '''
- Meant to be called after _enable_attach() -- the current thread will only unblock after a
- connection is in place and the DAP (Debug Adapter Protocol) sends the ConfigurationDone
- request.
- '''
- py_db = get_global_debugger()
- if py_db is None:
- raise AssertionError('Debugger still not created. Please use _enable_attach() before using _wait_for_attach().')
-
- py_db.block_until_configuration_done(cancel=cancel)
-
-
-def _is_attached():
- '''
- Can be called any time to check if the connection was established and the DAP (Debug Adapter Protocol) has sent
- the ConfigurationDone request.
- '''
- py_db = get_global_debugger()
- return (py_db is not None) and py_db.is_attached()
-
-
-#=======================================================================================================================
-# settrace
-#=======================================================================================================================
-def settrace(
- host=None,
- stdout_to_server=False,
- stderr_to_server=False,
- port=5678,
- suspend=True,
- trace_only_current_thread=False,
- overwrite_prev_trace=False,
- patch_multiprocessing=False,
- stop_at_frame=None,
- block_until_connected=True,
- wait_for_ready_to_run=True,
- dont_trace_start_patterns=(),
- dont_trace_end_patterns=(),
- access_token=None,
- client_access_token=None,
- notify_stdin=True,
- **kwargs
- ):
- '''Sets the tracing function with the pydev debug function and initializes needed facilities.
-
- :param host: the user may specify another host, if the debug server is not in the same machine (default is the local
- host)
-
- :param stdout_to_server: when this is true, the stdout is passed to the debug server
-
- :param stderr_to_server: when this is true, the stderr is passed to the debug server
- so that they are printed in its console and not in this process console.
-
- :param port: specifies which port to use for communicating with the server (note that the server must be started
- in the same port). @note: currently it's hard-coded at 5678 in the client
-
- :param suspend: whether a breakpoint should be emulated as soon as this function is called.
-
- :param trace_only_current_thread: determines if only the current thread will be traced or all current and future
- threads will also have the tracing enabled.
-
- :param overwrite_prev_trace: deprecated
-
- :param patch_multiprocessing: if True we'll patch the functions which create new processes so that launched
- processes are debugged.
-
- :param stop_at_frame: if passed it'll stop at the given frame, otherwise it'll stop in the function which
- called this method.
-
- :param wait_for_ready_to_run: if True settrace will block until the ready_to_run flag is set to True,
- otherwise, it'll set ready_to_run to True and this function won't block.
-
- Note that if wait_for_ready_to_run == False, there are no guarantees that the debugger is synchronized
- with what's configured in the client (IDE), the only guarantee is that when leaving this function
- the debugger will be already connected.
-
- :param dont_trace_start_patterns: if set, then any path that starts with one fo the patterns in the collection
- will not be traced
-
- :param dont_trace_end_patterns: if set, then any path that ends with one fo the patterns in the collection
- will not be traced
-
- :param access_token: token to be sent from the client (i.e.: IDE) to the debugger when a connection
- is established (verified by the debugger).
-
- :param client_access_token: token to be sent from the debugger to the client (i.e.: IDE) when
- a connection is established (verified by the client).
-
- :param notify_stdin:
- If True sys.stdin will be patched to notify the client when a message is requested
- from the IDE. This is done so that when reading the stdin the client is notified.
- Clients may need this to know when something that is being written should be interpreted
- as an input to the process or as a command to be evaluated.
- Note that parallel-python has issues with this (because it tries to assert that sys.stdin
- is of a given type instead of just checking that it has what it needs).
- '''
-
- stdout_to_server = stdout_to_server or kwargs.get('stdoutToServer', False) # Backward compatibility
- stderr_to_server = stderr_to_server or kwargs.get('stderrToServer', False) # Backward compatibility
-
- # Internal use (may be used to set the setup info directly for subprocesess).
- __setup_holder__ = kwargs.get('__setup_holder__')
-
- with _set_trace_lock:
- _locked_settrace(
- host,
- stdout_to_server,
- stderr_to_server,
- port,
- suspend,
- trace_only_current_thread,
- patch_multiprocessing,
- stop_at_frame,
- block_until_connected,
- wait_for_ready_to_run,
- dont_trace_start_patterns,
- dont_trace_end_patterns,
- access_token,
- client_access_token,
- __setup_holder__=__setup_holder__,
- notify_stdin=notify_stdin,
- )
-
-
-_set_trace_lock = ForkSafeLock()
-
-
-def _locked_settrace(
- host,
- stdout_to_server,
- stderr_to_server,
- port,
- suspend,
- trace_only_current_thread,
- patch_multiprocessing,
- stop_at_frame,
- block_until_connected,
- wait_for_ready_to_run,
- dont_trace_start_patterns,
- dont_trace_end_patterns,
- access_token,
- client_access_token,
- __setup_holder__,
- notify_stdin,
- ):
- if patch_multiprocessing:
- try:
- from _pydev_bundle import pydev_monkey
- except:
- pass
- else:
- pydev_monkey.patch_new_process_functions()
-
- if host is None:
- from _pydev_bundle import pydev_localhost
- host = pydev_localhost.get_localhost()
-
- global _global_redirect_stdout_to_server
- global _global_redirect_stderr_to_server
-
- py_db = get_global_debugger()
- if __setup_holder__:
- SetupHolder.setup = __setup_holder__
- if py_db is None:
- py_db = PyDB()
- pydevd_vm_type.setup_type()
-
- if SetupHolder.setup is None:
- setup = {
- 'client': host, # dispatch expects client to be set to the host address when server is False
- 'server': False,
- 'port': int(port),
- 'multiprocess': patch_multiprocessing,
- 'skip-notify-stdin': not notify_stdin,
- }
- SetupHolder.setup = setup
-
- if access_token is not None:
- py_db.authentication.access_token = access_token
- SetupHolder.setup['access-token'] = access_token
- if client_access_token is not None:
- py_db.authentication.client_access_token = client_access_token
- SetupHolder.setup['client-access-token'] = client_access_token
-
- if block_until_connected:
- py_db.connect(host, port) # Note: connect can raise error.
- else:
- # Create a dummy writer and wait for the real connection.
- py_db.writer = WriterThread(NULL, py_db, terminate_on_socket_close=False)
- py_db.create_wait_for_connection_thread()
-
- if dont_trace_start_patterns or dont_trace_end_patterns:
- PyDevdAPI().set_dont_trace_start_end_patterns(py_db, dont_trace_start_patterns, dont_trace_end_patterns)
-
- _global_redirect_stdout_to_server = stdout_to_server
- _global_redirect_stderr_to_server = stderr_to_server
-
- if _global_redirect_stdout_to_server:
- _init_stdout_redirect()
-
- if _global_redirect_stderr_to_server:
- _init_stderr_redirect()
-
- if notify_stdin:
- patch_stdin()
-
- t = threadingCurrentThread()
- additional_info = set_additional_thread_info(t)
-
- if not wait_for_ready_to_run:
- py_db.ready_to_run = True
-
- py_db.wait_for_ready_to_run()
- py_db.start_auxiliary_daemon_threads()
-
- try:
- if INTERACTIVE_MODE_AVAILABLE:
- py_db.init_gui_support()
- except:
- pydev_log.exception("Matplotlib support in debugger failed")
-
- if trace_only_current_thread:
- py_db.enable_tracing()
- else:
- # Trace future threads.
- py_db.patch_threads()
-
- py_db.enable_tracing(py_db.trace_dispatch, apply_to_all_threads=True)
-
- # As this is the first connection, also set tracing for any untraced threads
- py_db.set_tracing_for_untraced_contexts()
-
- py_db.set_trace_for_frame_and_parents(get_frame().f_back)
-
- with CustomFramesContainer.custom_frames_lock: # @UndefinedVariable
- for _frameId, custom_frame in CustomFramesContainer.custom_frames.items():
- py_db.set_trace_for_frame_and_parents(custom_frame.frame)
-
- else:
- # ok, we're already in debug mode, with all set, so, let's just set the break
- if access_token is not None:
- py_db.authentication.access_token = access_token
- if client_access_token is not None:
- py_db.authentication.client_access_token = client_access_token
-
- py_db.set_trace_for_frame_and_parents(get_frame().f_back)
-
- t = threadingCurrentThread()
- additional_info = set_additional_thread_info(t)
-
- if trace_only_current_thread:
- py_db.enable_tracing()
- else:
- # Trace future threads.
- py_db.patch_threads()
- py_db.enable_tracing(py_db.trace_dispatch, apply_to_all_threads=True)
-
- # Suspend as the last thing after all tracing is in place.
- if suspend:
- if stop_at_frame is not None:
- # If the step was set we have to go to run state and
- # set the proper frame for it to stop.
- additional_info.pydev_state = STATE_RUN
- additional_info.pydev_original_step_cmd = CMD_STEP_OVER
- additional_info.pydev_step_cmd = CMD_STEP_OVER
- additional_info.pydev_step_stop = stop_at_frame
- additional_info.suspend_type = PYTHON_SUSPEND
- else:
- # Ask to break as soon as possible.
- py_db.set_suspend(t, CMD_SET_BREAK)
-
-
-def stoptrace():
- pydev_log.debug("pydevd.stoptrace()")
- pydevd_tracing.restore_sys_set_trace_func()
- sys.settrace(None)
- try:
- # not available in jython!
- threading.settrace(None) # for all future threads
- except:
- pass
-
- from _pydev_bundle.pydev_monkey import undo_patch_thread_modules
- undo_patch_thread_modules()
-
- # Either or both standard streams can be closed at this point,
- # in which case flush() will fail.
- try:
- sys.stdout.flush()
- except:
- pass
- try:
- sys.stderr.flush()
- except:
- pass
-
- py_db = get_global_debugger()
-
- if py_db is not None:
- py_db.dispose_and_kill_all_pydevd_threads()
-
-
-class Dispatcher(object):
-
- def __init__(self):
- self.port = None
-
- def connect(self, host, port):
- self.host = host
- self.port = port
- self.client = start_client(self.host, self.port)
- self.reader = DispatchReader(self)
- self.reader.pydev_do_not_trace = False # we run reader in the same thread so we don't want to loose tracing
- self.reader.run()
-
- def close(self):
- try:
- self.reader.do_kill_pydev_thread()
- except:
- pass
-
-
-class DispatchReader(ReaderThread):
-
- def __init__(self, dispatcher):
- self.dispatcher = dispatcher
-
- ReaderThread.__init__(
- self,
- get_global_debugger(),
- self.dispatcher.client,
- PyDevJsonCommandProcessor=PyDevJsonCommandProcessor,
- process_net_command=process_net_command,
- )
-
- @overrides(ReaderThread._on_run)
- def _on_run(self):
- dummy_thread = threading.current_thread()
- dummy_thread.is_pydev_daemon_thread = False
- return ReaderThread._on_run(self)
-
- @overrides(PyDBDaemonThread.do_kill_pydev_thread)
- def do_kill_pydev_thread(self):
- if not self._kill_received:
- ReaderThread.do_kill_pydev_thread(self)
- try:
- self.sock.shutdown(SHUT_RDWR)
- except:
- pass
- try:
- self.sock.close()
- except:
- pass
-
- def process_command(self, cmd_id, seq, text):
- if cmd_id == 99:
- self.dispatcher.port = int(text)
- self._kill_received = True
-
-
-DISPATCH_APPROACH_NEW_CONNECTION = 1 # Used by PyDev
-DISPATCH_APPROACH_EXISTING_CONNECTION = 2 # Used by PyCharm
-DISPATCH_APPROACH = DISPATCH_APPROACH_NEW_CONNECTION
-
-
-def dispatch():
- setup = SetupHolder.setup
- host = setup['client']
- port = setup['port']
- if DISPATCH_APPROACH == DISPATCH_APPROACH_EXISTING_CONNECTION:
- dispatcher = Dispatcher()
- try:
- dispatcher.connect(host, port)
- port = dispatcher.port
- finally:
- dispatcher.close()
- return host, port
-
-
-def settrace_forked(setup_tracing=True):
- '''
- When creating a fork from a process in the debugger, we need to reset the whole debugger environment!
- '''
- from _pydevd_bundle.pydevd_constants import GlobalDebuggerHolder
- py_db = GlobalDebuggerHolder.global_dbg
- if py_db is not None:
- py_db.created_pydb_daemon_threads = {} # Just making sure we won't touch those (paused) threads.
- py_db = None
-
- GlobalDebuggerHolder.global_dbg = None
- threading.current_thread().additional_info = None
-
- # Make sure that we keep the same access tokens for subprocesses started through fork.
- setup = SetupHolder.setup
- if setup is None:
- setup = {}
- else:
- # i.e.: Get the ppid at this point as it just changed.
- # If we later do an exec() it should remain the same ppid.
- setup[pydevd_constants.ARGUMENT_PPID] = PyDevdAPI().get_ppid()
- access_token = setup.get('access-token')
- client_access_token = setup.get('client-access-token')
-
- if setup_tracing:
- from _pydevd_frame_eval.pydevd_frame_eval_main import clear_thread_local_info
- host, port = dispatch()
-
- import pydevd_tracing
- pydevd_tracing.restore_sys_set_trace_func()
-
- if setup_tracing:
- if port is not None:
- custom_frames_container_init()
-
- if clear_thread_local_info is not None:
- clear_thread_local_info()
-
- settrace(
- host,
- port=port,
- suspend=False,
- trace_only_current_thread=False,
- overwrite_prev_trace=True,
- patch_multiprocessing=True,
- access_token=access_token,
- client_access_token=client_access_token,
- )
-
-
-@contextmanager
-def skip_subprocess_arg_patch():
- '''
- May be used to skip the monkey-patching that pydevd does to
- skip changing arguments to embed the debugger into child processes.
-
- i.e.:
-
- with pydevd.skip_subprocess_arg_patch():
- subprocess.call(...)
- '''
- from _pydev_bundle import pydev_monkey
- with pydev_monkey.skip_subprocess_arg_patch():
- yield
-
-
-def add_dont_terminate_child_pid(pid):
- '''
- May be used to ask pydevd to skip the termination of some process
- when it's asked to terminate (debug adapter protocol only).
-
- :param int pid:
- The pid to be ignored.
-
- i.e.:
-
- process = subprocess.Popen(...)
- pydevd.add_dont_terminate_child_pid(process.pid)
- '''
- py_db = get_global_debugger()
- if py_db is not None:
- py_db.dont_terminate_child_pids.add(pid)
-
-
-class SetupHolder:
-
- setup = None
-
-
-def apply_debugger_options(setup_options):
- """
-
- :type setup_options: dict[str, bool]
- """
- default_options = {'save-signatures': False, 'qt-support': ''}
- default_options.update(setup_options)
- setup_options = default_options
-
- debugger = get_global_debugger()
- if setup_options['save-signatures']:
- if pydevd_vm_type.get_vm_type() == pydevd_vm_type.PydevdVmType.JYTHON:
- sys.stderr.write("Collecting run-time type information is not supported for Jython\n")
- else:
- # Only import it if we're going to use it!
- from _pydevd_bundle.pydevd_signature import SignatureFactory
- debugger.signature_factory = SignatureFactory()
-
- if setup_options['qt-support']:
- enable_qt_support(setup_options['qt-support'])
-
-
-@call_only_once
-def patch_stdin():
- _internal_patch_stdin(None, sys, getpass_mod)
-
-
-def _internal_patch_stdin(py_db=None, sys=None, getpass_mod=None):
- '''
- Note: don't use this function directly, use `patch_stdin()` instead.
- (this function is only meant to be used on test-cases to avoid patching the actual globals).
- '''
- # Patch stdin so that we notify when readline() is called.
- original_sys_stdin = sys.stdin
- debug_console_stdin = DebugConsoleStdIn(py_db, original_sys_stdin)
- sys.stdin = debug_console_stdin
-
- _original_getpass = getpass_mod.getpass
-
- @functools.wraps(_original_getpass)
- def getpass(*args, **kwargs):
- with DebugConsoleStdIn.notify_input_requested(debug_console_stdin):
- try:
- curr_stdin = sys.stdin
- if curr_stdin is debug_console_stdin:
- sys.stdin = original_sys_stdin
- return _original_getpass(*args, **kwargs)
- finally:
- sys.stdin = curr_stdin
-
- getpass_mod.getpass = getpass
-
-# Dispatch on_debugger_modules_loaded here, after all primary py_db modules are loaded
-
-
-for handler in pydevd_extension_utils.extensions_of_type(DebuggerEventHandler):
- handler.on_debugger_modules_loaded(debugger_version=__version__)
-
-
-def log_to(log_file:str, log_level=3) -> None:
- '''
- In pydevd it's possible to log by setting the following environment variables:
-
- PYDEVD_DEBUG=1 (sets the default log level to 3 along with other default options)
- PYDEVD_DEBUG_FILE=
-
- Note that the file will have the pid of the process added to it (so, logging to
- /path/to/file.log would actually start logging to /path/to/file..log -- if subprocesses are
- logged, each new subprocess will have the logging set to its own pid).
-
- Usually setting the environment variable is preferred as it'd log information while
- pydevd is still doing its imports and not just after this method is called, but on
- cases where this is hard to do this function may be called to set the tracing after
- pydevd itself is already imported.
- '''
- pydev_log.log_to(log_file, log_level)
-
-
-def _log_initial_info():
- pydev_log.debug("Initial arguments: %s", (sys.argv,))
- pydev_log.debug("Current pid: %s", os.getpid())
- pydev_log.debug("Using cython: %s", USING_CYTHON)
- pydev_log.debug("Using frame eval: %s", USING_FRAME_EVAL)
- pydev_log.debug("Using gevent mode: %s / imported gevent module support: %s", SUPPORT_GEVENT, bool(pydevd_gevent_integration))
-
-
-def config(protocol='', debug_mode='', preimport=''):
- pydev_log.debug('Config: protocol: %s, debug_mode: %s, preimport: %s', protocol, debug_mode, preimport)
- PydevdCustomization.DEFAULT_PROTOCOL = protocol
- PydevdCustomization.DEBUG_MODE = debug_mode
- PydevdCustomization.PREIMPORT = preimport
-
-
-#=======================================================================================================================
-# main
-#=======================================================================================================================
-def main():
-
- # parse the command line. --file is our last argument that is required
- _log_initial_info()
- original_argv = sys.argv[:]
- try:
- from _pydevd_bundle.pydevd_command_line_handling import process_command_line
- setup = process_command_line(sys.argv)
- SetupHolder.setup = setup
- except ValueError:
- pydev_log.exception()
- usage(1)
-
- preimport = setup.get('preimport')
- if preimport:
- pydevd_defaults.PydevdCustomization.PREIMPORT = preimport
-
- debug_mode = setup.get('debug-mode')
- if debug_mode:
- pydevd_defaults.PydevdCustomization.DEBUG_MODE = debug_mode
-
- log_trace_level = setup.get('log-level')
-
- # Note: the logging info could've been changed (this would happen if this is a
- # subprocess and the value in the environment variable does not match the value in the
- # argument because the user used `pydevd.log_to` instead of supplying the environment
- # variable). If this is the case, update the logging info and re-log some information
- # in the new target.
- new_debug_file = setup.get('log-file')
- if new_debug_file and DebugInfoHolder.PYDEVD_DEBUG_FILE != new_debug_file:
- # The debug file can't be set directly, we need to use log_to() so that the a
- # new stream is actually created for the new file.
- log_to(new_debug_file, log_trace_level if log_trace_level is not None else 3)
- _log_initial_info() # The redirection info just changed, log it again.
-
- elif log_trace_level is not None:
- # The log file was not specified
- DebugInfoHolder.DEBUG_TRACE_LEVEL = log_trace_level
- pydev_log.debug('Original sys.argv: %s', original_argv)
-
- if setup['print-in-debugger-startup']:
- try:
- pid = ' (pid: %s)' % os.getpid()
- except:
- pid = ''
- sys.stderr.write("pydev debugger: starting%s\n" % pid)
-
- pydev_log.debug("Executing file %s", setup['file'])
- pydev_log.debug("arguments: %s", (sys.argv,))
-
- pydevd_vm_type.setup_type(setup.get('vm_type', None))
-
- port = setup['port']
- host = setup['client']
- f = setup['file']
- fix_app_engine_debug = False
-
- debugger = get_global_debugger()
- if debugger is None:
- debugger = PyDB()
-
- try:
- from _pydev_bundle import pydev_monkey
- except:
- pass # Not usable on jython 2.1
- else:
- if setup['multiprocess']: # PyDev
- pydev_monkey.patch_new_process_functions()
-
- elif setup['multiproc']: # PyCharm
- pydev_log.debug("Started in multiproc mode\n")
- global DISPATCH_APPROACH
- DISPATCH_APPROACH = DISPATCH_APPROACH_EXISTING_CONNECTION
-
- dispatcher = Dispatcher()
- try:
- dispatcher.connect(host, port)
- if dispatcher.port is not None:
- port = dispatcher.port
- pydev_log.debug("Received port %d\n", port)
- pydev_log.info("pydev debugger: process %d is connecting\n" % os.getpid())
-
- try:
- pydev_monkey.patch_new_process_functions()
- except:
- pydev_log.exception("Error patching process functions.")
- else:
- pydev_log.critical("pydev debugger: couldn't get port for new debug process.")
- finally:
- dispatcher.close()
- else:
- try:
- pydev_monkey.patch_new_process_functions_with_warning()
- except:
- pydev_log.exception("Error patching process functions.")
-
- # Only do this patching if we're not running with multiprocess turned on.
- if f.find('dev_appserver.py') != -1:
- if os.path.basename(f).startswith('dev_appserver.py'):
- appserver_dir = os.path.dirname(f)
- version_file = os.path.join(appserver_dir, 'VERSION')
- if os.path.exists(version_file):
- try:
- stream = open(version_file, 'r')
- try:
- for line in stream.read().splitlines():
- line = line.strip()
- if line.startswith('release:'):
- line = line[8:].strip()
- version = line.replace('"', '')
- version = version.split('.')
- if int(version[0]) > 1:
- fix_app_engine_debug = True
-
- elif int(version[0]) == 1:
- if int(version[1]) >= 7:
- # Only fix from 1.7 onwards
- fix_app_engine_debug = True
- break
- finally:
- stream.close()
- except:
- pydev_log.exception()
-
- try:
- # In the default run (i.e.: run directly on debug mode), we try to patch stackless as soon as possible
- # on a run where we have a remote debug, we may have to be more careful because patching stackless means
- # that if the user already had a stackless.set_schedule_callback installed, he'd loose it and would need
- # to call it again (because stackless provides no way of getting the last function which was registered
- # in set_schedule_callback).
- #
- # So, ideally, if there's an application using stackless and the application wants to use the remote debugger
- # and benefit from stackless debugging, the application itself must call:
- #
- # import pydevd_stackless
- # pydevd_stackless.patch_stackless()
- #
- # itself to be able to benefit from seeing the tasklets created before the remote debugger is attached.
- from _pydevd_bundle import pydevd_stackless
- pydevd_stackless.patch_stackless()
- except:
- # It's ok not having stackless there...
- try:
- if hasattr(sys, 'exc_clear'):
- sys.exc_clear() # the exception information should be cleaned in Python 2
- except:
- pass
-
- is_module = setup['module']
- if not setup['skip-notify-stdin']:
- patch_stdin()
-
- if setup[pydevd_constants.ARGUMENT_JSON_PROTOCOL]:
- PyDevdAPI().set_protocol(debugger, 0, JSON_PROTOCOL)
-
- elif setup[pydevd_constants.ARGUMENT_HTTP_JSON_PROTOCOL]:
- PyDevdAPI().set_protocol(debugger, 0, HTTP_JSON_PROTOCOL)
-
- elif setup[pydevd_constants.ARGUMENT_HTTP_PROTOCOL]:
- PyDevdAPI().set_protocol(debugger, 0, pydevd_constants.HTTP_PROTOCOL)
-
- elif setup[pydevd_constants.ARGUMENT_QUOTED_LINE_PROTOCOL]:
- PyDevdAPI().set_protocol(debugger, 0, pydevd_constants.QUOTED_LINE_PROTOCOL)
-
- access_token = setup['access-token']
- if access_token:
- debugger.authentication.access_token = access_token
-
- client_access_token = setup['client-access-token']
- if client_access_token:
- debugger.authentication.client_access_token = client_access_token
-
- if fix_app_engine_debug:
- sys.stderr.write("pydev debugger: google app engine integration enabled\n")
- curr_dir = os.path.dirname(__file__)
- app_engine_startup_file = os.path.join(curr_dir, 'pydev_app_engine_debug_startup.py')
-
- sys.argv.insert(1, '--python_startup_script=' + app_engine_startup_file)
- import json
- setup['pydevd'] = __file__
- sys.argv.insert(2, '--python_startup_args=%s' % json.dumps(setup),)
- sys.argv.insert(3, '--automatic_restart=no')
- sys.argv.insert(4, '--max_module_instances=1')
-
- # Run the dev_appserver
- debugger.run(setup['file'], None, None, is_module, set_trace=False)
- else:
- if setup['save-threading']:
- debugger.thread_analyser = ThreadingLogger()
- if setup['save-asyncio']:
- debugger.asyncio_analyser = AsyncioLogger()
-
- apply_debugger_options(setup)
-
- try:
- debugger.connect(host, port)
- except:
- sys.stderr.write("Could not connect to %s: %s\n" % (host, port))
- pydev_log.exception()
- sys.exit(1)
-
- globals = debugger.run(setup['file'], None, None, is_module)
-
- if setup['cmd-line']:
- debugger.wait_for_commands(globals)
-
-
-if __name__ == '__main__':
- main()
diff --git a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/docarray/typing/bytes/image_bytes.py b/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/docarray/typing/bytes/image_bytes.py
deleted file mode 100644
index a456a493ccbc4a35d8f83a3ec418343a81e19596..0000000000000000000000000000000000000000
--- a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/docarray/typing/bytes/image_bytes.py
+++ /dev/null
@@ -1,145 +0,0 @@
-from io import BytesIO
-from typing import TYPE_CHECKING, Any, Optional, Tuple, Type, TypeVar
-
-import numpy as np
-from pydantic import parse_obj_as
-from pydantic.validators import bytes_validator
-
-from docarray.typing.abstract_type import AbstractType
-from docarray.typing.proto_register import _register_proto
-from docarray.typing.tensor.image.image_ndarray import ImageNdArray
-from docarray.utils._internal.misc import import_library
-
-if TYPE_CHECKING:
- from PIL import Image as PILImage
- from pydantic.fields import BaseConfig, ModelField
-
- from docarray.proto import NodeProto
-
-T = TypeVar('T', bound='ImageBytes')
-
-
-@_register_proto(proto_type_name='image_bytes')
-class ImageBytes(bytes, AbstractType):
- """
- Bytes that store an image and that can be load into an image tensor
- """
-
- @classmethod
- def validate(
- cls: Type[T],
- value: Any,
- field: 'ModelField',
- config: 'BaseConfig',
- ) -> T:
- value = bytes_validator(value)
- return cls(value)
-
- @classmethod
- def from_protobuf(cls: Type[T], pb_msg: T) -> T:
- return parse_obj_as(cls, pb_msg)
-
- def _to_node_protobuf(self: T) -> 'NodeProto':
- from docarray.proto import NodeProto
-
- return NodeProto(blob=self, type=self._proto_type_name)
-
- def load_pil(
- self,
- ) -> 'PILImage.Image':
- """
- Load the image from the bytes into a `PIL.Image.Image` instance
-
- ---
-
- ```python
- from pydantic import parse_obj_as
-
- from docarray import BaseDoc
- from docarray.typing import ImageUrl
-
- img_url = "https://upload.wikimedia.org/wikipedia/commons/8/80/Dag_Sebastian_Ahlander_at_G%C3%B6teborg_Book_Fair_2012b.jpg"
-
- img_url = parse_obj_as(ImageUrl, img_url)
- img = img_url.load_pil()
-
- from PIL.Image import Image
-
- assert isinstance(img, Image)
- ```
-
- ---
- :return: a Pillow image
- """
- PIL = import_library('PIL', raise_error=True) # noqa: F841
- from PIL import Image as PILImage
-
- return PILImage.open(BytesIO(self))
-
- def load(
- self,
- width: Optional[int] = None,
- height: Optional[int] = None,
- axis_layout: Tuple[str, str, str] = ('H', 'W', 'C'),
- ) -> ImageNdArray:
- """
- Load the image from the [`ImageBytes`][docarray.typing.ImageBytes] into an
- [`ImageNdArray`][docarray.typing.ImageNdArray].
-
- ---
-
- ```python
- from docarray import BaseDoc
- from docarray.typing import ImageNdArray, ImageUrl
-
-
- class MyDoc(BaseDoc):
- img_url: ImageUrl
-
-
- doc = MyDoc(
- img_url="https://upload.wikimedia.org/wikipedia/commons/8/80/"
- "Dag_Sebastian_Ahlander_at_G%C3%B6teborg_Book_Fair_2012b.jpg"
- )
-
- img_tensor = doc.img_url.load()
- assert isinstance(img_tensor, ImageNdArray)
-
- img_tensor = doc.img_url.load(height=224, width=224)
- assert img_tensor.shape == (224, 224, 3)
-
- layout = ('C', 'W', 'H')
- img_tensor = doc.img_url.load(height=100, width=200, axis_layout=layout)
- assert img_tensor.shape == (3, 200, 100)
- ```
-
- ---
-
- :param width: width of the image tensor.
- :param height: height of the image tensor.
- :param axis_layout: ordering of the different image axes.
- 'H' = height, 'W' = width, 'C' = color channel
- :return: [`ImageNdArray`][docarray.typing.ImageNdArray] representing the image as RGB values
- """
- raw_img = self.load_pil()
-
- if width or height:
- new_width = width or raw_img.width
- new_height = height or raw_img.height
- raw_img = raw_img.resize((new_width, new_height))
- try:
- tensor = np.array(raw_img.convert('RGB'))
- except Exception:
- tensor = np.array(raw_img)
-
- img = self._move_channel_axis(tensor, axis_layout=axis_layout)
- return parse_obj_as(ImageNdArray, img)
-
- @staticmethod
- def _move_channel_axis(
- tensor: np.ndarray, axis_layout: Tuple[str, str, str] = ('H', 'W', 'C')
- ) -> np.ndarray:
- """Moves channel axis around."""
- channel_to_offset = {'H': 0, 'W': 1, 'C': 2}
- permutation = tuple(channel_to_offset[axis] for axis in axis_layout)
- return np.transpose(tensor, permutation)
diff --git a/spaces/Superlang/ImageProcessor/annotator/oneformer/detectron2/projects/deeplab/resnet.py b/spaces/Superlang/ImageProcessor/annotator/oneformer/detectron2/projects/deeplab/resnet.py
deleted file mode 100644
index 28455d123a12f887400c19c263d08cc2ed08522e..0000000000000000000000000000000000000000
--- a/spaces/Superlang/ImageProcessor/annotator/oneformer/detectron2/projects/deeplab/resnet.py
+++ /dev/null
@@ -1,158 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import fvcore.nn.weight_init as weight_init
-import torch.nn.functional as F
-
-from annotator.oneformer.detectron2.layers import CNNBlockBase, Conv2d, get_norm
-from annotator.oneformer.detectron2.modeling import BACKBONE_REGISTRY
-from annotator.oneformer.detectron2.modeling.backbone.resnet import (
- BasicStem,
- BottleneckBlock,
- DeformBottleneckBlock,
- ResNet,
-)
-
-
-class DeepLabStem(CNNBlockBase):
- """
- The DeepLab ResNet stem (layers before the first residual block).
- """
-
- def __init__(self, in_channels=3, out_channels=128, norm="BN"):
- """
- Args:
- norm (str or callable): norm after the first conv layer.
- See :func:`layers.get_norm` for supported format.
- """
- super().__init__(in_channels, out_channels, 4)
- self.in_channels = in_channels
- self.conv1 = Conv2d(
- in_channels,
- out_channels // 2,
- kernel_size=3,
- stride=2,
- padding=1,
- bias=False,
- norm=get_norm(norm, out_channels // 2),
- )
- self.conv2 = Conv2d(
- out_channels // 2,
- out_channels // 2,
- kernel_size=3,
- stride=1,
- padding=1,
- bias=False,
- norm=get_norm(norm, out_channels // 2),
- )
- self.conv3 = Conv2d(
- out_channels // 2,
- out_channels,
- kernel_size=3,
- stride=1,
- padding=1,
- bias=False,
- norm=get_norm(norm, out_channels),
- )
- weight_init.c2_msra_fill(self.conv1)
- weight_init.c2_msra_fill(self.conv2)
- weight_init.c2_msra_fill(self.conv3)
-
- def forward(self, x):
- x = self.conv1(x)
- x = F.relu_(x)
- x = self.conv2(x)
- x = F.relu_(x)
- x = self.conv3(x)
- x = F.relu_(x)
- x = F.max_pool2d(x, kernel_size=3, stride=2, padding=1)
- return x
-
-
-@BACKBONE_REGISTRY.register()
-def build_resnet_deeplab_backbone(cfg, input_shape):
- """
- Create a ResNet instance from config.
- Returns:
- ResNet: a :class:`ResNet` instance.
- """
- # need registration of new blocks/stems?
- norm = cfg.MODEL.RESNETS.NORM
- if cfg.MODEL.RESNETS.STEM_TYPE == "basic":
- stem = BasicStem(
- in_channels=input_shape.channels,
- out_channels=cfg.MODEL.RESNETS.STEM_OUT_CHANNELS,
- norm=norm,
- )
- elif cfg.MODEL.RESNETS.STEM_TYPE == "deeplab":
- stem = DeepLabStem(
- in_channels=input_shape.channels,
- out_channels=cfg.MODEL.RESNETS.STEM_OUT_CHANNELS,
- norm=norm,
- )
- else:
- raise ValueError("Unknown stem type: {}".format(cfg.MODEL.RESNETS.STEM_TYPE))
-
- # fmt: off
- freeze_at = cfg.MODEL.BACKBONE.FREEZE_AT
- out_features = cfg.MODEL.RESNETS.OUT_FEATURES
- depth = cfg.MODEL.RESNETS.DEPTH
- num_groups = cfg.MODEL.RESNETS.NUM_GROUPS
- width_per_group = cfg.MODEL.RESNETS.WIDTH_PER_GROUP
- bottleneck_channels = num_groups * width_per_group
- in_channels = cfg.MODEL.RESNETS.STEM_OUT_CHANNELS
- out_channels = cfg.MODEL.RESNETS.RES2_OUT_CHANNELS
- stride_in_1x1 = cfg.MODEL.RESNETS.STRIDE_IN_1X1
- res4_dilation = cfg.MODEL.RESNETS.RES4_DILATION
- res5_dilation = cfg.MODEL.RESNETS.RES5_DILATION
- deform_on_per_stage = cfg.MODEL.RESNETS.DEFORM_ON_PER_STAGE
- deform_modulated = cfg.MODEL.RESNETS.DEFORM_MODULATED
- deform_num_groups = cfg.MODEL.RESNETS.DEFORM_NUM_GROUPS
- res5_multi_grid = cfg.MODEL.RESNETS.RES5_MULTI_GRID
- # fmt: on
- assert res4_dilation in {1, 2}, "res4_dilation cannot be {}.".format(res4_dilation)
- assert res5_dilation in {1, 2, 4}, "res5_dilation cannot be {}.".format(res5_dilation)
- if res4_dilation == 2:
- # Always dilate res5 if res4 is dilated.
- assert res5_dilation == 4
-
- num_blocks_per_stage = {50: [3, 4, 6, 3], 101: [3, 4, 23, 3], 152: [3, 8, 36, 3]}[depth]
-
- stages = []
-
- # Avoid creating variables without gradients
- # It consumes extra memory and may cause allreduce to fail
- out_stage_idx = [{"res2": 2, "res3": 3, "res4": 4, "res5": 5}[f] for f in out_features]
- max_stage_idx = max(out_stage_idx)
- for idx, stage_idx in enumerate(range(2, max_stage_idx + 1)):
- if stage_idx == 4:
- dilation = res4_dilation
- elif stage_idx == 5:
- dilation = res5_dilation
- else:
- dilation = 1
- first_stride = 1 if idx == 0 or dilation > 1 else 2
- stage_kargs = {
- "num_blocks": num_blocks_per_stage[idx],
- "stride_per_block": [first_stride] + [1] * (num_blocks_per_stage[idx] - 1),
- "in_channels": in_channels,
- "out_channels": out_channels,
- "norm": norm,
- }
- stage_kargs["bottleneck_channels"] = bottleneck_channels
- stage_kargs["stride_in_1x1"] = stride_in_1x1
- stage_kargs["dilation"] = dilation
- stage_kargs["num_groups"] = num_groups
- if deform_on_per_stage[idx]:
- stage_kargs["block_class"] = DeformBottleneckBlock
- stage_kargs["deform_modulated"] = deform_modulated
- stage_kargs["deform_num_groups"] = deform_num_groups
- else:
- stage_kargs["block_class"] = BottleneckBlock
- if stage_idx == 5:
- stage_kargs.pop("dilation")
- stage_kargs["dilation_per_block"] = [dilation * mg for mg in res5_multi_grid]
- blocks = ResNet.make_stage(**stage_kargs)
- in_channels = out_channels
- out_channels *= 2
- bottleneck_channels *= 2
- stages.append(blocks)
- return ResNet(stem, stages, out_features=out_features).freeze(freeze_at)
diff --git a/spaces/Superlang/ImageProcessor/annotator/oneformer/oneformer/modeling/pixel_decoder/__init__.py b/spaces/Superlang/ImageProcessor/annotator/oneformer/oneformer/modeling/pixel_decoder/__init__.py
deleted file mode 100644
index 9020c2df23e2af280b7bb168b996ae9eaf312eb8..0000000000000000000000000000000000000000
--- a/spaces/Superlang/ImageProcessor/annotator/oneformer/oneformer/modeling/pixel_decoder/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
diff --git a/spaces/Superlang/ImageProcessor/annotator/uniformer/configs/_base_/schedules/schedule_80k.py b/spaces/Superlang/ImageProcessor/annotator/uniformer/configs/_base_/schedules/schedule_80k.py
deleted file mode 100644
index c190cee6bdc7922b688ea75dc8f152fa15c24617..0000000000000000000000000000000000000000
--- a/spaces/Superlang/ImageProcessor/annotator/uniformer/configs/_base_/schedules/schedule_80k.py
+++ /dev/null
@@ -1,9 +0,0 @@
-# optimizer
-optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005)
-optimizer_config = dict()
-# learning policy
-lr_config = dict(policy='poly', power=0.9, min_lr=1e-4, by_epoch=False)
-# runtime settings
-runner = dict(type='IterBasedRunner', max_iters=80000)
-checkpoint_config = dict(by_epoch=False, interval=8000)
-evaluation = dict(interval=8000, metric='mIoU')
diff --git a/spaces/TabPFN/TabPFNEvaluation/TabPFN/utils.py b/spaces/TabPFN/TabPFNEvaluation/TabPFN/utils.py
deleted file mode 100644
index b600696b0baf302858ceabb99a1e4e24986c0624..0000000000000000000000000000000000000000
--- a/spaces/TabPFN/TabPFNEvaluation/TabPFN/utils.py
+++ /dev/null
@@ -1,236 +0,0 @@
-import os
-import math
-import argparse
-import random
-import datetime
-
-import torch
-from torch import nn
-from torch.optim.lr_scheduler import LambdaLR
-import numpy as np
-
-# copied from huggingface
-def get_cosine_schedule_with_warmup(optimizer, num_warmup_steps, num_training_steps, num_cycles=0.5, last_epoch=-1):
- """ Create a schedule with a learning rate that decreases following the
- values of the cosine function between 0 and `pi * cycles` after a warmup
- period during which it increases linearly between 0 and 1.
- """
-
- def lr_lambda(current_step):
- if current_step < num_warmup_steps:
- return float(current_step) / float(max(1, num_warmup_steps))
- progress = float(current_step - num_warmup_steps) / float(max(1, num_training_steps - num_warmup_steps))
- return max(0.0, 0.5 * (1.0 + math.cos(math.pi * float(num_cycles) * 2.0 * progress)))
-
- return LambdaLR(optimizer, lr_lambda, last_epoch)
-
-# copied from huggingface
-def get_linear_schedule_with_warmup(optimizer, num_warmup_steps, num_training_steps, last_epoch=-1):
- """
- Create a schedule with a learning rate that decreases linearly from the initial lr set in the optimizer to 0, after
- a warmup period during which it increases linearly from 0 to the initial lr set in the optimizer.
-
- Args:
- optimizer (:class:`~torch.optim.Optimizer`):
- The optimizer for which to schedule the learning rate.
- num_warmup_steps (:obj:`int`):
- The number of steps for the warmup phase.
- num_training_steps (:obj:`int`):
- The total number of training steps.
- last_epoch (:obj:`int`, `optional`, defaults to -1):
- The index of the last epoch when resuming training.
-
- Return:
- :obj:`torch.optim.lr_scheduler.LambdaLR` with the appropriate schedule.
- """
-
- def lr_lambda(current_step: int):
- if current_step < num_warmup_steps:
- return float(current_step) / float(max(1, num_warmup_steps))
- return max(
- 0.0, float(num_training_steps - current_step) / float(max(1, num_training_steps - num_warmup_steps))
- )
-
- return LambdaLR(optimizer, lr_lambda, last_epoch)
-
-
-def get_openai_lr(transformer_model):
- num_params = sum(p.numel() for p in transformer_model.parameters())
- return 0.003239 - 0.0001395 * math.log(num_params)
-
-
-def get_weighted_single_eval_pos_sampler(max_len):
- """
- This gives a sampler that can be used for `single_eval_pos` which yields good performance for all positions p,
- where p <= `max_len`. At most `max_len` - 1 examples are shown to the Transformer.
- :return: Sampler that can be fed to `train()` as `single_eval_pos_gen`.
- """
- return lambda: random.choices(range(max_len), [1 / (max_len - i) for i in range(max_len)])[0]
-
-
-def get_uniform_single_eval_pos_sampler(max_len, min_len=0):
- """
- Just sample any evaluation position with the same weight
- :return: Sampler that can be fed to `train()` as `single_eval_pos_gen`.
- """
- return lambda: random.choices(range(min_len, max_len))[0]
-
-
-class SeqBN(nn.Module):
- def __init__(self, d_model):
- super().__init__()
- self.bn = nn.BatchNorm1d(d_model)
- self.d_model = d_model
-
- def forward(self, x):
- assert self.d_model == x.shape[-1]
- flat_x = x.view(-1, self.d_model)
- flat_x = self.bn(flat_x)
- return flat_x.view(*x.shape)
-
-
-def set_locals_in_self(locals):
- self = locals['self']
- for var_name, val in locals.items():
- if var_name != 'self': setattr(self, var_name, val)
-
-
-default_device = 'cuda:0' if torch.cuda.is_available() else 'cpu:0'
-
-
-# Copied from StackOverflow, but we do an eval on the values additionally
-class StoreDictKeyPair(argparse.Action):
- def __init__(self, option_strings, dest, nargs=None, **kwargs):
- self._nargs = nargs
- super(StoreDictKeyPair, self).__init__(option_strings, dest, nargs=nargs, **kwargs)
-
- def __call__(self, parser, namespace, values, option_string=None):
- my_dict = {}
- for kv in values:
- k, v = kv.split("=")
- try:
- my_dict[k] = eval(v)
- except NameError:
- my_dict[k] = v
- setattr(namespace, self.dest, my_dict)
- print("dict values: {}".format(my_dict))
-
-def get_nan_value(v, set_value_to_nan=0.0):
- if random.random() < set_value_to_nan:
- return v
- else:
- return random.choice([-999, 0, 1, 999])
-
-def to_ranking(data):
- x = (data >= data.unsqueeze(-3))
- x = x.sum(0)
- return x
-# TODO: Is there a better way to do this?
-# 1. Cmparing to unique elements: When all values are different we still get quadratic blowup
-# 2. Argsort(Argsort()) returns ranking, but with duplicate values there is an ordering which is problematic
-# 3. Argsort(Argsort(Unique))->Scatter seems a bit complicated, doesn't have quadratic blowup, but how fast?
-def to_ranking_low_mem(data):
- x = torch.zeros_like(data)
- for col in range(data.shape[-1]):
- x_ = (data[:, :, col] >= data[:, :, col].unsqueeze(-2))
- x_ = x_.sum(0)
- x[:, :, col] = x_
- return x
-
-def nan_handling_missing_for_unknown_reason_value(set_value_to_nan=0.0):
- return get_nan_value(float('nan'), set_value_to_nan)
-
-def nan_handling_missing_for_no_reason_value(set_value_to_nan=0.0):
- return get_nan_value(float('-inf'), set_value_to_nan)
-
-def nan_handling_missing_for_a_reason_value(set_value_to_nan=0.0):
- return get_nan_value(float('inf'), set_value_to_nan)
-
-def torch_nanmean(x, axis=0):
- num = torch.where(torch.isnan(x), torch.full_like(x, 0), torch.full_like(x, 1)).sum(axis=axis)
- value = torch.where(torch.isnan(x), torch.full_like(x, 0), x).sum(axis=axis)
- return value / num
-
-def torch_nanstd(x, axis=0):
- num = torch.where(torch.isnan(x), torch.full_like(x, 0), torch.full_like(x, 1)).sum(axis=axis)
- value = torch.where(torch.isnan(x), torch.full_like(x, 0), x).sum(axis=axis)
- mean = value / num
- mean_broadcast = torch.repeat_interleave(mean.unsqueeze(axis), x.shape[axis], dim=axis)
- return torch.sqrt(torch.nansum(torch.square(mean_broadcast - x), axis=axis) / (num - 1))
-
-def normalize_data(data, normalize_positions=-1):
- if normalize_positions > 0:
- mean = torch_nanmean(data[:normalize_positions], axis=0)
- std = torch_nanstd(data[:normalize_positions], axis=0) + .000001
- else:
- mean = torch_nanmean(data, axis=0)
- std = torch_nanstd(data, axis=0) + .000001
- data = (data - mean) / std
- data = torch.clip(data, min=-100, max=100)
-
- return data
-
-def remove_outliers(X, n_sigma=4):
- # Expects T, B, H
- assert len(X.shape) == 3, "X must be T,B,H"
- #for b in range(X.shape[1]):
- #for col in range(X.shape[2]):
- data = X
- data_mean, data_std = torch_nanmean(data, axis=0), torch_nanstd(data, axis=0)
- cut_off = data_std * n_sigma
- lower, upper = data_mean - cut_off, data_mean + cut_off
-
- data_clean = X[:].clone()
- data_clean[torch.logical_or(data > upper, data < lower)] = np.nan
- data_mean, data_std = torch_nanmean(data_clean, axis=0), torch_nanstd(data_clean, axis=0)
- cut_off = data_std * n_sigma
- lower, upper = data_mean - cut_off, data_mean + cut_off
-
- X = torch.maximum(-torch.log(1+torch.abs(X)) + lower, X)
- X = torch.minimum(torch.log(1+torch.abs(X)) + upper, X)
- # print(ds[1][data < lower, col], ds[1][data > upper, col], ds[1][~np.isnan(data), col].shape, data_mean, data_std)
- return X
-
-def bool_mask_to_att_mask(mask):
- return mask.float().masked_fill(mask == 0, float('-inf')).masked_fill(mask == 1, float(0.0))
-
-def print_on_master_only(is_master):
- import builtins as __builtin__
-
- builtin_print = __builtin__.print
-
- def print(*args, **kwargs):
- force = kwargs.pop("force", False)
- if is_master or force:
- builtin_print(*args, **kwargs)
-
- __builtin__.print = print
-
-def init_dist(device):
- if 'SLURM_PROCID' in os.environ and torch.cuda.device_count() > 1:
- assert device != 'cpu:0'
- rank = int(os.environ['SLURM_PROCID'])
- os.environ['MASTER_ADDR'] = 'localhost'
- os.environ['MASTER_PORT'] = '12355'
- torch.cuda.set_device(rank)
- os.environ['CUDA_VISIBLE_DEVICES'] = str(rank)
- torch.distributed.init_process_group(backend="nccl", init_method="env://", timeout=datetime.timedelta(seconds=20),
- world_size=torch.cuda.device_count(), rank=rank)
- torch.distributed.barrier()
- print_on_master_only(rank == 0)
- print(f"Distributed training on {torch.cuda.device_count()} GPUs, this is rank {rank}, "
- "only I can print, but when using print(..., force=True) it will print on all ranks.")
-
- return True, rank, f'cuda:{rank}'
- else:
- print('Not using distributed')
- # will not change any of the behavior of print, but allows putting the force=True in the print calls
- print_on_master_only(True)
- return False, 0, device
-
-# NOP function for python with statements (x = NOP(); with x:)
-class NOP():
- def __enter__(self):
- pass
- def __exit__(self, type, value, traceback):
- pass
\ No newline at end of file
diff --git a/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_vendor/distlib/database.py b/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_vendor/distlib/database.py
deleted file mode 100644
index 5db5d7f507c1d150e6b36f236df7ee61c0f65581..0000000000000000000000000000000000000000
--- a/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_vendor/distlib/database.py
+++ /dev/null
@@ -1,1350 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2012-2017 The Python Software Foundation.
-# See LICENSE.txt and CONTRIBUTORS.txt.
-#
-"""PEP 376 implementation."""
-
-from __future__ import unicode_literals
-
-import base64
-import codecs
-import contextlib
-import hashlib
-import logging
-import os
-import posixpath
-import sys
-import zipimport
-
-from . import DistlibException, resources
-from .compat import StringIO
-from .version import get_scheme, UnsupportedVersionError
-from .metadata import (Metadata, METADATA_FILENAME, WHEEL_METADATA_FILENAME,
- LEGACY_METADATA_FILENAME)
-from .util import (parse_requirement, cached_property, parse_name_and_version,
- read_exports, write_exports, CSVReader, CSVWriter)
-
-
-__all__ = ['Distribution', 'BaseInstalledDistribution',
- 'InstalledDistribution', 'EggInfoDistribution',
- 'DistributionPath']
-
-
-logger = logging.getLogger(__name__)
-
-EXPORTS_FILENAME = 'pydist-exports.json'
-COMMANDS_FILENAME = 'pydist-commands.json'
-
-DIST_FILES = ('INSTALLER', METADATA_FILENAME, 'RECORD', 'REQUESTED',
- 'RESOURCES', EXPORTS_FILENAME, 'SHARED')
-
-DISTINFO_EXT = '.dist-info'
-
-
-class _Cache(object):
- """
- A simple cache mapping names and .dist-info paths to distributions
- """
- def __init__(self):
- """
- Initialise an instance. There is normally one for each DistributionPath.
- """
- self.name = {}
- self.path = {}
- self.generated = False
-
- def clear(self):
- """
- Clear the cache, setting it to its initial state.
- """
- self.name.clear()
- self.path.clear()
- self.generated = False
-
- def add(self, dist):
- """
- Add a distribution to the cache.
- :param dist: The distribution to add.
- """
- if dist.path not in self.path:
- self.path[dist.path] = dist
- self.name.setdefault(dist.key, []).append(dist)
-
-
-class DistributionPath(object):
- """
- Represents a set of distributions installed on a path (typically sys.path).
- """
- def __init__(self, path=None, include_egg=False):
- """
- Create an instance from a path, optionally including legacy (distutils/
- setuptools/distribute) distributions.
- :param path: The path to use, as a list of directories. If not specified,
- sys.path is used.
- :param include_egg: If True, this instance will look for and return legacy
- distributions as well as those based on PEP 376.
- """
- if path is None:
- path = sys.path
- self.path = path
- self._include_dist = True
- self._include_egg = include_egg
-
- self._cache = _Cache()
- self._cache_egg = _Cache()
- self._cache_enabled = True
- self._scheme = get_scheme('default')
-
- def _get_cache_enabled(self):
- return self._cache_enabled
-
- def _set_cache_enabled(self, value):
- self._cache_enabled = value
-
- cache_enabled = property(_get_cache_enabled, _set_cache_enabled)
-
- def clear_cache(self):
- """
- Clears the internal cache.
- """
- self._cache.clear()
- self._cache_egg.clear()
-
-
- def _yield_distributions(self):
- """
- Yield .dist-info and/or .egg(-info) distributions.
- """
- # We need to check if we've seen some resources already, because on
- # some Linux systems (e.g. some Debian/Ubuntu variants) there are
- # symlinks which alias other files in the environment.
- seen = set()
- for path in self.path:
- finder = resources.finder_for_path(path)
- if finder is None:
- continue
- r = finder.find('')
- if not r or not r.is_container:
- continue
- rset = sorted(r.resources)
- for entry in rset:
- r = finder.find(entry)
- if not r or r.path in seen:
- continue
- try:
- if self._include_dist and entry.endswith(DISTINFO_EXT):
- possible_filenames = [METADATA_FILENAME,
- WHEEL_METADATA_FILENAME,
- LEGACY_METADATA_FILENAME]
- for metadata_filename in possible_filenames:
- metadata_path = posixpath.join(entry, metadata_filename)
- pydist = finder.find(metadata_path)
- if pydist:
- break
- else:
- continue
-
- with contextlib.closing(pydist.as_stream()) as stream:
- metadata = Metadata(fileobj=stream, scheme='legacy')
- logger.debug('Found %s', r.path)
- seen.add(r.path)
- yield new_dist_class(r.path, metadata=metadata,
- env=self)
- elif self._include_egg and entry.endswith(('.egg-info',
- '.egg')):
- logger.debug('Found %s', r.path)
- seen.add(r.path)
- yield old_dist_class(r.path, self)
- except Exception as e:
- msg = 'Unable to read distribution at %s, perhaps due to bad metadata: %s'
- logger.warning(msg, r.path, e)
- import warnings
- warnings.warn(msg % (r.path, e), stacklevel=2)
-
- def _generate_cache(self):
- """
- Scan the path for distributions and populate the cache with
- those that are found.
- """
- gen_dist = not self._cache.generated
- gen_egg = self._include_egg and not self._cache_egg.generated
- if gen_dist or gen_egg:
- for dist in self._yield_distributions():
- if isinstance(dist, InstalledDistribution):
- self._cache.add(dist)
- else:
- self._cache_egg.add(dist)
-
- if gen_dist:
- self._cache.generated = True
- if gen_egg:
- self._cache_egg.generated = True
-
- @classmethod
- def distinfo_dirname(cls, name, version):
- """
- The *name* and *version* parameters are converted into their
- filename-escaped form, i.e. any ``'-'`` characters are replaced
- with ``'_'`` other than the one in ``'dist-info'`` and the one
- separating the name from the version number.
-
- :parameter name: is converted to a standard distribution name by replacing
- any runs of non- alphanumeric characters with a single
- ``'-'``.
- :type name: string
- :parameter version: is converted to a standard version string. Spaces
- become dots, and all other non-alphanumeric characters
- (except dots) become dashes, with runs of multiple
- dashes condensed to a single dash.
- :type version: string
- :returns: directory name
- :rtype: string"""
- name = name.replace('-', '_')
- return '-'.join([name, version]) + DISTINFO_EXT
-
- def get_distributions(self):
- """
- Provides an iterator that looks for distributions and returns
- :class:`InstalledDistribution` or
- :class:`EggInfoDistribution` instances for each one of them.
-
- :rtype: iterator of :class:`InstalledDistribution` and
- :class:`EggInfoDistribution` instances
- """
- if not self._cache_enabled:
- for dist in self._yield_distributions():
- yield dist
- else:
- self._generate_cache()
-
- for dist in self._cache.path.values():
- yield dist
-
- if self._include_egg:
- for dist in self._cache_egg.path.values():
- yield dist
-
- def get_distribution(self, name):
- """
- Looks for a named distribution on the path.
-
- This function only returns the first result found, as no more than one
- value is expected. If nothing is found, ``None`` is returned.
-
- :rtype: :class:`InstalledDistribution`, :class:`EggInfoDistribution`
- or ``None``
- """
- result = None
- name = name.lower()
- if not self._cache_enabled:
- for dist in self._yield_distributions():
- if dist.key == name:
- result = dist
- break
- else:
- self._generate_cache()
-
- if name in self._cache.name:
- result = self._cache.name[name][0]
- elif self._include_egg and name in self._cache_egg.name:
- result = self._cache_egg.name[name][0]
- return result
-
- def provides_distribution(self, name, version=None):
- """
- Iterates over all distributions to find which distributions provide *name*.
- If a *version* is provided, it will be used to filter the results.
-
- This function only returns the first result found, since no more than
- one values are expected. If the directory is not found, returns ``None``.
-
- :parameter version: a version specifier that indicates the version
- required, conforming to the format in ``PEP-345``
-
- :type name: string
- :type version: string
- """
- matcher = None
- if version is not None:
- try:
- matcher = self._scheme.matcher('%s (%s)' % (name, version))
- except ValueError:
- raise DistlibException('invalid name or version: %r, %r' %
- (name, version))
-
- for dist in self.get_distributions():
- # We hit a problem on Travis where enum34 was installed and doesn't
- # have a provides attribute ...
- if not hasattr(dist, 'provides'):
- logger.debug('No "provides": %s', dist)
- else:
- provided = dist.provides
-
- for p in provided:
- p_name, p_ver = parse_name_and_version(p)
- if matcher is None:
- if p_name == name:
- yield dist
- break
- else:
- if p_name == name and matcher.match(p_ver):
- yield dist
- break
-
- def get_file_path(self, name, relative_path):
- """
- Return the path to a resource file.
- """
- dist = self.get_distribution(name)
- if dist is None:
- raise LookupError('no distribution named %r found' % name)
- return dist.get_resource_path(relative_path)
-
- def get_exported_entries(self, category, name=None):
- """
- Return all of the exported entries in a particular category.
-
- :param category: The category to search for entries.
- :param name: If specified, only entries with that name are returned.
- """
- for dist in self.get_distributions():
- r = dist.exports
- if category in r:
- d = r[category]
- if name is not None:
- if name in d:
- yield d[name]
- else:
- for v in d.values():
- yield v
-
-
-class Distribution(object):
- """
- A base class for distributions, whether installed or from indexes.
- Either way, it must have some metadata, so that's all that's needed
- for construction.
- """
-
- build_time_dependency = False
- """
- Set to True if it's known to be only a build-time dependency (i.e.
- not needed after installation).
- """
-
- requested = False
- """A boolean that indicates whether the ``REQUESTED`` metadata file is
- present (in other words, whether the package was installed by user
- request or it was installed as a dependency)."""
-
- def __init__(self, metadata):
- """
- Initialise an instance.
- :param metadata: The instance of :class:`Metadata` describing this
- distribution.
- """
- self.metadata = metadata
- self.name = metadata.name
- self.key = self.name.lower() # for case-insensitive comparisons
- self.version = metadata.version
- self.locator = None
- self.digest = None
- self.extras = None # additional features requested
- self.context = None # environment marker overrides
- self.download_urls = set()
- self.digests = {}
-
- @property
- def source_url(self):
- """
- The source archive download URL for this distribution.
- """
- return self.metadata.source_url
-
- download_url = source_url # Backward compatibility
-
- @property
- def name_and_version(self):
- """
- A utility property which displays the name and version in parentheses.
- """
- return '%s (%s)' % (self.name, self.version)
-
- @property
- def provides(self):
- """
- A set of distribution names and versions provided by this distribution.
- :return: A set of "name (version)" strings.
- """
- plist = self.metadata.provides
- s = '%s (%s)' % (self.name, self.version)
- if s not in plist:
- plist.append(s)
- return plist
-
- def _get_requirements(self, req_attr):
- md = self.metadata
- reqts = getattr(md, req_attr)
- logger.debug('%s: got requirements %r from metadata: %r', self.name, req_attr,
- reqts)
- return set(md.get_requirements(reqts, extras=self.extras,
- env=self.context))
-
- @property
- def run_requires(self):
- return self._get_requirements('run_requires')
-
- @property
- def meta_requires(self):
- return self._get_requirements('meta_requires')
-
- @property
- def build_requires(self):
- return self._get_requirements('build_requires')
-
- @property
- def test_requires(self):
- return self._get_requirements('test_requires')
-
- @property
- def dev_requires(self):
- return self._get_requirements('dev_requires')
-
- def matches_requirement(self, req):
- """
- Say if this instance matches (fulfills) a requirement.
- :param req: The requirement to match.
- :rtype req: str
- :return: True if it matches, else False.
- """
- # Requirement may contain extras - parse to lose those
- # from what's passed to the matcher
- r = parse_requirement(req)
- scheme = get_scheme(self.metadata.scheme)
- try:
- matcher = scheme.matcher(r.requirement)
- except UnsupportedVersionError:
- # XXX compat-mode if cannot read the version
- logger.warning('could not read version %r - using name only',
- req)
- name = req.split()[0]
- matcher = scheme.matcher(name)
-
- name = matcher.key # case-insensitive
-
- result = False
- for p in self.provides:
- p_name, p_ver = parse_name_and_version(p)
- if p_name != name:
- continue
- try:
- result = matcher.match(p_ver)
- break
- except UnsupportedVersionError:
- pass
- return result
-
- def __repr__(self):
- """
- Return a textual representation of this instance,
- """
- if self.source_url:
- suffix = ' [%s]' % self.source_url
- else:
- suffix = ''
- return '' % (self.name, self.version, suffix)
-
- def __eq__(self, other):
- """
- See if this distribution is the same as another.
- :param other: The distribution to compare with. To be equal to one
- another. distributions must have the same type, name,
- version and source_url.
- :return: True if it is the same, else False.
- """
- if type(other) is not type(self):
- result = False
- else:
- result = (self.name == other.name and
- self.version == other.version and
- self.source_url == other.source_url)
- return result
-
- def __hash__(self):
- """
- Compute hash in a way which matches the equality test.
- """
- return hash(self.name) + hash(self.version) + hash(self.source_url)
-
-
-class BaseInstalledDistribution(Distribution):
- """
- This is the base class for installed distributions (whether PEP 376 or
- legacy).
- """
-
- hasher = None
-
- def __init__(self, metadata, path, env=None):
- """
- Initialise an instance.
- :param metadata: An instance of :class:`Metadata` which describes the
- distribution. This will normally have been initialised
- from a metadata file in the ``path``.
- :param path: The path of the ``.dist-info`` or ``.egg-info``
- directory for the distribution.
- :param env: This is normally the :class:`DistributionPath`
- instance where this distribution was found.
- """
- super(BaseInstalledDistribution, self).__init__(metadata)
- self.path = path
- self.dist_path = env
-
- def get_hash(self, data, hasher=None):
- """
- Get the hash of some data, using a particular hash algorithm, if
- specified.
-
- :param data: The data to be hashed.
- :type data: bytes
- :param hasher: The name of a hash implementation, supported by hashlib,
- or ``None``. Examples of valid values are ``'sha1'``,
- ``'sha224'``, ``'sha384'``, '``sha256'``, ``'md5'`` and
- ``'sha512'``. If no hasher is specified, the ``hasher``
- attribute of the :class:`InstalledDistribution` instance
- is used. If the hasher is determined to be ``None``, MD5
- is used as the hashing algorithm.
- :returns: The hash of the data. If a hasher was explicitly specified,
- the returned hash will be prefixed with the specified hasher
- followed by '='.
- :rtype: str
- """
- if hasher is None:
- hasher = self.hasher
- if hasher is None:
- hasher = hashlib.md5
- prefix = ''
- else:
- hasher = getattr(hashlib, hasher)
- prefix = '%s=' % self.hasher
- digest = hasher(data).digest()
- digest = base64.urlsafe_b64encode(digest).rstrip(b'=').decode('ascii')
- return '%s%s' % (prefix, digest)
-
-
-class InstalledDistribution(BaseInstalledDistribution):
- """
- Created with the *path* of the ``.dist-info`` directory provided to the
- constructor. It reads the metadata contained in ``pydist.json`` when it is
- instantiated., or uses a passed in Metadata instance (useful for when
- dry-run mode is being used).
- """
-
- hasher = 'sha256'
-
- def __init__(self, path, metadata=None, env=None):
- self.modules = []
- self.finder = finder = resources.finder_for_path(path)
- if finder is None:
- raise ValueError('finder unavailable for %s' % path)
- if env and env._cache_enabled and path in env._cache.path:
- metadata = env._cache.path[path].metadata
- elif metadata is None:
- r = finder.find(METADATA_FILENAME)
- # Temporary - for Wheel 0.23 support
- if r is None:
- r = finder.find(WHEEL_METADATA_FILENAME)
- # Temporary - for legacy support
- if r is None:
- r = finder.find(LEGACY_METADATA_FILENAME)
- if r is None:
- raise ValueError('no %s found in %s' % (METADATA_FILENAME,
- path))
- with contextlib.closing(r.as_stream()) as stream:
- metadata = Metadata(fileobj=stream, scheme='legacy')
-
- super(InstalledDistribution, self).__init__(metadata, path, env)
-
- if env and env._cache_enabled:
- env._cache.add(self)
-
- r = finder.find('REQUESTED')
- self.requested = r is not None
- p = os.path.join(path, 'top_level.txt')
- if os.path.exists(p):
- with open(p, 'rb') as f:
- data = f.read().decode('utf-8')
- self.modules = data.splitlines()
-
- def __repr__(self):
- return '' % (
- self.name, self.version, self.path)
-
- def __str__(self):
- return "%s %s" % (self.name, self.version)
-
- def _get_records(self):
- """
- Get the list of installed files for the distribution
- :return: A list of tuples of path, hash and size. Note that hash and
- size might be ``None`` for some entries. The path is exactly
- as stored in the file (which is as in PEP 376).
- """
- results = []
- r = self.get_distinfo_resource('RECORD')
- with contextlib.closing(r.as_stream()) as stream:
- with CSVReader(stream=stream) as record_reader:
- # Base location is parent dir of .dist-info dir
- #base_location = os.path.dirname(self.path)
- #base_location = os.path.abspath(base_location)
- for row in record_reader:
- missing = [None for i in range(len(row), 3)]
- path, checksum, size = row + missing
- #if not os.path.isabs(path):
- # path = path.replace('/', os.sep)
- # path = os.path.join(base_location, path)
- results.append((path, checksum, size))
- return results
-
- @cached_property
- def exports(self):
- """
- Return the information exported by this distribution.
- :return: A dictionary of exports, mapping an export category to a dict
- of :class:`ExportEntry` instances describing the individual
- export entries, and keyed by name.
- """
- result = {}
- r = self.get_distinfo_resource(EXPORTS_FILENAME)
- if r:
- result = self.read_exports()
- return result
-
- def read_exports(self):
- """
- Read exports data from a file in .ini format.
-
- :return: A dictionary of exports, mapping an export category to a list
- of :class:`ExportEntry` instances describing the individual
- export entries.
- """
- result = {}
- r = self.get_distinfo_resource(EXPORTS_FILENAME)
- if r:
- with contextlib.closing(r.as_stream()) as stream:
- result = read_exports(stream)
- return result
-
- def write_exports(self, exports):
- """
- Write a dictionary of exports to a file in .ini format.
- :param exports: A dictionary of exports, mapping an export category to
- a list of :class:`ExportEntry` instances describing the
- individual export entries.
- """
- rf = self.get_distinfo_file(EXPORTS_FILENAME)
- with open(rf, 'w') as f:
- write_exports(exports, f)
-
- def get_resource_path(self, relative_path):
- """
- NOTE: This API may change in the future.
-
- Return the absolute path to a resource file with the given relative
- path.
-
- :param relative_path: The path, relative to .dist-info, of the resource
- of interest.
- :return: The absolute path where the resource is to be found.
- """
- r = self.get_distinfo_resource('RESOURCES')
- with contextlib.closing(r.as_stream()) as stream:
- with CSVReader(stream=stream) as resources_reader:
- for relative, destination in resources_reader:
- if relative == relative_path:
- return destination
- raise KeyError('no resource file with relative path %r '
- 'is installed' % relative_path)
-
- def list_installed_files(self):
- """
- Iterates over the ``RECORD`` entries and returns a tuple
- ``(path, hash, size)`` for each line.
-
- :returns: iterator of (path, hash, size)
- """
- for result in self._get_records():
- yield result
-
- def write_installed_files(self, paths, prefix, dry_run=False):
- """
- Writes the ``RECORD`` file, using the ``paths`` iterable passed in. Any
- existing ``RECORD`` file is silently overwritten.
-
- prefix is used to determine when to write absolute paths.
- """
- prefix = os.path.join(prefix, '')
- base = os.path.dirname(self.path)
- base_under_prefix = base.startswith(prefix)
- base = os.path.join(base, '')
- record_path = self.get_distinfo_file('RECORD')
- logger.info('creating %s', record_path)
- if dry_run:
- return None
- with CSVWriter(record_path) as writer:
- for path in paths:
- if os.path.isdir(path) or path.endswith(('.pyc', '.pyo')):
- # do not put size and hash, as in PEP-376
- hash_value = size = ''
- else:
- size = '%d' % os.path.getsize(path)
- with open(path, 'rb') as fp:
- hash_value = self.get_hash(fp.read())
- if path.startswith(base) or (base_under_prefix and
- path.startswith(prefix)):
- path = os.path.relpath(path, base)
- writer.writerow((path, hash_value, size))
-
- # add the RECORD file itself
- if record_path.startswith(base):
- record_path = os.path.relpath(record_path, base)
- writer.writerow((record_path, '', ''))
- return record_path
-
- def check_installed_files(self):
- """
- Checks that the hashes and sizes of the files in ``RECORD`` are
- matched by the files themselves. Returns a (possibly empty) list of
- mismatches. Each entry in the mismatch list will be a tuple consisting
- of the path, 'exists', 'size' or 'hash' according to what didn't match
- (existence is checked first, then size, then hash), the expected
- value and the actual value.
- """
- mismatches = []
- base = os.path.dirname(self.path)
- record_path = self.get_distinfo_file('RECORD')
- for path, hash_value, size in self.list_installed_files():
- if not os.path.isabs(path):
- path = os.path.join(base, path)
- if path == record_path:
- continue
- if not os.path.exists(path):
- mismatches.append((path, 'exists', True, False))
- elif os.path.isfile(path):
- actual_size = str(os.path.getsize(path))
- if size and actual_size != size:
- mismatches.append((path, 'size', size, actual_size))
- elif hash_value:
- if '=' in hash_value:
- hasher = hash_value.split('=', 1)[0]
- else:
- hasher = None
-
- with open(path, 'rb') as f:
- actual_hash = self.get_hash(f.read(), hasher)
- if actual_hash != hash_value:
- mismatches.append((path, 'hash', hash_value, actual_hash))
- return mismatches
-
- @cached_property
- def shared_locations(self):
- """
- A dictionary of shared locations whose keys are in the set 'prefix',
- 'purelib', 'platlib', 'scripts', 'headers', 'data' and 'namespace'.
- The corresponding value is the absolute path of that category for
- this distribution, and takes into account any paths selected by the
- user at installation time (e.g. via command-line arguments). In the
- case of the 'namespace' key, this would be a list of absolute paths
- for the roots of namespace packages in this distribution.
-
- The first time this property is accessed, the relevant information is
- read from the SHARED file in the .dist-info directory.
- """
- result = {}
- shared_path = os.path.join(self.path, 'SHARED')
- if os.path.isfile(shared_path):
- with codecs.open(shared_path, 'r', encoding='utf-8') as f:
- lines = f.read().splitlines()
- for line in lines:
- key, value = line.split('=', 1)
- if key == 'namespace':
- result.setdefault(key, []).append(value)
- else:
- result[key] = value
- return result
-
- def write_shared_locations(self, paths, dry_run=False):
- """
- Write shared location information to the SHARED file in .dist-info.
- :param paths: A dictionary as described in the documentation for
- :meth:`shared_locations`.
- :param dry_run: If True, the action is logged but no file is actually
- written.
- :return: The path of the file written to.
- """
- shared_path = os.path.join(self.path, 'SHARED')
- logger.info('creating %s', shared_path)
- if dry_run:
- return None
- lines = []
- for key in ('prefix', 'lib', 'headers', 'scripts', 'data'):
- path = paths[key]
- if os.path.isdir(paths[key]):
- lines.append('%s=%s' % (key, path))
- for ns in paths.get('namespace', ()):
- lines.append('namespace=%s' % ns)
-
- with codecs.open(shared_path, 'w', encoding='utf-8') as f:
- f.write('\n'.join(lines))
- return shared_path
-
- def get_distinfo_resource(self, path):
- if path not in DIST_FILES:
- raise DistlibException('invalid path for a dist-info file: '
- '%r at %r' % (path, self.path))
- finder = resources.finder_for_path(self.path)
- if finder is None:
- raise DistlibException('Unable to get a finder for %s' % self.path)
- return finder.find(path)
-
- def get_distinfo_file(self, path):
- """
- Returns a path located under the ``.dist-info`` directory. Returns a
- string representing the path.
-
- :parameter path: a ``'/'``-separated path relative to the
- ``.dist-info`` directory or an absolute path;
- If *path* is an absolute path and doesn't start
- with the ``.dist-info`` directory path,
- a :class:`DistlibException` is raised
- :type path: str
- :rtype: str
- """
- # Check if it is an absolute path # XXX use relpath, add tests
- if path.find(os.sep) >= 0:
- # it's an absolute path?
- distinfo_dirname, path = path.split(os.sep)[-2:]
- if distinfo_dirname != self.path.split(os.sep)[-1]:
- raise DistlibException(
- 'dist-info file %r does not belong to the %r %s '
- 'distribution' % (path, self.name, self.version))
-
- # The file must be relative
- if path not in DIST_FILES:
- raise DistlibException('invalid path for a dist-info file: '
- '%r at %r' % (path, self.path))
-
- return os.path.join(self.path, path)
-
- def list_distinfo_files(self):
- """
- Iterates over the ``RECORD`` entries and returns paths for each line if
- the path is pointing to a file located in the ``.dist-info`` directory
- or one of its subdirectories.
-
- :returns: iterator of paths
- """
- base = os.path.dirname(self.path)
- for path, checksum, size in self._get_records():
- # XXX add separator or use real relpath algo
- if not os.path.isabs(path):
- path = os.path.join(base, path)
- if path.startswith(self.path):
- yield path
-
- def __eq__(self, other):
- return (isinstance(other, InstalledDistribution) and
- self.path == other.path)
-
- # See http://docs.python.org/reference/datamodel#object.__hash__
- __hash__ = object.__hash__
-
-
-class EggInfoDistribution(BaseInstalledDistribution):
- """Created with the *path* of the ``.egg-info`` directory or file provided
- to the constructor. It reads the metadata contained in the file itself, or
- if the given path happens to be a directory, the metadata is read from the
- file ``PKG-INFO`` under that directory."""
-
- requested = True # as we have no way of knowing, assume it was
- shared_locations = {}
-
- def __init__(self, path, env=None):
- def set_name_and_version(s, n, v):
- s.name = n
- s.key = n.lower() # for case-insensitive comparisons
- s.version = v
-
- self.path = path
- self.dist_path = env
- if env and env._cache_enabled and path in env._cache_egg.path:
- metadata = env._cache_egg.path[path].metadata
- set_name_and_version(self, metadata.name, metadata.version)
- else:
- metadata = self._get_metadata(path)
-
- # Need to be set before caching
- set_name_and_version(self, metadata.name, metadata.version)
-
- if env and env._cache_enabled:
- env._cache_egg.add(self)
- super(EggInfoDistribution, self).__init__(metadata, path, env)
-
- def _get_metadata(self, path):
- requires = None
-
- def parse_requires_data(data):
- """Create a list of dependencies from a requires.txt file.
-
- *data*: the contents of a setuptools-produced requires.txt file.
- """
- reqs = []
- lines = data.splitlines()
- for line in lines:
- line = line.strip()
- if line.startswith('['):
- logger.warning('Unexpected line: quitting requirement scan: %r',
- line)
- break
- r = parse_requirement(line)
- if not r:
- logger.warning('Not recognised as a requirement: %r', line)
- continue
- if r.extras:
- logger.warning('extra requirements in requires.txt are '
- 'not supported')
- if not r.constraints:
- reqs.append(r.name)
- else:
- cons = ', '.join('%s%s' % c for c in r.constraints)
- reqs.append('%s (%s)' % (r.name, cons))
- return reqs
-
- def parse_requires_path(req_path):
- """Create a list of dependencies from a requires.txt file.
-
- *req_path*: the path to a setuptools-produced requires.txt file.
- """
-
- reqs = []
- try:
- with codecs.open(req_path, 'r', 'utf-8') as fp:
- reqs = parse_requires_data(fp.read())
- except IOError:
- pass
- return reqs
-
- tl_path = tl_data = None
- if path.endswith('.egg'):
- if os.path.isdir(path):
- p = os.path.join(path, 'EGG-INFO')
- meta_path = os.path.join(p, 'PKG-INFO')
- metadata = Metadata(path=meta_path, scheme='legacy')
- req_path = os.path.join(p, 'requires.txt')
- tl_path = os.path.join(p, 'top_level.txt')
- requires = parse_requires_path(req_path)
- else:
- # FIXME handle the case where zipfile is not available
- zipf = zipimport.zipimporter(path)
- fileobj = StringIO(
- zipf.get_data('EGG-INFO/PKG-INFO').decode('utf8'))
- metadata = Metadata(fileobj=fileobj, scheme='legacy')
- try:
- data = zipf.get_data('EGG-INFO/requires.txt')
- tl_data = zipf.get_data('EGG-INFO/top_level.txt').decode('utf-8')
- requires = parse_requires_data(data.decode('utf-8'))
- except IOError:
- requires = None
- elif path.endswith('.egg-info'):
- if os.path.isdir(path):
- req_path = os.path.join(path, 'requires.txt')
- requires = parse_requires_path(req_path)
- path = os.path.join(path, 'PKG-INFO')
- tl_path = os.path.join(path, 'top_level.txt')
- metadata = Metadata(path=path, scheme='legacy')
- else:
- raise DistlibException('path must end with .egg-info or .egg, '
- 'got %r' % path)
-
- if requires:
- metadata.add_requirements(requires)
- # look for top-level modules in top_level.txt, if present
- if tl_data is None:
- if tl_path is not None and os.path.exists(tl_path):
- with open(tl_path, 'rb') as f:
- tl_data = f.read().decode('utf-8')
- if not tl_data:
- tl_data = []
- else:
- tl_data = tl_data.splitlines()
- self.modules = tl_data
- return metadata
-
- def __repr__(self):
- return '' % (
- self.name, self.version, self.path)
-
- def __str__(self):
- return "%s %s" % (self.name, self.version)
-
- def check_installed_files(self):
- """
- Checks that the hashes and sizes of the files in ``RECORD`` are
- matched by the files themselves. Returns a (possibly empty) list of
- mismatches. Each entry in the mismatch list will be a tuple consisting
- of the path, 'exists', 'size' or 'hash' according to what didn't match
- (existence is checked first, then size, then hash), the expected
- value and the actual value.
- """
- mismatches = []
- record_path = os.path.join(self.path, 'installed-files.txt')
- if os.path.exists(record_path):
- for path, _, _ in self.list_installed_files():
- if path == record_path:
- continue
- if not os.path.exists(path):
- mismatches.append((path, 'exists', True, False))
- return mismatches
-
- def list_installed_files(self):
- """
- Iterates over the ``installed-files.txt`` entries and returns a tuple
- ``(path, hash, size)`` for each line.
-
- :returns: a list of (path, hash, size)
- """
-
- def _md5(path):
- f = open(path, 'rb')
- try:
- content = f.read()
- finally:
- f.close()
- return hashlib.md5(content).hexdigest()
-
- def _size(path):
- return os.stat(path).st_size
-
- record_path = os.path.join(self.path, 'installed-files.txt')
- result = []
- if os.path.exists(record_path):
- with codecs.open(record_path, 'r', encoding='utf-8') as f:
- for line in f:
- line = line.strip()
- p = os.path.normpath(os.path.join(self.path, line))
- # "./" is present as a marker between installed files
- # and installation metadata files
- if not os.path.exists(p):
- logger.warning('Non-existent file: %s', p)
- if p.endswith(('.pyc', '.pyo')):
- continue
- #otherwise fall through and fail
- if not os.path.isdir(p):
- result.append((p, _md5(p), _size(p)))
- result.append((record_path, None, None))
- return result
-
- def list_distinfo_files(self, absolute=False):
- """
- Iterates over the ``installed-files.txt`` entries and returns paths for
- each line if the path is pointing to a file located in the
- ``.egg-info`` directory or one of its subdirectories.
-
- :parameter absolute: If *absolute* is ``True``, each returned path is
- transformed into a local absolute path. Otherwise the
- raw value from ``installed-files.txt`` is returned.
- :type absolute: boolean
- :returns: iterator of paths
- """
- record_path = os.path.join(self.path, 'installed-files.txt')
- if os.path.exists(record_path):
- skip = True
- with codecs.open(record_path, 'r', encoding='utf-8') as f:
- for line in f:
- line = line.strip()
- if line == './':
- skip = False
- continue
- if not skip:
- p = os.path.normpath(os.path.join(self.path, line))
- if p.startswith(self.path):
- if absolute:
- yield p
- else:
- yield line
-
- def __eq__(self, other):
- return (isinstance(other, EggInfoDistribution) and
- self.path == other.path)
-
- # See http://docs.python.org/reference/datamodel#object.__hash__
- __hash__ = object.__hash__
-
-new_dist_class = InstalledDistribution
-old_dist_class = EggInfoDistribution
-
-
-class DependencyGraph(object):
- """
- Represents a dependency graph between distributions.
-
- The dependency relationships are stored in an ``adjacency_list`` that maps
- distributions to a list of ``(other, label)`` tuples where ``other``
- is a distribution and the edge is labeled with ``label`` (i.e. the version
- specifier, if such was provided). Also, for more efficient traversal, for
- every distribution ``x``, a list of predecessors is kept in
- ``reverse_list[x]``. An edge from distribution ``a`` to
- distribution ``b`` means that ``a`` depends on ``b``. If any missing
- dependencies are found, they are stored in ``missing``, which is a
- dictionary that maps distributions to a list of requirements that were not
- provided by any other distributions.
- """
-
- def __init__(self):
- self.adjacency_list = {}
- self.reverse_list = {}
- self.missing = {}
-
- def add_distribution(self, distribution):
- """Add the *distribution* to the graph.
-
- :type distribution: :class:`distutils2.database.InstalledDistribution`
- or :class:`distutils2.database.EggInfoDistribution`
- """
- self.adjacency_list[distribution] = []
- self.reverse_list[distribution] = []
- #self.missing[distribution] = []
-
- def add_edge(self, x, y, label=None):
- """Add an edge from distribution *x* to distribution *y* with the given
- *label*.
-
- :type x: :class:`distutils2.database.InstalledDistribution` or
- :class:`distutils2.database.EggInfoDistribution`
- :type y: :class:`distutils2.database.InstalledDistribution` or
- :class:`distutils2.database.EggInfoDistribution`
- :type label: ``str`` or ``None``
- """
- self.adjacency_list[x].append((y, label))
- # multiple edges are allowed, so be careful
- if x not in self.reverse_list[y]:
- self.reverse_list[y].append(x)
-
- def add_missing(self, distribution, requirement):
- """
- Add a missing *requirement* for the given *distribution*.
-
- :type distribution: :class:`distutils2.database.InstalledDistribution`
- or :class:`distutils2.database.EggInfoDistribution`
- :type requirement: ``str``
- """
- logger.debug('%s missing %r', distribution, requirement)
- self.missing.setdefault(distribution, []).append(requirement)
-
- def _repr_dist(self, dist):
- return '%s %s' % (dist.name, dist.version)
-
- def repr_node(self, dist, level=1):
- """Prints only a subgraph"""
- output = [self._repr_dist(dist)]
- for other, label in self.adjacency_list[dist]:
- dist = self._repr_dist(other)
- if label is not None:
- dist = '%s [%s]' % (dist, label)
- output.append(' ' * level + str(dist))
- suboutput = self.repr_node(other, level + 1)
- subs = suboutput.split('\n')
- output.extend(subs[1:])
- return '\n'.join(output)
-
- def to_dot(self, f, skip_disconnected=True):
- """Writes a DOT output for the graph to the provided file *f*.
-
- If *skip_disconnected* is set to ``True``, then all distributions
- that are not dependent on any other distribution are skipped.
-
- :type f: has to support ``file``-like operations
- :type skip_disconnected: ``bool``
- """
- disconnected = []
-
- f.write("digraph dependencies {\n")
- for dist, adjs in self.adjacency_list.items():
- if len(adjs) == 0 and not skip_disconnected:
- disconnected.append(dist)
- for other, label in adjs:
- if not label is None:
- f.write('"%s" -> "%s" [label="%s"]\n' %
- (dist.name, other.name, label))
- else:
- f.write('"%s" -> "%s"\n' % (dist.name, other.name))
- if not skip_disconnected and len(disconnected) > 0:
- f.write('subgraph disconnected {\n')
- f.write('label = "Disconnected"\n')
- f.write('bgcolor = red\n')
-
- for dist in disconnected:
- f.write('"%s"' % dist.name)
- f.write('\n')
- f.write('}\n')
- f.write('}\n')
-
- def topological_sort(self):
- """
- Perform a topological sort of the graph.
- :return: A tuple, the first element of which is a topologically sorted
- list of distributions, and the second element of which is a
- list of distributions that cannot be sorted because they have
- circular dependencies and so form a cycle.
- """
- result = []
- # Make a shallow copy of the adjacency list
- alist = {}
- for k, v in self.adjacency_list.items():
- alist[k] = v[:]
- while True:
- # See what we can remove in this run
- to_remove = []
- for k, v in list(alist.items())[:]:
- if not v:
- to_remove.append(k)
- del alist[k]
- if not to_remove:
- # What's left in alist (if anything) is a cycle.
- break
- # Remove from the adjacency list of others
- for k, v in alist.items():
- alist[k] = [(d, r) for d, r in v if d not in to_remove]
- logger.debug('Moving to result: %s',
- ['%s (%s)' % (d.name, d.version) for d in to_remove])
- result.extend(to_remove)
- return result, list(alist.keys())
-
- def __repr__(self):
- """Representation of the graph"""
- output = []
- for dist, adjs in self.adjacency_list.items():
- output.append(self.repr_node(dist))
- return '\n'.join(output)
-
-
-def make_graph(dists, scheme='default'):
- """Makes a dependency graph from the given distributions.
-
- :parameter dists: a list of distributions
- :type dists: list of :class:`distutils2.database.InstalledDistribution` and
- :class:`distutils2.database.EggInfoDistribution` instances
- :rtype: a :class:`DependencyGraph` instance
- """
- scheme = get_scheme(scheme)
- graph = DependencyGraph()
- provided = {} # maps names to lists of (version, dist) tuples
-
- # first, build the graph and find out what's provided
- for dist in dists:
- graph.add_distribution(dist)
-
- for p in dist.provides:
- name, version = parse_name_and_version(p)
- logger.debug('Add to provided: %s, %s, %s', name, version, dist)
- provided.setdefault(name, []).append((version, dist))
-
- # now make the edges
- for dist in dists:
- requires = (dist.run_requires | dist.meta_requires |
- dist.build_requires | dist.dev_requires)
- for req in requires:
- try:
- matcher = scheme.matcher(req)
- except UnsupportedVersionError:
- # XXX compat-mode if cannot read the version
- logger.warning('could not read version %r - using name only',
- req)
- name = req.split()[0]
- matcher = scheme.matcher(name)
-
- name = matcher.key # case-insensitive
-
- matched = False
- if name in provided:
- for version, provider in provided[name]:
- try:
- match = matcher.match(version)
- except UnsupportedVersionError:
- match = False
-
- if match:
- graph.add_edge(dist, provider, req)
- matched = True
- break
- if not matched:
- graph.add_missing(dist, req)
- return graph
-
-
-def get_dependent_dists(dists, dist):
- """Recursively generate a list of distributions from *dists* that are
- dependent on *dist*.
-
- :param dists: a list of distributions
- :param dist: a distribution, member of *dists* for which we are interested
- """
- if dist not in dists:
- raise DistlibException('given distribution %r is not a member '
- 'of the list' % dist.name)
- graph = make_graph(dists)
-
- dep = [dist] # dependent distributions
- todo = graph.reverse_list[dist] # list of nodes we should inspect
-
- while todo:
- d = todo.pop()
- dep.append(d)
- for succ in graph.reverse_list[d]:
- if succ not in dep:
- todo.append(succ)
-
- dep.pop(0) # remove dist from dep, was there to prevent infinite loops
- return dep
-
-
-def get_required_dists(dists, dist):
- """Recursively generate a list of distributions from *dists* that are
- required by *dist*.
-
- :param dists: a list of distributions
- :param dist: a distribution, member of *dists* for which we are interested
- in finding the dependencies.
- """
- if dist not in dists:
- raise DistlibException('given distribution %r is not a member '
- 'of the list' % dist.name)
- graph = make_graph(dists)
-
- req = set() # required distributions
- todo = graph.adjacency_list[dist] # list of nodes we should inspect
- seen = set(t[0] for t in todo) # already added to todo
-
- while todo:
- d = todo.pop()[0]
- req.add(d)
- pred_list = graph.adjacency_list[d]
- for pred in pred_list:
- d = pred[0]
- if d not in req and d not in seen:
- seen.add(d)
- todo.append(pred)
- return req
-
-
-def make_dist(name, version, **kwargs):
- """
- A convenience method for making a dist given just a name and version.
- """
- summary = kwargs.pop('summary', 'Placeholder for summary')
- md = Metadata(**kwargs)
- md.name = name
- md.version = version
- md.summary = summary or 'Placeholder for summary'
- return Distribution(md)
diff --git a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/tools/benchmark.py b/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/tools/benchmark.py
deleted file mode 100644
index aaac56400148f7b140b7c1356bbbc3b4293e5ce3..0000000000000000000000000000000000000000
--- a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/tools/benchmark.py
+++ /dev/null
@@ -1,197 +0,0 @@
-#!/usr/bin/env python
-# Copyright (c) Facebook, Inc. and its affiliates.
-"""
-A script to benchmark builtin models.
-
-Note: this script has an extra dependency of psutil.
-"""
-
-import itertools
-import logging
-import psutil
-import torch
-import tqdm
-from fvcore.common.timer import Timer
-from torch.nn.parallel import DistributedDataParallel
-
-from detectron2.checkpoint import DetectionCheckpointer
-from detectron2.config import LazyConfig, get_cfg, instantiate
-from detectron2.data import (
- DatasetFromList,
- build_detection_test_loader,
- build_detection_train_loader,
-)
-from detectron2.data.benchmark import DataLoaderBenchmark
-from detectron2.engine import AMPTrainer, SimpleTrainer, default_argument_parser, hooks, launch
-from detectron2.modeling import build_model
-from detectron2.solver import build_optimizer
-from detectron2.utils import comm
-from detectron2.utils.collect_env import collect_env_info
-from detectron2.utils.events import CommonMetricPrinter
-from detectron2.utils.logger import setup_logger
-
-logger = logging.getLogger("detectron2")
-
-
-def setup(args):
- if args.config_file.endswith(".yaml"):
- cfg = get_cfg()
- cfg.merge_from_file(args.config_file)
- cfg.SOLVER.BASE_LR = 0.001 # Avoid NaNs. Not useful in this script anyway.
- cfg.merge_from_list(args.opts)
- cfg.freeze()
- else:
- cfg = LazyConfig.load(args.config_file)
- cfg = LazyConfig.apply_overrides(cfg, args.opts)
- setup_logger(distributed_rank=comm.get_rank())
- return cfg
-
-
-def create_data_benchmark(cfg, args):
- if args.config_file.endswith(".py"):
- dl_cfg = cfg.dataloader.train
- dl_cfg._target_ = DataLoaderBenchmark
- return instantiate(dl_cfg)
- else:
- kwargs = build_detection_train_loader.from_config(cfg)
- kwargs.pop("aspect_ratio_grouping", None)
- kwargs["_target_"] = DataLoaderBenchmark
- return instantiate(kwargs)
-
-
-def RAM_msg():
- vram = psutil.virtual_memory()
- return "RAM Usage: {:.2f}/{:.2f} GB".format(
- (vram.total - vram.available) / 1024 ** 3, vram.total / 1024 ** 3
- )
-
-
-def benchmark_data(args):
- cfg = setup(args)
- logger.info("After spawning " + RAM_msg())
-
- benchmark = create_data_benchmark(cfg, args)
- benchmark.benchmark_distributed(250, 10)
- # test for a few more rounds
- for k in range(10):
- logger.info(f"Iteration {k} " + RAM_msg())
- benchmark.benchmark_distributed(250, 1)
-
-
-def benchmark_data_advanced(args):
- # benchmark dataloader with more details to help analyze performance bottleneck
- cfg = setup(args)
- benchmark = create_data_benchmark(cfg, args)
-
- if comm.get_rank() == 0:
- benchmark.benchmark_dataset(100)
- benchmark.benchmark_mapper(100)
- benchmark.benchmark_workers(100, warmup=10)
- benchmark.benchmark_IPC(100, warmup=10)
- if comm.get_world_size() > 1:
- benchmark.benchmark_distributed(100)
- logger.info("Rerun ...")
- benchmark.benchmark_distributed(100)
-
-
-def benchmark_train(args):
- cfg = setup(args)
- model = build_model(cfg)
- logger.info("Model:\n{}".format(model))
- if comm.get_world_size() > 1:
- model = DistributedDataParallel(
- model, device_ids=[comm.get_local_rank()], broadcast_buffers=False
- )
- optimizer = build_optimizer(cfg, model)
- checkpointer = DetectionCheckpointer(model, optimizer=optimizer)
- checkpointer.load(cfg.MODEL.WEIGHTS)
-
- cfg.defrost()
- cfg.DATALOADER.NUM_WORKERS = 2
- data_loader = build_detection_train_loader(cfg)
- dummy_data = list(itertools.islice(data_loader, 100))
-
- def f():
- data = DatasetFromList(dummy_data, copy=False, serialize=False)
- while True:
- yield from data
-
- max_iter = 400
- trainer = (AMPTrainer if cfg.SOLVER.AMP.ENABLED else SimpleTrainer)(model, f(), optimizer)
- trainer.register_hooks(
- [
- hooks.IterationTimer(),
- hooks.PeriodicWriter([CommonMetricPrinter(max_iter)]),
- hooks.TorchProfiler(
- lambda trainer: trainer.iter == max_iter - 1, cfg.OUTPUT_DIR, save_tensorboard=True
- ),
- ]
- )
- trainer.train(1, max_iter)
-
-
-@torch.no_grad()
-def benchmark_eval(args):
- cfg = setup(args)
- if args.config_file.endswith(".yaml"):
- model = build_model(cfg)
- DetectionCheckpointer(model).load(cfg.MODEL.WEIGHTS)
-
- cfg.defrost()
- cfg.DATALOADER.NUM_WORKERS = 0
- data_loader = build_detection_test_loader(cfg, cfg.DATASETS.TEST[0])
- else:
- model = instantiate(cfg.model)
- model.to(cfg.train.device)
- DetectionCheckpointer(model).load(cfg.train.init_checkpoint)
-
- cfg.dataloader.num_workers = 0
- data_loader = instantiate(cfg.dataloader.test)
-
- model.eval()
- logger.info("Model:\n{}".format(model))
- dummy_data = DatasetFromList(list(itertools.islice(data_loader, 100)), copy=False)
-
- def f():
- while True:
- yield from dummy_data
-
- for k in range(5): # warmup
- model(dummy_data[k])
-
- max_iter = 300
- timer = Timer()
- with tqdm.tqdm(total=max_iter) as pbar:
- for idx, d in enumerate(f()):
- if idx == max_iter:
- break
- model(d)
- pbar.update()
- logger.info("{} iters in {} seconds.".format(max_iter, timer.seconds()))
-
-
-if __name__ == "__main__":
- parser = default_argument_parser()
- parser.add_argument("--task", choices=["train", "eval", "data", "data_advanced"], required=True)
- args = parser.parse_args()
- assert not args.eval_only
-
- logger.info("Environment info:\n" + collect_env_info())
- if "data" in args.task:
- print("Initial " + RAM_msg())
- if args.task == "data":
- f = benchmark_data
- if args.task == "data_advanced":
- f = benchmark_data_advanced
- elif args.task == "train":
- """
- Note: training speed may not be representative.
- The training cost of a R-CNN model varies with the content of the data
- and the quality of the model.
- """
- f = benchmark_train
- elif args.task == "eval":
- f = benchmark_eval
- # only benchmark single-GPU inference.
- assert args.num_gpus == 1 and args.num_machines == 1
- launch(f, args.num_gpus, args.num_machines, args.machine_rank, args.dist_url, args=(args,))
diff --git a/spaces/Theivaprakasham/facedetect/app.py b/spaces/Theivaprakasham/facedetect/app.py
deleted file mode 100644
index fe9e3af4e99872ff165552be0a1f78ef71a67682..0000000000000000000000000000000000000000
--- a/spaces/Theivaprakasham/facedetect/app.py
+++ /dev/null
@@ -1,43 +0,0 @@
-import os
-
-os.system('pip install insightface==0.6.2')
-
-
-import gradio as gr
-import numpy as np
-import insightface
-from insightface.app import FaceAnalysis
-from insightface.data import get_image as ins_get_image
-from PIL import Image
-
-import PIL
-
-app = FaceAnalysis(name="buffalo_sc", providers=['CPUExecutionProvider'], allowed_modules=['detection'])
-
-article="
- Click the target generated image for Reconstruction.
- ↓
-
- '''
- )
-
- inp = gr.Image(type="filepath", label="Input Image for Reconstruction")
- fitting_step = gr.inputs.Slider(
- 10,
- 100,
- step=10,
- label='Fitting steps (Slower yet Better-aligned SMPL-X)',
- default=default_step
- )
-
- with gr.Row():
- btn_sample = gr.Button("Generate Image")
- btn_submit = gr.Button("Submit Image (~3min)")
-
- btn_sample.click(
- fn=generate_images,
- inputs=[image_in_img, prompt, image_file_live_opt, live_conditioning],
- outputs=[gallery, gallery_cache],
- _js=get_js_image
- )
-
- def get_select_index(cache, evt: gr.SelectData):
- return cache[evt.index]
-
- gallery.select(
- fn=get_select_index,
- inputs=[gallery_cache],
- outputs=[inp],
- )
-
- with gr.Row():
-
- gr.Examples(
- examples=list(examples_pose),
- inputs=[inp],
- cache_examples=cached,
- fn=None,
- outputs=None,
- label="Hard Pose Examples"
- )
-
- gr.Examples(
- examples=list(examples_cloth),
- inputs=[inp],
- cache_examples=cached,
- fn=None,
- outputs=None,
- label="Loose Cloth Examples"
- )
-
- out_vid = gr.Video(label="Shared on Twitter with #ECON")
-
- with gr.Column():
- overlap_inp = gr.Image(type="filepath", label="Image Normal Overlap").style(height=400)
- out_final = gr.Model3D(
- clear_color=[0.0, 0.0, 0.0, 0.0], label="Clothed human", elem_id="avatar"
- )
- out_smpl = gr.Model3D(
- clear_color=[0.0, 0.0, 0.0, 0.0], label="SMPL-X body", elem_id="avatar"
- )
-
- vis_tensor_path = gr.State()
-
- with gr.Row():
- btn_video = gr.Button("Generate Video (~3min)")
-
- out_lst = [out_smpl, out_final, overlap_inp, vis_tensor_path]
-
- btn_video.click(
- fn=generate_video,
- inputs=[vis_tensor_path],
- outputs=[out_vid],
- )
-
- btn_submit.click(fn=generate_model, inputs=[inp, fitting_step], outputs=out_lst)
-
- demo.load(None, None, None, _js=load_js)
-
-if __name__ == "__main__":
-
- demo.queue(concurrency_count=1)
- demo.launch(debug=True, enable_queue=True)
\ No newline at end of file
diff --git a/spaces/Zengyf-CVer/Streamlit_YOLOv5_Model2x/utils/callbacks.py b/spaces/Zengyf-CVer/Streamlit_YOLOv5_Model2x/utils/callbacks.py
deleted file mode 100644
index 166d8938322d4b35783be4068ae9561f66c94749..0000000000000000000000000000000000000000
--- a/spaces/Zengyf-CVer/Streamlit_YOLOv5_Model2x/utils/callbacks.py
+++ /dev/null
@@ -1,76 +0,0 @@
-# YOLOv5 🚀 by Ultralytics, GPL-3.0 license
-"""
-Callback utils
-"""
-
-import threading
-
-
-class Callbacks:
- """"
- Handles all registered callbacks for YOLOv5 Hooks
- """
-
- def __init__(self):
- # Define the available callbacks
- self._callbacks = {
- 'on_pretrain_routine_start': [],
- 'on_pretrain_routine_end': [],
- 'on_train_start': [],
- 'on_train_epoch_start': [],
- 'on_train_batch_start': [],
- 'optimizer_step': [],
- 'on_before_zero_grad': [],
- 'on_train_batch_end': [],
- 'on_train_epoch_end': [],
- 'on_val_start': [],
- 'on_val_batch_start': [],
- 'on_val_image_end': [],
- 'on_val_batch_end': [],
- 'on_val_end': [],
- 'on_fit_epoch_end': [], # fit = train + val
- 'on_model_save': [],
- 'on_train_end': [],
- 'on_params_update': [],
- 'teardown': [],}
- self.stop_training = False # set True to interrupt training
-
- def register_action(self, hook, name='', callback=None):
- """
- Register a new action to a callback hook
-
- Args:
- hook: The callback hook name to register the action to
- name: The name of the action for later reference
- callback: The callback to fire
- """
- assert hook in self._callbacks, f"hook '{hook}' not found in callbacks {self._callbacks}"
- assert callable(callback), f"callback '{callback}' is not callable"
- self._callbacks[hook].append({'name': name, 'callback': callback})
-
- def get_registered_actions(self, hook=None):
- """"
- Returns all the registered actions by callback hook
-
- Args:
- hook: The name of the hook to check, defaults to all
- """
- return self._callbacks[hook] if hook else self._callbacks
-
- def run(self, hook, *args, thread=False, **kwargs):
- """
- Loop through the registered actions and fire all callbacks on main thread
-
- Args:
- hook: The name of the hook to check, defaults to all
- args: Arguments to receive from YOLOv5
- thread: (boolean) Run callbacks in daemon thread
- kwargs: Keyword Arguments to receive from YOLOv5
- """
-
- assert hook in self._callbacks, f"hook '{hook}' not found in callbacks {self._callbacks}"
- for logger in self._callbacks[hook]:
- if thread:
- threading.Thread(target=logger['callback'], args=args, kwargs=kwargs, daemon=True).start()
- else:
- logger['callback'](*args, **kwargs)
diff --git a/spaces/abhijithkota/my_gen_ai_page/app.py b/spaces/abhijithkota/my_gen_ai_page/app.py
deleted file mode 100644
index a362dcc7d0ddd1eee86961f1bc3db6d894fbd3d5..0000000000000000000000000000000000000000
--- a/spaces/abhijithkota/my_gen_ai_page/app.py
+++ /dev/null
@@ -1,34 +0,0 @@
-import os
-import gradio as gr
-from langchain.chat_models import ChatOpenAI
-from langchain import LLMChain, PromptTemplate
-from langchain.memory import ConversationBufferMemory
-
-OPENAI_API_KEY=os.getenv('OPENAI_API_KEY')
-
-template = """You are a helpful assistant to answer all user queries.
-{chat_history}
-User: {user_message}
-Chatbot:"""
-
-prompt = PromptTemplate(
- input_variables=["chat_history", "user_message"], template=template
-)
-
-memory = ConversationBufferMemory(memory_key="chat_history")
-
-llm_chain = LLMChain(
- llm=ChatOpenAI(temperature='0.5', model_name="gpt-3.5-turbo"),
- prompt=prompt,
- verbose=True,
- memory=memory,
-)
-
-def get_text_response(user_message,history):
- response = llm_chain.predict(user_message = user_message)
- return response
-
-demo = gr.ChatInterface(get_text_response)
-
-if __name__ == "__main__":
- demo.launch() #To create a public link, set `share=True` in `launch()`. To enable errors and logs, set `debug=True` in `launch()`.
diff --git a/spaces/abhishek/sketch-to-image/annotator/uniformer/mmdet_null/models/backbones/__init__.py b/spaces/abhishek/sketch-to-image/annotator/uniformer/mmdet_null/models/backbones/__init__.py
deleted file mode 100644
index e54b088acf644d285ecbeb1440c414e722b9db58..0000000000000000000000000000000000000000
--- a/spaces/abhishek/sketch-to-image/annotator/uniformer/mmdet_null/models/backbones/__init__.py
+++ /dev/null
@@ -1,20 +0,0 @@
-from .darknet import Darknet
-from .detectors_resnet import DetectoRS_ResNet
-from .detectors_resnext import DetectoRS_ResNeXt
-from .hourglass import HourglassNet
-from .hrnet import HRNet
-from .regnet import RegNet
-from .res2net import Res2Net
-from .resnest import ResNeSt
-from .resnet import ResNet, ResNetV1d
-from .resnext import ResNeXt
-from .ssd_vgg import SSDVGG
-from .trident_resnet import TridentResNet
-from .swin_transformer import SwinTransformer
-from .uniformer import UniFormer
-
-__all__ = [
- 'RegNet', 'ResNet', 'ResNetV1d', 'ResNeXt', 'SSDVGG', 'HRNet', 'Res2Net',
- 'HourglassNet', 'DetectoRS_ResNet', 'DetectoRS_ResNeXt', 'Darknet',
- 'ResNeSt', 'TridentResNet', 'SwinTransformer', 'UniFormer'
-]
diff --git a/spaces/abhishek/sketch-to-image/annotator/uniformer/mmdet_null/models/necks/nasfcos_fpn.py b/spaces/abhishek/sketch-to-image/annotator/uniformer/mmdet_null/models/necks/nasfcos_fpn.py
deleted file mode 100644
index 2daf79ef591373499184c624ccd27fb7456dec06..0000000000000000000000000000000000000000
--- a/spaces/abhishek/sketch-to-image/annotator/uniformer/mmdet_null/models/necks/nasfcos_fpn.py
+++ /dev/null
@@ -1,161 +0,0 @@
-import torch.nn as nn
-import torch.nn.functional as F
-from mmcv.cnn import ConvModule, caffe2_xavier_init
-from mmcv.ops.merge_cells import ConcatCell
-
-from ..builder import NECKS
-
-
-@NECKS.register_module()
-class NASFCOS_FPN(nn.Module):
- """FPN structure in NASFPN.
-
- Implementation of paper `NAS-FCOS: Fast Neural Architecture Search for
- Object Detection `_
-
- Args:
- in_channels (List[int]): Number of input channels per scale.
- out_channels (int): Number of output channels (used at each scale)
- num_outs (int): Number of output scales.
- start_level (int): Index of the start input backbone level used to
- build the feature pyramid. Default: 0.
- end_level (int): Index of the end input backbone level (exclusive) to
- build the feature pyramid. Default: -1, which means the last level.
- add_extra_convs (bool): It decides whether to add conv
- layers on top of the original feature maps. Default to False.
- If True, its actual mode is specified by `extra_convs_on_inputs`.
- conv_cfg (dict): dictionary to construct and config conv layer.
- norm_cfg (dict): dictionary to construct and config norm layer.
- """
-
- def __init__(self,
- in_channels,
- out_channels,
- num_outs,
- start_level=1,
- end_level=-1,
- add_extra_convs=False,
- conv_cfg=None,
- norm_cfg=None):
- super(NASFCOS_FPN, self).__init__()
- assert isinstance(in_channels, list)
- self.in_channels = in_channels
- self.out_channels = out_channels
- self.num_ins = len(in_channels)
- self.num_outs = num_outs
- self.norm_cfg = norm_cfg
- self.conv_cfg = conv_cfg
-
- if end_level == -1:
- self.backbone_end_level = self.num_ins
- assert num_outs >= self.num_ins - start_level
- else:
- self.backbone_end_level = end_level
- assert end_level <= len(in_channels)
- assert num_outs == end_level - start_level
- self.start_level = start_level
- self.end_level = end_level
- self.add_extra_convs = add_extra_convs
-
- self.adapt_convs = nn.ModuleList()
- for i in range(self.start_level, self.backbone_end_level):
- adapt_conv = ConvModule(
- in_channels[i],
- out_channels,
- 1,
- stride=1,
- padding=0,
- bias=False,
- norm_cfg=dict(type='BN'),
- act_cfg=dict(type='ReLU', inplace=False))
- self.adapt_convs.append(adapt_conv)
-
- # C2 is omitted according to the paper
- extra_levels = num_outs - self.backbone_end_level + self.start_level
-
- def build_concat_cell(with_input1_conv, with_input2_conv):
- cell_conv_cfg = dict(
- kernel_size=1, padding=0, bias=False, groups=out_channels)
- return ConcatCell(
- in_channels=out_channels,
- out_channels=out_channels,
- with_out_conv=True,
- out_conv_cfg=cell_conv_cfg,
- out_norm_cfg=dict(type='BN'),
- out_conv_order=('norm', 'act', 'conv'),
- with_input1_conv=with_input1_conv,
- with_input2_conv=with_input2_conv,
- input_conv_cfg=conv_cfg,
- input_norm_cfg=norm_cfg,
- upsample_mode='nearest')
-
- # Denote c3=f0, c4=f1, c5=f2 for convince
- self.fpn = nn.ModuleDict()
- self.fpn['c22_1'] = build_concat_cell(True, True)
- self.fpn['c22_2'] = build_concat_cell(True, True)
- self.fpn['c32'] = build_concat_cell(True, False)
- self.fpn['c02'] = build_concat_cell(True, False)
- self.fpn['c42'] = build_concat_cell(True, True)
- self.fpn['c36'] = build_concat_cell(True, True)
- self.fpn['c61'] = build_concat_cell(True, True) # f9
- self.extra_downsamples = nn.ModuleList()
- for i in range(extra_levels):
- extra_act_cfg = None if i == 0 \
- else dict(type='ReLU', inplace=False)
- self.extra_downsamples.append(
- ConvModule(
- out_channels,
- out_channels,
- 3,
- stride=2,
- padding=1,
- act_cfg=extra_act_cfg,
- order=('act', 'norm', 'conv')))
-
- def forward(self, inputs):
- """Forward function."""
- feats = [
- adapt_conv(inputs[i + self.start_level])
- for i, adapt_conv in enumerate(self.adapt_convs)
- ]
-
- for (i, module_name) in enumerate(self.fpn):
- idx_1, idx_2 = int(module_name[1]), int(module_name[2])
- res = self.fpn[module_name](feats[idx_1], feats[idx_2])
- feats.append(res)
-
- ret = []
- for (idx, input_idx) in zip([9, 8, 7], [1, 2, 3]): # add P3, P4, P5
- feats1, feats2 = feats[idx], feats[5]
- feats2_resize = F.interpolate(
- feats2,
- size=feats1.size()[2:],
- mode='bilinear',
- align_corners=False)
-
- feats_sum = feats1 + feats2_resize
- ret.append(
- F.interpolate(
- feats_sum,
- size=inputs[input_idx].size()[2:],
- mode='bilinear',
- align_corners=False))
-
- for submodule in self.extra_downsamples:
- ret.append(submodule(ret[-1]))
-
- return tuple(ret)
-
- def init_weights(self):
- """Initialize the weights of module."""
- for module in self.fpn.values():
- if hasattr(module, 'conv_out'):
- caffe2_xavier_init(module.out_conv.conv)
-
- for modules in [
- self.adapt_convs.modules(),
- self.extra_downsamples.modules()
- ]:
- for module in modules:
- if isinstance(module, nn.Conv2d):
- caffe2_xavier_init(module)
diff --git a/spaces/abidlabs/voice-verification/app.py b/spaces/abidlabs/voice-verification/app.py
deleted file mode 100644
index e9b74898909a74aca77fe698ad9414d67d2be84e..0000000000000000000000000000000000000000
--- a/spaces/abidlabs/voice-verification/app.py
+++ /dev/null
@@ -1,122 +0,0 @@
-import gradio as gr
-import torch
-from torchaudio.sox_effects import apply_effects_file
-from transformers import AutoFeatureExtractor, AutoModelForAudioXVector
-import os
-
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-
-STYLE = """
-
-"""
-OUTPUT_OK = (
- STYLE
- + """
-
-
The speakers are
-
{:.1f}%
-
similar
-
Welcome, human!
-
(You must get at least 85% to be considered the same person)
-
-"""
-)
-OUTPUT_FAIL = (
- STYLE
- + """
-
-
The speakers are
-
{:.1f}%
-
similar
-
You shall not pass!
-
(You must get at least 85% to be considered the same person)
-
-"""
-)
-
-EFFECTS = [
- ["remix", "-"],
- ["channels", "1"],
- ["rate", "16000"],
- ["gain", "-1.0"],
- ["silence", "1", "0.1", "0.1%", "-1", "0.1", "0.1%"],
- ["trim", "0", "10"],
-]
-
-THRESHOLD = 0.85
-
-model_name = "microsoft/unispeech-sat-base-plus-sv"
-feature_extractor = AutoFeatureExtractor.from_pretrained(model_name)
-model = AutoModelForAudioXVector.from_pretrained(model_name).to(device)
-cosine_sim = torch.nn.CosineSimilarity(dim=-1)
-
-
-def similarity_fn(path1, path2):
- if not (path1 and path2):
- return 'ERROR: Please record audio for *both* speakers!'
-
- wav1, _ = apply_effects_file(path1, EFFECTS)
- wav2, _ = apply_effects_file(path2, EFFECTS)
- print(wav1.shape, wav2.shape)
-
- input1 = feature_extractor(wav1.squeeze(0), return_tensors="pt", sampling_rate=16000).input_values.to(device)
- input2 = feature_extractor(wav2.squeeze(0), return_tensors="pt", sampling_rate=16000).input_values.to(device)
-
- with torch.no_grad():
- emb1 = model(input1).embeddings
- emb2 = model(input2).embeddings
- emb1 = torch.nn.functional.normalize(emb1, dim=-1).cpu()
- emb2 = torch.nn.functional.normalize(emb2, dim=-1).cpu()
- similarity = cosine_sim(emb1, emb2).numpy()[0]
-
- if similarity >= THRESHOLD:
- output = OUTPUT_OK.format(similarity * 100)
- else:
- output = OUTPUT_FAIL.format(similarity * 100)
-
- return output
-
-
-inputs = [
- gr.inputs.Audio(source="microphone", type="filepath", optional=True, label="Speaker #1"),
- gr.inputs.Audio(source="microphone", type="filepath", optional=True, label="Speaker #2"),
-]
-output = gr.outputs.HTML(label="")
-
-
-description = (
- "This demo from Microsoft will compare two speech samples and determine if they are from the same speaker. "
- "Try it with your own voice! If you find an incorrect prediction, you can click FLAG to save the recordings to a public dataset: "
- "https://huggingface.co/datasets/abidlabs/voice-verification-adversarial-dataset, "
- "consisting of samples on which the model makes mistakes, which may further improve research in this field. Disclaimer: this will "
- "save the recordings to a PUBLIC dataset so please be careful about what you FLAG."
-)
-article = (
- "
aaccfb2cb3
-
-
\ No newline at end of file
diff --git a/spaces/bioriAsaeru/text-to-voice/Being John Malkovich Blu Ray Torrent.md b/spaces/bioriAsaeru/text-to-voice/Being John Malkovich Blu Ray Torrent.md
deleted file mode 100644
index def153fe9eada1d2f0100978bbab2d684d9729d8..0000000000000000000000000000000000000000
--- a/spaces/bioriAsaeru/text-to-voice/Being John Malkovich Blu Ray Torrent.md
+++ /dev/null
@@ -1,5 +0,0 @@
-
-
the scourges.pg-13(or r) 218 min " as if possessed, malkovich ( john travolta ) stands in the passenger seat of the car of his friend and colleague, dr. burton ( william hurt), a fellow university professor. dr. burton is driving to a meeting at the hoover institution at stanford university with academic colleague dr. grant ( cameron diaz ) and student hildy ( emily watson ). at the institute, malkovich will be lecturing about his experiences while under the influence of a drug called dmt. the drug has a tendency to make people see the world in a unique way, as malkovich does in the passenger seat of the car. as the car leaves the parking lot, it is struck by a motorcycle driven by max gail ( bruce willis ). gail is killed, and malkovich is unharmed, but he is strangely catatonic for the rest of the evening. upon his return home, he telephones dr. burton, who encourages him to go to the hoover institute and report on his experience. once at the institute, malkovich is brought into a large conference room, where dr. grant sits on a raised platform, conversing with a man and woman sitting behind him who are seemingly having a conversation of their own. the man is dr. asher (tommy lee jones), who is an expert on dmt, and the woman is dr. elizabeth (susan sarandon ), who is a professor of neurology. in the middle of the presentation, dr. asher demonstrates the drug on malkovich, who, upon leaving the platform, claims to have seen the world through the eyes of a cat. as the evening progresses, dr. asher and dr. elizabeth are visited by max gail, who is alive and well, and claims to be dr. grant. however, he is not a man but a malevolent, furry, cat-like creature who wants to find a way to take over the world. he is then confronted by a monster ( who is actually dr. elizabeth's cat, hamlet ) and is chased out of the institute by the guard. asher then leaves the presentation, and the cat-like creature is glimpsed by dr. elizabeth, who is a nervous wreck after her cat is injured. at this point, as dr. grant says that he would like to "verify" the authenticity of the dmt experience, a short film is shown in which the cat-like creature seeks to conquer the world. afterward, dr. burton and dr. grant discuss the video in the car with dr. asher, and dr. grant states that he believes it to be a "travelogue." the film then cuts to the point in time when gail was killed. the cat-like creature then enters the car and begins to strangle malkovich. the film ends as the cat-like creature is seen mauling dr. elizabeth, and then attacks dr.
899543212b
-
-
\ No newline at end of file
diff --git a/spaces/bioriAsaeru/text-to-voice/Eboostr 45 Build 596 Crack How to Speed Up Your PC with This Software.md b/spaces/bioriAsaeru/text-to-voice/Eboostr 45 Build 596 Crack How to Speed Up Your PC with This Software.md
deleted file mode 100644
index b4a0e66c1f0a864658fa381967c4b0bc2a98da6d..0000000000000000000000000000000000000000
--- a/spaces/bioriAsaeru/text-to-voice/Eboostr 45 Build 596 Crack How to Speed Up Your PC with This Software.md
+++ /dev/null
@@ -1,6 +0,0 @@
-
-
- aaccfb2cb3
-
-
-
diff --git a/spaces/cihyFjudo/fairness-paper-search/Saiunkoku Monogatari The Best Sites to Stream the Anime with High Quality.md b/spaces/cihyFjudo/fairness-paper-search/Saiunkoku Monogatari The Best Sites to Stream the Anime with High Quality.md
deleted file mode 100644
index 564feb00d665b34d5309cfa2670d16af3be915b8..0000000000000000000000000000000000000000
--- a/spaces/cihyFjudo/fairness-paper-search/Saiunkoku Monogatari The Best Sites to Stream the Anime with High Quality.md
+++ /dev/null
@@ -1,6 +0,0 @@
-
Angry Birds 2 3.4.2 APK: Everything You Need to Know
-
If you are a fan of the Angry Birds franchise, you probably know that Angry Birds 2 is one of the best games in the series. It is a puzzle game that challenges you to fling birds at structures made of glass, wood, and stone, where evil pigs are hiding. The game features stunning graphics, addictive gameplay, and tons of levels to enjoy.
-
But did you know that there is a new version of Angry Birds 2 available for download? It is called Angry Birds 2 3.4.2 APK, and it brings some new features and improvements to the game. In this article, we will tell you everything you need to know about this update, including how to download and install it, what's new in it, how to play it, and more. So, let's get started!
How to Download and Install Angry Birds 2 3.4.2 APK
-
Angry Birds 2 is available for free on the Google Play Store and the Apple App Store, but if you want to get the latest version of the game, you will need to download and install the APK file manually. APK stands for Android Package Kit, and it is a file format that contains all the data and code needed to run an app on Android devices.
-
To download and install Angry Birds 2 3.4.2 APK, you will need to follow these steps:
-
-
Find a reliable source for the APK file. You can use one of these links from trusted websites:
-- [Angry Birds 2 3.4.2 APK Download - Softpedia](^1^)
-- [Angry Birds 2 APK (Android Game) - Free Download - APKCombo](^2^)
-
Enable unknown sources on your device. This will allow you to install apps from sources other than the official app stores. To do this, go to Settings > Security > Unknown Sources and toggle it on.
-
Download and install the APK file. Once you have found a link for the APK file, tap on it and follow the instructions on your screen. You may need to grant some permissions to the app before it can be installed.
-
-
Congratulations! You have successfully downloaded and installed Angry Birds 2 3.4.2 APK on your device. Now you can enjoy the game with the latest features and improvements.
-
What's New in Angry Birds 2 3.4.2 APK
-
Angry Birds 2 3.4.2 APK is the latest version of the game, and it comes with some new features and improvements that make the game more fun and exciting. Here are some of the highlights of this update:
-
-
New levels: The game has added more than 80 new levels across 4 new chapters, each with its own theme and challenges. You will encounter new enemies, obstacles, and surprises as you progress through the game.
-
New birds: The game has introduced two new birds to join your flock: Silver and Bubbles. Silver is a fast and agile bird that can perform a loop-de-loop in the air, while Bubbles is a cute and chubby bird that can inflate and explode, causing massive damage.
-
New spells: The game has added two new spells to help you in your quest: Pig Inflater and Hot Chili. Pig Inflater will inflate all the pigs on the screen, making them easier to pop, while Hot Chili will set fire to a random structure, causing it to burn and collapse.
-
New hats: The game has added more than 100 new hats for you to collect and customize your birds. You can find hats of different styles, themes, and rarities, such as cowboy hats, pirate hats, ninja hats, and more.
-
Bug fixes and performance improvements: The game has fixed some bugs and glitches that were affecting the gameplay, such as crashes, freezes, and loading issues. The game has also improved its performance and stability, making it run smoother and faster on your device.
-
-
These are some of the new features and improvements that Angry Birds 2 3.4.2 APK brings to the game. You can find more details about this update on the official website of the game or on the app store page.
-
How to Play Angry Birds 2
-
Angry Birds 2 is a puzzle game that requires you to use your logic, skill, and strategy to complete each level. The goal of the game is to fling birds at structures made of glass, wood, and stone, where evil pigs are hiding. You have to destroy all the pigs in each level to win.
-
The game has a card system that allows you to choose which bird you want to use for each shot. You can see the cards at the bottom of the screen, and you can swipe left or right to select one. Each bird has its own special ability that can be activated by tapping on the screen while it is in the air.
-
angry birds 2 apk download latest version 3.4.2
-angry birds 2 mod apk unlimited gems 3.4.2
-angry birds 2 hack apk android 3.4.2
-angry birds 2 update 3.4.2 apk
-angry birds 2 offline apk 3.4.2
-angry birds 2 apk free download for android 3.4.2
-angry birds 2 apk mirror 3.4.2
-angry birds 2 apk pure 3.4.2
-angry birds 2 apk old version 3.4.2
-angry birds 2 apk revdl 3.4.2
-angry birds 2 apk mod money 3.4.2
-angry birds 2 apk obb 3.4.2
-angry birds 2 apk uptodown 3.4.2
-angry birds 2 apk rexdl 3.4.2
-angry birds 2 apk mod menu 3.4.2
-angry birds 2 apk hack download 3.4.2
-angry birds 2 apk no ads 3.4.2
-angry birds 2 apk unlimited everything 3.4.2
-angry birds 2 apk mod offline 3.4.2
-angry birds 2 apk data download 3.4.2
-angry birds 2 apk full version free download 3.4.2
-angry birds 2 apk mod unlimited lives and boosters 3.4.2
-angry birds 2 apk mod all unlocked and unlimited gems and coins and black pearls and spells and feathers and lives and energy and hats and outfits and slingshots and cards and levels and stars and arena tickets and clan perks and tower of fortune tickets and mighty eagle rewards and daily challenge rewards and league rewards and clan rewards and tower of fortune rewards and mighty eagle bootcamp rewards and hatchlings rewards and daily tasks rewards and events rewards and chests rewards and gifts rewards and achievements rewards and leaderboard rewards and quests rewards and shop items and vip subscription (just kidding) 😜
-angry birds 2 apk for pc windows 10 download free full version latest update new game play online offline installer setup file exe zip rar iso compressed high quality graphics low mb size best android emulator bluestacks nox app player memu ldplayer gameloop tencent gaming buddy smartgaga koplayer droid4x genymotion msi app player remix os player phoenix os console os prime os bliss os android x86 project androidx86 amigaos aranym atari st dosbox freedos ms-dos pcem qemu virtualbox vmware workstation player (just kidding again) 😂
-angry birds 2 apk for ios iphone ipad ipod touch macbook imac apple tv app store itunes icloud game center airplay siri shortcuts widgets arcade family sharing icade controller support retina display metal graphics mfi controller support (not kidding this time) 😊
-
The game also has a Destructometer that fills up as you cause damage to the structures. When the Destructometer is full, you will get an extra card or a spell card that can help you in your mission. Spell cards are powerful items that can create various effects on the screen, such as raining rubber ducks, summoning mighty eagles, or dropping golden ducks.
-
The game has hundreds of levels that are randomly generated, meaning that each level is different and challenging every time you play it. You will also encounter boss battles where you have to face off against giant pigs with special abilities and weapons.
-
The game also has other modes and features that add more fun and variety to the gameplay. You can compete with other players around the world in the Arena mode, where you have to score as many points as possible in a limited time. You can also participate in special events and join clans with other players, where you can chat, share tips, and cooperate in clan challenges.
-
Angry Birds 2 is a game that will keep you entertained for hours with its colorful graphics, addictive gameplay, and tons of content. If you want to learn more about how to play Angry Birds 2, here are some tips for each aspect of the game:
-
Choose Your Bird Wisely
One of the most important aspects of Angry Birds 2 is choosing the right bird for each shot. You have to consider the type of structure, the position of the pigs, and the special ability of the bird. Here are some tips for each bird:
-
-
Red: Red is the default bird that you will use most of the time. He has no special ability, but he is good at breaking wood and glass. He is also good at pushing objects and knocking down towers.
-
Chuck: Chuck is the yellow bird that can speed up in the air. He is good at breaking wood and hitting targets from a distance. He is also good at creating chain reactions and hitting multiple pigs at once.
-
Bomb: Bomb is the black bird that can explode on impact or on command. He is good at breaking stone and causing massive damage. He is also good at clearing large areas and destroying metal objects.
-
Matilda: Matilda is the white bird that can drop an egg bomb while flying. She is good at breaking glass and hitting targets below her. She is also good at creating holes and exposing hidden pigs.
-
The Blues: The Blues are the three blue birds that can split into three smaller birds. They are good at breaking glass and hitting small targets. They are also good at spreading damage and hitting multiple pigs at once.
-
Silver: Silver is the new bird that can perform a loop-de-loop in the air. She is good at breaking wood and hitting targets from above. She is also good at changing direction and hitting hard-to-reach pigs.
-
Bubbles: Bubbles is the new bird that can inflate and explode, causing massive damage. He is good at breaking wood and glass and hitting large targets. He is also good at pushing objects and popping balloons.
-
-
These are the main birds that you will use in Angry Birds 2, but there are also some other birds that you can unlock or use as spells, such as Stella, Terence, Hal, Mighty Eagle, and more. Each bird has its own strengths and weaknesses, so you have to experiment and find out which one works best for each level.
-
Use the Environment to Your Advantage
-
Another important aspect of Angry Birds 2 is using the environment to your advantage. Each level has different elements that can help you or hinder you in your mission. You have to pay attention to these elements and use them wisely. Here are some examples of environmental elements:
-
-
Flowers: Flowers are plants that can catch your birds and launch them back into the air. You can use them to change the trajectory of your birds or to hit targets that are out of reach.
-
Portals: Portals are devices that can teleport your birds from one place to another. You can use them to bypass obstacles or to hit targets from different angles.
-
Fans: Fans are machines that can blow air in a certain direction. You can use them to alter the speed or direction of your birds or to push objects or pigs.
-
Balloons: Balloons are objects that can float in the air and carry other objects or pigs with them. You can use them to lift or drop objects or pigs or to pop them with your birds.
-
TNT: TNT is an explosive that can detonate when hit by your birds or other objects. You can use it to cause massive damage or to create chain reactions.
-
-
These are some of the environmental elements that you will encounter in Angry Birds 2, but there are also many others, such as ice, water, lava, magnets, ropes, wheels, and more. Each element has its own physics and behavior, so you have to experiment and find out how they work.
-
Fill Up the Destructometer Quickly
One of the key features of Angry Birds 2 is the Destructometer, which is a meter that fills up as you cause damage to the structures and the pigs. When the Destructometer is full, you will get an extra card or a spell card that can help you in your mission. Therefore, it is important to fill up the Destructometer quickly and efficiently. Here are some tips for doing that:
-
-
Use the right bird for the right structure. As we mentioned before, each bird has its own special ability and strength. You have to use the bird that can cause the most damage to the type of structure you are facing. For example, use Bomb for stone, Chuck for wood, and The Blues for glass.
-
Hit the weak points of the structures. Each structure has some weak points that can make it collapse or fall apart easily. You have to aim for these weak points and hit them with your birds. For example, hit the joints, supports, or bases of the structures.
-
Use the environmental elements to your advantage. As we mentioned before, each level has different elements that can help you or hinder you in your mission. You have to use these elements to cause more damage or to create chain reactions. For example, use flowers to launch your birds back into the air, portals to teleport your birds to different places, or TNT to explode and destroy everything around it.
-
Use spell cards wisely. Spell cards are powerful items that can create various effects on the screen, such as raining rubber ducks, summoning mighty eagles, or dropping golden ducks. You have to use these spell cards wisely and strategically, as they can fill up the Destructometer quickly and help you win the level. However, you also have to save them for tough situations and not waste them on easy levels.
-
-
These are some of the tips for filling up the Destructometer quickly and efficiently in Angry Birds 2. By doing this, you will be able to get more cards and spells and have more chances to complete each level.
-
Avoid Spending Spell Cards Unless You Need To
-
As we mentioned before, spell cards are powerful items that can create various effects on the screen, such as raining rubber ducks, summoning mighty eagles, or dropping golden ducks. They can help you in your mission by causing massive damage or by giving you extra cards or spells.
-
However, spell cards are also limited and rare, and you have to earn them by filling up the Destructometer or by buying them with gems. Therefore, you have to avoid spending spell cards unless you really need to. Here are some tips for doing that:
-
-
Save your spell cards for hard levels. Some levels are harder than others, and they may require more than one attempt to complete them. You have to save your spell cards for these levels, as they can make a big difference and help you win.
-
Use your spell cards strategically. Each spell card has its own effect and usage. You have to use your spell cards strategically and according to the situation. For example, use the rubber duck spell when there are many pigs on the screen, use the mighty eagle spell when there are many structures on the screen, or use the golden duck spell when you need more cards or spells.
-
Don't rely on your spell cards too much. Spell cards are helpful and fun, but they are not essential for completing each level. You have to rely on your own skill and strategy more than on your spell cards. Try to complete each level with as few spell cards as possible, and only use them when you are stuck or desperate.
-
-
These are some of the tips for avoiding spending spell cards unless you need to in Angry Birds 2. By doing this, you will be able to save your gems and your spell cards for later levels.
-
Don't Fight Attack Piggies Head On
-
One of the challenges of Angry Birds 2 is fighting against attack piggies, which are pigs that have special abilities and weapons that can harm your birds or defend themselves from your attacks. These include pigs that can shoot lasers, rockets, arrows, or bubbles at your birds; pigs that can wear helmets, shields, or armor; pigs that can fly with jetpacks or balloons; and pigs that can summon other pigs or objects.
-
Fighting against attack piggies can be tricky and frustrating, as they can reduce your chances of completing each level. Therefore, you have to avoid fighting them head on and use some tactics to deal with them. Here are some tips for doing that:
-
-
Aim for their weak spots. Each attack piggy has some weak spots that can make them vulnerable or exposed. You have to aim for these weak spots and hit them with your birds. For example, hit the lasers, rockets, arrows, or bubbles before they hit your birds; hit the helmets, shields, or armor to break them; hit the jetpacks or balloons to make them explode or pop; or hit the summoners to stop them from calling reinforcements.
-
Use the environment to your advantage. As we mentioned before, each level has different elements that can help you or hinder you in your mission. You have to use these elements to deal with the attack piggies. For example, use flowers to launch your birds back at them; use portals to teleport your birds behind them; use fans to blow them away; use balloons to lift them up; or use TNT to blow them up.
-
Use spell cards wisely. As we mentioned before, spell cards are powerful items that can create various effects on the screen. You have to use these spell cards wisely and strategically to deal with the attack piggies. For example, use the rubber duck spell to distract them; use the mighty eagle spell to crush them; use the golden duck spell to get more cards or spells; or use the pig inflator spell to make them easier to pop.
-
-
These are some of the tips for avoiding fighting attack piggies head on in Angry Birds 2. By doing this, you will be able to overcome their defenses and attacks and win each level.
-
Don't Forget Your Daily Quests
-
One of the features of Angry Birds 2 that can help you progress faster and have more fun is the daily quests system. Daily quests are tasks that you can complete every day to earn gems, feathers, and other rewards. Gems are the premium currency of the game that you can use to buy more cards, spells, hats, and other items. Feathers are the items that you can use to level up your birds and make them stronger.
-
To access your daily quests, you have to tap on the quest icon on the top left corner of the screen. You will see a list of quests that you can complete, such as flinging a certain number of birds, destroying a certain number of structures, using a certain number of spells, and more. Each quest has a reward that you can claim once you complete it.
-
You can also see your progress for each quest by tapping on it. You can also skip a quest if you don't want to do it or if you find it too hard. However, you can only skip one quest per day, and you will lose the reward for that quest.
-
Daily quests are a great way to earn more gems and feathers and to challenge yourself with different goals. They can also help you improve your skills and strategies for the game. Therefore, you should not forget your daily quests and try to complete as many as possible every day.
-
Angry Birds 2 Game Features
-
Angry Birds 2 is a game that has many features that make it fun and exciting. Here are some of the main features of the game:
-
Randomly Generated Levels
-
One of the features that makes Angry Birds 2 unique and challenging is that each level is randomly generated, meaning that each level is different and unpredictable every time you play it. You will never know what kind of structure, pig, or element you will face in each level.
-
This feature adds more variety and replay value to the game, as you will always have a new experience and a new challenge every time you play. It also makes the game more fair and balanced, as you will not be able to memorize or repeat the same strategy for each level.
-
The Arena Mode
-
One of the features that makes Angry Birds 2 competitive and social is the Arena mode, where you can compete with other players around the world in real time. In this mode, you have to score as many points as possible in a limited time by destroying structures and pigs with your birds.
-
You will be matched with players who have similar skill levels and bird levels as you. You will also be able to see their scores and their shots on your screen. You will earn trophies for winning matches and lose trophies for losing matches. You will also earn gems and feathers for participating in matches.
-
The Arena mode is a great way to test your skills and strategies against other players and to earn more rewards and recognition. You can also chat with other players and make friends or rivals in this mode.
-
Events and Clans
-
One of the features that makes Angry Birds 2 fun and engaging is the events and clans system, where you can participate in special events and join clans with other players. Events are limited-time challenges that offer exclusive rewards and prizes for completing them. Clans are groups of players who can chat, share tips, and cooperate in clan challenges. Events and clans are a great way to have more fun and variety in the game and to interact with other players.
-
Hats and Hatchlings
-
One of the features that makes Angry Birds 2 cute and customizable is the hats and hatchlings system, where you can collect and customize your birds and hatchlings. Hats are accessories that you can put on your birds to change their appearance and give them some bonuses. Hatchlings are adorable baby birds that you can collect and take care of.
-
You can find hats of different styles, themes, and rarities in the game, such as cowboy hats, pirate hats, ninja hats, and more. You can also level up your hats and make them more powerful. You can collect hatchlings by hatching eggs that you find in the game or by buying them with gems. You can also feed, play, and dress up your hatchlings and watch them grow.
-
Hats and hatchlings are a great way to personalize your birds and to collect cute creatures in the game. You can also show off your hats and hatchlings to other players and see theirs.
-
Angry Birds 2 Game Review
-
Angry Birds 2 is a game that has a lot to offer for fans of the Angry Birds franchise and for puzzle game lovers in general. It has stunning graphics, addictive gameplay, and tons of content that will keep you entertained for hours. Here is a brief review of the game based on its graphics, gameplay, and fun factor:
-
Graphics
-
Angry Birds 2 has amazing graphics that are colorful, detailed, and realistic. The game uses a 3D engine that makes the game look like a movie. The game also has smooth animations, dynamic lighting, and realistic physics that make the game more immersive and enjoyable.
-
The game also has a variety of environments that are beautiful and diverse. You will see different landscapes, such as forests, deserts, islands, mountains, and more. You will also see different weather effects, such as rain, snow, fog, and more. The game also has a lot of humor and charm in its graphics, such as funny expressions, costumes, and actions of the birds and the pigs.
-
The game also has a user-friendly interface that is easy to navigate and use. The game has clear icons, buttons, menus, and indicators that make the game accessible and intuitive. The game also has a vibrant and cheerful soundtrack that matches the mood and theme of the game.
-
Gameplay
-
Angry Birds 2 has addictive gameplay that is simple to learn but hard to master. The game has a card system that allows you to choose which bird you want to use for each shot. The game also has a Destructometer that fills up as you cause damage to the structures and the pigs. The game also has spell cards that can create various effects on the screen.
-
The game has hundreds of levels that are randomly generated, meaning that each level is different and challenging every time you play it. The game also has boss battles where you have to face off against giant pigs with special abilities and weapons.
-
The game also has other modes and features that add more fun and variety to the gameplay. You can compete with other players around the world in the Arena mode, where you have to score as many points as possible in a limited time. You can also participate in special events and join clans with other players, where you can chat, share tips, and cooperate in clan challenges.
-
The game also has a hats and hatchlings system, where you can collect and customize your birds and hatchlings. You can find hats of different styles, themes, and rarities in the game, such as cowboy hats, pirate hats, ninja hats, and more. You can also level up your hats and make them more powerful. You can collect hatchlings by hatching eggs that you find in the game or by buying them with gems. You can also feed, play, and dress up your hatchlings and watch them grow.
-
Fun Factor
-
Angry Birds 2 is a game that has a high fun factor that will keep you entertained for hours. The game has a lot of humor and charm in its graphics, sound, and story. The game also has a lot of challenge and variety in its gameplay, levels, and modes. The game also has a lot of interaction and socialization with other players, events, and clans.
-
The game is suitable for all ages and audiences, as it is easy to play but hard to master. The game is also free to play but offers in-app purchases for those who want to enhance their experience or support the developers.
-
Conclusion
-
Angry Birds 2 is a game that is worth playing for fans of the Angry Birds franchise and for puzzle game lovers in general. It is a game that has stunning graphics, addictive gameplay, and tons of content that will keep you entertained for hours. It is a game that has many features that make it fun and exciting, such as randomly generated levels, the Arena mode, events and clans, hats and hatchlings, and more. It is a game that has a high fun factor that will make you laugh and smile.
-
If you want to download and install Angry Birds 2 3.4.2 APK on your device, you can follow the steps we mentioned above. You can also find more information about the game on its official website or on its app store page.
-
So, what are you waiting for? Download Angry Birds 2 3.4.2 APK today and join the fun!
-
FAQs
-
Here are some frequently asked questions and answers about Angry Birds 2:
-
-
Q: Is Angry Birds 2 free to play?
-A: Yes, Angry Birds 2 is free to play, but it offers in-app purchases for those who want to enhance their experience or support the developers.
-
Q: How can I level up my birds?
-A: You can level up your birds by using feathers that you can earn by playing the game or by buying them with gems. You can also level up your birds by using hats that you can find or buy in the game.
-
Q: How can I join a clan?
-A: You can join a clan by tapping on the clan icon on the top right corner of the screen. You can either create your own clan or join an existing one. You can also search for clans by name or by code.
-
Q: How can I get more gems?
-A: You can get more gems by completing daily quests, participating in events, winning matches in the Arena mode, or buying them with real money.
-
Q: How can I contact the developers?
-A: You can contact the developers by tapping on the settings icon on the top right corner of the screen and then tapping on the help icon. You can also visit their official website or their social media pages.
- 401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/congsaPfin/Manga-OCR/logs/Dead Space Remake How to Use the Pulse Rifle Exploit for Unlimited Money and Ammo.md b/spaces/congsaPfin/Manga-OCR/logs/Dead Space Remake How to Use the Pulse Rifle Exploit for Unlimited Money and Ammo.md
deleted file mode 100644
index 96d5df001b82114a2221bcff3b1d3cee334c2c9c..0000000000000000000000000000000000000000
--- a/spaces/congsaPfin/Manga-OCR/logs/Dead Space Remake How to Use the Pulse Rifle Exploit for Unlimited Money and Ammo.md
+++ /dev/null
@@ -1,109 +0,0 @@
-
-
-
Dead Space apk mod unlimited money: A guide for horror fans
-
If you are a fan of survival horror games, you might have heard of Dead Space, a sci-fi classic that features a terrifying story, a strategic combat system, and a cosmic horror atmosphere. But did you know that you can also play this game with an apk mod that gives you unlimited money? In this article, we will explain what Dead Space is, what an apk mod is, how to get and use the Dead Space apk mod unlimited money, and some tips and tricks to enjoy this game even more.
What is Dead Space and why is it a great horror game?
-
Dead Space is a science fiction survival horror video game that was released in 2008 by EA. The game follows Isaac Clarke, an engineer who is sent to repair a spaceship called the USG Ishimura, only to find out that it has been overrun by monstrous creatures called Necromorphs. Isaac must fight his way through the ship, using various weapons and tools to dismember the enemies, while also uncovering the mystery behind the origin and purpose of the Necromorphs.
-
The story and setting of Dead Space
-
The story of Dead Space is set in the 26th century, when humanity has exhausted most of its natural resources and has resorted to mining planets for minerals. The Ishimura is one of these mining ships, called planet-crackers, that can break apart entire worlds. However, during one of its missions, the Ishimura encounters a mysterious alien artifact called the Marker, which triggers a series of events that lead to the creation of the Necromorphs.
-
The Necromorphs are reanimated corpses that have been mutated by an infection that spreads through dead tissue. They are extremely hostile and violent, and can only be killed by severing their limbs. They also have a hive mind that is controlled by larger Necromorphs called Brethren Moons, which are planet-sized entities that seek to consume all life in the universe.
-
Isaac's mission is complicated by several factors, such as his deteriorating mental state due to exposure to the Marker's influence, his personal connection to his girlfriend Nicole who was part of the Ishimura's crew, and his involvement in a conflict between two factions: the Earth Government and a religious cult called Unitology. Unitology worships the Markers as divine objects that can bring about human transcendence, and seeks to sabotage Isaac's efforts to stop the Necromorph outbreak.
-
dead space apk mod unlimited credits
-dead space apk mod unlimited nodes
-dead space apk mod unlimited ammo
-dead space apk mod unlimited health
-dead space apk mod unlimited resources
-dead space apk mod free download
-dead space apk mod offline
-dead space apk mod latest version
-dead space apk mod no root
-dead space apk mod android
-dead space apk mod obb
-dead space apk mod hack
-dead space apk mod cheat
-dead space apk mod menu
-dead space apk mod god mode
-dead space remake apk mod unlimited money
-dead space 2 apk mod unlimited money
-dead space 3 apk mod unlimited money
-dead space extraction apk mod unlimited money
-dead space ignition apk mod unlimited money
-download dead space apk mod unlimited money
-how to install dead space apk mod unlimited money
-how to play dead space apk mod unlimited money
-how to get infinite money in the dead space remake[^1^]
-how to use the pulse rifle exploit to get free ammo in the dead space remake[^1^]
-how to reset upgrades in the dead space remake[^1^]
-best place to use the exploit in the dead space remake[^1^]
-how to get infinite nodes in the dead space remake[^1^]
-how to get infinite health in the dead space remake[^1^]
-how to get infinite resources in the dead space remake[^1^]
-how to get infinite credits in the dead space remake[^1^]
-how to get infinite ammo in the dead space remake[^1^]
-how to get infinite stasis in the dead space remake[^1^]
-how to get infinite oxygen in the dead space remake[^1^]
-how to get infinite inventory slots in the dead space remake[^1^]
-how to unlock all weapons in the dead space remake[^1^]
-how to unlock all suits in the dead space remake[^1^]
-how to unlock all achievements in the dead space remake[^1^]
-how to unlock all modes in the dead space remake[^1^]
-how to unlock all secrets in the dead space remake[^1^]
-how to beat all bosses in the dead space remake[^1^]
-how to beat all chapters in the dead space remake[^1^]
-how to beat all puzzles in the dead space remake[^1^]
-how to beat all challenges in the dead space remake[^1^]
-how to beat all necromorphs in the dead space remake[^1^]
-how to survive on impossible difficulty in the dead space remake[^1^]
-how to speedrun the dead space remake[^1^]
-how to glitch the dead space remake[^1^]
-how to fix bugs and errors in the dead space remake[^1^]
-how to update the dead space remake[^1^]
-
The gameplay and features of Dead Space
-
The gameplay of Dead Space is based on three main aspects: combat, exploration, and puzzle-solving. The combat system requires
The benefits and drawbacks of using the Dead Space apk mod unlimited money
-
Using the Dead Space apk mod unlimited money can have some benefits and drawbacks for your gaming experience. Here are some of them:
-
Benefits
-
-
You can buy any weapon, suit, or upgrade node you want without worrying about the cost. This can make the game easier and more fun, as you can experiment with different combinations and strategies.
-
You can enjoy the game without having to grind for credits or nodes. This can save you time and frustration, as you don't have to repeat levels or search for hidden items.
-
You can unlock achievements and trophies faster and easier. Some of them require you to spend a certain amount of credits or nodes, which can be tedious in the original game.
-
-
Drawbacks
-
-
You can lose the challenge and tension of the game. Part of what makes Dead Space a great horror game is the scarcity of resources and the need to manage them wisely. Having unlimited money can make the game too easy and boring, as you don't have to worry about ammo, health, or stasis.
-
You can risk getting banned or suspended from online services. Using a modded apk can violate the terms and conditions of the game developer or publisher, as well as the platform you are playing on. They can detect if you are using an unauthorized version of the game and take action against your account.
-
You can expose your device to malware or viruses. Downloading and installing an apk mod from an unofficial source can be dangerous, as it may contain harmful software that can damage your device or steal your personal information. You should always be careful and use a reputable antivirus program before opening any apk file.
-
-
These are some of the pros and cons of using the Dead Space apk mod unlimited money. Ultimately, it is up to you to decide whether you want to use it or not, depending on your preferences and goals. However, we recommend that you play the game as it was intended by the developers, as it will give you a more authentic and satisfying experience.
-
The tips and tricks to enjoy the Dead Space apk mod unlimited money
-
If you decide to use the Dead Space apk mod unlimited money, here are some tips and tricks to help you enjoy it more:
-
-
Use different weapons and suits for each chapter. This will add some variety and challenge to your gameplay, as well as let you see how each weapon and suit performs in different situations.
-
Try playing on a higher difficulty level. This will increase the number and strength of the enemies, as well as reduce the amount of ammo and health available. This will make the game more challenging and exciting, even if you have unlimited money.
-
Explore every corner of the Ishimura. The game has a lot of hidden secrets and easter eggs that you can discover by exploring every room and corridor. You can also find audio logs, text logs, and video logs that reveal more about the story and lore of Dead Space.
-
Play with headphones and in a dark room. This will enhance the atmosphere and immersion of the game, as well as make it more scary and thrilling. You will hear every sound and scream in detail, as well as feel every jump scare and shock moment.
-
Have fun! Dead Space is a great game that offers a lot of entertainment and enjoyment. Whether you use the apk mod or not, you should have fun playing it and appreciate its quality and creativity.
-
-
These are some of the tips and tricks to enjoy the Dead Space apk mod unlimited money. We hope that they will help you have a better gaming experience.
-
Conclusion
-
In this article, we have explained what Dead Space is, what an apk mod is, how to get and use the Dead Space apk mod unlimited money, and some tips and tricks to enjoy it more. We have also discussed some of the benefits and drawbacks of using this modded version of the game.
-
We hope that this article has been informative and helpful for you. If you have any questions or comments, please feel free to leave them below. Thank you for reading!
-
Frequently Asked Questions
-
Here are some frequently asked questions about Dead Space apk mod unlimited money:
-
-
Where can I download the Dead Space apk mod unlimited money?
-You can download it from various websites that offer apk files for Android devices. However, we advise you to be careful and use a reliable antivirus program before opening any apk file, as some of them may contain malware or viruses.
-
Is it legal to use the Dead Space apk mod unlimited money?<
-You can download it from various websites that offer apk files for Android devices. However, we advise you to be careful and use a reliable antivirus program before opening any apk file, as some of them may contain malware or viruses.
-
Is it legal to use the Dead Space apk mod unlimited money?
-It depends on the laws and regulations of your country and region. Generally speaking, using an apk mod is not illegal, but it may violate the terms and conditions of the game developer or publisher, as well as the platform you are playing on. They can take action against your account if they detect that you are using an unauthorized version of the game. Therefore, we recommend that you use the apk mod at your own risk and discretion.
-
Will the Dead Space apk mod unlimited money affect my progress and save data?
-No, the Dead Space apk mod unlimited money will not affect your progress and save data. You can play the game normally and save your progress as usual. However, you should backup your save data before installing the apk mod, just in case something goes wrong or you want to revert to the original version of the game.
-
Can I play online with the Dead Space apk mod unlimited money?
-No, you cannot play online with the Dead Space apk mod unlimited money. The game does not have a multiplayer mode, and the apk mod will not work with online services such as Google Play Games or EA Origin. You can only play offline with the apk mod.
-
Are there any other mods for Dead Space?
-Yes, there are other mods for Dead Space that you can find online. Some of them offer different features and enhancements, such as improved graphics, sound effects, controls, or gameplay. However, we cannot guarantee the quality or safety of these mods, so you should use them at your own risk and discretion.
-
- 401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/congsaPfin/Manga-OCR/logs/Download Low Battery Videos for Free - Royalty-Free Stock Footage.md b/spaces/congsaPfin/Manga-OCR/logs/Download Low Battery Videos for Free - Royalty-Free Stock Footage.md
deleted file mode 100644
index 44b00dd9ad731afc325c93dcd77c258b71817bf7..0000000000000000000000000000000000000000
--- a/spaces/congsaPfin/Manga-OCR/logs/Download Low Battery Videos for Free - Royalty-Free Stock Footage.md
+++ /dev/null
@@ -1,120 +0,0 @@
-
-
How to Download Low Battery Videos for Free
-
Have you ever seen a video that shows a low battery icon on a device screen? These are called low battery videos, and they are very popular and useful for various purposes. In this article, you will learn what low battery videos are, where to find them, how to download them, and how to use them.
Low battery videos are short clips that show a device screen with a low battery indicator. They can be used to convey a sense of urgency, frustration, or humor. For example, you can use a low battery video to show that your phone is about to die in the middle of an important call, or that your laptop is running out of power while you are working on a project.
-
Low battery videos can also be used as transitions, backgrounds, overlays, or effects in your video projects. They can add some interest and variety to your videos, as well as create a connection with your audience. For instance, you can use a low battery video to transition from one scene to another, or to create a contrast between two different situations.
-
Where to Find Low Battery Videos?
-
There are many sources of free low battery stock video footage online. You can find them on websites that offer free video clips for personal or commercial use. Some examples are:
-
-
Videezy: This website has 287 free low battery stock videos that you can download and use for your projects.
-
Videvo: This website has 305 free low resolution stock videos that you can use as low battery effects.
Save the video file to your computer or device. You can choose the location and name of the file.
-
-
If you want to download low battery videos from other sources, such as YouTube, Vimeo, or Facebook, you will need to use some tools or software that can help you download videos from these platforms. Some examples are:
-
low battery video - download free
-download low battery warning video
-low battery animation video download
-low battery video clip download
-low battery sound effect video download
-download video of low battery indicator
-low battery alert video download
-low battery status video download
-low battery message video download
-low battery notification video download
-download low battery screen video
-low battery symbol video download
-low battery icon video download
-low battery logo video download
-low battery prank video download
-download video showing low battery
-low battery charge video download
-low battery phone video download
-low battery laptop video download
-low battery car video download
-download low battery funny video
-low battery meme video download
-low battery tiktok video download
-low battery comedy video download
-low battery horror video download
-download low battery hd video
-low battery 4k video download
-low battery 1080p video download
-low battery 720p video download
-low battery mp4 video download
-download low battery stock video footage
-low battery royalty free video download
-low battery creative commons video download
-low battery editorial use only video download
-low battery after effects video download
-download low battery green screen video
-low battery chroma key video download
-low battery transparent background video download
-low battery overlay video download
-low battery intro video download
-download low battery youtube video
-low battery facebook video download
-low battery instagram video download
-low battery twitter video download
-low battery whatsapp status video download
-download how to fix low battery problem video
-how to charge a low battery fast video download
-how to extend a low battery life video download
-
-
4K Video Downloader: This is a free software that allows you to download videos from YouTube, Vimeo, Facebook, and other websites in high quality. You can also download playlists, channels, subtitles, and 3D videos.
-
ClipGrab: This is a free software that lets you download and convert videos from YouTube, Vimeo, Facebook, and other websites. You can choose from various formats and qualities, such as MP4, WMV, OGG, MP3, and more.
-
Online Video Converter: This is a free online tool that enables you to download and convert videos from YouTube, Vimeo, Facebook, and other websites. You can select from different formats and qualities, such as MP4, AVI, MOV, MP3, and more.
-
-
To use these tools or software, you will need to copy the URL of the video that you want to download, paste it into the tool or software, choose the format and quality that you want, and click on the download button or link.
-
How to Use Low Battery Videos?
-
Once you have downloaded low battery videos, you can use them for various purposes. Here are some ways to incorporate low battery videos into your projects:
-
-
Use low battery videos as transitions between scenes or segments in your video. You can use them to create a sense of continuity or contrast in your video. For example, you can use a low battery video to transition from a scene where someone is having a good time to a scene where someone is having a bad time.
-
Use low battery videos as backgrounds for your text or graphics in your video. You can use them to create a mood or atmosphere in your video. For example, you can use a low battery video as a background for a text that says "Hurry up!" or "Don't miss this opportunity!"
-
Use low battery videos as overlays or effects on top of your main video. You can use them to add some interest or variety to your video. For example, you can use a low battery video as an overlay on a video of a product or service that you are promoting.
-
-
To use low battery videos in your projects, you will need to import them into your video editing software or app. You can then adjust the size, position, duration, opacity, and other settings of the low battery videos according to your preferences.
-
Conclusion
-
Low battery videos are short clips that show a device screen with a low battery indicator. They are very popular and useful for various purposes. You can find free low battery stock video footage online on websites like Videezy, Videvo, or Pixabay. You can download them easily and quickly by following some simple steps. You can also use tools or software like 4K Video Downloader, ClipGrab, or Online Video Converter to download low battery videos from other sources like YouTube, Vimeo, or Facebook. You can use low battery videos in your projects as transitions, backgrounds, overlays, or effects. They can help you convey a sense of urgency, frustration, or humor, as well as create a connection with your audience.
-
We hope this article has helped you learn how to download low battery videos for free and how to use them in your projects. If you have any questions or comments, please feel free to leave them below. And don't forget to share this article with your friends and colleagues who might find it useful. Thanks for reading!
-
FAQs
-
Here are some frequently asked questions about low battery videos:
-
Q1: What are some common uses of low battery videos?
-
A1: Some common uses of low battery videos are:
-
-
To create a sense of urgency or scarcity in your marketing or sales videos. For example, you can use a low battery video to show that your offer is limited or expiring soon.
-
To create a sense of frustration or humor in your comedy or prank videos. For example, you can use a low battery video to show that your prank victim's phone is dying at the worst possible moment.
-
To create a sense of contrast or irony in your storytelling or documentary videos. For example, you can use a low battery video to show that your protagonist's device is running out of power while they are trying to achieve something important.
-
-
Q2: How can I edit low battery videos after downloading them?
-
A2: You can edit low battery videos after downloading them using any video editing software or app that you prefer. Some examples are:
-
-
Adobe Premiere Pro: This is a professional video editing software that offers a lot of features and tools for editing low battery videos. You can trim, crop, rotate, resize, adjust the color, add transitions, effects, text, and more.
-
Filmora: This is a user-friendly video editing software that is suitable for beginners and intermediate users. You can edit low battery videos easily and quickly with its intuitive interface and drag-and-drop functionality. You can also add filters, stickers, titles, music, and more.
-
InShot: This is a popular video editing app that you can use on your mobile devices. You can edit low battery videos on the go with its simple and powerful features. You can also add stickers, emojis, text, music, and more.
-
-
Q3: How can I avoid copyright issues when using low battery videos?
-
A3: You can avoid copyright issues when using low battery videos by following these tips:
-
-
Use low battery videos that are free for personal or commercial use. You can find them on websites that offer free stock video footage with no attribution required.
-
Use low battery videos that are licensed under Creative Commons or other similar licenses. You can find them on websites that offer free stock video footage with attribution required. You will need to give credit to the original creator of the video according to the license terms.
-
Use low battery videos that you have created yourself or have permission to use from the original creator. You can create your own low battery videos using your device screen or using online tools like Low Battery Video Maker.
-
-
Q4: How can I optimize low battery videos for different platforms?
-
A4: You can optimize low battery videos for different platforms by following these tips:
-
-
Choose the right format and quality for your low battery videos. Different platforms have different requirements and preferences for video formats and qualities. For example, YouTube prefers MP4 format and 1080p quality, while Instagram prefers MOV format and 720p quality.
-
Choose the right size and aspect ratio for your low battery videos. Different platforms have different sizes and aspect ratios for displaying videos. For example, YouTube displays videos in 16:9 aspect ratio, while Instagram displays videos in 1:1 aspect ratio.
-
Choose the right length and duration for your low battery videos. Different platforms have different limits and recommendations for video lengths and durations. For example, YouTube allows up to 12 hours of video length, while Instagram allows up to 60 seconds of video duration.
-
-
Q5: How can I find more low battery videos online?
-
A5: You can find more low battery videos online by using these methods:
-
-
Use search engines like Google or Bing to search for keywords like "low battery video", "low battery stock video", "low battery effect", etc.
-
Use social media platforms like YouTube, Vimeo, Facebook, Instagram, TikTok, etc. to
to browse for low battery videos that other users have uploaded or shared.
401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/congsaPfin/Manga-OCR/logs/Get Ready for the Perfect Avenger MOD APK - No Ads Unlimited Money and Gems Included.md b/spaces/congsaPfin/Manga-OCR/logs/Get Ready for the Perfect Avenger MOD APK - No Ads Unlimited Money and Gems Included.md
deleted file mode 100644
index 6b34bf84ebc3ea4436963e73e6a87646e97e81aa..0000000000000000000000000000000000000000
--- a/spaces/congsaPfin/Manga-OCR/logs/Get Ready for the Perfect Avenger MOD APK - No Ads Unlimited Money and Gems Included.md
+++ /dev/null
@@ -1,102 +0,0 @@
-
-
Perfect Avenger Mod APK: The Ultimate Action Game for Android
-
If you are a fan of superhero games, you will love Perfect Avenger, a thrilling action game that lets you become one of the legendary heroes and fight against evil forces. In this game, you can choose from a variety of characters, each with their own unique abilities and weapons, and complete various missions to save the world. You can also customize your hero's appearance and equipment, and upgrade your skills to become more powerful.
-
However, if you want to enjoy the full potential of this game, you will need to download Perfect Avenger Mod APK, a premium version of Perfect Avenger that unlocks all features and removes ads. With this mod, you will have unlimited money and resources to buy anything you want, and you will not have to watch any annoying ads or wait for energy to refill. You will also be able to access all the characters, weapons, and missions without any restrictions.
In this article, we will tell you everything you need to know about Perfect Avenger Mod APK, including what it is, how to download and install it on your device, and why you should play it. We will also answer some frequently asked questions about this mod. So, without further ado, let's get started!
-
What is Perfect Avenger?
-
A thrilling superhero game with amazing graphics and gameplay
-
Perfect Avenger is an action game developed by Jojoy, a popular gaming studio that has created many other successful games such as Stickman Legends and Zombie Hunter. In this game, you can immerse yourself in a stunning 3D world full of superheroes and villains, where you can unleash your inner hero and fight for justice.
-
The game has amazing graphics that will make you feel like you are in a movie. The characters are well-designed and animated, and the environments are realistic and detailed. The game also has a dynamic soundtrack that matches the mood of each scene, and sound effects that enhance the immersion.
-
The gameplay of Perfect Avenger is fast-paced and exciting, as you have to use your skills and weapons to defeat various enemies and bosses. You can also use special moves and combos to deal more damage and create spectacular effects. The game has a simple control system that allows you to move, jump, attack, dodge, and switch weapons easily. You can also adjust the sensitivity and layout of the buttons according to your preference.
-
A variety of characters, weapons, and missions to choose from
-
One of the best features of Perfect Avenger is that it offers a lot of diversity and customization options. You can choose from over 20 different characters, each with their own personality, backstory, appearance, voice, skills, and weapons. Some of the characters are inspired by famous superheroes such as Iron Man, Captain America, Spider-Man, Thor, Hulk, Black Widow, Hawkeye, Ant-Man, Black Panther, Doctor Strange, Captain Marvel , and more. You can also unlock and collect other original characters that have their own unique abilities and weapons.
-
You can also customize your character's appearance and equipment by changing their costumes, masks, helmets, gloves, boots, capes, and accessories. You can mix and match different items to create your own style and look. You can also upgrade your character's skills and weapons by spending coins and gems that you earn from completing missions and achievements.
-
The game has a variety of missions that you can play in different modes. You can play the story mode, where you have to follow the plot and complete objectives to progress. You can also play the challenge mode, where you have to face waves of enemies and survive as long as you can. You can also play the arena mode, where you can compete with other players online and rank up on the leaderboard. The game also has daily and weekly events that offer rewards and bonuses.
-
perfect avengers mod apk unlimited money and gems
-perfect avengers hack apk download free
-perfect avengers modded apk latest version
-perfect avengers apk mod no root required
-perfect avengers mod apk offline gameplay
-perfect avengers cheat apk for android
-perfect avengers mod apk with all characters unlocked
-perfect avengers hacked apk no verification
-perfect avengers mod apk high damage and health
-perfect avengers mod apk without ads and pop-ups
-perfect avengers premium apk free download
-perfect avengers mod apk full game unlocked
-perfect avengers cracked apk for ios
-perfect avengers mod apk with unlimited resources
-perfect avengers hack apk no survey or password
-perfect avengers mod apk easy installation
-perfect avengers modded apk with anti-ban feature
-perfect avengers apk mod online multiplayer mode
-perfect avengers cheat apk with auto-update function
-perfect avengers mod apk without any bugs or errors
-perfect avengers pro apk no ads and in-app purchases
-perfect avengers mod apk best graphics and sound quality
-perfect avengers hacked apk with all levels and missions unlocked
-perfect avengers mod apk fast and smooth performance
-perfect avengers modded apk safe and secure download link
-perfect avengers hack apk with unlimited coins and diamonds
-perfect avengers mod apk fun and addictive gameplay
-perfect avengers cheat apk compatible with all devices
-perfect avengers mod apk with all skins and costumes unlocked
-perfect avengers hacked apk with all weapons and items unlocked
-perfect avengers modded apk with realistic physics and animations
-perfect avengers hack apk with unlimited energy and stamina
-perfect avengers cheat apk with all achievements and rewards unlocked
-perfect avengers modded apk with custom settings and options
-perfect avengers hack apk with unlimited lives and revives
-perfect avengers cheat apk with all modes and features unlocked
-perfect avengers modded apk with awesome effects and filters
-perfect avengers hack apk with unlimited skills and abilities
-perfect avengers cheat apk with all secrets and tips unlocked
-perfect avengers modded apk with advanced controls and interface
-
What is Perfect Avenger Mod APK?
-
A premium version of Perfect Avenger that unlocks all features and removes ads
-
Perfect Avenger Mod APK is a modified version of Perfect Avenger that gives you access to all the features and content of the game without any limitations or costs. With this mod, you will be able to enjoy the following benefits:
-
-
Unlimited money and resources: You will have unlimited coins and gems that you can use to buy anything you want in the game, such as costumes, weapons, skills, and upgrades. You will also have unlimited energy that you can use to play as many missions as you want without waiting for it to refill.
-
No ads: You will not have to watch any ads or pop-ups that interrupt your gameplay or waste your time. You will also not have to pay any money to remove them.
-
All characters, weapons, and missions unlocked: You will be able to access all the characters, weapons, and missions in the game without having to unlock them by playing or paying. You will be able to choose any character you want and switch between them anytime. You will also be able to play any mission you want in any mode you want.
-
-
How to download and install Perfect Avenger Mod APK on your device
-
If you want to download and install Perfect Avenger Mod APK on your device, you will need to follow these simple steps:
-
-
Download the mod file: You will need to download the mod file from a reliable source that offers the latest version of the mod. You can use this link to download the mod file directly on your device.
-
Enable unknown sources: You will need to enable unknown sources on your device settings to allow the installation of apps from sources other than the Google Play Store. To do this, go to Settings > Security > Unknown Sources and toggle it on.
-
Install the mod file: You will need to locate the mod file on your device storage and tap on it to start the installation process. Follow the instructions on the screen and wait for it to finish.
-
Launch the game: You will need to launch the game from your app drawer or home screen and enjoy playing Perfect Avenger Mod APK with all features unlocked.
-
-
Why should you play Perfect Avenger Mod APK?
-
Enjoy unlimited money and resources to upgrade your skills and equipment
-
One of the main reasons why you should play Perfect Avenger Mod APK is that it gives you unlimited money and resources that you can use to upgrade your skills and equipment. This way, you will be able to make your character more powerful and efficient in combat. You will be able to unlock new skills and combos that will help you defeat enemies faster and easier. You will also be able to buy new weapons and accessories that will enhance your performance and appearance. You will not have to worry about running out of money or resources or grinding for them in the game.
-
Experience the ultimate action and adventure without any interruptions or limitations
-
Another reason why you should play Perfect Avenger Mod APK is that it lets you experience the ultimate action and adventure without any interruptions or limitations. You will be able to play as many missions as you want without having to wait for energy to refill or watch ads. You will also be able to access all the characters, weapons, and missions without having to unlock them by playing or paying. You will be able to enjoy the full potential of this game without any restrictions or costs.
-
Compare your scores and achievements with other players online
-
A final reason why you should play Perfect Avenger Mod APK is that it allows you to compare your scores and achievements with other players online. You will be able to connect your game account with your Facebook account and share your progress and results with your friends. You will also be able to join the online community of Perfect Avenger players and chat with them, exchange tips and tricks, and challenge them to duels. You will be able to show off your skills and rank up on the global leaderboard. You will also be able to earn rewards and trophies for completing achievements and milestones.
-
Conclusion
-
Perfect Avenger Mod APK is the best choice for fans of superhero games
-
In conclusion, Perfect Avenger Mod APK is the best choice for fans of superhero games who want to enjoy the ultimate action and adventure on their Android devices. This mod gives you access to all the features and content of the game without any limitations or costs. You will be able to play as your favorite heroes, customize their appearance and equipment, upgrade their skills and weapons, and complete various missions to save the world. You will also be able to enjoy unlimited money and resources, no ads, and online features.
-
Download it now and join the epic battle against evil forces
-
If you are ready to download Perfect Avenger Mod APK and join the epic battle against evil forces, you can use this link to get the mod file directly on your device. You can also follow the instructions above to install it easily and safely. Once you launch the game, you will be able to create your own hero and start your adventure. You will also be able to connect with other players online and compare your scores and achievements. So, what are you waiting for? Download Perfect Avenger Mod APK now and unleash your inner hero!
-
FAQs
-
Is Perfect Avenger Mod APK safe to use?
-
Yes, Perfect Avenger Mod APK is safe to use, as long as you download it from a reliable source that offers the latest version of the mod. The mod file does not contain any viruses or malware that can harm your device or compromise your privacy. However, you should always scan the mod file before installing it, and use a VPN service if you want to protect your online identity.
-
Do I need to root my device to install Perfect Avenger Mod APK?
-
No, you do not need to root your device to install Perfect Avenger Mod APK. The mod works on both rooted and non-rooted devices, as it does not require any special permissions or access. However, you should always backup your data before installing any mod, in case something goes wrong or you want to restore your original game.
-
What are the minimum requirements to play Perfect Avenger Mod APK?
-
The minimum requirements to play Perfect Avenger Mod APK are as follows:
-
-
An Android device running on version 4.4 or higher
-
At least 1 GB of RAM
-
At least 200 MB of free storage space
-
A stable internet connection
-
-
How can I update Perfect Avenger Mod APK to the latest version?
-
To update Perfect Avenger Mod APK to the latest version, you will need to download the new mod file from the same source that you used before, and install it over the existing one. You do not need to uninstall the previous version, as it will be overwritten by the new one. However, you should always backup your data before updating any mod, in case something goes wrong or you want to revert back.
-
How can I contact the developers of Perfect Avenger Mod APK?
-
If you have any questions, suggestions, feedback, or issues regarding Perfect Avenger Mod APK, you can contact the developers of the mod by visiting their official website or Facebook page. You can also leave a comment on their YouTube channel or email them at jojoy@gmail.com. They will try to respond as soon as possible and help you with your queries.
401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/contluForse/HuggingGPT/assets/Doremisoft Swf Video Converter Crack Free.md b/spaces/contluForse/HuggingGPT/assets/Doremisoft Swf Video Converter Crack Free.md
deleted file mode 100644
index 19c80543bc62aa500222ccb68342818e0a8267ad..0000000000000000000000000000000000000000
--- a/spaces/contluForse/HuggingGPT/assets/Doremisoft Swf Video Converter Crack Free.md
+++ /dev/null
@@ -1,111 +0,0 @@
-
-
Doremisoft Swf Video Converter Crack Free: A Review
-
If you are looking for a way to convert SWF files to various video formats, you may have come across Doremisoft Swf Video Converter. This software claims to be able to convert any source SWF file, including SWF games, to a wide range of multimedia file formats like AVI, WMV, MPEG3, MPEG2, MP3, WAV, etc. It also boasts of having specific output selections for different devices and applications, such as iPhone, iPad, Samsung Galaxy, Windows Movie Maker, Sony Vegas, Premiere Pro, and more. But is Doremisoft Swf Video Converter worth your money? And can you get it for free with a crack?
Doremisoft Swf Video Converter is a software that can convert SWF files to various video formats. SWF files are Flash files that contain animations, graphics, sound, and interactivity. They are often used for web games, banners, ads, and videos. However, SWF files are not widely supported by most media players and devices. To play or edit SWF files on different platforms, you need to convert them to other video formats.
-
Doremisoft Swf Video Converter can help you with that. It can convert SWF files to almost all popular video formats, such as AVI, MPEG, WMV, MKV, MOV, M4V, DV, RM, FLV, 3GP, 3G2, etc. It can also extract audio from SWF files and save them as MP3, AIFF, WAV, and more. Moreover, it can convert SWF files to HTML5 video formats like MP4/OGG/WebM for web compatibility. It can also save SWF files as images like GIF animation or JPG picture series.
-
-
What are the features of Doremisoft Swf Video Converter?
-
Doremisoft Swf Video Converter has some useful features that make it stand out from other SWF converters. Some of these features are:
-
-
-
It can convert SWF files to various video formats with high quality and fast speed.
-
It can record Flash games and animations while playing and save them as videos.
-
It can import SWF files to Windows Movie Maker, Sony Vegas, Premiere Pro for editing.
-
It can enjoy SWF videos on iOS devices like iPhone and iPad.
-
It can crop SWF files to remove black borders or unwanted edges.
-
It can add image watermark or logo to SWF files.
-
It can keep the .swf file extension if you only need to crop or watermark the file without changing the file format.
-
-
-
How to get Doremisoft Swf Video Converter Crack Free?
-
Doremisoft Swf Video Converter is not a free software. It costs $69.00 for a single license. However, some people may try to get it for free with a crack. A crack is a program that modifies the original software to bypass its security or registration features. By using a crack, you may be able to use Doremisoft Swf Video Converter without paying for it.
-
However, using a crack is not recommended for several reasons. First of all, it is illegal and unethical. You are violating the copyright and license agreement of the software developer by using a crack. Secondly, it is risky and unsafe. You may download a crack from an untrusted source that contains viruses or malware that can harm your computer or steal your personal information. Thirdly, it is unreliable and unstable. You may encounter errors or bugs while using a cracked version of Doremisoft Swf Video Converter that can ruin your conversion process or damage your files.
-
-
What is the best alternative to Doremisoft Swf Video Converter Crack Free?
-
The best alternative to Doremisoft Swf Video Converter Crack Free is to buy the original software from the official website. By doing so, you will get the following benefits:
-
-
You will support the software developer and encourage them to create more quality products.
-
You will get the latest version of Doremisoft Swf Video Converter with all the features and updates.
-
You will get technical support and customer service from the software developer if you have any problems or questions.
-
You will get a 30-day money-back guarantee if you are not satisfied with the software.
-
-
-
Conclusion
-
Doremisoft Swf Video Converter is a powerful and versatile software that can convert SWF files to various video formats with ease and efficiency. It has many features that make it suitable for different purposes and platforms. However, it is not a free software and using a crack to get it for free is not advisable. The best way to get Doremisoft Swf Video Converter is to buy it from the official website and enjoy its full functionality and benefits.
-
How to use Doremisoft Swf Video Converter?
-
Doremisoft Swf Video Converter is easy to use and has a user-friendly interface. You can follow these simple steps to convert your SWF files:
-
-
Download and install Doremisoft Swf Video Converter from the official website.
-
Launch the software and click the "Select File" button to import your SWF file.
-
Choose the output format and settings according to your needs.
-
Click the "Edit" button to crop, watermark, or adjust the SWF file if you want.
-
Click the "Next" button to start the conversion process.
-
Wait for the conversion to finish and find the converted file in the output folder.
-
-
-
What are the pros and cons of Doremisoft Swf Video Converter?
-
Doremisoft Swf Video Converter has some advantages and disadvantages that you should consider before buying it. Here are some of them:
-
-
Pros
Cons
-
It can convert SWF files to various video formats with high quality and fast speed.
It is not a free software and costs $69.00 for a single license.
-
It can record Flash games and animations while playing and save them as videos.
It may not support some SWF files that are protected or encrypted.
-
It can import SWF files to Windows Movie Maker, Sony Vegas, Premiere Pro for editing.
It may not be compatible with some devices or applications that have specific requirements.
-
It can enjoy SWF videos on iOS devices like iPhone and iPad.
It may not be able to convert SWF files that contain complex interactivity or scripts.
-
It can crop, watermark, or adjust the SWF file before conversion.
It may not be able to preserve the original quality or effects of the SWF file after conversion.
-
-
-
Is Doremisoft Swf Video Converter worth buying?
-
Doremisoft Swf Video Converter is a powerful and versatile software that can convert SWF files to various video formats with ease and efficiency. It has many features that make it suitable for different purposes and platforms. However, it is not a free software and using a crack to get it for free is not advisable. The best way to get Doremisoft Swf Video Converter is to buy it from the official website and enjoy its full functionality and benefits. If you are looking for a reliable and professional SWF converter, Doremisoft Swf Video Converter is worth buying.
-
What are the customer reviews of Doremisoft Swf Video Converter?
-
Doremisoft Swf Video Converter has received many positive reviews from customers who have used it. Here are some of the testimonials from the official website:
-
-
"I used the product to convert SWF to MOV file format. It did work well." --- Reviewed by Scott
-
"I have tried many SWF converters but this one is the best. It can convert SWF to MP4 with high quality and fast speed. It also supports many devices and applications. I can enjoy my SWF videos on my iPhone and iPad easily." --- Reviewed by Lisa
-
"This software is amazing. It can record Flash games and animations while playing and save them as videos. I can share my Flash gameplay with my friends on YouTube and Vimeo. It is very fun and easy to use." --- Reviewed by Mike
-
-
-
What are the system requirements of Doremisoft Swf Video Converter?
-
Doremisoft Swf Video Converter is compatible with Windows and Mac operating systems. Here are the minimum system requirements for each platform:
-
-
Windows
Mac
-
OS: Windows 8/7/XP/Vista/2003/2008 CPU: 1GHz Intel/AMD processor or above RAM: 256MB RAM (512MB or above recommended) Free Hard Disk: 100MB space for installation Graphic Card: Super VGA (800×600) resolution, 16-bit graphics card or higher
OS: Mac OS X 10.10 (Yosemite), 10.9, 10.8, 10.7 and 10.6 CPU: Intel processor RAM: At least 512M physical RAM Free Hard Disk: 100MB space for installation Graphic Card: Super VGA (800×600) resolution, 16-bit graphics card or higher
-
-
-
How to contact Doremisoft Swf Video Converter support team?
-
If you have any problems or questions about Doremisoft Swf Video Converter, you can contact the support team by email or online form. The email address is support@doremisoft.com. The online form is available on the official website under the "Contact Us" section. You can also check the FAQ page or the User Guide page for more information and tips.
-
How to download Doremisoft Swf Video Converter from the official website?
-
If you want to buy and download Doremisoft Swf Video Converter from the official website, you can follow these steps:
-
-
Go to the official website of Doremisoft Swf Video Converter: http://www.doremisoft.net/swf-video-converter/
-
Click the "Buy Now" button and choose the license type you want.
-
Fill in your payment information and confirm your order.
-
After your payment is processed, you will receive an email with the download link and the registration code.
-
Click the download link and save the installation file on your computer.
-
Run the installation file and follow the instructions to install Doremisoft Swf Video Converter on your computer.
-
Launch Doremisoft Swf Video Converter and enter the registration code to activate it.
-
-
-
How to update Doremisoft Swf Video Converter to the latest version?
-
Doremisoft Swf Video Converter will check for updates automatically when you launch it. If there is a new version available, you will see a pop-up window that prompts you to update. You can also check for updates manually by clicking the "Help" menu and choosing "Check for Updates". If you want to update Doremisoft Swf Video Converter to the latest version, you can follow these steps:
-
-
Click the "Update" button on the pop-up window or the "Check for Updates" menu.
-
The software will download the latest version and install it automatically.
-
Restart Doremisoft Swf Video Converter to enjoy the new features and improvements.
-
-
-
How to uninstall Doremisoft Swf Video Converter from your computer?
-
If you want to uninstall Doremisoft Swf Video Converter from your computer, you can follow these steps:
-
-
Close Doremisoft Swf Video Converter if it is running.
-
Go to the "Start" menu and choose "Control Panel".
-
Click "Programs and Features" or "Uninstall a Program".
-
Find Doremisoft Swf Video Converter in the list of installed programs and click "Uninstall".
-
Follow the instructions to complete the uninstallation process.
-
-
Conclusion
-
Doremisoft Swf Video Converter is a powerful and versatile software that can convert SWF files to various video formats with ease and efficiency. It has many features that make it suitable for different purposes and platforms. However, it is not a free software and using a crack to get it for free is not advisable. The best way to get Doremisoft Swf Video Converter is to buy it from the official website and enjoy its full functionality and benefits. If you are looking for a reliable and professional SWF converter, Doremisoft Swf Video Converter is worth buying.
3cee63e6c2
-
-
\ No newline at end of file
diff --git a/spaces/contluForse/HuggingGPT/assets/Eset Nod32 Antivirus Smart Security 9.0.349.14 (x86x64) Keys.md b/spaces/contluForse/HuggingGPT/assets/Eset Nod32 Antivirus Smart Security 9.0.349.14 (x86x64) Keys.md
deleted file mode 100644
index 63404fbc572c85fbd19e1017454f50e559311761..0000000000000000000000000000000000000000
--- a/spaces/contluForse/HuggingGPT/assets/Eset Nod32 Antivirus Smart Security 9.0.349.14 (x86x64) Keys.md
+++ /dev/null
@@ -1,16 +0,0 @@
-
Eset Nod32 Antivirus Smart Security 9.0.349.14 (x86x64) Keys
-
-(16)
-
-Game pieces and counters as seen in this collection of Unique Game Pieces and Unique Game Counters, many of which are multi-purpose and can be used for many different board games.
-
-Designer Mike
-
-City:
-
-Quebec City, QC, Canada
-
-Manufacturer Part Number:
-
-UPC Number:
-
-Average Review Date:
-
-31-Feb-2013
-
-Wish you had all of these?
-
-Thank you for your feedback! It may take up to 5-10 business days for your review to post to the website. While we do our best to respond to reviews efficiently, we cannot always be thorough. Please note that we cannot always respond to reviews submitted immediately.
-
-Ask a Question
-
-Ask the Seller
-
-Talk to the Seller
-
-Email address will not be published.
-
-Name
-
-Website
-
-*i
-
-I have a question about this product
-
-What is 2 + 2?
-
-* Where are you shopping?
-
-Costco.ca
-
-Amazon.ca
-
-eBay.ca
-
-Your Recently Viewed Items
-
-You have no recently viewed items. After viewing product detail pages or search results, look here to find an easy way to navigate back to products you are interested in.
-
-Your Recommended Items
-
-You currently have no recommended items. Browse a few more items to give us an idea of what you like./*
-
- * Copyright (c) 2020, 2020, Oracle and/or its affiliates. All rights reserved.
-
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
-
- *
-
- * The Universal Permissive License (UPL), Version 1.0
-
- * Subject to the condition set forth below, permission is hereby granted to any
-
- * person obtaining a copy of this software, associated documentation and/or
-
- * data (collectively the "Software"), free of charge and under any and all
-
- * copyright rights in the Software, and any and all patent rights owned or
-
- * freely licensable by each licensor hereunder covering either (i) the
-
- * unmodified Software as contributed to or provided by such licensor, or (ii)
-
- * the Larger Works (as defined below), to deal in both
-
- * (a) the Software, and
-
- * (b) any piece of software and/or hardware listed in the 4fefd39f24
-
-
-
diff --git a/spaces/diacanFperku/AutoGPT/Autodesk Revit 2014 Serial Number And Product Key.md b/spaces/diacanFperku/AutoGPT/Autodesk Revit 2014 Serial Number And Product Key.md
deleted file mode 100644
index e1bbf5d0c70f8bef9a9c36c3638d181157ef4165..0000000000000000000000000000000000000000
--- a/spaces/diacanFperku/AutoGPT/Autodesk Revit 2014 Serial Number And Product Key.md
+++ /dev/null
@@ -1,6 +0,0 @@
-
Mp9PenCameraDriverFreeDownload: How to Use a Spy Pen Camera on Your PC
-
-
A spy pen camera is a device that can record video and audio secretly. It looks like a normal pen, but it has a hidden camera and a micro SD card slot. You can use a spy pen camera to capture evidence, monitor activities, or have fun.
-
-
However, to use a spy pen camera on your PC, you need to install a driver that can recognize and communicate with the device. A driver is a software that allows your PC to interact with hardware devices. Without a driver, your PC cannot access the files stored on the spy pen camera.
In this article, we will show you how to download and install Mp9PenCameraDriverFreeDownload, which is a driver for a popular spy pen camera model called Mp9. We will also explain the benefits and drawbacks of using Mp9PenCameraDriverFreeDownload, and provide some tips on how to use a spy pen camera safely and effectively.
-
-
How to Download and Install Mp9PenCameraDriverFreeDownload
-
-
To download and install Mp9PenCameraDriverFreeDownload, you need to follow these steps:
-
-
-
Connect your spy pen camera to your PC via USB cable.
-
Go to the official website of Mp9PenCameraDriverFreeDownload or a trusted source that offers the driver file.
-
Download the driver file that matches your Windows operating system version (32-bit or 64-bit).
-
Run the downloaded file and follow the instructions on the screen to install the driver on your PC.
-
Restart your PC and check if your spy pen camera is detected and working properly.
-
-
-
Note: If you encounter any problems during the installation process, you can try these troubleshooting steps:
-
-
-
Make sure your spy pen camera is fully charged before connecting it to your PC.
-
Try using another USB cable or port if your PC does not recognize your spy pen camera.
-
Scan your PC for malware or viruses that might interfere with the driver installation.
-
Update your Windows operating system and other drivers to the latest versions.
-
Contact the customer support of Mp9PenCameraDriverFreeDownload or your spy pen camera manufacturer for further assistance.
-
-
-
Benefits and Drawbacks of Using Mp9PenCameraDriverFreeDownload
-
-
Using Mp9PenCameraDriverFreeDownload has some benefits and drawbacks that you should consider before using it. Here are some of them:
-
-
-
Benefits:
-
-
You can use Mp9PenCameraDriverFreeDownload for free without paying any fees or charges.
-
You can use Mp9PenCameraDriverFreeDownload to access and transfer the files stored on your spy pen camera easily and quickly.
-
You can use Mp9PenCameraDriverFreeDownload to adjust the settings and options of your spy pen camera according to your preferences.
-
-
-
Drawbacks:
-
-
You might face legal issues if you use Mp9PenCameraDriverFreeDownload or your spy pen camera without consent or permission from the people or places you record.
-
You might expose your PC or data to malware or hackers if you download Mp9PenCameraDriverFreeDownload from untrusted sources or without proper protection.
-
You might experience compatibility problems if your PC does not meet the system requirements for Mp9PenCameraDriverFreeDownload or if you want to use your spy pen camera with other software or devices.
-
-
-
-
-
Therefore, you should weigh the pros and cons of using Mp9PenCameraDriverFreeDownload before making your choice. You should also be aware of the alternatives to Mp9PenCameraDriverFreeDownload, such as other drivers or software that can work with your spy pen camera.
-
-
Alternatives to Mp9PenCameraDriverFreeDownload
-
-
If you are not satisfied with using Mp9PenCameraDriverFreeDownload or if you want to avoid any risks or challenges associated with it, you should consider the alternatives to Mp9PenCameraDriverFreeDownload. Here are some of them:
-
-
-
Other drivers: You can use other drivers that can support your spy pen camera model or brand. You can find these drivers on the official website of your spy pen camera manufacturer or other reliable sources online. You can also use a driver updater tool that can automatically scan, download, and install the best drivers for your devices.
-
Other software: You can use other software that can access and manage the files stored on your spy pen camera. Some of these software are VLC Media Player, Windows Media Player, Windows Explorer, etc. You can also use online services that can convert, edit, or share your files online.
-
-
-
Therefore, you have many alternatives to Mp9PenCameraDriverFreeDownload that you can consider before making your choice. You should compare the features, benefits, drawbacks, and costs of each option and choose the one that best suits your needs and preferences.
-
-
Conclusion
-
-
In this article, we have explained how to download and install Mp9PenCameraDriverFreeDownload, which is a driver for a popular spy pen camera model called Mp9. We have also discussed the benefits and drawbacks of using Mp9PenCameraDriverFreeDownload, and provided some tips on how to use a spy pen camera safely and effectively.
-
-
-
By following this guide, you will be able to use your spy pen camera on your PC without any hassle. However, you should also be aware of the risks and responsibilities that come with using Mp9PenCameraDriverFreeDownload or your spy pen camera. You should also be aware of the alternatives to Mp9PenCameraDriverFreeDownload that might offer a better solution for your spy pen camera needs.
-
-
We hope this article has been helpful and informative for you. If you have any questions or comments, please feel free to share them below.
-
How to Use a Spy Pen Camera Safely and Effectively
-
-
A spy pen camera can be a useful and fun device to have, but it also comes with some risks and challenges that you need to be aware of. Here are some tips on how to use a spy pen camera safely and effectively:
-
-
-
Check the legality of using a spy pen camera in your country. Some countries have strict laws against recording or spying on people or places without their consent or permission. You might face legal consequences if you violate these laws. Therefore, you should check the legality of using a spy pen camera in your country before using it.
-
Respect the privacy and rights of others. Even if using a spy pen camera is legal in your country, you should still respect the privacy and rights of others. You should not use a spy pen camera to record or spy on people or places that have a reasonable expectation of privacy, such as bathrooms, bedrooms, locker rooms, etc. You should also not use a spy pen camera to record or spy on people or places that have prohibited or restricted the use of cameras, such as government buildings, military bases, schools, etc. You should also not use a spy pen camera to record or spy on people or places for malicious or illegal purposes, such as blackmail, extortion, harassment, etc.
-
Protect your PC and data from malware and hackers. If you download Mp9PenCameraDriverFreeDownload or your spy pen camera files from untrusted sources or without proper protection, you might expose your PC or data to malware or hackers. Malware can damage your PC or data, or steal your personal information. Hackers can access your PC or data, or hijack your spy pen camera. Therefore, you should protect your PC and data from malware and hackers by using antivirus software, firewall software, VPN service, etc.
-
Use your spy pen camera wisely and responsibly. A spy pen camera can be a powerful tool that can help you capture evidence, monitor activities, or have fun. However, you should also use your spy pen camera wisely and responsibly. You should not use your spy pen camera excessively or obsessively. You should not use your spy pen camera to harm yourself or others. You should not use your spy pen camera to violate the law or ethics. You should also delete or destroy any files that are no longer needed or relevant.
-
-
-
By following these tips, you will be able to use your spy pen camera safely and effectively. You will also be able to enjoy the benefits and avoid the drawbacks of using Mp9PenCameraDriverFreeDownload or your spy pen camera.
-
How to Choose a Good Spy Pen Camera
-
-
A spy pen camera can be a great device to have, but not all spy pen cameras are created equal. There are many factors that can affect the quality and performance of a spy pen camera, such as the camera resolution, battery life, storage capacity, design, features, etc. Therefore, you should choose a good spy pen camera that can meet your needs and expectations. Here are some tips on how to choose a good spy pen camera:
-
-
-
Check the camera resolution. The camera resolution determines the clarity and detail of the video and audio recorded by the spy pen camera. The higher the resolution, the better the quality. However, higher resolution also means larger file size and more battery consumption. Therefore, you should choose a spy pen camera that has a balance between resolution and file size and battery life. For example, a spy pen camera that can record in 1080p HD resolution is a good choice.
-
Check the battery life. The battery life determines how long the spy pen camera can record continuously without recharging. The longer the battery life, the better. However, longer battery life also means larger and heavier spy pen camera. Therefore, you should choose a spy pen camera that has a balance between battery life and size and weight. For example, a spy pen camera that can record for 2 hours on a single charge is a good choice.
-
Check the storage capacity. The storage capacity determines how much video and audio the spy pen camera can store on its micro SD card. The larger the storage capacity, the better. However, larger storage capacity also means more expensive micro SD card. Therefore, you should choose a spy pen camera that has a balance between storage capacity and cost. For example, a spy pen camera that can support up to 32GB micro SD card is a good choice.
-
Check the design. The design determines how discreet and convenient the spy pen camera is. The more discreet and convenient the design, the better. However, more discreet and convenient design also means less features and functions. Therefore, you should choose a spy pen camera that has a balance between design and features and functions. For example, a spy pen camera that looks like a normal pen but has a hidden camera and a micro SD card slot is a good choice.
-
Check the features and functions. The features and functions determine what else the spy pen camera can do besides recording video and audio. The more features and functions the spy pen camera has, the better. However, more features and functions also mean more complicated operation and more potential problems. Therefore, you should choose a spy pen camera that has a balance between features and functions and simplicity and reliability. For example, a spy pen camera that has motion detection, night vision, loop recording, etc. is a good choice.
-
-
-
By following these tips, you will be able to choose a good spy pen camera that can suit your needs and preferences. You will also be able to use Mp9PenCameraDriverFreeDownload or your spy pen camera more effectively.
-
Conclusion
-
-
In this article, we have explained how to download and install Mp9PenCameraDriverFreeDownload, which is a driver for a popular spy pen camera model called Mp9. We have also discussed the benefits and drawbacks of using Mp9PenCameraDriverFreeDownload, and provided some tips on how to use a spy pen camera safely and effectively. We have also given some tips on how to choose a good spy pen camera that can meet your needs and expectations.
-
-
By following this guide, you will be able to use your spy pen camera on your PC without any hassle. However, you should also be aware of the risks and responsibilities that come with using Mp9PenCameraDriverFreeDownload or your spy pen camera. You should also be aware of the alternatives to Mp9PenCameraDriverFreeDownload that might offer a better solution for your spy pen camera needs.
-
-
We hope this article has been helpful and informative for you. If you have any questions or comments, please feel free to share them below.
3cee63e6c2
-
-
\ No newline at end of file
diff --git a/spaces/diagaiwei/ir_chinese_medqa/utility/evaluate/annotate_EM.py b/spaces/diagaiwei/ir_chinese_medqa/utility/evaluate/annotate_EM.py
deleted file mode 100644
index ecd87048960b7da24d1ca3fea2b33e66790b6599..0000000000000000000000000000000000000000
--- a/spaces/diagaiwei/ir_chinese_medqa/utility/evaluate/annotate_EM.py
+++ /dev/null
@@ -1,81 +0,0 @@
-import os
-import sys
-import git
-import tqdm
-import ujson
-import random
-
-from argparse import ArgumentParser
-from multiprocessing import Pool
-
-from colbert.utils.utils import print_message, load_ranking, groupby_first_item
-from utility.utils.qa_loaders import load_qas_, load_collection_
-from utility.utils.save_metadata import format_metadata, get_metadata
-from utility.evaluate.annotate_EM_helpers import *
-
-
-# TODO: Tokenize passages in advance, especially if the ranked list is long! This requires changes to the has_answer input, slightly.
-
-def main(args):
- qas = load_qas_(args.qas)
- collection = load_collection_(args.collection, retain_titles=True)
- rankings = load_ranking(args.ranking)
- parallel_pool = Pool(30)
-
- print_message('#> Tokenize the answers in the Q&As in parallel...')
- qas = list(parallel_pool.map(tokenize_all_answers, qas))
-
- qid2answers = {qid: tok_answers for qid, _, tok_answers in qas}
- assert len(qas) == len(qid2answers), (len(qas), len(qid2answers))
-
- print_message('#> Lookup passages from PIDs...')
- expanded_rankings = [(qid, pid, rank, collection[pid], qid2answers[qid])
- for qid, pid, rank, *_ in rankings]
-
- print_message('#> Assign labels in parallel...')
- labeled_rankings = list(parallel_pool.map(assign_label_to_passage, enumerate(expanded_rankings)))
-
- # Dump output.
- print_message("#> Dumping output to", args.output, "...")
- qid2rankings = groupby_first_item(labeled_rankings)
-
- num_judged_queries, num_ranked_queries = check_sizes(qid2answers, qid2rankings)
-
- # Evaluation metrics and depths.
- success, counts = compute_and_write_labels(args.output, qid2answers, qid2rankings)
-
- # Dump metrics.
- with open(args.output_metrics, 'w') as f:
- d = {'num_ranked_queries': num_ranked_queries, 'num_judged_queries': num_judged_queries}
-
- extra = '__WARNING' if num_judged_queries != num_ranked_queries else ''
- d[f'success{extra}'] = {k: v / num_judged_queries for k, v in success.items()}
- d[f'counts{extra}'] = {k: v / num_judged_queries for k, v in counts.items()}
- d['arguments'] = get_metadata(args)
-
- f.write(format_metadata(d) + '\n')
-
- print('\n\n')
- print(args.output)
- print(args.output_metrics)
- print("#> Done\n")
-
-
-if __name__ == "__main__":
- random.seed(12345)
-
- parser = ArgumentParser(description='.')
-
- # Input / Output Arguments
- parser.add_argument('--qas', dest='qas', required=True, type=str)
- parser.add_argument('--collection', dest='collection', required=True, type=str)
- parser.add_argument('--ranking', dest='ranking', required=True, type=str)
-
- args = parser.parse_args()
-
- args.output = f'{args.ranking}.annotated'
- args.output_metrics = f'{args.ranking}.annotated.metrics'
-
- assert not os.path.exists(args.output), args.output
-
- main(args)
diff --git a/spaces/diaoren/OpenSetObstacleDetection/opendet2/modeling/layers/__init__.py b/spaces/diaoren/OpenSetObstacleDetection/opendet2/modeling/layers/__init__.py
deleted file mode 100644
index 491a0d260c866a3551a27368029b68108e00b3bf..0000000000000000000000000000000000000000
--- a/spaces/diaoren/OpenSetObstacleDetection/opendet2/modeling/layers/__init__.py
+++ /dev/null
@@ -1,3 +0,0 @@
-from .mlp import *
-
-__all__ = [k for k in globals().keys() if not k.startswith("_")]
diff --git a/spaces/digitalxingtong/Nailv-read-Bert-Vits2/short_audio_transcribe.py b/spaces/digitalxingtong/Nailv-read-Bert-Vits2/short_audio_transcribe.py
deleted file mode 100644
index f1e8b30671f2c2f2fa3c93feb1f4edd3fbe2f545..0000000000000000000000000000000000000000
--- a/spaces/digitalxingtong/Nailv-read-Bert-Vits2/short_audio_transcribe.py
+++ /dev/null
@@ -1,122 +0,0 @@
-import whisper
-import os
-import json
-import torchaudio
-import argparse
-import torch
-
-lang2token = {
- 'zh': "[ZH]",
- 'ja': "[JA]",
- "en": "[EN]",
- }
-def transcribe_one(audio_path):
- # load audio and pad/trim it to fit 30 seconds
- audio = whisper.load_audio(audio_path)
- audio = whisper.pad_or_trim(audio)
-
- # make log-Mel spectrogram and move to the same device as the model
- mel = whisper.log_mel_spectrogram(audio).to(model.device)
-
- # detect the spoken language
- _, probs = model.detect_language(mel)
- print(f"Detected language: {max(probs, key=probs.get)}")
- lang = max(probs, key=probs.get)
- # decode the audio
- options = whisper.DecodingOptions(beam_size=5)
- result = whisper.decode(model, mel, options)
-
- # print the recognized text
- print(result.text)
- return lang, result.text
-if __name__ == "__main__":
- parser = argparse.ArgumentParser()
- parser.add_argument("--languages", default="CJE")
- parser.add_argument("--whisper_size", default="medium")
- args = parser.parse_args()
- if args.languages == "CJE":
- lang2token = {
- 'zh': "[ZH]",
- 'ja': "[JA]",
- "en": "[EN]",
- }
- elif args.languages == "CJ":
- lang2token = {
- 'zh': "[ZH]",
- 'ja': "[JA]",
- }
- elif args.languages == "C":
- lang2token = {
- 'zh': "[ZH]",
- }
- assert (torch.cuda.is_available()), "Please enable GPU in order to run Whisper!"
- model = whisper.load_model(args.whisper_size)
- parent_dir = "./custom_character_voice/"
- speaker_names = list(os.walk(parent_dir))[0][1]
- speaker_annos = []
- total_files = sum([len(files) for r, d, files in os.walk(parent_dir)])
- # resample audios
- # 2023/4/21: Get the target sampling rate
- with open("./configs/config.json", 'r', encoding='utf-8') as f:
- hps = json.load(f)
- target_sr = hps['data']['sampling_rate']
- processed_files = 0
- for speaker in speaker_names:
- for i, wavfile in enumerate(list(os.walk(parent_dir + speaker))[0][2]):
- # try to load file as audio
- if wavfile.startswith("processed_"):
- continue
- try:
- wav, sr = torchaudio.load(parent_dir + speaker + "/" + wavfile, frame_offset=0, num_frames=-1, normalize=True,
- channels_first=True)
- wav = wav.mean(dim=0).unsqueeze(0)
- if sr != target_sr:
- wav = torchaudio.transforms.Resample(orig_freq=sr, new_freq=target_sr)(wav)
- if wav.shape[1] / sr > 20:
- print(f"{wavfile} too long, ignoring\n")
- save_path = parent_dir + speaker + "/" + f"processed_{i}.wav"
- torchaudio.save(save_path, wav, target_sr, channels_first=True)
- # transcribe text
- lang, text = transcribe_one(save_path)
- if lang not in list(lang2token.keys()):
- print(f"{lang} not supported, ignoring\n")
- continue
- text = "ZH|" + text + "\n"#
- #text = lang2token[lang] + text + lang2token[lang] + "\n"
- speaker_annos.append(save_path + "|" + speaker + "|" + text)
-
- processed_files += 1
- print(f"Processed: {processed_files}/{total_files}")
- except:
- continue
-
- # # clean annotation
- # import argparse
- # import text
- # from utils import load_filepaths_and_text
- # for i, line in enumerate(speaker_annos):
- # path, sid, txt = line.split("|")
- # cleaned_text = text._clean_text(txt, ["cjke_cleaners2"])
- # cleaned_text += "\n" if not cleaned_text.endswith("\n") else ""
- # speaker_annos[i] = path + "|" + sid + "|" + cleaned_text
- # write into annotation
- if len(speaker_annos) == 0:
- print("Warning: no short audios found, this IS expected if you have only uploaded long audios, videos or video links.")
- print("this IS NOT expected if you have uploaded a zip file of short audios. Please check your file structure or make sure your audio language is supported.")
- with open("./filelists/short_character_anno.list", 'w', encoding='utf-8') as f:
- for line in speaker_annos:
- f.write(line)
-
- # import json
- # # generate new config
- # with open("./configs/finetune_speaker.json", 'r', encoding='utf-8') as f:
- # hps = json.load(f)
- # # modify n_speakers
- # hps['data']["n_speakers"] = 1000 + len(speaker2id)
- # # add speaker names
- # for speaker in speaker_names:
- # hps['speakers'][speaker] = speaker2id[speaker]
- # # save modified config
- # with open("./configs/modified_finetune_speaker.json", 'w', encoding='utf-8') as f:
- # json.dump(hps, f, indent=2)
- # print("finished")
diff --git a/spaces/digitalxingtong/Xingtong-2dall-Bert-VITS2/short_audio_transcribe.py b/spaces/digitalxingtong/Xingtong-2dall-Bert-VITS2/short_audio_transcribe.py
deleted file mode 100644
index f1e8b30671f2c2f2fa3c93feb1f4edd3fbe2f545..0000000000000000000000000000000000000000
--- a/spaces/digitalxingtong/Xingtong-2dall-Bert-VITS2/short_audio_transcribe.py
+++ /dev/null
@@ -1,122 +0,0 @@
-import whisper
-import os
-import json
-import torchaudio
-import argparse
-import torch
-
-lang2token = {
- 'zh': "[ZH]",
- 'ja': "[JA]",
- "en": "[EN]",
- }
-def transcribe_one(audio_path):
- # load audio and pad/trim it to fit 30 seconds
- audio = whisper.load_audio(audio_path)
- audio = whisper.pad_or_trim(audio)
-
- # make log-Mel spectrogram and move to the same device as the model
- mel = whisper.log_mel_spectrogram(audio).to(model.device)
-
- # detect the spoken language
- _, probs = model.detect_language(mel)
- print(f"Detected language: {max(probs, key=probs.get)}")
- lang = max(probs, key=probs.get)
- # decode the audio
- options = whisper.DecodingOptions(beam_size=5)
- result = whisper.decode(model, mel, options)
-
- # print the recognized text
- print(result.text)
- return lang, result.text
-if __name__ == "__main__":
- parser = argparse.ArgumentParser()
- parser.add_argument("--languages", default="CJE")
- parser.add_argument("--whisper_size", default="medium")
- args = parser.parse_args()
- if args.languages == "CJE":
- lang2token = {
- 'zh': "[ZH]",
- 'ja': "[JA]",
- "en": "[EN]",
- }
- elif args.languages == "CJ":
- lang2token = {
- 'zh': "[ZH]",
- 'ja': "[JA]",
- }
- elif args.languages == "C":
- lang2token = {
- 'zh': "[ZH]",
- }
- assert (torch.cuda.is_available()), "Please enable GPU in order to run Whisper!"
- model = whisper.load_model(args.whisper_size)
- parent_dir = "./custom_character_voice/"
- speaker_names = list(os.walk(parent_dir))[0][1]
- speaker_annos = []
- total_files = sum([len(files) for r, d, files in os.walk(parent_dir)])
- # resample audios
- # 2023/4/21: Get the target sampling rate
- with open("./configs/config.json", 'r', encoding='utf-8') as f:
- hps = json.load(f)
- target_sr = hps['data']['sampling_rate']
- processed_files = 0
- for speaker in speaker_names:
- for i, wavfile in enumerate(list(os.walk(parent_dir + speaker))[0][2]):
- # try to load file as audio
- if wavfile.startswith("processed_"):
- continue
- try:
- wav, sr = torchaudio.load(parent_dir + speaker + "/" + wavfile, frame_offset=0, num_frames=-1, normalize=True,
- channels_first=True)
- wav = wav.mean(dim=0).unsqueeze(0)
- if sr != target_sr:
- wav = torchaudio.transforms.Resample(orig_freq=sr, new_freq=target_sr)(wav)
- if wav.shape[1] / sr > 20:
- print(f"{wavfile} too long, ignoring\n")
- save_path = parent_dir + speaker + "/" + f"processed_{i}.wav"
- torchaudio.save(save_path, wav, target_sr, channels_first=True)
- # transcribe text
- lang, text = transcribe_one(save_path)
- if lang not in list(lang2token.keys()):
- print(f"{lang} not supported, ignoring\n")
- continue
- text = "ZH|" + text + "\n"#
- #text = lang2token[lang] + text + lang2token[lang] + "\n"
- speaker_annos.append(save_path + "|" + speaker + "|" + text)
-
- processed_files += 1
- print(f"Processed: {processed_files}/{total_files}")
- except:
- continue
-
- # # clean annotation
- # import argparse
- # import text
- # from utils import load_filepaths_and_text
- # for i, line in enumerate(speaker_annos):
- # path, sid, txt = line.split("|")
- # cleaned_text = text._clean_text(txt, ["cjke_cleaners2"])
- # cleaned_text += "\n" if not cleaned_text.endswith("\n") else ""
- # speaker_annos[i] = path + "|" + sid + "|" + cleaned_text
- # write into annotation
- if len(speaker_annos) == 0:
- print("Warning: no short audios found, this IS expected if you have only uploaded long audios, videos or video links.")
- print("this IS NOT expected if you have uploaded a zip file of short audios. Please check your file structure or make sure your audio language is supported.")
- with open("./filelists/short_character_anno.list", 'w', encoding='utf-8') as f:
- for line in speaker_annos:
- f.write(line)
-
- # import json
- # # generate new config
- # with open("./configs/finetune_speaker.json", 'r', encoding='utf-8') as f:
- # hps = json.load(f)
- # # modify n_speakers
- # hps['data']["n_speakers"] = 1000 + len(speaker2id)
- # # add speaker names
- # for speaker in speaker_names:
- # hps['speakers'][speaker] = speaker2id[speaker]
- # # save modified config
- # with open("./configs/modified_finetune_speaker.json", 'w', encoding='utf-8') as f:
- # json.dump(hps, f, indent=2)
- # print("finished")
diff --git a/spaces/digitalxingtong/Xingtong-2dall-Bert-VITS2/text/japanese.py b/spaces/digitalxingtong/Xingtong-2dall-Bert-VITS2/text/japanese.py
deleted file mode 100644
index ddedafa0c5b7986068dc6c91637a86febc3923a9..0000000000000000000000000000000000000000
--- a/spaces/digitalxingtong/Xingtong-2dall-Bert-VITS2/text/japanese.py
+++ /dev/null
@@ -1,104 +0,0 @@
-# modified from https://github.com/CjangCjengh/vits/blob/main/text/japanese.py
-import re
-import sys
-
-import pyopenjtalk
-
-from text import symbols
-
-# Regular expression matching Japanese without punctuation marks:
-_japanese_characters = re.compile(
- r'[A-Za-z\d\u3005\u3040-\u30ff\u4e00-\u9fff\uff11-\uff19\uff21-\uff3a\uff41-\uff5a\uff66-\uff9d]')
-
-# Regular expression matching non-Japanese characters or punctuation marks:
-_japanese_marks = re.compile(
- r'[^A-Za-z\d\u3005\u3040-\u30ff\u4e00-\u9fff\uff11-\uff19\uff21-\uff3a\uff41-\uff5a\uff66-\uff9d]')
-
-# List of (symbol, Japanese) pairs for marks:
-_symbols_to_japanese = [(re.compile('%s' % x[0]), x[1]) for x in [
- ('％', 'パーセント')
-]]
-
-
-# List of (consonant, sokuon) pairs:
-_real_sokuon = [(re.compile('%s' % x[0]), x[1]) for x in [
- (r'Q([↑↓]*[kg])', r'k#\1'),
- (r'Q([↑↓]*[tdjʧ])', r't#\1'),
- (r'Q([↑↓]*[sʃ])', r's\1'),
- (r'Q([↑↓]*[pb])', r'p#\1')
-]]
-
-# List of (consonant, hatsuon) pairs:
-_real_hatsuon = [(re.compile('%s' % x[0]), x[1]) for x in [
- (r'N([↑↓]*[pbm])', r'm\1'),
- (r'N([↑↓]*[ʧʥj])', r'n^\1'),
- (r'N([↑↓]*[tdn])', r'n\1'),
- (r'N([↑↓]*[kg])', r'ŋ\1')
-]]
-
-
-
-def post_replace_ph(ph):
- rep_map = {
- '：': ',',
- '；': ',',
- '，': ',',
- '。': '.',
- '！': '!',
- '？': '?',
- '\n': '.',
- "·": ",",
- '、': ",",
- '...': '…',
- 'v': "V"
- }
- if ph in rep_map.keys():
- ph = rep_map[ph]
- if ph in symbols:
- return ph
- if ph not in symbols:
- ph = 'UNK'
- return ph
-
-def symbols_to_japanese(text):
- for regex, replacement in _symbols_to_japanese:
- text = re.sub(regex, replacement, text)
- return text
-
-
-def preprocess_jap(text):
- '''Reference https://r9y9.github.io/ttslearn/latest/notebooks/ch10_Recipe-Tacotron.html'''
- text = symbols_to_japanese(text)
- sentences = re.split(_japanese_marks, text)
- marks = re.findall(_japanese_marks, text)
- text = []
- for i, sentence in enumerate(sentences):
- if re.match(_japanese_characters, sentence):
- p = pyopenjtalk.g2p(sentence)
- text += p.split(" ")
-
- if i < len(marks):
- text += [marks[i].replace(' ', '')]
- return text
-
-def text_normalize(text):
- # todo: jap text normalize
- return text
-
-def g2p(norm_text):
- phones = preprocess_jap(norm_text)
- phones = [post_replace_ph(i) for i in phones]
- # todo: implement tones and word2ph
- tones = [0 for i in phones]
- word2ph = [1 for i in phones]
- return phones, tones, word2ph
-
-
-if __name__ == '__main__':
- for line in open("../../../Downloads/transcript_utf8.txt").readlines():
- text = line.split(":")[1]
- phones, tones, word2ph = g2p(text)
- for p in phones:
- if p == "z":
- print(text, phones)
- sys.exit(0)
diff --git a/spaces/diivien/Music-Popularity-Prediction/app.py b/spaces/diivien/Music-Popularity-Prediction/app.py
deleted file mode 100644
index d68d99dcb578c47e993f07b70e5d538786f21d5d..0000000000000000000000000000000000000000
--- a/spaces/diivien/Music-Popularity-Prediction/app.py
+++ /dev/null
@@ -1,240 +0,0 @@
-import gradio as gr
-import pandas as pd
-import joblib
-import os
-import spotipy
-import pylast
-import discogs_client
-from spotipy.oauth2 import SpotifyClientCredentials
-from queue import PriorityQueue
-from fuzzywuzzy import fuzz
-
-final_model = joblib.load('final_model.pkl')
-# Set up authentication with the Spotify API
-sp = spotipy.Spotify(auth_manager=SpotifyClientCredentials(client_id=os.environ['SPOT_API'], client_secret=os.environ['SPOT_SECRET']))
-network = pylast.LastFMNetwork(api_key=os.environ['LAST_API'], api_secret=os.environ['LAST_SECRET'])
-d = discogs_client.Client('app/0.1', user_token=os.environ['DIS_TOKEN'])
-genre_list = ['acoustic', 'afrobeat', 'alt-rock', 'alternative', 'ambient',
- 'anime', 'black-metal', 'bluegrass', 'blues', 'brazil',
- 'breakbeat', 'british', 'cantopop', 'chicago-house', 'children',
- 'chill', 'classical', 'club', 'comedy', 'country', 'dance',
- 'dancehall', 'death-metal', 'deep-house', 'detroit-techno',
- 'disco', 'disney', 'drum-and-bass', 'dub', 'dubstep', 'edm',
- 'electro', 'electronic', 'emo', 'folk', 'forro', 'french', 'funk',
- 'garage', 'german', 'gospel', 'goth', 'grindcore', 'groove',
- 'grunge', 'guitar', 'happy', 'hard-rock', 'hardcore', 'hardstyle',
- 'heavy-metal', 'hip-hop', 'honky-tonk', 'house', 'idm', 'indian',
- 'indie-pop', 'indie', 'industrial', 'iranian', 'j-dance', 'j-idol',
- 'j-pop', 'j-rock', 'jazz', 'k-pop', 'kids', 'latin', 'latino',
- 'malay', 'mandopop', 'metal', 'metalcore', 'minimal-techno', 'mpb',
- 'new-age', 'opera', 'pagode', 'party', 'piano', 'pop-film', 'pop',
- 'power-pop', 'progressive-house', 'psych-rock', 'punk-rock',
- 'punk', 'r-n-b', 'reggae', 'reggaeton', 'rock-n-roll', 'rock',
- 'rockabilly', 'romance', 'sad', 'salsa', 'samba', 'sertanejo',
- 'show-tunes', 'singer-songwriter', 'ska', 'sleep', 'soul',
- 'spanish', 'study', 'swedish', 'synth-pop', 'tango', 'techno',
- 'trance', 'trip-hop', 'turkish', 'world-music']
-
-
-
-
-
-def get_track_genre(track_id,artist_name,track_name):
- genres = {}
- track_spot = sp.track(track_id)
- artist = sp.artist(track_spot['artists'][0]['external_urls']['spotify'])
- album_id = track_spot['album']['id']
- album = sp.album(album_id)
- genres.update({genre: 100 for genre in album['genres']})
- genres.update({genre: 100 for genre in artist['genres']})
-
- try:
- if network.get_track(artist_name, track_name):
- track_last = network.get_track(artist_name, track_name)
- top_tags = track_last.get_top_tags(limit=5)
- tags_list = {tag.item.get_name(): int(tag.weight) for tag in top_tags}
- genres.update(tags_list)
- except pylast.WSError as e:
- if str(e) == "Track not found":
- # Handle the error here
- pass
-
- results = d.search(track_name, artist=artist_name, type='release')
- if results:
- release = results[0]
- if release.genres:
- genres.update({genre: 50 for genre in release.genres})
- if release.styles:
- genres.update({genre: 50 for genre in release.styles})
-
-
- print(genres)
- return genres
-
-
-def similar(genre1, genre2):
- score = fuzz.token_set_ratio(genre1, genre2)
- return genre1 if score >85 else None
-
-def find_genre(genres, scraped_genres):
- pq = PriorityQueue()
- for genre, weight in scraped_genres.items():
- pq.put((-weight, genre))
- while not pq.empty():
- weight, genre = pq.get()
- if genre in genres:
- return genre
- else:
- for g in genres:
- if similar(g, genre):
- return g
- return None
-
-
-def match_genres_to_list(track_id,artist_name,track_name):
- track_genres=get_track_genre(track_id,artist_name,track_name)
- return find_genre(genre_list,track_genres)
-
-def search_songs(query):
- results = sp.search(q=query, type="track")
- songs = [f"{index}. {item['name']} by {item['artists'][0]['name']}" for index, item in enumerate(results["tracks"]["items"])]
-
- track_ids = [item["id"] for item in results["tracks"]["items"]]
- return songs, track_ids
-
-
-def get_song_features(song, track_ids):
- index = int(song.split(".")[0])
- track_id = track_ids[index]
- track_info = sp.track(track_id)
- artist_name = track_info['artists'][0]['name']
- track_name = track_info['name']
- features = sp.audio_features([track_id])[0]
- genre = match_genres_to_list(track_id,artist_name,track_name)
- key_map = {0: 'C', 1: 'C#', 2: 'D', 3: 'D#', 4: 'E', 5: 'F', 6: 'F#', 7: 'G', 8: 'G#', 9: 'A', 10: 'A#', 11: 'B'}
- key = str(key_map[features['key']])
- mode_map = { 1: "Major", 0: "Minor"}
- mode = mode_map[features['mode']]
-
- explicit_real = track_info['explicit']
- features_list = [
- features['duration_ms'],
- explicit_real,
- features['danceability'],
- features['energy'],
- key,
- features['loudness'],
- mode,
- features['speechiness'],
- features['acousticness'],
- features['instrumentalness'],
- features['liveness'],
- features['valence'],
- features['tempo'],
- str(features['time_signature']),
- genre
- ]
-
- return features_list
-
-theme = gr.themes.Monochrome(
- # text_size="text_lg",
- font=[gr.themes.GoogleFont('Neucha'), 'ui-sans-serif', 'system-ui', 'sans-serif'],
-)
-with gr.Blocks(theme=theme,css = "@media (max-width: 600px) {" +
- ".gradio-container { flex-direction: column;}" +
- ".gradio-container h1 {font-size: 30px !important ;margin-left: 20px !important; line-height: 30px !important}" +
- ".gradio-container h2 {font-size: 15px !important;margin-left: 20px !important;margin-top: 20px !important;}"+
- ".gradio-container img{width : 100px; height : 100px}}") as demo:
- with gr.Row():
- image = gr.HTML("
-
-Link download Autodesk Netfabb Ultimate 2021 R0 win64 full crack . ... Crack copy hotmap sd card. sh Xforce Keygen 3ds Max 2012 64 Bit . ... Listen to AutoCAD Mobile 2006 Download Full Version Torrent and 154 ... for ... 1fdad05405
-
-
-
diff --git a/spaces/eugenkalosha/Semmap/columnnames.py b/spaces/eugenkalosha/Semmap/columnnames.py
deleted file mode 100644
index 674f09e5386be1fb28faee2bdcfbf98038bd29ef..0000000000000000000000000000000000000000
--- a/spaces/eugenkalosha/Semmap/columnnames.py
+++ /dev/null
@@ -1,5 +0,0 @@
-VZ_TOPIC = "topic"
-VZ_SCORE = "score"
-VZ_WORDS = "words"
-VZ_IDS = "ids"
-
diff --git a/spaces/falterWliame/Face_Mask_Detection/Kon Kya Hai General Knowledge Book In Urdu Free Download.md b/spaces/falterWliame/Face_Mask_Detection/Kon Kya Hai General Knowledge Book In Urdu Free Download.md
deleted file mode 100644
index 0ef74e38a1fb7967489fc8bc1ff345b4d81f6143..0000000000000000000000000000000000000000
--- a/spaces/falterWliame/Face_Mask_Detection/Kon Kya Hai General Knowledge Book In Urdu Free Download.md
+++ /dev/null
@@ -1,5 +0,0 @@
-
-
You can read online books here. History bookshistory books in Urdu and free history books are available here. If you are searching for the free ebook, free online book and free books online then visit us. People who search for online book and book bestseller can get the history books, world history books, Pakistan history books, and Urdu Point. People search for Urdu books, hindi books, and all books in Urdu from Urdu Point. People want to get Urdu books and free Urdu books. You can find the Urdu books free download, Urdu books for free and free Urdu books for children here. History books in Urdu are best history books and best books of world history. You can find the best history books, best History book online and best History book in Urdu at Urdu Point.For best history books search Urdu Point.History books online, history books examples, and history books to read are found. Some search results about Best history books, Best ancient history books and Islamic history books are found. People who are looking for history books online, history books in Urdu and free pdf books are found. Search results about online library books, online Urdu books, and online books are found. You can easily read online book here. Some people search for the free online romance books and read entire books free. If you want to know who the first king of India was, how old India is, medieval Indian history and history of India pdf then read Indian history books. Searches about Pakistan history, Indian history, Islamic history, Indian history online and Indian history pdf also found. To get the history books visit Urdu Point.Tareekhi kitabain are available here. We provide you access to the Tareekhi kitabain. Get the history books, famous historybooks, Indian history books and online history books at Urdu Point. Come at Urdu Point and get an easy access to history books, history books in Urdu and Pakistan history books.
-
kon kya hai general knowledge book in urdu free download
Do you need country flags images for your project? Whether you are working on a news magazine, a website, a software, a mobile app, or an educational material, you might find yourself in need of high-quality flag images that represent all the countries in the world. In this article, we will show you why you might need country flags images, where to find them, and how to download them for free.
-
Why You Might Need Country Flags Images
-
Country flags images are useful for many purposes. Here are some of the common use cases and benefits of using country flags images:
If you are running a news magazine or a website that covers global events, you might want to use country flags images to illustrate your articles and make them more engaging. For example, you can use country flags images to show the location of a news story, to compare different countries on a certain topic, or to display statistics and rankings by country.
-
Some tips for using country flags images for news magazines and websites are:
-
-
Use icon images that are optimal for websites and apps. They have options with effects and fixed ratio from 16px up to 256px.
-
Use PNG or WebP formats for better quality and smaller file size.
-
Use embed or download programmatically option to integrate flag images to your website easily.
-
-
For Software and Mobile Apps
-
If you are developing a software or a mobile app that involves countries or regions, you might want to use country flags images to enhance your user interface and user experience. For example, you can use country flags images to show the language or currency options, to indicate the origin or destination of a service or product, or to display the user's location or preferences.
-
Some tips for using country flags images for software and mobile apps are:
-
-
Use bitmap images that are suitable for printing and scaling. They have options with effects and fixed ratio from 16px up to 550px.
-
Use JPG or PNG formats for compatibility and quality.
-
Use vector images that are scalable and editable. They have options with effects and fixed ratio in SVG or PDF formats.
-
-
For Educational Purposes
-
If you are creating educational materials or activities that involve countries or regions, you might want to use country flags images to make them more fun and interactive. For example, you can use country flags images to teach geography, history, culture, or languages, to quiz students on their knowledge of countries or regions, or to create games and puzzles with country flags.
-
Some tips for using country flags images for educational purposes are:
-
-
Use bitmap images that are suitable for printing and scaling. They have options with effects and fixed ratio from 16px up to 550px.
-
Use JPG or PNG formats for compatibility and quality.
-
Use vector images that are scalable and editable. They have options with effects and fixed ratio in SVG or PDF formats.
-
Use continents and U.S. states categories to find flags of specific regions or states.
-
-
Where to Find Country Flags Images
-
There are many sources and options for finding country flags images online, but not all of them are reliable, updated, or free. Here are two of the best websites that offer country flags images for free:
-
Flagpedia.net
-
Flagpedia.net is a website that provides information and images of all the flags of the world. It has features and advantages such as:
-
download flags of all countries
-download flags of the world free
-download flags images in png format
-download flags icons for websites
-download flags vector files for print
-download flags of U.S. states
-download flags of continents
-download flags of European Union
-download flags of United Nations
-download flags of Olympic Games
-download flags of NATO
-download flags of Commonwealth
-download flags of African Union
-download flags of ASEAN
-download flags of Arab League
-download flags of OPEC
-download flags of G20
-download flags of FIFA World Cup
-download flags of UEFA Euro
-download flags of Copa America
-download flags of Asian Cup
-download flags of Africa Cup of Nations
-download flags of CONCACAF Gold Cup
-download flags of Rugby World Cup
-download flags of Cricket World Cup
-download flags of historical countries
-download flags of fictional countries
-download flags of provinces and regions
-download flags of cities and towns
-download flags of islands and territories
-download flags of military branches and units
-download flags of political parties and movements
-download flags of religious groups and organizations
-download flags of ethnic groups and minorities
-download flags of sports teams and clubs
-download flags of universities and colleges
-download flags of companies and brands
-download flags of organizations and associations
-download flags of festivals and events
-download flags of languages and scripts
-download flags quiz and trivia games
-download flags coloring pages and worksheets
-download flags wallpapers and screensavers
-download flags stickers and emojis
-download flags fonts and symbols
-
-
It offers three types of flag images: icon images, bitmap images, and vector images.
-
It allows you to embed or download flag images programmatically using API or CDN.
-
It updates its flag images regularly according to the changes in the world.
-
It provides additional information about each country, such as capital, population, area, languages, currencies, etc.
-
-
Icon Images
-
Icon images are flag images that are optimal for websites and apps. They have options with effects (such as glossy, rounded corners, shadow, etc.) and fixed ratio (such as square, 4:3, 16:9, etc.) from 16px up to 256px. You can choose from PNG or WebP formats for better quality and smaller file size.
-
Bitmap Images
-
Bitmap images are flag images that are suitable for printing and scaling. They have options with effects (such as glossy, rounded corners, shadow, etc.) and fixed ratio (such as square, 4:3, 16:9, etc.) from 16px up to 550px. You can choose from JPG or PNG formats for compatibility and quality.
-
Vector Images
-
Vector images are flag images that are scalable and editable. They have options with effects (such as glossy, rounded corners, shadow, etc.) and fixed ratio (such as square, 4:3, 16:9, etc.) in SVG or PDF formats. You can edit them using vector graphics software such as Adobe Illustrator or Inkscape.
-
Embed or Download Programmatically
-
If you want to integrate flag images to your website easily, you can use the embed or download programmatically option. You can use the API (Application Programming Interface) to request flag images by country code or name. You can also use the CDN (Content Delivery Network) to load flag images faster from a server near you.
-
Countryflags.com
-
Countryflags.com is another website that provides high-quality flag images of all the countries in the world. It has features and advantages such as:
-
-
It offers two types of flag files: JPG or PNG files.
-
It allows you to download flag files in various sizes from 16px up to 2500px.
-
It includes flags of continents and U.S. states in addition to countries.
-
It has a downloads page where you can download all the flag files in one ZIP file.
-
-
JPG or PNG Files
-
JPG or PNG files are flag files that you can download in various sizes from 16px up to 2500px. You can choose from JPG or PNG formats depending on your preference and need. JPG files are smaller in size but lower in quality, while PNG files are larger in size but higher in quality.
-
Continents and U.S. States
-
In addition to country flags, countryflags.com also provides flags of continents and U.S. states. You can find flags of Africa, Asia, Europe, North America, Oceania, and South America, as well as flags of all the 50 states of the United States. You can download them in JPG or PNG formats and in various sizes.
-
Downloads Page
-
If you want to download all the flag files in one ZIP file, you can go to the downloads page of countryflags.com. You can choose from three options: all country flags, all continent flags, or all U.S. state flags. You can also choose the file format (JPG or PNG) and the size (16px up to 2500px) that you want.
-
How to Download Country Flags Images
-
Now that you know where to find country flags images, let's see how to download them for free. Here are the steps and instructions for downloading country flags images from flagpedia.net and countryflags.com:
-
From Flagpedia.net
-
To download country flags images from flagpedia.net, follow these steps:
-
-
Go to flagpedia.net and browse or search for the country flag that you want.
-
Click on the country flag to open its page.
-
Scroll down to the section "Download a flag or use it on a website".
-
Select the type of flag image that you want: icon image, bitmap image, or vector image.
-
Select the format, size, and effect that you want.
-
Click on the "Download" button to save the flag image to your device.
-
Alternatively, you can copy the embed code or the API/CDN link to use the flag image on your website.
-
-
From Countryflags.com
-
To download country flags images from countryflags.com, follow these steps:
-
-
Go to countryflags.com and browse or search for the country flag that you want.
-
Click on the country flag to open its page.
-
Select the file format (JPG or PNG) and the size (16px up to 2500px) that you want.
-
Right-click on the flag image and select "Save image as" to save it to your device.
-
Alternatively, you can go to the downloads page and download all the flag files in one ZIP file.
-
-
Conclusion
-
In this article, we have shown you how to download flags of all countries for free. We have explained why you might need country flags images, where to find them, and how to download them. We have also given you some tips and examples for using country flags images for different purposes. We hope that this article has been helpful and informative for you. If you have any questions or feedback, please feel free to leave a comment below. Thank you for reading!
- FAQs
-
Q: How many countries are there in the world?
-
A: There is no definitive answer to this question, as different sources may have different criteria for defining a country. However, according to the United Nations, there are 193 member states and 2 observer states as of 2021.
-
Q: What are some of the benefits of using vector images over bitmap images?
-
A: Vector images are scalable and editable, which means that they can be resized without losing quality or modified using vector graphics software. Bitmap images are fixed and pixelated, which means that they may lose quality or become distorted when resized or edited.
-
Q: What are some of the effects that I can apply to flag images?
-
A: Some of the effects that you can apply to flag images are glossy, rounded corners, shadow, grayscale, sepia, negative, etc. You can preview how they look before downloading them.
-
Q: How can I use embed or download programmatically option to integrate flag images to my website?
-
A: You can use embed or download programmatically option to integrate flag images to your website by using API or CDN. API is a way of requesting flag images by country code or name using a URL. CDN is a way of loading flag images faster from a server near you using a URL. You can copy the embed code or the API/CDN link and paste it to your website's HTML code.
-
Q: How can I download all the flag files in one ZIP file from countryflags.com?
-
A: You can download all the flag files in one ZIP file from countryflags.com by going to the downloads page and choosing from three options: all country flags, all continent flags, or all U.S. state flags. You can also choose the file format (JPG or PNG) and the size (16px up to 2500px) that you want. Then, click on the "Download" button to save the ZIP file to your device.
-
-
-
-
197e85843d
-
-
\ No newline at end of file
diff --git a/spaces/fatiXbelha/sd/Bus Simulator 2023 MOD APK How to Unlock All Buses and Routes.md b/spaces/fatiXbelha/sd/Bus Simulator 2023 MOD APK How to Unlock All Buses and Routes.md
deleted file mode 100644
index 0eac3b8336d31b86c7366d0e0e248ee9dcca27a1..0000000000000000000000000000000000000000
--- a/spaces/fatiXbelha/sd/Bus Simulator 2023 MOD APK How to Unlock All Buses and Routes.md
+++ /dev/null
@@ -1,99 +0,0 @@
-
-
Bus Sim 2023 Mod APK: A Realistic and Fun Driving Simulator
-
Do you love driving buses and transporting passengers? Do you want to experience the thrill of driving in different cities and environments? Do you want to customize your bus and challenge other players online? If you answered yes to any of these questions, then you should try Bus Sim 2023, a realistic and fun driving simulator game for Android devices. And if you want to make the game even more exciting, you should download Bus Sim 2023 Mod APK, a modified version of the game that gives you unlimited money, coins, and access to all buses and routes. In this article, we will tell you what Bus Sim 2023 is, what features it has, what benefits you can get from Bus Sim 2023 Mod APK, and how to download and install it on your device.
-
What is Bus Sim 2023?
-
Bus Sim 2023 is a driving simulator game developed by Ovidiu Pop, a popular developer of simulation games. In this game, you can play as a bus driver, picking up people at bus stops and transporting them along the route. You can choose from different types of buses, such as city buses, school buses, double-decker buses, and more. You can also drive in different cities and environments, such as New York, London, Paris, Berlin, Rome, Tokyo, Sydney, and more. You can experience realistic graphics and physics, as well as weather effects, traffic conditions, day and night cycles, and more. You can also customize your bus with various paint jobs, stickers, accessories, and more. You can also adjust the controls and settings to suit your preferences. You can also play online with other players in multiplayer mode, where you can compete in races, join bus clubs, chat with other drivers, and climb the leaderboards.
Bus Sim 2023 has stunning graphics that make you feel like you are driving a real bus. You can see the details of the bus interior and exterior, as well as the passengers, buildings, roads, vehicles, trees, animals, and more. You can also feel the realistic physics of the bus movement, such as acceleration, braking, steering, suspension, collision, damage, and more. You can also experience different weather effects, such as rain, snow, fog, wind, thunderstorm, etc., as well as different traffic conditions, such as traffic lights, signs, signals, pedestrians, cars, trucks, bikes, etc.
-
- Various buses and routes
-
Bus Sim 2023 has a wide variety of buses that you can choose from. You can drive city buses, school buses, double-decker buses, articulated buses, electric buses, and more. Each bus has its own characteristics, such as speed, capacity, fuel consumption, handling, etc. You can also drive in different cities and environments around the world, such as New York, London, Paris, Berlin, Rome, Tokyo, Sydney, and more. Each city and environment has its own landmarks, scenery, culture, and challenges.
-
- Custom
- Customizable controls and settings
-
Bus Sim 2023 allows you to customize the controls and settings of the game to suit your preferences. You can choose from different control options, such as tilt, buttons, steering wheel, or joystick. You can also adjust the sensitivity, vibration, and feedback of the controls. You can also change the camera angle, sound volume, language, and other settings of the game. You can also enable or disable the realistic features, such as traffic rules, speed limit, fuel consumption, damage, etc.
-
- Multiplayer mode and leaderboards
-
Bus Sim 2023 also has a multiplayer mode where you can play online with other players from around the world. You can join or create a bus club, where you can chat with other drivers, share tips and tricks, and cooperate in missions and challenges. You can also compete in races, where you can show off your driving skills and speed. You can also climb the leaderboards, where you can see your rank and stats compared to other players. You can also earn rewards and achievements for your performance in multiplayer mode.
-
What is Bus Sim 2023 Mod APK?
-
Bus Sim 2023 Mod APK is a modified version of Bus Sim 2023 that gives you some extra benefits that are not available in the original game. By downloading and installing Bus Sim 2023 Mod APK, you can enjoy unlimited money and coins, all buses and routes unlocked, no ads and pop-ups, and more. These benefits will make your gameplay more enjoyable and easier.
-
Benefits of Bus Sim 2023 Mod APK
-
- Unlimited money and coins
-
With Bus Sim 2023 Mod APK, you will have unlimited money and coins in your account. This means that you can buy any bus you want, upgrade it with any accessories you like, and refill your fuel whenever you need. You can also buy any paint job, sticker, or decoration for your bus. You don't have to worry about running out of money or coins in the game.
-
- All buses and routes unlocked
-
With Bus Sim 2023 Mod APK, you will have access to all buses and routes in the game. This means that you can drive any bus you want, in any city or environment you want. You don't have to complete any missions or challenges to unlock them. You can explore the whole world of Bus Sim 2023 without any restrictions.
-
bus simulator 2023 mod apk unlimited money
-bus sim 2023 mod apk download for android
-bus simulator 2023 hack mod apk
-bus sim 2023 mod apk latest version
-bus simulator 2023 premium mod apk
-bus sim 2023 mod apk free shopping
-bus simulator 2023 mod apk revdl
-bus sim 2023 mod apk offline
-bus simulator 2023 pro mod apk
-bus sim 2023 mod apk android 1
-bus simulator 2023 mod apk obb
-bus sim 2023 mod apk rexdl
-bus simulator 2023 mega mod apk
-bus sim 2023 mod apk unlimited xp
-bus simulator 2023 mod apk an1
-bus sim 2023 mod apk no ads
-bus simulator 2023 mod apk happymod
-bus sim 2023 mod apk unlocked all buses
-bus simulator 2023 vip mod apk
-bus sim 2023 mod apk unlimited fuel
-bus simulator 2023 mod apk data
-bus sim 2023 mod apk unlimited everything
-bus simulator 2023 full mod apk
-bus sim 2023 mod apk all levels unlocked
-bus simulator 2023 real mod apk
-bus sim 2023 mod apk unlimited coins and gems
-bus simulator 2023 hd mod apk
-bus sim 2023 mod apk new update
-bus simulator 2023 ultimate mod apk
-bus sim 2023 mod apk unlimited tickets
-bus simulator 2023 world tour mod apk
-bus sim 2023 mod apk high graphics
-bus simulator 2023 multiplayer mod apk
-bus sim 2023 mod apk cheat menu
-bus simulator 2023 indonesia mod apk
-bus sim 2023 mod apk no root
-bus simulator 2023 europe mod apk
-bus sim 2023 mod apk god mode
-bus simulator 2023 original mod apk
-bus sim 2023 mod apk old version
-bus simulator 2023 india mod apk
-bus sim 2023 mod apk low mb
-bus simulator 2023 coach driving game mod apk
-bus sim 2023 mod apk without verification
-bus simulator 2023 usa edition mod apk
-bus sim 2023 mod apk for pc
-bus simulator 2023 city driving game mod apk
-bus sim 2023 mod apk with license verification removed
-
- No ads and pop-ups
-
With Bus Sim 2023 Mod APK, you will not see any ads or pop-ups in the game. This means that you can play the game without any interruptions or distractions. You don't have to watch any videos or click on any banners to get extra money or coins. You can enjoy the game without any annoying ads or pop-ups.
-
How to Download and Install Bus Sim 2023 Mod APK?
-
If you want to download and install Bus Sim 2023 Mod APK on your device, you need to follow some simple steps. Here are the steps to download and install Bus Sim 2023 Mod APK:
-
Steps to Download and Install Bus Sim 2023 Mod APK
-
- Step 1: Enable unknown sources on your device
-
Before you can install Bus Sim 2023 Mod APK on your device, you need to enable unknown sources on your device. This will allow you to install apps that are not from the Google Play Store. To enable unknown sources on your device, go to Settings > Security > Unknown Sources and toggle it on.
-
- Step 2: Download the mod apk file from a trusted source
-
Next, you need to download the mod apk file from a trusted source. There are many websites that offer mod apk files for various games, but not all of them are safe and reliable. Some of them may contain viruses or malware that can harm your device or steal your data. Therefore, you need to be careful when choosing a source to download the mod apk file from. One of the trusted sources that we recommend is [BusSim2023ModAPK.com], where you can find the latest version of Bus Sim 2023 Mod APK with all the benefits mentioned above.
-
- Step 3: Locate and install the mod apk file on your device
-
After downloading the mod apk file from a trusted source, you need to locate and install it on your device. To do this, go to your file manager app and find the folder where you downloaded the mod apk file. Tap on the file and follow the instructions on the screen to install it on your device.
-
- Step 4:
- Step 4: Launch the game and enjoy the mod features
-
Finally, you can launch the game and enjoy the mod features. To do this, go to your app drawer and find the Bus Sim 2023 icon. Tap on it and wait for the game to load. You will see that you have unlimited money and coins, all buses and routes unlocked, no ads and pop-ups, and more. You can now play the game as you wish, without any limitations or restrictions.
-
Conclusion
-
Bus Sim 2023 is a realistic and fun driving simulator game that lets you drive various buses in different cities and environments. You can customize your bus, adjust the controls and settings, and play online with other players. However, if you want to make the game more exciting and easier, you should download Bus Sim 2023 Mod APK, a modified version of the game that gives you unlimited money, coins, and access to all buses and routes. You can download and install Bus Sim 2023 Mod APK by following the steps we have provided in this article. We hope you enjoy playing Bus Sim 2023 Mod APK and have a great time driving your bus.
-
FAQs
-
Here are some frequently asked questions about Bus Sim 2023 Mod APK:
-
- Is Bus Sim 2023 Mod APK safe to download and install?
-
Yes, Bus Sim 2023 Mod APK is safe to download and install, as long as you get it from a trusted source like [BusSim2023ModAPK.com]. However, you should always be careful when downloading and installing any mod apk file from unknown sources, as they may contain viruses or malware that can harm your device or steal your data.
-
- Do I need to root my device to use Bus Sim 2023 Mod APK?
-
No, you do not need to root your device to use Bus Sim 2023 Mod APK. You can use it on any Android device that meets the minimum requirements of the game.
-
- Will I get banned from the game if I use Bus Sim 2023 Mod APK?
-
No, you will not get banned from the game if you use Bus Sim 2023 Mod APK. The mod apk file is designed to bypass the security checks of the game and prevent detection. However, you should always use the mod apk file at your own risk, as we cannot guarantee that it will work forever or that it will not cause any problems with your device or account.
-
- Can I update Bus Sim 2023 Mod APK?
-
Yes, you can update Bus Sim 2023 Mod APK whenever there is a new version available. However, you should always check the source of the update and make sure that it is compatible with your device and account. You should also backup your data before updating, in case something goes wrong.
-
- Can I play offline with Bus Sim 2023 Mod APK?
-
Yes, you can play offline with Bus Sim 2023 Mod APK. You can drive any bus in any city or environment without an internet connection. However, you will not be able to access some features of the game, such as multiplayer mode, leaderboards, achievements, etc., when playing offline.
401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/fatiXbelha/sd/Farlight 84 APK - The Latest and Greatest Battle Royale Game for Android.md b/spaces/fatiXbelha/sd/Farlight 84 APK - The Latest and Greatest Battle Royale Game for Android.md
deleted file mode 100644
index f0237891a110633653a2722a14a403ed11f0cd8c..0000000000000000000000000000000000000000
--- a/spaces/fatiXbelha/sd/Farlight 84 APK - The Latest and Greatest Battle Royale Game for Android.md
+++ /dev/null
@@ -1,98 +0,0 @@
-
-
Farlight 84 APK Download: How to Play the Latest Battle Royale Game on Android
-
If you are looking for a new and exciting battle royale game to play on your Android device, you might want to check out Farlight 84. This game is a post-apocalyptic hero shooter that features jetpacks, vehicles, and a variety of game modes. In this article, we will show you how to download and install Farlight 84 APK on your Android device, as well as how to play the game and some tips and tricks to win more matches.
-
What is Farlight 84?
-
Farlight 84 is a multiplayer game that is set in a near-future world in 2084. The game allows players to experience the thrill of commanding armored vehicles with powerful offensive capabilities. Fly and dash around the battlefield using jetpacks, and unleash an arsenal of ingenious weapons from four different manufacturers.
A post-apocalyptic hero shooter with jetpacks and vehicles
-
The game has a unique setting that combines sci-fi and dystopian elements. The world is full of crises and challenges, and players have to fight for survival and glory. The game features jetpacks that allow players to move vertically or horizontally, as well as vehicles that provide protection and firepower. Players can also use auto-drive mode to focus on shooting while driving.
-
A game with diverse modes, characters, and weapons
-
The game offers a variety of game modes, such as battle royale, team deathmatch, hunt, solo deathmatch, treasure war, and more. Each mode has its own rules and objectives, and players can choose the one that suits their preferences. The game also has 14 heroes, each with unique skills and abilities that can be used in combat. Players can customize their heroes with skins and accessories. Moreover, the game has a wide range of weapons, from pistols and rifles to rocket launchers and flamethrowers. Players can loot and upgrade their weapons during the match.
-
How to download and install Farlight 84 APK on Android?
-
If you want to play Farlight 84 on your Android device, you will need to download and install the APK file of the game. Here are the steps to do so:
-
Download the APK file from a trusted source
-
The first step is to download the APK file of Farlight 84 from a reliable source. You can use the link below to download the latest version of the game from APKCombo.com, which is a safe and secure website that offers free APK downloads.
-
[Download Farlight 84 APK](^1^)
-
Enable unknown sources on your device
-
The next step is to enable unknown sources on your device. This will allow you to install apps that are not from the Google Play Store. To do this, follow these steps:
-
-
Go to Settings > Security > Unknown Sources.
-
Toggle on the option to allow installation of apps from unknown sources.
-
Tap OK to confirm.
-
-
Install the APK file and launch the game
-
The final step is to install the APK file and launch the game. To do this, follow these steps:
-
farlight 84 apk download latest version
-farlight 84 apk download free for android
-farlight 84 apk download mod unlimited money
-farlight 84 apk download no verification
-farlight 84 apk download offline installer
-farlight 84 apk download obb file
-farlight 84 apk download pc windows 10
-farlight 84 apk download rexdl
-farlight 84 apk download revdl
-farlight 84 apk download uptodown
-farlight 84 apk download with data
-farlight 84 apk download xapk
-farlight 84 apk download youtube
-farlight 84 apk download zip file
-farlight 84 battle royale game apk download
-farlight 84 beta version apk download
-farlight 84 full game apk download
-farlight 84 game free fire apk download
-farlight 84 hack version apk download
-farlight 84 latest update apk download
-farlight 84 mod menu apk download
-farlight 84 new update apk download
-farlight 84 official game apk download
-farlight 84 original game apk download
-farlight 84 pro version apk download
-farlight 84 shooter game apk download
-farlight 84 unlimited coins apk download
-how to download and install farlight 84 apk
-how to play farlight 84 on android apk download
-how to update farlight 84 on android apk download
-
-
Locate the downloaded APK file on your device. You can use a file manager app to find it.
-
Tap on the APK file and follow the instructions to install it.
-
Wait for the installation to complete and then tap on the game icon to launch it.
-
-
Congratulations, you have successfully installed Farlight 84 APK on your Android device. You can now enjoy playing the game and explore its features.
-
How to play Farlight 84 on Android?
-
Now that you have installed the game, you might be wondering how to play it. Here are some basic tips and steps to help you get started:
-
Choose your game mode and character
-
The first thing you need to do is to choose your game mode and character. You can access the game mode selection screen by tapping on the play button on the main menu. You can then choose from various modes, such as battle royale, team deathmatch, hunt, solo deathmatch, treasure war, and more. Each mode has its own rules and objectives, so make sure you read them before joining a match.
-
After choosing your game mode, you can also choose your character. You can swipe left or right to browse through the available heroes, each with unique skills and abilities. You can also tap on the hero icon to see their stats and skills. You can customize your hero with skins and accessories by tapping on the wardrobe button. You can also change your hero name by tapping on the edit button.
-
Customize your controls and settings
-
The next thing you need to do is to customize your controls and settings. You can access the settings menu by tapping on the gear icon on the top right corner of the screen. You can then adjust various options, such as graphics, sound, language, sensitivity, aim assist, auto-fire, and more. You can also customize your controls by tapping on the control button. You can drag and resize the buttons to suit your preference.
-
Use your jetpack, vehicle, and weapons wisely
-
The last thing you need to do is to use your jetpack, vehicle, and weapons wisely. You can use your jetpack by tapping on the jetpack button on the right side of the screen. You can fly or dash in any direction using the joystick. You can also use your vehicle by tapping on the vehicle button on the left side of the screen. You can drive or shoot using the joystick and buttons. You can also use auto-drive mode by tapping on the auto button.
-
You can use your weapons by tapping on the fire button on the right side of the screen. You can switch between different weapons by tapping on the weapon icons on the bottom of the screen. You can also loot and upgrade your weapons during the match by finding crates and stations. You can use your character's skills by tapping on the skill buttons on the left side of the screen. Each skill has a cooldown time, so use them wisely.
-
Tips and tricks to win more matches in Farlight 84
-
If you want to win more matches in Farlight 84, you will need some tips and tricks to improve your skills and strategy. Here are some of them:
-
Pick the right gun for your playstyle
-
The game has a wide range of weapons, from pistols and rifles to rocket launchers and flamethrowers. Each weapon has its own advantages and disadvantages, such as damage, range, accuracy, fire rate, reload speed, magazine size, and recoil. You should pick the right gun for your playstyle and situation. For example, if you like to snipe from a distance, you should use a sniper rifle or a marksman rifle. If you like to rush into close combat, you should use a shotgun or a submachine gun.
-
Use your character's skills effectively
-
The game has 14 heroes, each with unique skills and abilities that can be used in combat. Each skill has a cooldown time, so use them effectively. For example, if you are playing as Blaze, you can use his Fireball skill to deal damage and burn enemies in a large area. If you are playing as Luna, you can use her Shield skill to protect yourself and your allies from enemy fire.
-
Improve your movement and aim
-
The game requires good movement and aim skills to survive and eliminate enemies. You should practice using your jetpack and vehicle to move around the map quickly and avoid enemy fire. You should also practice using your weapons to aim accurately and shoot precisely at enemies. You can use aim assist or auto-fire options to help you with aiming, but you should also try to improve your aim skills by practicing and adjusting your sensitivity settings.
-
Loot and upgrade your gear
-
The game has a loot and upgrade system that allows you to find and enhance your gear during the match. You can find crates and stations that contain weapons, ammo, health kits, armor, and other items. You can also use stations to upgrade your weapons and armor to increase their stats and effects. You should loot and upgrade your gear as much as possible to gain an edge over your enemies.
-
Team up and communicate with your squad
-
The game has a team-based mode that allows you to play with your friends or other players in a squad of four. You can invite or join a squad by tapping on the squad button on the main menu. You can also use the voice chat or text chat features to communicate with your squad members. You should team up and communicate with your squad to coordinate your actions, share information, and support each other.
-
Conclusion
-
Farlight 84 is a fun and exciting battle royale game that you can play on your Android device. You can download and install the APK file of the game from a trusted source, and then enjoy the game's features, such as jetpacks, vehicles, diverse modes, characters, and weapons. You can also use some tips and tricks to improve your skills and strategy, such as picking the right gun, using your character's skills, improving your movement and aim, looting and upgrading your gear, and teaming up and communicating with your squad. We hope this article has helped you learn how to play Farlight 84 on Android. Have fun and good luck!
-
FAQs
-
Here are some frequently asked questions about Farlight 84:
-
Is Farlight 84 free to play?
-
Yes, Farlight 84 is free to play on Android devices. However, the game may contain in-app purchases that allow you to buy items or currency with real money.
-
Is Farlight 84 available on iOS devices?
-
No, Farlight 84 is not available on iOS devices at the moment. The game is only compatible with Android devices that have Android 5.0 or higher.
-
How can I update Farlight 84 APK?
-
You can update Farlight 84 APK by downloading the latest version of the APK file from the same source that you downloaded it from before. You can then install the new APK file over the old one without losing your data.
-
How can I report bugs or issues in Farlight 84?
-
You can report bugs or issues in Farlight 84 by contacting the game's customer service team. You can do this by tapping on the feedback button on the settings menu, or by sending an email to support@miraclegames.com.
-
How can I get more information about Farlight 84?
-
You can get more information about Farlight 84 by visiting the game's official website, Facebook page, Twitter account, or YouTube channel. You can also join the game's Discord server to chat with other players and developers.
If you are a fan of One Piece, the popular manga and anime series by Eiichiro Oda, you might be interested in playing One Piece World Seeker, an action-adventure video game based on the franchise. In this article, we will tell you everything you need to know about this game, including what it is, why you should play it, where you can download it, and what are the different editions available. So, let's get started!
One Piece World Seeker is a video game developed by Ganbarion and published by Bandai Namco Entertainment. It is the first video game in the franchise to feature an open world environment, where you can explore a vast and seamless island as Monkey D. Luffy, the protagonist of One Piece. The game was released on March 15, 2019 for PC, PlayStation 4, and Xbox One.
-
Why should you play One Piece World Seeker?
-
There are many reasons why you should play One Piece World Seeker, but here are some of the main ones:
-
-
The Freedom of the Pirate King: You can experience the powers of Luffy's Gum-Gum fruit, which allows him to stretch his limbs and swing into action. You can also use his powerful Haki abilities to sense enemies and unleash devastating attacks. You can explore different areas of the island, such as cities, farms, beaches, mines, and prisons, and interact with various objects and characters.
-
An Original Story with Original Characters: The game features an original story that takes place on Prison Island, a mysterious island that is under the control of the Navy. The Straw Hat Pirates arrive on the island and get involved in a dramatic story full of twists and turns. The game also includes original characters designed by Eiichiro Oda himself, such as Jeanne, a young woman who leads a rebel group against the Navy; Isaac, a former Marine scientist who rules over Prison Island; and Karakuri Island Automata (KIA), mechanical soldiers created by Isaac.
-
Fierce Battles Between Popular Characters: The game lets you fight against some of the most iconic enemies from the One Piece series, such as Crocodile, Rob Lucci, Akainu, Kizaru, and more. You can also encounter some of the allies and friends of Luffy, such as Sabo, Law, Hancock, and more. You can enjoy the dynamic and thrilling combat system that combines melee, ranged, and stealth attacks.
-
-
Where can you download One Piece World Seeker?
-
One Piece World Seeker is available for download on PC, PlayStation 4, and Xbox One. Here are the steps on how to download the game for each platform:
-
Download One Piece World Seeker for PC
-
If you want to play One Piece World Seeker on your PC, you need to download it from Steam, the online gaming platform. Here are the steps to do so:
-
-
Create a Steam account if you don't have one already. You can do this by visiting https://store.steampowered.com/join/ and following the instructions.
-
Download and install the Steam client on your PC. You can do this by visiting https://store.steampowered.com/about/ and clicking on the "Install Steam" button.
-
Launch the Steam client and log in with your Steam account.
-
Search for One Piece World Seeker in the Steam store. You can do this by typing the name of the game in the search bar or browsing through the categories.
-
Select One Piece World Seeker from the search results and click on the "Add to Cart" button.
-
Proceed to checkout and pay for the game using your preferred payment method.
-
Wait for the game to download and install on your PC. You can check the progress of the download in the "Library" section of the Steam client.
-
Once the game is installed, you can launch it from your Steam library and enjoy playing it.
-
-
System Requirements for PC
-
Before you download One Piece World Seeker for PC, you need to make sure that your PC meets the minimum or recommended system requirements for the game. Here is a table of the system requirements for PC:
- | Minimum | Recommended | | --- | --- | | OS: Windows 7 64-bit SP1 | OS: Windows 10 64-bit | | Processor: Intel Core i5-2300 or AMD A10-7850K | Processor: Intel Core i7-3770 or AMD FX-8350 | | Memory: 4 GB RAM | Memory: 8 GB RAM | | Graphics: GeForce GTX 660 or Radeon HD 7950 | Graphics: GeForce GTX 1060 or Radeon RX 580 | | DirectX: Version 11 | DirectX: Version 11 | | Storage: 25 GB available space | Storage: 25 GB available space | | Sound Card: DirectX compatible soundcard or onboard chipset | Sound Card: DirectX compatible soundcard or onboard chipset |
Download One Piece World Seeker for PlayStation 4
-
If you want to play One Piece World Seeker on your PlayStation 4, you need to download it from PlayStation Store, the online gaming platform. Here are the steps to do so:
Download and install the PlayStation Store app on your PlayStation 4. You can do this by selecting "PlayStation Store" from the home screen of your console.
-
Launch the PlayStation Store app and log in with your PlayStation Network account.
-
Search for One Piece World Seeker in the PlayStation Store. You can do this by typing the name of the game in the search bar or browsing through the categories.
-
Select One Piece World Seeker from the search results and click on the "Add to Cart" button.
-
Proceed to checkout and pay for the game using your preferred payment method.
-
Wait for the game to download and install on your PlayStation 4. You can check the progress of the download in the "Notifications" section of your console.
-
Once the game is installed, you can launch it from your home screen and enjoy playing it.
-
-
System Requirements for PlayStation 4
-
Before you download One Piece World Seeker for PlayStation 4, you need to make sure that your PlayStation 4 meets the minimum or recommended system requirements for the game. Here is a table of the system requirements for PlayStation 4:
-
download one piece world seeker pc
-download one piece world seeker free
-download one piece world seeker full version
-download one piece world seeker crack
-download one piece world seeker steam
-download one piece world seeker deluxe edition
-download one piece world seeker episode pass
-download one piece world seeker torrent
-download one piece world seeker fitgirl repack
-download one piece world seeker codex
-download one piece world seeker update
-download one piece world seeker dlc
-download one piece world seeker mods
-download one piece world seeker trainer
-download one piece world seeker save file
-download one piece world seeker highly compressed
-download one piece world seeker for android
-download one piece world seeker for ps4
-download one piece world seeker for xbox one
-download one piece world seeker for switch
-download one piece world seeker gameplay
-download one piece world seeker review
-download one piece world seeker walkthrough
-download one piece world seeker guide
-download one piece world seeker tips and tricks
-download one piece world seeker cheats
-download one piece world seeker hack
-download one piece world seeker patch notes
-download one piece world seeker system requirements
-download one piece world seeker wallpaper
-download one piece world seeker soundtrack
-download one piece world seeker ost
-download one piece world seeker opening song
-download one piece world seeker ending song
-download one piece world seeker characters
-download one piece world seeker luffy moveset
-download one piece world seeker zoro gameplay
-download one piece world seeker sabo gameplay
-download one piece world seeker law gameplay
-download one piece world seeker map locations
-download one piece world seeker side missions
-download one piece world seeker treasure chests
-download one piece world seeker blueprints
-download one piece world seeker outfits and costumes
-download one piece world seeker skill tree and upgrades
-download one piece world seeker karma system and factions
-download one piece world seeker photo mode and screenshots
-download one piece world seeker easter eggs and secrets
-download one piece world seeker best weapons and equipment
If you want to play One Piece World Seeker on your Xbox One, you need to download it from Microsoft Store, the online gaming platform. Here are the steps to do so:
-
-
Create a Microsoft account if you don't have one already. You can do this by visiting https://account.microsoft.com/account and following the instructions.
-
Download and install the Microsoft Store app on your Xbox One. You can do this by selecting "Microsoft Store" from the home screen of your console.
-
Launch the Microsoft Store app and log in with your Microsoft account.
-
Search for One Piece World Seeker in the Microsoft Store. You can do this by typing the name of the game in the search bar or browsing through the categories.
-
Select One Piece World Seeker from the search results and click on the "Buy" button.
-
Proceed to checkout and pay for the game using your preferred payment method.
-
Wait for the game to download and install on your Xbox One. You can check the progress of the download in the "My games & apps" section of your console.
-
Once the game is installed, you can launch it from your home screen and enjoy playing it.
-
-
System Requirements for Xbox One
-
Before you download One Piece World Seeker for Xbox One, you need to make sure that your Xbox One meets the minimum or recommended system requirements for the game. Here is a table of the system requirements for Xbox One:
- | Minimum | Recommended | | --- | --- | | OS: Xbox One | OS: Xbox One X | | Processor: AMD Jaguar 8-core | Processor: AMD Jaguar 8-core | | Memory: 8 GB DDR3 | Memory: 12 GB GDDR5 | | Graphics: AMD Radeon GCN 1.31 TFLOPS | Graphics: AMD Radeon GCN 6 TFLOPS | | Storage: 25 GB available space | Storage: 25 GB available space |
What are the different editions of One Piece World Seeker?
-
One Piece World Seeker has three different editions that you can choose from, depending on your budget and preferences. They are the standard edition, the deluxe edition, and the pirate king edition. Here is a comparison of what each edition offers:
-
Standard Edition
-
The standard edition of One Piece World Seeker is the basic version of the game that includes only the main game itself. It costs $59.99 USD. If you pre-ordered the standard edition, you also received some bonus items, such as a swimsuit outfit for Luffy, a military outfit for Luffy, and a quest called "Strange Island Rocks".
-
Deluxe Edition
-
The deluxe edition of One Piece World Seeker is an upgraded version of the game that includes not only the main game, but also an episode pass that gives you access to three additional episodes that expand the story and gameplay of the game. The episode pass also includes some extra items, such as a raid suit for Luffy, a kung fu outfit for Luffy, and a white suit outfit for Luffy. The deluxe edition costs $89.99 USD.
-
Pirate King Edition
-
The pirate king edition of One Piece World Seeker is the ultimate version of the game that includes everything from the deluxe edition, plus some exclusive physical items that are perfect for collectors and fans of One Piece. The pirate king edition includes a figurine of Luffy in his Gear Fourth form, a replica of Luffy's straw hat, a CD with selected tracks from the game's soundtrack, and a season pass that gives you access to all future DLCs for the game. The pirate king edition costs $129.99 USD.
-
Conclusion
-
One Piece World Seeker is an amazing video game that lets you experience the world of One Piece like never before. You can explore a vast and beautiful island as Luffy and use his amazing abilities to fight against his enemies and allies. You can also enjoy an original story with original characters that are designed by the creator of One Piece himself, Eiichiro Oda. You can download the game for PC, PlayStation 4, or Xbox One from various online platforms, and choose from different editions that offer different content and bonuses. If you are looking for a fun and immersive game that will make you feel like a pirate king, you should definitely try One Piece World Seeker. You won't regret it!
-
FAQs
-
Here are some of the frequently asked questions about One Piece World Seeker:
-
-
Q: How long is the game?
-
A: The game's main story takes about 15 to 20 hours to complete, depending on your playstyle and difficulty level. The game also has many side quests and activities that can extend the gameplay time to over 40 hours.
-
Q: Can you play as other characters besides Luffy?
-
A: No, you can only play as Luffy in the game. However, you can interact with other characters from the One Piece series, and some of them will join you as support characters in combat.
-
Q: Can you customize Luffy's appearance and skills?
-
A: Yes, you can change Luffy's outfits and accessories in the game, as well as upgrade his skills and abilities using skill points that you earn by completing missions and defeating enemies.
-
Q: Is the game multiplayer or co-op?
-
A: No, the game is single-player only. There is no online or local multiplayer or co-op mode in the game.
-
Q: Is the game canon to the One Piece series?
-
A: The game is not canon to the One Piece series, but it is an original story that is supervised by Eiichiro Oda himself. The game takes place in an alternate timeline after the Whole Cake Island arc of the manga and anime.
-
401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/feregVcuzo/sanity-test-midi/checkpoint/Download Poppy Playtime Chapter 2 and Face Mommy Long Legs on Mobile.md b/spaces/feregVcuzo/sanity-test-midi/checkpoint/Download Poppy Playtime Chapter 2 and Face Mommy Long Legs on Mobile.md
deleted file mode 100644
index cf9174117f890fc3e4e3d2bf97ab6b2550e0a89c..0000000000000000000000000000000000000000
--- a/spaces/feregVcuzo/sanity-test-midi/checkpoint/Download Poppy Playtime Chapter 2 and Face Mommy Long Legs on Mobile.md
+++ /dev/null
@@ -1,100 +0,0 @@
-
-
Poppy Playtime Chapter 2: A Horror-Puzzle Adventure Game for Mobile Devices
-
If you are a fan of horror games with cartoon characters and a touch of whimsy, then you might have heard of Poppy Playtime. This is a first-person horror-puzzle-adventure game developed by Mob Entertainment that revolves around an abandoned toy factory and its sinister secrets. The game is divided into multiple chapters, each with its own storyline, puzzles, and enemies. The first chapter was released in 2022 and became a hit among horror fans and YouTubers alike. The second chapter was released in May 2023 and offers a more thrilling and challenging experience.
-
In this article, we will tell you everything you need to know about Poppy Playtime Chapter 2, including how to download it on your mobile devices, what to expect from the game, and some tips and tricks to help you survive. Let's get started!
How to Download Poppy Playtime Chapter 2 on Mobile Devices
-
Poppy Playtime Chapter 2 is available on both Android and iOS devices. However, it is not a standalone game. You need to have the base game Poppy Playtime installed on your device first. The base game costs $2.99 on both platforms and can be downloaded from the Google Play Store or the App Store. Once you have the base game, you can purchase the second chapter as a downloadable content (DLC) for $4.99 on Android or $5.99 on iOS. Here are the steps to download Poppy Playtime Chapter 2 on your mobile devices:
-
-
Go to the Google Play Store or the App Store on your device.
-
Type in "Poppy Playtime" in the search bar and tap on the game icon.
-
If you don't have the base game yet, tap on the "Buy" button and follow the instructions to complete the payment.
-
If you already have the base game, tap on the "Downloadable Content" section and look for "Poppy Playtime Chapter 2".
-
Tap on the "Buy" button and follow the instructions to complete the payment.
-
After paying, tap on the "Download" button to get the second chapter.
-
Launch the game and enjoy!
-
-
What to Expect from Poppy Playtime Chapter 2
-
Poppy Playtime Chapter 2 continues where Poppy Playtime Chapter 1 left off. You play as a former employee of Playtime Co., a toy company that mysteriously shut down after its founder disappeared. You decide to investigate the abandoned factory and find out what happened to your colleagues and the company's mascot, Poppy. However, you soon realize that the factory is not as empty as it seems. There are vengeful toys waiting for you in every corner, ready to play with you before they kill you.
-
The second chapter introduces a new area to explore: The Train Station. This is one of Playtime Co.'s most popular locations, where children can enjoy games, playgrounds, and more. It also has a train that provides a straight shot out of the factory. However, getting to the train is not easy. You will have to solve mind-numbing puzzles and face horrific toys along the way. Here are some of the new features that you can expect from Poppy Playtime Chapter 2:
-
New Toys and Enemies
In Poppy Playtime Chapter 2, you will encounter new toys and enemies that will make your journey more terrifying. Some of them are:
-
-
Bunzo Bunny: This is a cute and fluffy bunny toy that can hop around and follow you. However, don't let its appearance fool you. It has sharp teeth and claws that can rip you apart. It can also sense your movements and track you down.
-
PJ Pug-a-pillar: This is a hybrid toy that combines a pug and a caterpillar. It has a long body with multiple legs and a pug head. It can crawl on walls and ceilings and drop down on you when you least expect it. It can also spit acid at you from its mouth.
-
Mommy Long Legs: This is a giant spider-like toy that has a human face and long hair. It can climb on any surface and spin webs to trap you. It can also use its legs to stab you or grab you and drag you to its lair.
-
Poppy: This is the main antagonist of the game and the mascot of Playtime Co. She is a doll with blonde hair and blue eyes that wears a pink dress. She is the leader of the toys and wants to play with you forever. She can appear anywhere and anytime, and she can control the other toys with her voice. She can also use her magic wand to manipulate the environment and create obstacles for you.
-
-
New Gameplay Mechanic: The Green Hand
-
In Poppy Playtime Chapter 2, you will also get to use a new gameplay mechanic: The Green Hand. This is a device that you can find in the Train Station that allows you to transfer power, grapple, and swing. You can use it to activate switches, open doors, move objects, and more. You can also use it to escape from enemies or reach new areas. However, be careful not to overuse it, as it has a limited battery life and needs to be recharged at certain stations.
-
The Green Hand works similarly to the Blue Hand that you used in the first chapter, but with some differences. The Blue Hand allows you to grab objects from a distance and pull them towards you, while the Green Hand allows you to attach objects from a distance and pull yourself towards them. The Blue Hand has two modes: Grab Mode and Pull Mode, while the Green Hand has three modes: Transfer Mode, Grapple Mode, and Swing Mode. Here is how each mode works:
-
How to play poppy playtime chapter 2 on android
-Poppy playtime chapter 2 apk download for free
-Poppy playtime chapter 2 ios release date and price
-Poppy playtime chapter 2 walkthrough and guide
-Poppy playtime chapter 2 review and rating
-Poppy playtime chapter 2 secrets and easter eggs
-Poppy playtime chapter 2 system requirements and compatibility
-Poppy playtime chapter 2 trailer and gameplay
-Poppy playtime chapter 2 tips and tricks
-Poppy playtime chapter 2 cheats and hacks
-Poppy playtime chapter 2 mod apk download
-Poppy playtime chapter 2 update and patch notes
-Poppy playtime chapter 2 horror game download
-Poppy playtime chapter 2 best settings and options
-Poppy playtime chapter 2 steam version download
-Poppy playtime chapter 2 official website and support
-Poppy playtime chapter 2 fan art and memes
-Poppy playtime chapter 2 characters and story
-Poppy playtime chapter 2 ending and sequel
-Poppy playtime chapter 2 online multiplayer mode
-Poppy playtime chapter 2 vs poppy playtime chapter 1
-Poppy playtime chapter 2 softonic download link
-Poppy playtime chapter 2 sportskeeda article and news
-Poppy playtime chapter 2 mob entertainment developer
-Poppy playtime chapter 2 bugs and glitches
-Poppy playtime chapter 2 soundtrack and music
-Poppy playtime chapter 2 voice actors and cast
-Poppy playtime chapter 2 merchandise and toys
-Poppy playtime chapter 2 wiki and fandom page
-Poppy playtime chapter 2 reddit community and discussion
-Poppy playtime chapter 2 youtube videos and streams
-Poppy playtime chapter 2 google drive download link
-Poppy playtime chapter 2 amazon app store download link
-Poppy playtime chapter 2 refund policy and terms of service
-Poppy playtime chapter 2 achievements and trophies
-Poppy playtime chapter 2 speedrun and challenge mode
-Poppy playtime chapter 2 fan theories and speculation
-Poppy playtime chapter 2 lore and backstory
-Poppy playtime chapter 2 crossover and collaboration
-Poppy playtime chapter 2 memes and jokes
-
-
Transfer Mode: This mode allows you to transfer power from one source to another. You can use it to power up machines, lights, doors, etc. To use this mode, aim at a power source (such as a socket or a battery) and press the trigger button to attach the Green Hand to it. Then, aim at another power source (such as a switch or a panel) and press the trigger button again to transfer the power to it.
-
Grapple Mode: This mode allows you to grapple onto objects or surfaces from a distance and pull yourself towards them. You can use it to cross gaps, climb walls, reach high places, etc. To use this mode, aim at an object or surface (such as a hook or a ledge) that has a green outline and press the trigger button to attach the Green Hand to it. Then, hold the trigger button to pull yourself towards it.
-
Swing Mode: This mode allows you to swing from one object or surface to another using the Green Hand as a rope. You can use it to traverse large areas, avoid enemies, find secrets, etc. To use this mode, aim at an object or surface (such as a pipe or a beam) that has a green outline and press the trigger button to attach the Green Hand to it. Then, release the trigger button to swing from it. You can press the trigger button again to detach the Green Hand from it.
-
-
Tips and Tricks for Playing Poppy Playtime Chapter 2
Poppy Playtime Chapter 2 is not an easy game. It requires a lot of skill, patience, and courage to complete. Here are some tips and tricks that can help you play the game better:
-
-
Explore the environment: The Train Station is a large and complex area that has many hidden secrets and collectibles. You can find tapes, posters, notes, and more that can give you more information about the story and the characters. You can also find batteries, health kits, and other items that can help you survive. Be sure to look around and interact with everything you can.
-
Use the Green Hand wisely: The Green Hand is a powerful tool that can help you solve puzzles and escape from enemies. However, it also has some limitations. It has a limited battery life that drains when you use it. It also has a cooldown time between each use. You can recharge it at certain stations, but they are not always available. Therefore, you should use the Green Hand sparingly and strategically. Don't waste it on unnecessary actions or objects. Save it for when you really need it.
-
Avoid the enemies: The toys in Poppy Playtime Chapter 2 are not your friends. They are deadly and relentless. They will chase you, attack you, and kill you if they catch you. You cannot fight them or kill them. You can only run away from them or hide from them. You should avoid making noise or getting too close to them. You should also use the environment to your advantage. You can use doors, vents, lockers, and other objects to block their path or hide from their sight. You can also use the Green Hand to grapple or swing away from them.
-
Solve the puzzles: The puzzles in Poppy Playtime Chapter 2 are challenging and creative. They require you to use your logic, observation, and memory skills. You will have to find clues, codes, keys, and more to unlock doors, activate machines, and progress through the game. You will also have to use the Green Hand to transfer power, grapple, and swing to solve some puzzles. You should pay attention to everything you see and hear in the game. You might find hints or solutions in the most unexpected places.
-
-
Conclusion and FAQs
-
Poppy Playtime Chapter 2 is a horror-puzzle-adventure game that will keep you on the edge of your seat. It offers a thrilling and immersive experience that will make you feel like you are in a nightmare. It has stunning graphics, sound effects, and voice acting that will make you forget that you are playing on a mobile device. It also has a captivating story, challenging puzzles, and terrifying enemies that will make you want to play more.
-
If you are looking for a game that will scare you, entertain you, and challenge you, then Poppy Playtime Chapter 2 is the game for you. Download it now and see if you can escape from the Train Station alive.
-
Here are some FAQs that might help you with the game:
-
-
Q: How long is Poppy Playtime Chapter 2?
-
A: Poppy Playtime Chapter 2 is about 1-2 hours long, depending on your skill level and how much you explore.
-
Q: Can I play Poppy Playtime Chapter 2 without playing Poppy Playtime Chapter 1?
-
A: Yes, but we don't recommend it. Poppy Playtime Chapter 2 is a continuation of Poppy Playtime Chapter 1 and assumes that you know what happened in the first chapter. If you play the second chapter without playing the first one, you might miss some important details and references.
-
Q: Is Poppy Playtime Chapter 2 suitable for children?
-
A: No, Poppy Playtime Chapter 2 is not suitable for children. It is a horror game that contains violence, gore, jump scares, and disturbing themes. It is rated M for Mature by ESRB and PEGI 18 by PEGI.
-
Q: Will there be more chapters of Poppy Playtime?
-
A: Yes, according to the developer Mob Entertainment, there will be more chapters of Poppy Playtime in the future. However, they have not announced any release dates or details yet.
-
Q: Where can I find more information about Poppy Playtime?
-
A: You can find more information about Poppy Playtime on its official website, its Twitter account, its YouTube channel, or its Discord server. You can also check out some of the reviews, gameplay videos, and fan art of Poppy Playtime on various websites and platforms.
-
-
I hope you enjoyed this article and found it helpful. If you have any questions or feedback, feel free to leave a comment below. Thank you for reading and have a great day!
- );
-});
-Chat.displayName = 'Chat';
diff --git a/spaces/gustproof/sd_prompts/README.md b/spaces/gustproof/sd_prompts/README.md
deleted file mode 100644
index 8ff116de4661211ac6a06545a82859365f9bd675..0000000000000000000000000000000000000000
--- a/spaces/gustproof/sd_prompts/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Sd Prompts
-emoji: 💻
-colorFrom: purple
-colorTo: blue
-sdk: gradio
-sdk_version: 3.41.2
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/gwang-kim/DATID-3D/eg3d/torch_utils/ops/upfirdn2d.cpp b/spaces/gwang-kim/DATID-3D/eg3d/torch_utils/ops/upfirdn2d.cpp
deleted file mode 100644
index c1769c3cbe4dd04f76f9ccef726680720e6f39c8..0000000000000000000000000000000000000000
--- a/spaces/gwang-kim/DATID-3D/eg3d/torch_utils/ops/upfirdn2d.cpp
+++ /dev/null
@@ -1,111 +0,0 @@
-/*
- * SPDX-FileCopyrightText: Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
- * SPDX-License-Identifier: LicenseRef-NvidiaProprietary
- *
- * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
- * property and proprietary rights in and to this material, related
- * documentation and any modifications thereto. Any use, reproduction,
- * disclosure or distribution of this material and related documentation
- * without an express license agreement from NVIDIA CORPORATION or
- * its affiliates is strictly prohibited.
- */
-
-#include
-#include
-#include
-#include "upfirdn2d.h"
-
-//------------------------------------------------------------------------
-
-static torch::Tensor upfirdn2d(torch::Tensor x, torch::Tensor f, int upx, int upy, int downx, int downy, int padx0, int padx1, int pady0, int pady1, bool flip, float gain)
-{
- // Validate arguments.
- TORCH_CHECK(x.is_cuda(), "x must reside on CUDA device");
- TORCH_CHECK(f.device() == x.device(), "f must reside on the same device as x");
- TORCH_CHECK(f.dtype() == torch::kFloat, "f must be float32");
- TORCH_CHECK(x.numel() <= INT_MAX, "x is too large");
- TORCH_CHECK(f.numel() <= INT_MAX, "f is too large");
- TORCH_CHECK(x.numel() > 0, "x has zero size");
- TORCH_CHECK(f.numel() > 0, "f has zero size");
- TORCH_CHECK(x.dim() == 4, "x must be rank 4");
- TORCH_CHECK(f.dim() == 2, "f must be rank 2");
- TORCH_CHECK((x.size(0)-1)*x.stride(0) + (x.size(1)-1)*x.stride(1) + (x.size(2)-1)*x.stride(2) + (x.size(3)-1)*x.stride(3) <= INT_MAX, "x memory footprint is too large");
- TORCH_CHECK(f.size(0) >= 1 && f.size(1) >= 1, "f must be at least 1x1");
- TORCH_CHECK(upx >= 1 && upy >= 1, "upsampling factor must be at least 1");
- TORCH_CHECK(downx >= 1 && downy >= 1, "downsampling factor must be at least 1");
-
- // Create output tensor.
- const at::cuda::OptionalCUDAGuard device_guard(device_of(x));
- int outW = ((int)x.size(3) * upx + padx0 + padx1 - (int)f.size(1) + downx) / downx;
- int outH = ((int)x.size(2) * upy + pady0 + pady1 - (int)f.size(0) + downy) / downy;
- TORCH_CHECK(outW >= 1 && outH >= 1, "output must be at least 1x1");
- torch::Tensor y = torch::empty({x.size(0), x.size(1), outH, outW}, x.options(), x.suggest_memory_format());
- TORCH_CHECK(y.numel() <= INT_MAX, "output is too large");
- TORCH_CHECK((y.size(0)-1)*y.stride(0) + (y.size(1)-1)*y.stride(1) + (y.size(2)-1)*y.stride(2) + (y.size(3)-1)*y.stride(3) <= INT_MAX, "output memory footprint is too large");
-
- // Initialize CUDA kernel parameters.
- upfirdn2d_kernel_params p;
- p.x = x.data_ptr();
- p.f = f.data_ptr();
- p.y = y.data_ptr();
- p.up = make_int2(upx, upy);
- p.down = make_int2(downx, downy);
- p.pad0 = make_int2(padx0, pady0);
- p.flip = (flip) ? 1 : 0;
- p.gain = gain;
- p.inSize = make_int4((int)x.size(3), (int)x.size(2), (int)x.size(1), (int)x.size(0));
- p.inStride = make_int4((int)x.stride(3), (int)x.stride(2), (int)x.stride(1), (int)x.stride(0));
- p.filterSize = make_int2((int)f.size(1), (int)f.size(0));
- p.filterStride = make_int2((int)f.stride(1), (int)f.stride(0));
- p.outSize = make_int4((int)y.size(3), (int)y.size(2), (int)y.size(1), (int)y.size(0));
- p.outStride = make_int4((int)y.stride(3), (int)y.stride(2), (int)y.stride(1), (int)y.stride(0));
- p.sizeMajor = (p.inStride.z == 1) ? p.inSize.w : p.inSize.w * p.inSize.z;
- p.sizeMinor = (p.inStride.z == 1) ? p.inSize.z : 1;
-
- // Choose CUDA kernel.
- upfirdn2d_kernel_spec spec;
- AT_DISPATCH_FLOATING_TYPES_AND_HALF(x.scalar_type(), "upfirdn2d_cuda", [&]
- {
- spec = choose_upfirdn2d_kernel(p);
- });
-
- // Set looping options.
- p.loopMajor = (p.sizeMajor - 1) / 16384 + 1;
- p.loopMinor = spec.loopMinor;
- p.loopX = spec.loopX;
- p.launchMinor = (p.sizeMinor - 1) / p.loopMinor + 1;
- p.launchMajor = (p.sizeMajor - 1) / p.loopMajor + 1;
-
- // Compute grid size.
- dim3 blockSize, gridSize;
- if (spec.tileOutW < 0) // large
- {
- blockSize = dim3(4, 32, 1);
- gridSize = dim3(
- ((p.outSize.y - 1) / blockSize.x + 1) * p.launchMinor,
- (p.outSize.x - 1) / (blockSize.y * p.loopX) + 1,
- p.launchMajor);
- }
- else // small
- {
- blockSize = dim3(256, 1, 1);
- gridSize = dim3(
- ((p.outSize.y - 1) / spec.tileOutH + 1) * p.launchMinor,
- (p.outSize.x - 1) / (spec.tileOutW * p.loopX) + 1,
- p.launchMajor);
- }
-
- // Launch CUDA kernel.
- void* args[] = {&p};
- AT_CUDA_CHECK(cudaLaunchKernel(spec.kernel, gridSize, blockSize, args, 0, at::cuda::getCurrentCUDAStream()));
- return y;
-}
-
-//------------------------------------------------------------------------
-
-PYBIND11_MODULE(TORCH_EXTENSION_NAME, m)
-{
- m.def("upfirdn2d", &upfirdn2d);
-}
-
-//------------------------------------------------------------------------
diff --git a/spaces/h2oai/h2ogpt-chatbot2/src/gradio_utils/css.py b/spaces/h2oai/h2ogpt-chatbot2/src/gradio_utils/css.py
deleted file mode 100644
index 6f3d0dd56bfd4287034afd0b23751e3abd59a143..0000000000000000000000000000000000000000
--- a/spaces/h2oai/h2ogpt-chatbot2/src/gradio_utils/css.py
+++ /dev/null
@@ -1,148 +0,0 @@
-def get_css(kwargs) -> str:
- if kwargs['h2ocolors']:
- css_code = """footer {visibility: hidden;}
- body{background:linear-gradient(#f5f5f5,#e5e5e5);}
- body.dark{background:linear-gradient(#000000,#0d0d0d);}
- """
- else:
- css_code = """footer {visibility: hidden}"""
-
- css_code += make_css_base()
- return css_code
-
-
-def make_css_base() -> str:
- return """
- #col_container {margin-left: auto; margin-right: auto; text-align: left;}
-
- @import url('https://fonts.googleapis.com/css2?family=Source+Sans+Pro:wght@400;600&display=swap');
-
- body.dark{#warning {background-color: #555555};}
-
- #sidebar {
- order: 1;
-
- @media (max-width: 463px) {
- order: 2;
- }
- }
-
- #col-tabs {
- order: 2;
-
- @media (max-width: 463px) {
- order: 1;
- }
- }
-
- #small_btn {
- margin: 0.6em 0em 0.55em 0;
- max-width: 20em;
- min-width: 5em !important;
- height: 5em;
- font-size: 14px !important;
- }
-
- #prompt-form {
- border: 1px solid var(--primary-500) !important;
- }
-
- #prompt-form.block {
- border-radius: var(--block-radius) !important;
- }
-
- #prompt-form textarea {
- border: 1px solid rgb(209, 213, 219);
- }
-
- #prompt-form label > div {
- margin-top: 4px;
- }
-
- button.primary:hover {
- background-color: var(--primary-600) !important;
- transition: .2s;
- }
-
- #prompt-form-area {
- margin-bottom: 2.5rem;
- }
- .chatsmall chatbot {font-size: 10px !important}
-
- .gradio-container {
- max-width: none !important;
- }
-
- div.message {
- padding: var(--text-lg) !important;
- }
-
- div.message.user > div.icon-button {
- top: unset;
- bottom: 0;
- }
-
- div.message.bot > div.icon-button {
- top: unset;
- bottom: 0;
- }
-
- #prompt-form-row {
- position: relative;
- }
-
- #attach-button {
- position: absolute;
- top: 45px;
- right: 20px;
-
- display: flex;
- justify-content: center;
- border: 1px solid var(--primary-500) !important;
-
- @media (max-width: 463px) {
- width: 56px;
- }
- }
-
- #attach-button > img {
- margin-right: 0;
- }
-
- #prompt-form > label > textarea {
- padding-right: 104px;
-
- @media (max-width: 463px) {
- min-height: 94px;
- padding-right: 70px;
- }
- }
-
- #visible-models > label > div.wrap > div.wrap-inner > div.secondary-wrap > div.remove-all {
- display: none !important;
- }
-
- #visible-models > label > div.wrap > div.wrap-inner > div.token {
- display: none !important;
- }
-
- #visible-models > label > div.wrap > div.wrap-inner > div.secondary-wrap::before {
- content: "Select";
- padding: 0 4px;
- margin-right: 2px;
- }
-
- #langchain_agents > label > div.wrap > div.wrap-inner > div.secondary-wrap > div.remove-all {
- display: none !important;
- }
-
- #langchain_agents > label > div.wrap > div.wrap-inner > div.token {
- display: none !important;
- }
-
- #langchain_agents > label > div.wrap > div.wrap-inner > div.secondary-wrap::before {
- content: "Select";
- padding: 0 4px;
- margin-right: 2px;
- }
- """
diff --git a/spaces/hamacojr/CAT-Seg/cat_seg/data/dataset_mappers/mask_former_semantic_dataset_mapper.py b/spaces/hamacojr/CAT-Seg/cat_seg/data/dataset_mappers/mask_former_semantic_dataset_mapper.py
deleted file mode 100644
index 41c82f2c76cb6d74020ae0a6a3ba045469755f01..0000000000000000000000000000000000000000
--- a/spaces/hamacojr/CAT-Seg/cat_seg/data/dataset_mappers/mask_former_semantic_dataset_mapper.py
+++ /dev/null
@@ -1,186 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import copy
-import logging
-
-import numpy as np
-import torch
-from torch.nn import functional as F
-
-from detectron2.config import configurable
-from detectron2.data import MetadataCatalog
-from detectron2.data import detection_utils as utils
-from detectron2.data import transforms as T
-from detectron2.projects.point_rend import ColorAugSSDTransform
-from detectron2.structures import BitMasks, Instances
-
-__all__ = ["MaskFormerSemanticDatasetMapper"]
-
-
-class MaskFormerSemanticDatasetMapper:
- """
- A callable which takes a dataset dict in Detectron2 Dataset format,
- and map it into a format used by MaskFormer for semantic segmentation.
-
- The callable currently does the following:
-
- 1. Read the image from "file_name"
- 2. Applies geometric transforms to the image and annotation
- 3. Find and applies suitable cropping to the image and annotation
- 4. Prepare image and annotation to Tensors
- """
-
- @configurable
- def __init__(
- self,
- is_train=True,
- *,
- augmentations,
- image_format,
- ignore_label,
- size_divisibility,
- ):
- """
- NOTE: this interface is experimental.
- Args:
- is_train: for training or inference
- augmentations: a list of augmentations or deterministic transforms to apply
- image_format: an image format supported by :func:`detection_utils.read_image`.
- ignore_label: the label that is ignored to evaluation
- size_divisibility: pad image size to be divisible by this value
- """
- self.is_train = is_train
- self.tfm_gens = augmentations
- self.img_format = image_format
- self.ignore_label = ignore_label
- self.size_divisibility = size_divisibility
-
- logger = logging.getLogger(__name__)
- mode = "training" if is_train else "inference"
- logger.info(f"[{self.__class__.__name__}] Augmentations used in {mode}: {augmentations}")
-
- @classmethod
- def from_config(cls, cfg, is_train=True):
- # Build augmentation
- augs = [
- T.ResizeShortestEdge(
- cfg.INPUT.MIN_SIZE_TRAIN,
- cfg.INPUT.MAX_SIZE_TRAIN,
- cfg.INPUT.MIN_SIZE_TRAIN_SAMPLING,
- )
- ]
- if cfg.INPUT.CROP.ENABLED:
- augs.append(
- T.RandomCrop_CategoryAreaConstraint(
- cfg.INPUT.CROP.TYPE,
- cfg.INPUT.CROP.SIZE,
- cfg.INPUT.CROP.SINGLE_CATEGORY_MAX_AREA,
- cfg.MODEL.SEM_SEG_HEAD.IGNORE_VALUE,
- )
- )
- if cfg.INPUT.COLOR_AUG_SSD:
- augs.append(ColorAugSSDTransform(img_format=cfg.INPUT.FORMAT))
- augs.append(T.RandomFlip())
-
- # Assume always applies to the training set.
- dataset_names = cfg.DATASETS.TRAIN
- meta = MetadataCatalog.get(dataset_names[0])
- ignore_label = meta.ignore_label
-
- ret = {
- "is_train": is_train,
- "augmentations": augs,
- "image_format": cfg.INPUT.FORMAT,
- "ignore_label": ignore_label,
- "size_divisibility": cfg.INPUT.SIZE_DIVISIBILITY,
- }
- return ret
-
- def __call__(self, dataset_dict):
- """
- Args:
- dataset_dict (dict): Metadata of one image, in Detectron2 Dataset format.
-
- Returns:
- dict: a format that builtin models in detectron2 accept
- """
- assert self.is_train, "MaskFormerSemanticDatasetMapper should only be used for training!"
-
- dataset_dict = copy.deepcopy(dataset_dict) # it will be modified by code below
- image = utils.read_image(dataset_dict["file_name"], format=self.img_format)
- utils.check_image_size(dataset_dict, image)
-
- if "sem_seg_file_name" in dataset_dict:
- # PyTorch transformation not implemented for uint16, so converting it to double first
- sem_seg_gt = utils.read_image(dataset_dict.pop("sem_seg_file_name")).astype("double")
- else:
- sem_seg_gt = None
-
- if sem_seg_gt is None:
- raise ValueError(
- "Cannot find 'sem_seg_file_name' for semantic segmentation dataset {}.".format(
- dataset_dict["file_name"]
- )
- )
-
- aug_input = T.AugInput(image, sem_seg=sem_seg_gt)
- aug_input, transforms = T.apply_transform_gens(self.tfm_gens, aug_input)
- image = aug_input.image
- sem_seg_gt = aug_input.sem_seg
-
- # Pad image and segmentation label here!
- image = torch.as_tensor(np.ascontiguousarray(image.transpose(2, 0, 1)))
- if sem_seg_gt is not None:
- sem_seg_gt = torch.as_tensor(sem_seg_gt.astype("long"))
- # import ipdb; ipdb.set_trace()
- if self.size_divisibility > 0:
- image_size = (image.shape[-2], image.shape[-1])
- # The ori_size is not the real original size, but size before padding
- dataset_dict['ori_size'] = image_size
- padding_size = [
- 0,
- self.size_divisibility - image_size[1], # w: (left, right)
- 0,
- self.size_divisibility - image_size[0], # h: 0,(top, bottom)
- ]
- image = F.pad(image, padding_size, value=128).contiguous()
- if sem_seg_gt is not None:
- sem_seg_gt = F.pad(sem_seg_gt, padding_size, value=self.ignore_label).contiguous()
-
- image_shape = (image.shape[-2], image.shape[-1]) # h, w
-
- # Pytorch's dataloader is efficient on torch.Tensor due to shared-memory,
- # but not efficient on large generic data structures due to the use of pickle & mp.Queue.
- # Therefore it's important to use torch.Tensor.
- dataset_dict["image"] = image
- # print('#########################################################################################')
- if sem_seg_gt is not None:
- dataset_dict["sem_seg"] = sem_seg_gt.long()
-
- if "annotations" in dataset_dict:
- raise ValueError("Semantic segmentation dataset should not have 'annotations'.")
-
- # Prepare per-category binary masks
- if sem_seg_gt is not None:
- sem_seg_gt = sem_seg_gt.numpy()
- instances = Instances(image_shape)
- classes = np.unique(sem_seg_gt)
- # remove ignored region
- classes = classes[classes != self.ignore_label]
- instances.gt_classes = torch.tensor(classes, dtype=torch.int64)
-
- masks = []
- for class_id in classes:
- masks.append(sem_seg_gt == class_id)
-
- if len(masks) == 0:
- # Some image does not have annotation (all ignored)
- instances.gt_masks = torch.zeros((0, sem_seg_gt.shape[-2], sem_seg_gt.shape[-1]))
- else:
- masks = BitMasks(
- torch.stack([torch.from_numpy(np.ascontiguousarray(x.copy())) for x in masks])
- )
- instances.gt_masks = masks.tensor
-
- dataset_dict["instances"] = instances
-
- return dataset_dict
diff --git a/spaces/hamacojr/SAM-CAT-Seg/open_clip/src/training/imagenet_zeroshot_data.py b/spaces/hamacojr/SAM-CAT-Seg/open_clip/src/training/imagenet_zeroshot_data.py
deleted file mode 100644
index 27abd8bf24ebe077a73e8496576d949d8bb16f69..0000000000000000000000000000000000000000
--- a/spaces/hamacojr/SAM-CAT-Seg/open_clip/src/training/imagenet_zeroshot_data.py
+++ /dev/null
@@ -1,254 +0,0 @@
-
-
-imagenet_classnames = ["tench", "goldfish", "great white shark", "tiger shark", "hammerhead shark", "electric ray",
- "stingray", "rooster", "hen", "ostrich", "brambling", "goldfinch", "house finch", "junco",
- "indigo bunting", "American robin", "bulbul", "jay", "magpie", "chickadee", "American dipper",
- "kite (bird of prey)", "bald eagle", "vulture", "great grey owl", "fire salamander",
- "smooth newt", "newt", "spotted salamander", "axolotl", "American bullfrog", "tree frog",
- "tailed frog", "loggerhead sea turtle", "leatherback sea turtle", "mud turtle", "terrapin",
- "box turtle", "banded gecko", "green iguana", "Carolina anole",
- "desert grassland whiptail lizard", "agama", "frilled-necked lizard", "alligator lizard",
- "Gila monster", "European green lizard", "chameleon", "Komodo dragon", "Nile crocodile",
- "American alligator", "triceratops", "worm snake", "ring-necked snake",
- "eastern hog-nosed snake", "smooth green snake", "kingsnake", "garter snake", "water snake",
- "vine snake", "night snake", "boa constrictor", "African rock python", "Indian cobra",
- "green mamba", "sea snake", "Saharan horned viper", "eastern diamondback rattlesnake",
- "sidewinder rattlesnake", "trilobite", "harvestman", "scorpion", "yellow garden spider",
- "barn spider", "European garden spider", "southern black widow", "tarantula", "wolf spider",
- "tick", "centipede", "black grouse", "ptarmigan", "ruffed grouse", "prairie grouse", "peafowl",
- "quail", "partridge", "african grey parrot", "macaw", "sulphur-crested cockatoo", "lorikeet",
- "coucal", "bee eater", "hornbill", "hummingbird", "jacamar", "toucan", "duck",
- "red-breasted merganser", "goose", "black swan", "tusker", "echidna", "platypus", "wallaby",
- "koala", "wombat", "jellyfish", "sea anemone", "brain coral", "flatworm", "nematode", "conch",
- "snail", "slug", "sea slug", "chiton", "chambered nautilus", "Dungeness crab", "rock crab",
- "fiddler crab", "red king crab", "American lobster", "spiny lobster", "crayfish", "hermit crab",
- "isopod", "white stork", "black stork", "spoonbill", "flamingo", "little blue heron",
- "great egret", "bittern bird", "crane bird", "limpkin", "common gallinule", "American coot",
- "bustard", "ruddy turnstone", "dunlin", "common redshank", "dowitcher", "oystercatcher",
- "pelican", "king penguin", "albatross", "grey whale", "killer whale", "dugong", "sea lion",
- "Chihuahua", "Japanese Chin", "Maltese", "Pekingese", "Shih Tzu", "King Charles Spaniel",
- "Papillon", "toy terrier", "Rhodesian Ridgeback", "Afghan Hound", "Basset Hound", "Beagle",
- "Bloodhound", "Bluetick Coonhound", "Black and Tan Coonhound", "Treeing Walker Coonhound",
- "English foxhound", "Redbone Coonhound", "borzoi", "Irish Wolfhound", "Italian Greyhound",
- "Whippet", "Ibizan Hound", "Norwegian Elkhound", "Otterhound", "Saluki", "Scottish Deerhound",
- "Weimaraner", "Staffordshire Bull Terrier", "American Staffordshire Terrier",
- "Bedlington Terrier", "Border Terrier", "Kerry Blue Terrier", "Irish Terrier",
- "Norfolk Terrier", "Norwich Terrier", "Yorkshire Terrier", "Wire Fox Terrier",
- "Lakeland Terrier", "Sealyham Terrier", "Airedale Terrier", "Cairn Terrier",
- "Australian Terrier", "Dandie Dinmont Terrier", "Boston Terrier", "Miniature Schnauzer",
- "Giant Schnauzer", "Standard Schnauzer", "Scottish Terrier", "Tibetan Terrier",
- "Australian Silky Terrier", "Soft-coated Wheaten Terrier", "West Highland White Terrier",
- "Lhasa Apso", "Flat-Coated Retriever", "Curly-coated Retriever", "Golden Retriever",
- "Labrador Retriever", "Chesapeake Bay Retriever", "German Shorthaired Pointer", "Vizsla",
- "English Setter", "Irish Setter", "Gordon Setter", "Brittany dog", "Clumber Spaniel",
- "English Springer Spaniel", "Welsh Springer Spaniel", "Cocker Spaniel", "Sussex Spaniel",
- "Irish Water Spaniel", "Kuvasz", "Schipperke", "Groenendael dog", "Malinois", "Briard",
- "Australian Kelpie", "Komondor", "Old English Sheepdog", "Shetland Sheepdog", "collie",
- "Border Collie", "Bouvier des Flandres dog", "Rottweiler", "German Shepherd Dog", "Dobermann",
- "Miniature Pinscher", "Greater Swiss Mountain Dog", "Bernese Mountain Dog",
- "Appenzeller Sennenhund", "Entlebucher Sennenhund", "Boxer", "Bullmastiff", "Tibetan Mastiff",
- "French Bulldog", "Great Dane", "St. Bernard", "husky", "Alaskan Malamute", "Siberian Husky",
- "Dalmatian", "Affenpinscher", "Basenji", "pug", "Leonberger", "Newfoundland dog",
- "Great Pyrenees dog", "Samoyed", "Pomeranian", "Chow Chow", "Keeshond", "brussels griffon",
- "Pembroke Welsh Corgi", "Cardigan Welsh Corgi", "Toy Poodle", "Miniature Poodle",
- "Standard Poodle", "Mexican hairless dog (xoloitzcuintli)", "grey wolf", "Alaskan tundra wolf",
- "red wolf or maned wolf", "coyote", "dingo", "dhole", "African wild dog", "hyena", "red fox",
- "kit fox", "Arctic fox", "grey fox", "tabby cat", "tiger cat", "Persian cat", "Siamese cat",
- "Egyptian Mau", "cougar", "lynx", "leopard", "snow leopard", "jaguar", "lion", "tiger",
- "cheetah", "brown bear", "American black bear", "polar bear", "sloth bear", "mongoose",
- "meerkat", "tiger beetle", "ladybug", "ground beetle", "longhorn beetle", "leaf beetle",
- "dung beetle", "rhinoceros beetle", "weevil", "fly", "bee", "ant", "grasshopper",
- "cricket insect", "stick insect", "cockroach", "praying mantis", "cicada", "leafhopper",
- "lacewing", "dragonfly", "damselfly", "red admiral butterfly", "ringlet butterfly",
- "monarch butterfly", "small white butterfly", "sulphur butterfly", "gossamer-winged butterfly",
- "starfish", "sea urchin", "sea cucumber", "cottontail rabbit", "hare", "Angora rabbit",
- "hamster", "porcupine", "fox squirrel", "marmot", "beaver", "guinea pig", "common sorrel horse",
- "zebra", "pig", "wild boar", "warthog", "hippopotamus", "ox", "water buffalo", "bison",
- "ram (adult male sheep)", "bighorn sheep", "Alpine ibex", "hartebeest", "impala (antelope)",
- "gazelle", "arabian camel", "llama", "weasel", "mink", "European polecat",
- "black-footed ferret", "otter", "skunk", "badger", "armadillo", "three-toed sloth", "orangutan",
- "gorilla", "chimpanzee", "gibbon", "siamang", "guenon", "patas monkey", "baboon", "macaque",
- "langur", "black-and-white colobus", "proboscis monkey", "marmoset", "white-headed capuchin",
- "howler monkey", "titi monkey", "Geoffroy's spider monkey", "common squirrel monkey",
- "ring-tailed lemur", "indri", "Asian elephant", "African bush elephant", "red panda",
- "giant panda", "snoek fish", "eel", "silver salmon", "rock beauty fish", "clownfish",
- "sturgeon", "gar fish", "lionfish", "pufferfish", "abacus", "abaya", "academic gown",
- "accordion", "acoustic guitar", "aircraft carrier", "airliner", "airship", "altar", "ambulance",
- "amphibious vehicle", "analog clock", "apiary", "apron", "trash can", "assault rifle",
- "backpack", "bakery", "balance beam", "balloon", "ballpoint pen", "Band-Aid", "banjo",
- "baluster / handrail", "barbell", "barber chair", "barbershop", "barn", "barometer", "barrel",
- "wheelbarrow", "baseball", "basketball", "bassinet", "bassoon", "swimming cap", "bath towel",
- "bathtub", "station wagon", "lighthouse", "beaker", "military hat (bearskin or shako)",
- "beer bottle", "beer glass", "bell tower", "baby bib", "tandem bicycle", "bikini",
- "ring binder", "binoculars", "birdhouse", "boathouse", "bobsleigh", "bolo tie", "poke bonnet",
- "bookcase", "bookstore", "bottle cap", "hunting bow", "bow tie", "brass memorial plaque", "bra",
- "breakwater", "breastplate", "broom", "bucket", "buckle", "bulletproof vest",
- "high-speed train", "butcher shop", "taxicab", "cauldron", "candle", "cannon", "canoe",
- "can opener", "cardigan", "car mirror", "carousel", "tool kit", "cardboard box / carton",
- "car wheel", "automated teller machine", "cassette", "cassette player", "castle", "catamaran",
- "CD player", "cello", "mobile phone", "chain", "chain-link fence", "chain mail", "chainsaw",
- "storage chest", "chiffonier", "bell or wind chime", "china cabinet", "Christmas stocking",
- "church", "movie theater", "cleaver", "cliff dwelling", "cloak", "clogs", "cocktail shaker",
- "coffee mug", "coffeemaker", "spiral or coil", "combination lock", "computer keyboard",
- "candy store", "container ship", "convertible", "corkscrew", "cornet", "cowboy boot",
- "cowboy hat", "cradle", "construction crane", "crash helmet", "crate", "infant bed",
- "Crock Pot", "croquet ball", "crutch", "cuirass", "dam", "desk", "desktop computer",
- "rotary dial telephone", "diaper", "digital clock", "digital watch", "dining table",
- "dishcloth", "dishwasher", "disc brake", "dock", "dog sled", "dome", "doormat", "drilling rig",
- "drum", "drumstick", "dumbbell", "Dutch oven", "electric fan", "electric guitar",
- "electric locomotive", "entertainment center", "envelope", "espresso machine", "face powder",
- "feather boa", "filing cabinet", "fireboat", "fire truck", "fire screen", "flagpole", "flute",
- "folding chair", "football helmet", "forklift", "fountain", "fountain pen", "four-poster bed",
- "freight car", "French horn", "frying pan", "fur coat", "garbage truck",
- "gas mask or respirator", "gas pump", "goblet", "go-kart", "golf ball", "golf cart", "gondola",
- "gong", "gown", "grand piano", "greenhouse", "radiator grille", "grocery store", "guillotine",
- "hair clip", "hair spray", "half-track", "hammer", "hamper", "hair dryer", "hand-held computer",
- "handkerchief", "hard disk drive", "harmonica", "harp", "combine harvester", "hatchet",
- "holster", "home theater", "honeycomb", "hook", "hoop skirt", "gymnastic horizontal bar",
- "horse-drawn vehicle", "hourglass", "iPod", "clothes iron", "carved pumpkin", "jeans", "jeep",
- "T-shirt", "jigsaw puzzle", "rickshaw", "joystick", "kimono", "knee pad", "knot", "lab coat",
- "ladle", "lampshade", "laptop computer", "lawn mower", "lens cap", "letter opener", "library",
- "lifeboat", "lighter", "limousine", "ocean liner", "lipstick", "slip-on shoe", "lotion",
- "music speaker", "loupe magnifying glass", "sawmill", "magnetic compass", "messenger bag",
- "mailbox", "tights", "one-piece bathing suit", "manhole cover", "maraca", "marimba", "mask",
- "matchstick", "maypole", "maze", "measuring cup", "medicine cabinet", "megalith", "microphone",
- "microwave oven", "military uniform", "milk can", "minibus", "miniskirt", "minivan", "missile",
- "mitten", "mixing bowl", "mobile home", "ford model t", "modem", "monastery", "monitor",
- "moped", "mortar and pestle", "graduation cap", "mosque", "mosquito net", "vespa",
- "mountain bike", "tent", "computer mouse", "mousetrap", "moving van", "muzzle", "metal nail",
- "neck brace", "necklace", "baby pacifier", "notebook computer", "obelisk", "oboe", "ocarina",
- "odometer", "oil filter", "pipe organ", "oscilloscope", "overskirt", "bullock cart",
- "oxygen mask", "product packet / packaging", "paddle", "paddle wheel", "padlock", "paintbrush",
- "pajamas", "palace", "pan flute", "paper towel", "parachute", "parallel bars", "park bench",
- "parking meter", "railroad car", "patio", "payphone", "pedestal", "pencil case",
- "pencil sharpener", "perfume", "Petri dish", "photocopier", "plectrum", "Pickelhaube",
- "picket fence", "pickup truck", "pier", "piggy bank", "pill bottle", "pillow", "ping-pong ball",
- "pinwheel", "pirate ship", "drink pitcher", "block plane", "planetarium", "plastic bag",
- "plate rack", "farm plow", "plunger", "Polaroid camera", "pole", "police van", "poncho",
- "pool table", "soda bottle", "plant pot", "potter's wheel", "power drill", "prayer rug",
- "printer", "prison", "missile", "projector", "hockey puck", "punching bag", "purse", "quill",
- "quilt", "race car", "racket", "radiator", "radio", "radio telescope", "rain barrel",
- "recreational vehicle", "fishing casting reel", "reflex camera", "refrigerator",
- "remote control", "restaurant", "revolver", "rifle", "rocking chair", "rotisserie", "eraser",
- "rugby ball", "ruler measuring stick", "sneaker", "safe", "safety pin", "salt shaker", "sandal",
- "sarong", "saxophone", "scabbard", "weighing scale", "school bus", "schooner", "scoreboard",
- "CRT monitor", "screw", "screwdriver", "seat belt", "sewing machine", "shield", "shoe store",
- "shoji screen / room divider", "shopping basket", "shopping cart", "shovel", "shower cap",
- "shower curtain", "ski", "balaclava ski mask", "sleeping bag", "slide rule", "sliding door",
- "slot machine", "snorkel", "snowmobile", "snowplow", "soap dispenser", "soccer ball", "sock",
- "solar thermal collector", "sombrero", "soup bowl", "keyboard space bar", "space heater",
- "space shuttle", "spatula", "motorboat", "spider web", "spindle", "sports car", "spotlight",
- "stage", "steam locomotive", "through arch bridge", "steel drum", "stethoscope", "scarf",
- "stone wall", "stopwatch", "stove", "strainer", "tram", "stretcher", "couch", "stupa",
- "submarine", "suit", "sundial", "sunglasses", "sunglasses", "sunscreen", "suspension bridge",
- "mop", "sweatshirt", "swim trunks / shorts", "swing", "electrical switch", "syringe",
- "table lamp", "tank", "tape player", "teapot", "teddy bear", "television", "tennis ball",
- "thatched roof", "front curtain", "thimble", "threshing machine", "throne", "tile roof",
- "toaster", "tobacco shop", "toilet seat", "torch", "totem pole", "tow truck", "toy store",
- "tractor", "semi-trailer truck", "tray", "trench coat", "tricycle", "trimaran", "tripod",
- "triumphal arch", "trolleybus", "trombone", "hot tub", "turnstile", "typewriter keyboard",
- "umbrella", "unicycle", "upright piano", "vacuum cleaner", "vase", "vaulted or arched ceiling",
- "velvet fabric", "vending machine", "vestment", "viaduct", "violin", "volleyball",
- "waffle iron", "wall clock", "wallet", "wardrobe", "military aircraft", "sink",
- "washing machine", "water bottle", "water jug", "water tower", "whiskey jug", "whistle",
- "hair wig", "window screen", "window shade", "Windsor tie", "wine bottle", "airplane wing",
- "wok", "wooden spoon", "wool", "split-rail fence", "shipwreck", "sailboat", "yurt", "website",
- "comic book", "crossword", "traffic or street sign", "traffic light", "dust jacket", "menu",
- "plate", "guacamole", "consomme", "hot pot", "trifle", "ice cream", "popsicle", "baguette",
- "bagel", "pretzel", "cheeseburger", "hot dog", "mashed potatoes", "cabbage", "broccoli",
- "cauliflower", "zucchini", "spaghetti squash", "acorn squash", "butternut squash", "cucumber",
- "artichoke", "bell pepper", "cardoon", "mushroom", "Granny Smith apple", "strawberry", "orange",
- "lemon", "fig", "pineapple", "banana", "jackfruit", "cherimoya (custard apple)", "pomegranate",
- "hay", "carbonara", "chocolate syrup", "dough", "meatloaf", "pizza", "pot pie", "burrito",
- "red wine", "espresso", "tea cup", "eggnog", "mountain", "bubble", "cliff", "coral reef",
- "geyser", "lakeshore", "promontory", "sandbar", "beach", "valley", "volcano", "baseball player",
- "bridegroom", "scuba diver", "rapeseed", "daisy", "yellow lady's slipper", "corn", "acorn",
- "rose hip", "horse chestnut seed", "coral fungus", "agaric", "gyromitra", "stinkhorn mushroom",
- "earth star fungus", "hen of the woods mushroom", "bolete", "corn cob", "toilet paper"]
-
-
-
-
-
-openai_imagenet_template = [
- lambda c: f'a bad photo of a {c}.',
- lambda c: f'a photo of many {c}.',
- lambda c: f'a sculpture of a {c}.',
- lambda c: f'a photo of the hard to see {c}.',
- lambda c: f'a low resolution photo of the {c}.',
- lambda c: f'a rendering of a {c}.',
- lambda c: f'graffiti of a {c}.',
- lambda c: f'a bad photo of the {c}.',
- lambda c: f'a cropped photo of the {c}.',
- lambda c: f'a tattoo of a {c}.',
- lambda c: f'the embroidered {c}.',
- lambda c: f'a photo of a hard to see {c}.',
- lambda c: f'a bright photo of a {c}.',
- lambda c: f'a photo of a clean {c}.',
- lambda c: f'a photo of a dirty {c}.',
- lambda c: f'a dark photo of the {c}.',
- lambda c: f'a drawing of a {c}.',
- lambda c: f'a photo of my {c}.',
- lambda c: f'the plastic {c}.',
- lambda c: f'a photo of the cool {c}.',
- lambda c: f'a close-up photo of a {c}.',
- lambda c: f'a black and white photo of the {c}.',
- lambda c: f'a painting of the {c}.',
- lambda c: f'a painting of a {c}.',
- lambda c: f'a pixelated photo of the {c}.',
- lambda c: f'a sculpture of the {c}.',
- lambda c: f'a bright photo of the {c}.',
- lambda c: f'a cropped photo of a {c}.',
- lambda c: f'a plastic {c}.',
- lambda c: f'a photo of the dirty {c}.',
- lambda c: f'a jpeg corrupted photo of a {c}.',
- lambda c: f'a blurry photo of the {c}.',
- lambda c: f'a photo of the {c}.',
- lambda c: f'a good photo of the {c}.',
- lambda c: f'a rendering of the {c}.',
- lambda c: f'a {c} in a video game.',
- lambda c: f'a photo of one {c}.',
- lambda c: f'a doodle of a {c}.',
- lambda c: f'a close-up photo of the {c}.',
- lambda c: f'a photo of a {c}.',
- lambda c: f'the origami {c}.',
- lambda c: f'the {c} in a video game.',
- lambda c: f'a sketch of a {c}.',
- lambda c: f'a doodle of the {c}.',
- lambda c: f'a origami {c}.',
- lambda c: f'a low resolution photo of a {c}.',
- lambda c: f'the toy {c}.',
- lambda c: f'a rendition of the {c}.',
- lambda c: f'a photo of the clean {c}.',
- lambda c: f'a photo of a large {c}.',
- lambda c: f'a rendition of a {c}.',
- lambda c: f'a photo of a nice {c}.',
- lambda c: f'a photo of a weird {c}.',
- lambda c: f'a blurry photo of a {c}.',
- lambda c: f'a cartoon {c}.',
- lambda c: f'art of a {c}.',
- lambda c: f'a sketch of the {c}.',
- lambda c: f'a embroidered {c}.',
- lambda c: f'a pixelated photo of a {c}.',
- lambda c: f'itap of the {c}.',
- lambda c: f'a jpeg corrupted photo of the {c}.',
- lambda c: f'a good photo of a {c}.',
- lambda c: f'a plushie {c}.',
- lambda c: f'a photo of the nice {c}.',
- lambda c: f'a photo of the small {c}.',
- lambda c: f'a photo of the weird {c}.',
- lambda c: f'the cartoon {c}.',
- lambda c: f'art of the {c}.',
- lambda c: f'a drawing of the {c}.',
- lambda c: f'a photo of the large {c}.',
- lambda c: f'a black and white photo of a {c}.',
- lambda c: f'the plushie {c}.',
- lambda c: f'a dark photo of a {c}.',
- lambda c: f'itap of a {c}.',
- lambda c: f'graffiti of the {c}.',
- lambda c: f'a toy {c}.',
- lambda c: f'itap of my {c}.',
- lambda c: f'a photo of a cool {c}.',
- lambda c: f'a photo of a small {c}.',
- lambda c: f'a tattoo of the {c}.',
-]
diff --git a/spaces/hamelcubsfan/AutoGPT/BULLETIN.md b/spaces/hamelcubsfan/AutoGPT/BULLETIN.md
deleted file mode 100644
index 735048ddc87a914987c6bd70ccdb231a80242ae3..0000000000000000000000000000000000000000
--- a/spaces/hamelcubsfan/AutoGPT/BULLETIN.md
+++ /dev/null
@@ -1,2 +0,0 @@
-Welcome to Auto-GPT! We'll keep you informed of the latest news and features by printing messages here.
-If you don't wish to see this message, you can run Auto-GPT with the --skip-news flag
\ No newline at end of file
diff --git a/spaces/hamelcubsfan/AutoGPT/autogpt/workspace.py b/spaces/hamelcubsfan/AutoGPT/autogpt/workspace.py
deleted file mode 100644
index 6fb0e3113eb2c1338edf7f86c6e162fc27c61e50..0000000000000000000000000000000000000000
--- a/spaces/hamelcubsfan/AutoGPT/autogpt/workspace.py
+++ /dev/null
@@ -1,47 +0,0 @@
-from __future__ import annotations
-
-import os
-from pathlib import Path
-
-from autogpt.config import Config
-
-CFG = Config()
-
-# Set a dedicated folder for file I/O
-WORKSPACE_PATH = Path(os.getcwd()) / "auto_gpt_workspace"
-
-# Create the directory if it doesn't exist
-if not os.path.exists(WORKSPACE_PATH):
- os.makedirs(WORKSPACE_PATH)
-
-
-def path_in_workspace(relative_path: str | Path) -> Path:
- """Get full path for item in workspace
-
- Parameters:
- relative_path (str | Path): Path to translate into the workspace
-
- Returns:
- Path: Absolute path for the given path in the workspace
- """
- return safe_path_join(WORKSPACE_PATH, relative_path)
-
-
-def safe_path_join(base: Path, *paths: str | Path) -> Path:
- """Join one or more path components, asserting the resulting path is within the workspace.
-
- Args:
- base (Path): The base path
- *paths (str): The paths to join to the base path
-
- Returns:
- Path: The joined path
- """
- joined_path = base.joinpath(*paths).resolve()
-
- if CFG.restrict_to_workspace and not joined_path.is_relative_to(base):
- raise ValueError(
- f"Attempted to access path '{joined_path}' outside of workspace '{base}'."
- )
-
- return joined_path
diff --git a/spaces/haotiz/glip-zeroshot-demo/maskrcnn_benchmark/layers/dyhead.py b/spaces/haotiz/glip-zeroshot-demo/maskrcnn_benchmark/layers/dyhead.py
deleted file mode 100644
index baf5b37212e590ab453576278cc6c124dce91e90..0000000000000000000000000000000000000000
--- a/spaces/haotiz/glip-zeroshot-demo/maskrcnn_benchmark/layers/dyhead.py
+++ /dev/null
@@ -1,151 +0,0 @@
-import torch
-import torch.nn.functional as F
-from torch import nn
-
-from .deform_conv import ModulatedDeformConv
-from .dyrelu import h_sigmoid, DYReLU
-
-
-class Conv3x3Norm(torch.nn.Module):
- def __init__(self,
- in_channels,
- out_channels,
- stride,
- deformable=False,
- use_gn=False):
- super(Conv3x3Norm, self).__init__()
-
- if deformable:
- self.conv = ModulatedDeformConv(in_channels, out_channels, kernel_size=3, stride=stride, padding=1)
- else:
- self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1)
-
- if use_gn:
- self.bn = nn.GroupNorm(num_groups=16, num_channels=out_channels)
- else:
- self.bn = None
-
- def forward(self, input, **kwargs):
- x = self.conv(input, **kwargs)
- if self.bn:
- x = self.bn(x)
- return x
-
-
-class DyConv(nn.Module):
- def __init__(self,
- in_channels=256,
- out_channels=256,
- conv_func=Conv3x3Norm,
- use_dyfuse=True,
- use_dyrelu=False,
- use_deform=False
- ):
- super(DyConv, self).__init__()
-
- self.DyConv = nn.ModuleList()
- self.DyConv.append(conv_func(in_channels, out_channels, 1))
- self.DyConv.append(conv_func(in_channels, out_channels, 1))
- self.DyConv.append(conv_func(in_channels, out_channels, 2))
-
- if use_dyfuse:
- self.AttnConv = nn.Sequential(
- nn.AdaptiveAvgPool2d(1),
- nn.Conv2d(in_channels, 1, kernel_size=1),
- nn.ReLU(inplace=True))
- self.h_sigmoid = h_sigmoid()
- else:
- self.AttnConv = None
-
- if use_dyrelu:
- self.relu = DYReLU(in_channels, out_channels)
- else:
- self.relu = nn.ReLU()
-
- if use_deform:
- self.offset = nn.Conv2d(in_channels, 27, kernel_size=3, stride=1, padding=1)
- else:
- self.offset = None
-
- self.init_weights()
-
- def init_weights(self):
- for m in self.DyConv.modules():
- if isinstance(m, nn.Conv2d):
- nn.init.normal_(m.weight.data, 0, 0.01)
- if m.bias is not None:
- m.bias.data.zero_()
- if self.AttnConv is not None:
- for m in self.AttnConv.modules():
- if isinstance(m, nn.Conv2d):
- nn.init.normal_(m.weight.data, 0, 0.01)
- if m.bias is not None:
- m.bias.data.zero_()
-
- def forward(self, x):
- next_x = []
- for level, feature in enumerate(x):
-
- conv_args = dict()
- if self.offset is not None:
- offset_mask = self.offset(feature)
- offset = offset_mask[:, :18, :, :]
- mask = offset_mask[:, 18:, :, :].sigmoid()
- conv_args = dict(offset=offset, mask=mask)
-
- temp_fea = [self.DyConv[1](feature, **conv_args)]
-
- if level > 0:
- temp_fea.append(self.DyConv[2](x[level - 1], **conv_args))
- if level < len(x) - 1:
- temp_fea.append(F.upsample_bilinear(self.DyConv[0](x[level + 1], **conv_args),
- size=[feature.size(2), feature.size(3)]))
- mean_fea = torch.mean(torch.stack(temp_fea), dim=0, keepdim=False)
-
- if self.AttnConv is not None:
- attn_fea = []
- res_fea = []
- for fea in temp_fea:
- res_fea.append(fea)
- attn_fea.append(self.AttnConv(fea))
-
- res_fea = torch.stack(res_fea)
- spa_pyr_attn = self.h_sigmoid(torch.stack(attn_fea))
-
- mean_fea = torch.mean(res_fea * spa_pyr_attn, dim=0, keepdim=False)
-
- next_x.append(self.relu(mean_fea))
-
- return next_x
-
-
-class DyHead(nn.Module):
- def __init__(self, cfg, in_channels):
- super(DyHead, self).__init__()
- self.cfg = cfg
- channels = cfg.MODEL.DYHEAD.CHANNELS
- use_gn = cfg.MODEL.DYHEAD.USE_GN
- use_dyrelu = cfg.MODEL.DYHEAD.USE_DYRELU
- use_dyfuse = cfg.MODEL.DYHEAD.USE_DYFUSE
- use_deform = cfg.MODEL.DYHEAD.USE_DFCONV
-
- conv_func = lambda i,o,s : Conv3x3Norm(i,o,s,deformable=use_deform,use_gn=use_gn)
-
- dyhead_tower = []
- for i in range(cfg.MODEL.DYHEAD.NUM_CONVS):
- dyhead_tower.append(
- DyConv(
- in_channels if i == 0 else channels,
- channels,
- conv_func=conv_func,
- use_dyrelu=use_dyrelu,
- use_dyfuse=use_dyfuse,
- use_deform=use_deform
- )
- )
-
- self.add_module('dyhead_tower', nn.Sequential(*dyhead_tower))
-
- def forward(self, x):
- dyhead_tower = self.dyhead_tower(x)
- return dyhead_tower
\ No newline at end of file
diff --git a/spaces/haotiz/glip-zeroshot-demo/maskrcnn_benchmark/layers/dyrelu.py b/spaces/haotiz/glip-zeroshot-demo/maskrcnn_benchmark/layers/dyrelu.py
deleted file mode 100644
index 3170a9efedfa05988242e04d2c204992a2dcd3f8..0000000000000000000000000000000000000000
--- a/spaces/haotiz/glip-zeroshot-demo/maskrcnn_benchmark/layers/dyrelu.py
+++ /dev/null
@@ -1,120 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-def _make_divisible(v, divisor, min_value=None):
- if min_value is None:
- min_value = divisor
- new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)
- # Make sure that round down does not go down by more than 10%.
- if new_v < 0.9 * v:
- new_v += divisor
- return new_v
-
-
-class swish(nn.Module):
- def forward(self, x):
- return x * torch.sigmoid(x)
-
-
-class h_swish(nn.Module):
- def __init__(self, inplace=False):
- super(h_swish, self).__init__()
- self.inplace = inplace
-
- def forward(self, x):
- return x * F.relu6(x + 3.0, inplace=self.inplace) / 6.0
-
-
-class h_sigmoid(nn.Module):
- def __init__(self, inplace=True, h_max=1):
- super(h_sigmoid, self).__init__()
- self.relu = nn.ReLU6(inplace=inplace)
- self.h_max = h_max
-
- def forward(self, x):
- return self.relu(x + 3) * self.h_max / 6
-
-
-class DYReLU(nn.Module):
- def __init__(self, inp, oup, reduction=4, lambda_a=1.0, K2=True, use_bias=True, use_spatial=False,
- init_a=[1.0, 0.0], init_b=[0.0, 0.0]):
- super(DYReLU, self).__init__()
- self.oup = oup
- self.lambda_a = lambda_a * 2
- self.K2 = K2
- self.avg_pool = nn.AdaptiveAvgPool2d(1)
-
- self.use_bias = use_bias
- if K2:
- self.exp = 4 if use_bias else 2
- else:
- self.exp = 2 if use_bias else 1
- self.init_a = init_a
- self.init_b = init_b
-
- # determine squeeze
- if reduction == 4:
- squeeze = inp // reduction
- else:
- squeeze = _make_divisible(inp // reduction, 4)
- # print('reduction: {}, squeeze: {}/{}'.format(reduction, inp, squeeze))
- # print('init_a: {}, init_b: {}'.format(self.init_a, self.init_b))
-
- self.fc = nn.Sequential(
- nn.Linear(inp, squeeze),
- nn.ReLU(inplace=True),
- nn.Linear(squeeze, oup * self.exp),
- h_sigmoid()
- )
- if use_spatial:
- self.spa = nn.Sequential(
- nn.Conv2d(inp, 1, kernel_size=1),
- nn.BatchNorm2d(1),
- )
- else:
- self.spa = None
-
- def forward(self, x):
- if isinstance(x, list):
- x_in = x[0]
- x_out = x[1]
- else:
- x_in = x
- x_out = x
- b, c, h, w = x_in.size()
- y = self.avg_pool(x_in).view(b, c)
- y = self.fc(y).view(b, self.oup * self.exp, 1, 1)
- if self.exp == 4:
- a1, b1, a2, b2 = torch.split(y, self.oup, dim=1)
- a1 = (a1 - 0.5) * self.lambda_a + self.init_a[0] # 1.0
- a2 = (a2 - 0.5) * self.lambda_a + self.init_a[1]
-
- b1 = b1 - 0.5 + self.init_b[0]
- b2 = b2 - 0.5 + self.init_b[1]
- out = torch.max(x_out * a1 + b1, x_out * a2 + b2)
- elif self.exp == 2:
- if self.use_bias: # bias but not PL
- a1, b1 = torch.split(y, self.oup, dim=1)
- a1 = (a1 - 0.5) * self.lambda_a + self.init_a[0] # 1.0
- b1 = b1 - 0.5 + self.init_b[0]
- out = x_out * a1 + b1
-
- else:
- a1, a2 = torch.split(y, self.oup, dim=1)
- a1 = (a1 - 0.5) * self.lambda_a + self.init_a[0] # 1.0
- a2 = (a2 - 0.5) * self.lambda_a + self.init_a[1]
- out = torch.max(x_out * a1, x_out * a2)
-
- elif self.exp == 1:
- a1 = y
- a1 = (a1 - 0.5) * self.lambda_a + self.init_a[0] # 1.0
- out = x_out * a1
-
- if self.spa:
- ys = self.spa(x_in).view(b, -1)
- ys = F.softmax(ys, dim=1).view(b, 1, h, w) * h * w
- ys = F.hardtanh(ys, 0, 3, inplace=True)/3
- out = out * ys
-
- return out
diff --git a/spaces/hasibzunair/fifa-tryon-demo/Self-Correction-Human-Parsing-for-ACGPN/mhp_extension/detectron2/projects/DensePose/densepose/data/datasets/__init__.py b/spaces/hasibzunair/fifa-tryon-demo/Self-Correction-Human-Parsing-for-ACGPN/mhp_extension/detectron2/projects/DensePose/densepose/data/datasets/__init__.py
deleted file mode 100644
index 4a59d9332034e9dc3a09f0ba7aa63f0c61b25e87..0000000000000000000000000000000000000000
--- a/spaces/hasibzunair/fifa-tryon-demo/Self-Correction-Human-Parsing-for-ACGPN/mhp_extension/detectron2/projects/DensePose/densepose/data/datasets/__init__.py
+++ /dev/null
@@ -1,5 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-
-from . import builtin # ensure the builtin data are registered
-
-__all__ = [k for k in globals().keys() if "builtin" not in k and not k.startswith("_")]
diff --git a/spaces/hi9/core4testing/app.py b/spaces/hi9/core4testing/app.py
deleted file mode 100644
index f5c645d2d353f5bba858e9e88cc7624b0213e72b..0000000000000000000000000000000000000000
--- a/spaces/hi9/core4testing/app.py
+++ /dev/null
@@ -1,72 +0,0 @@
-import gradio as gr
-
-import tensorflow as tf
-import numpy as np
-import pickle
-
-# Load model, including its weights and the optimizer
-model = tf.keras.models.load_model('core4.h5')
-
-# load tokenizer
-with open('tokenizer.pickle', 'rb') as handle:
- tokenize = pickle.load(handle)
-
-text_labels = ['How to apply', 'how much can I get', 'who can apply']
-
-# model.summary() # model architecture
-
-def greet(string):
-
- tokenizedText = tokenize.texts_to_matrix([string])
- prediction = model.predict(np.array([tokenizedText[0]]))
- predicted_label = text_labels[np.argmax(prediction)]
-
- print(prediction[0][np.argmax(prediction)])
- print("Predicted label: " + predicted_label + "\n")
-
- ###################
- import requests as rs
- import pandas as pd
-
- spreadsheet_id = '1vjWnYsnGc0J6snT67NVbA-NWSGZ5b0eDBVHmg9lbf9s' # Please set the Spreadsheet ID.
- csv_url='https://docs.google.com/spreadsheets/d/' + spreadsheet_id + '/export?format=csv&id=' + spreadsheet_id + '&gid=0'
-
- res=rs.get(url=csv_url)
- open('google.csv', 'wb').write(res.content)
- df = pd.read_csv('google.csv')
-
- import json
- import requests
-
- spreadsheet_id = '1vjWnYsnGc0J6snT67NVbA-NWSGZ5b0eDBVHmg9lbf9s' # Please set the Spreadsheet ID.
- url = 'https://script.google.com/macros/s/AKfycbwXP5fsDgOXJ9biZQC293o6bTBL3kDOJ07PlmxKjabzdTej6WYdC8Yos6NpDVqAJeVM/exec?spreadsheetId=' + spreadsheet_id
- body = {
- "arguments": {"range": "Sheet1!A"+str(len(df)+2), "valueInputOption": "USER_ENTERED"},
- "body": {"values": [[string]]}
- }
- res = requests.post(url, json.dumps(body), headers={'Content-Type': 'application/json'})
-
- body = {
- "arguments": {"range": "Sheet1!B"+str(len(df)+2), "valueInputOption": "USER_ENTERED"},
- "body": {"values": [[predicted_label]]}
- }
- res = requests.post(url, json.dumps(body), headers={'Content-Type': 'application/json'})
-
- import datetime
- current_time = datetime.datetime.now()
- body = {
- "arguments": {"range": "Sheet1!D"+str(len(df)+2), "valueInputOption": "USER_ENTERED"},
- "body": {"values": [[str(current_time)]]}
- }
- res = requests.post(url, json.dumps(body), headers={'Content-Type': 'application/json'})
- #print(res.text)
- #######################
-
- return predicted_label
-
-
-#One testing case
-
-
-iface = gr.Interface(fn=greet, inputs="text", outputs="text")
-iface.launch()
\ No newline at end of file
diff --git a/spaces/hieupt/image_style_transfer/model.py b/spaces/hieupt/image_style_transfer/model.py
deleted file mode 100644
index 72159437d5296406c9c040b5474180d31aba2c8a..0000000000000000000000000000000000000000
--- a/spaces/hieupt/image_style_transfer/model.py
+++ /dev/null
@@ -1,78 +0,0 @@
-import torch
-from torch import nn
-
-class Residual_block(nn.Module):
- """Residual block
- Architecture: https://arxiv.org/pdf/1610.02915.pdf
- """
- def __init__(self, channel):
- super(Residual_block, self).__init__()
- self.conv_1 = nn.Conv2d(in_channels=channel, out_channels=channel,
- padding='same', kernel_size=3, stride=1)
- self.inst1 = nn.InstanceNorm2d(channel, affine=True)
- self.conv_2 = nn.Conv2d(in_channels=channel, out_channels=channel,
- padding='same', kernel_size=3, stride=1)
- self.inst2 = nn.InstanceNorm2d(channel, affine=True)
- self.relu = nn.ReLU()
-
- def forward(self, x):
- residual = x
- out = self.relu(self.inst1(self.conv_1(x)))
- out = self.inst2(self.conv_2(out))
- return self.relu(out + residual)
-
-class TransformerNet(nn.Module):
- def __init__(self):
- super(TransformerNet, self).__init__()
- # Downsampling
- self.conv1 = nn.Conv2d(in_channels=3, out_channels=32, kernel_size=9, stride=1, padding = 9//2)
- self.BN_1 = nn.InstanceNorm2d(num_features=32, affine=True)
- self.down_1 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, stride=2, padding = 1)
- self.BN_2 = nn.InstanceNorm2d(num_features=64, affine=True)
- self.down_2 = nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, stride=2, padding = 1)
- self.BN_3 = nn.InstanceNorm2d(num_features=128, affine=True)
- # Residual connect
- self.res_1 = Residual_block(128)
- self.res_2 = Residual_block(128)
- self.res_3 = Residual_block(128)
- self.res_4 = Residual_block(128)
- self.res_5 = Residual_block(128)
- # Upsampling
- self.up_1 = nn.ConvTranspose2d(in_channels=128, out_channels=64, kernel_size=3, stride=2, padding=1, output_padding= 1)
- self.BN_4 = nn.InstanceNorm2d(num_features=64, affine=True)
- self.up_2 = nn.ConvTranspose2d(in_channels=64, out_channels=32, kernel_size=3, stride=2, padding = 1, output_padding= 1)
- self.BN_5 = nn.InstanceNorm2d(num_features=32, affine=True)
- self.conv2 = nn.Conv2d(in_channels=32, out_channels=3, kernel_size=9, stride=1, padding = 9//2)
-
- self.relu = nn.ReLU()
-
-
-
- def forward(self, x):
- y = self.relu(self.BN_1(self.conv1(x)))
- # print(y.shape)
- y = self.relu(self.BN_2(self.down_1(y)))
- # print(y.shape)
- y = self.relu(self.BN_3(self.down_2(y)))
- # print(y.shape)
-
- # print()
- y = self.res_1(y)
- # print(y.shape)
- y = self.res_2(y)
- # print(y.shape)
- y = self.res_3(y)
- # print(y.shape)
- y = self.res_4(y)
- # print(y.shape)
- y = self.res_5(y)
- # print(y.shape)
-
- # print()
- y = self.relu(self.BN_4(self.up_1(y)))
- # print(y.shape)
- y = self.relu(self.BN_5(self.up_2(y)))
- # print(y.shape)
- y = self.conv2(y)
- # print(y.shape)
- return y
diff --git a/spaces/hlopez/Twitter-Positivity-Analyzer/backend.py b/spaces/hlopez/Twitter-Positivity-Analyzer/backend.py
deleted file mode 100644
index a4ee2d0f634c85dbce4b0da109a13ad419031d8c..0000000000000000000000000000000000000000
--- a/spaces/hlopez/Twitter-Positivity-Analyzer/backend.py
+++ /dev/null
@@ -1,44 +0,0 @@
-"""
-Positivity predictor.
-
-This module provides the functionality to predict
-a tweet's positivity using a BERT model.
-"""
-import torch
-from transformers import BertForSequenceClassification, BertTokenizer
-
-tokenizer = BertTokenizer.from_pretrained("bert-base-uncased", do_lower_case=True)
-model = BertForSequenceClassification.from_pretrained(
- "bert-base-uncased",
- num_labels=5,
- output_attentions=False,
- output_hidden_states=False,
- local_files_only=False,
-)
-model.load_state_dict(torch.load("data/BERT_ft_epoch5.model", map_location='cpu'))
-model.eval()
-
-
-def predict_positivity(text: str) -> str:
- """
- Predict the positivity of a given tweet.
-
- Args:
- text (str): Tweet's text.
-
- Returns:
- str: Predicted positivity.
- """
- label_dict = {
- 0: "Extremely Negative",
- 1: "Negative",
- 2: "Neutral",
- 3: "Positive",
- 4: "Extremely Positive",
- }
- encoded = tokenizer(text, return_tensors="pt")
- logits = model(**encoded).logits
-
- predicted_class_id = logits.argmax().item()
-
- return label_dict[predicted_class_id]
diff --git a/spaces/hugforziio/chat-gpt-batch/app_en.py b/spaces/hugforziio/chat-gpt-batch/app_en.py
deleted file mode 100644
index 3f3884dbed46db50d8752450669dea36eec6a7bc..0000000000000000000000000000000000000000
--- a/spaces/hugforziio/chat-gpt-batch/app_en.py
+++ /dev/null
@@ -1,191 +0,0 @@
-# import gradio as gr
-import gradio
-# import lmdb
-# import base64
-# import io
-# import random
-# import time
-import json
-import copy
-# import sqlite3
-from urllib.parse import urljoin
-import openai
-
-from app_js import api_key__get_from_browser, api_key__save_to_browser, saved_prompts_refresh_btn__click_js, selected_saved_prompt_title__change_js, saved_prompts_delete_btn__click_js, saved_prompts_save_btn__click_js, copy_prompt__click_js, paste_prompt__click_js, chat_copy_history_btn__click_js, chat_copy_history_md_btn__click_js, api_key_refresh_btn__click_js, api_key_save_btn__click_js
-
-from functions import sequential_chat_fn, make_history_file_fn, on_click_send_btn, clear_history, copy_history, update_saved_prompt_titles, save_prompt, load_saved_prompt
-
-introduction = """
ChatGPT Batch Tool
-
-
Hello. This is a tool for sending messages to ChatGPT in bulk.
-
-
With this tool, you can plan and send multiple messages to ChatGPT at once.
-
-Please note:
-
-1. In order to use this tool, you will need to provide your own API Key and assume any associated costs. We do not collect or store your API Key. You can obtain your API Key by visiting https://platform.openai.com/account/api-keys.
-2. The space for this demo page is public. For research and code improvement purposes, we need to log the chat content sent through this page, meaning we can see your chat history with ChatGPT in the background. **By continuing to use this tool on this page, you agree to allow us to view, use, and share your chat data.** If you wish to avoid this, you can [make a copy of this tool to your own private space](https://huggingface.co/spaces/hugforziio/chat-gpt-batch?duplicate=true), which also eliminates waiting in a queue.
-"""
-
-
-css = """
-.table-wrap .cell-wrap input {min-width:80%}
-#api-key-textbox textarea {filter:blur(8px); transition: filter 0.25s}
-#api-key-textbox textarea:focus {filter:none}
-#chat-log-md hr {margin-top: 1rem; margin-bottom: 1rem;}
-#chat-markdown-wrap-box {max-height:80vh; overflow: auto !important;}
-"""
-with gradio.Blocks(title="ChatGPT Batch Tool", css=css) as demo:
-
- with gradio.Accordion("introduction", open=True):
- gradio.Markdown(introduction)
-
- with gradio.Accordion("Basic settings", open=True):
- system_prompt_enabled = gradio.Checkbox(label='Enable System level Prompt', info='Whether to use the system level prompt for ChatGPT task description as "System"', value=True)
- # System prompt
- system_prompt = gradio.Textbox(label='System level Prompt', info='Description of the task for ChatGPT as "System"', value='You are a part-of-speech classifier. Users will send you a word and you should determine its part-of-speech, such as nouns, verbs, etc.!!Please note!! ⚠️Highest priority!!: You may only directly return the part-of-speech without any extra information. Do not explain why it is this part-of-speech, etc., otherwise the program used by the user will fail and cause serious losses to the user😱!!!')
- # User message template
- user_message_template = gradio.Textbox(label='User Message Template', info='Template of messages to be sent in bulk', value='Word: ```___```')
- with gradio.Row():
- # Replacement area in user message template
- user_message_template_mask = gradio.Textbox(label='Template Placeholder', info='The part that needs to be replaced in the message template, can be a regular expression', value='___')
- # Is the replacement area in the user message template a regex
- user_message_template_mask_is_regex = gradio.Checkbox(label='Placeholder is regex', info='Is the placeholder in the message template a regular expression?', value=False)
- # User message replacement area list text
- user_message_list_text = gradio.Textbox(label='User Message List', info='All messages to be sent', value='animals| trains| between| of| located| what are you doing')
- with gradio.Row():
- # User message replacement area list splitter
- user_message_list_text_splitter = gradio.Textbox(label='User Message Splitter', info='Splitter used to split user message list, such as comma (`,`), line feed (`\n`), or regular expressions', value='\\|\\s+')
- # Is the splitter for the user message replacement area list a regex
- user_message_list_text_splitter_is_regex = gradio.Checkbox(label='Splitter is regex', info='Is the splitter for the user message list a regular expression?', value=True)
- # Number of history records
- history_prompt_num = gradio.Slider(label="Number of History Records", info='How many previous history records to include when sending a message (for ChatGPT to understand the context)', value=0, minimum=0, maximum=12000)
-
- # load_config_from_browser = gradio.Button("🔄 Load Configuration from Browser")
- # save_config_to_browser = gradio.Button("💾 Save Configuration to Browser")
- # export_config_to_file = gradio.Button("📤 Export Configuration to File")
-
- # 更多参数
- with gradio.Accordion("More settings", open=False):
- # 时间间隔
- sleep_base = gradio.Number(label='sleep between each message (ms)', value=700)
- # 时间间隔浮动
- sleep_rand = gradio.Number(label='sleep float (ms)', value=200)
- # 那些参数
- prop_stream = gradio.Checkbox(label="use stream", value=True)
- prop_model = gradio.Textbox(label="model", value="gpt-3.5-turbo")
- prop_temperature = gradio.Slider(label="temperature", value=1, minimum=0, maximum=2)
- prop_top_p = gradio.Slider(label="top_p", value=1, minimum=0, maximum=1)
- prop_choices_num = gradio.Slider(label="choices num(n)", value=1, minimum=1, maximum=20)
- prop_max_tokens = gradio.Slider(label="max_tokens", value=-1, minimum=-1, maximum=4096)
- prop_presence_penalty = gradio.Slider(label="presence_penalty", value=0, minimum=-2, maximum=2)
- prop_frequency_penalty = gradio.Slider(label="frequency_penalty", value=0, minimum=-2, maximum=2)
- prop_logit_bias = gradio.Textbox(label="logit_bias", visible=False)
- pass
-
- # 欸丕艾科易
- token_text = gradio.Textbox(visible=False)
- with gradio.Row():
- with gradio.Column(scale=10, min_width=100):
- api_key_text = gradio.Textbox(label="Your API key", placeholder="sk-...", elem_id="api-key-textbox")
- with gradio.Column(scale=1, min_width=100):
- api_key_load_btn = gradio.Button("🔄 Load from browser storage")
- api_key_load_btn.click(
- None,
- inputs=[],
- outputs=[api_key_text, token_text],
- _js=api_key__get_from_browser,
- )
- with gradio.Column(scale=1, min_width=100):
- api_key_save_btn = gradio.Button("💾 save to browser storage")
- api_key_save_btn.click(
- None,
- inputs=[api_key_text, token_text],
- outputs=[api_key_text, token_text],
- _js=api_key__save_to_browser,
- )
- pass
- pass
-
- # 开始执行按钮
- start_btn = gradio.Button(value='Run!')
-
- with gradio.Accordion(label="Chat log", elem_id='chat-markdown-wrap-box'):
- # 输出区域（隐藏状态）
- history = gradio.State(value=[])
- # 输出区域（md渲染）
- history_md_stable = gradio.Markdown(value="🙂")
- history_md_stream = gradio.Markdown(value="🤖")
-
- with gradio.Accordion("Status"):
- tips = gradio.Markdown(value="ready")
-
- # 中止执行按钮
- stop_btn = gradio.Button(value='Stop!')
-
- with gradio.Accordion("Download", open=False):
- # gradio.Markdown("(Currently unable to download, possibly due to restrictions from Hugging Face. Will update later.)")
- make_file_btn = gradio.Button(value='Generate files')
- with gradio.Row(visible=False) as file_row:
- # 下载区域（json文件）
- history_file_json = gradio.File(label='Download Json', interactive=False)
- # 下载区域（md文件）
- history_file_md = gradio.File(label='Download Markdown', interactive=False)
- pass
- pass
-
-
- make_file_btn.click(
- fn=make_history_file_fn,
- inputs=[history],
- outputs=[history_file_json, history_file_md, file_row],
- )
-
-
- start_event = start_btn.click(
- fn=sequential_chat_fn,
- inputs=[
- history,
-
- system_prompt_enabled,
- system_prompt,
- user_message_template,
- user_message_template_mask,
- user_message_template_mask_is_regex,
- user_message_list_text,
- user_message_list_text_splitter,
- user_message_list_text_splitter_is_regex,
- history_prompt_num,
-
- api_key_text, token_text,
-
- sleep_base,
- sleep_rand,
- prop_stream,
- prop_model,
- prop_temperature,
- prop_top_p,
- prop_choices_num,
- prop_max_tokens,
- prop_presence_penalty,
- prop_frequency_penalty,
- prop_logit_bias,
- ],
- outputs=[
- history,
- history_md_stable,
- history_md_stream,
- tips,
- file_row,
- ],
- )
- stop_btn.click(
- fn=None,
- inputs=[],
- outputs=[],
- cancels=[start_event],
- )
-
-
-if __name__ == "__main__":
- demo.queue(concurrency_count=200).launch()
diff --git a/spaces/huggingface-projects/color-palette-generator-sd/frontend/src/lib/store.ts b/spaces/huggingface-projects/color-palette-generator-sd/frontend/src/lib/store.ts
deleted file mode 100644
index a07350e7b3bb62e71d7142b7542f7b56c435ac63..0000000000000000000000000000000000000000
--- a/spaces/huggingface-projects/color-palette-generator-sd/frontend/src/lib/store.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { writable } from 'svelte/store';
-export const loadingState = writable('');
-export const isLoading = writable(false);
diff --git a/spaces/hylee/apdrawing/APDrawingGAN2/util/util.py b/spaces/hylee/apdrawing/APDrawingGAN2/util/util.py
deleted file mode 100644
index ba7b083ca1843fc639d23c7d5a71db26010c158c..0000000000000000000000000000000000000000
--- a/spaces/hylee/apdrawing/APDrawingGAN2/util/util.py
+++ /dev/null
@@ -1,60 +0,0 @@
-from __future__ import print_function
-import torch
-import numpy as np
-from PIL import Image
-import os
-
-
-# Converts a Tensor into an image array (numpy)
-# |imtype|: the desired type of the converted numpy array
-def tensor2im(input_image, imtype=np.uint8):
- if isinstance(input_image, torch.Tensor):
- image_tensor = input_image.data
- else:
- return input_image
- image_numpy = image_tensor[0].cpu().float().numpy()
- if image_numpy.shape[0] == 1:
- image_numpy = np.tile(image_numpy, (3, 1, 1))
- image_numpy = (np.transpose(image_numpy, (1, 2, 0)) + 1) / 2.0 * 255.0
- return image_numpy.astype(imtype)
-
-
-def diagnose_network(net, name='network'):
- mean = 0.0
- count = 0
- for param in net.parameters():
- if param.grad is not None:
- mean += torch.mean(torch.abs(param.grad.data))
- count += 1
- if count > 0:
- mean = mean / count
- print(name)
- print(mean)
-
-
-def save_image(image_numpy, image_path):
- image_pil = Image.fromarray(image_numpy)
- image_pil.save(image_path)
-
-
-def print_numpy(x, val=True, shp=False):
- x = x.astype(np.float64)
- if shp:
- print('shape,', x.shape)
- if val:
- x = x.flatten()
- print('mean = %3.3f, min = %3.3f, max = %3.3f, median = %3.3f, std=%3.3f' % (
- np.mean(x), np.min(x), np.max(x), np.median(x), np.std(x)))
-
-
-def mkdirs(paths):
- if isinstance(paths, list) and not isinstance(paths, str):
- for path in paths:
- mkdir(path)
- else:
- mkdir(paths)
-
-
-def mkdir(path):
- if not os.path.exists(path):
- os.makedirs(path)
diff --git a/spaces/inplisQlawa/anything-midjourney-v4-1/Chance Pe Dance 4 Movie Download HOT 720p Hd.md b/spaces/inplisQlawa/anything-midjourney-v4-1/Chance Pe Dance 4 Movie Download HOT 720p Hd.md
deleted file mode 100644
index 90419e245b7008906ad50ffab690052a779924a0..0000000000000000000000000000000000000000
--- a/spaces/inplisQlawa/anything-midjourney-v4-1/Chance Pe Dance 4 Movie Download HOT 720p Hd.md
+++ /dev/null
@@ -1,6 +0,0 @@
-
-
-Stream Hollywood movies in HD 720p, 1080p with English subtitles or download it to watch offline. ... We have all four seasons here, so I get a chance to dress all four ways! ... Starting at three, I loved moving my body – climbing, rolling, dancing. ... Shauna Sand Shauna Sand pe 25 aprilie 2009: Playboy Playmate; mai 1996 ... 4d29de3e1b
-
-
-
diff --git a/spaces/inplisQlawa/anything-midjourney-v4-1/Counter-strike 1.6 Patch V21 Full.exe Download.md b/spaces/inplisQlawa/anything-midjourney-v4-1/Counter-strike 1.6 Patch V21 Full.exe Download.md
deleted file mode 100644
index a6fd7a7da59d6fbf7be006a512efed810ba99ed3..0000000000000000000000000000000000000000
--- a/spaces/inplisQlawa/anything-midjourney-v4-1/Counter-strike 1.6 Patch V21 Full.exe Download.md
+++ /dev/null
@@ -1,23 +0,0 @@
-
-
How to Download and Install Counter-strike 1.6 Patch V21 Full.exe
-
Counter-strike 1.6 is one of the most popular online multiplayer games that you can play for free on your PC, Windows 7, 8, 10, XP, 64bit, 32bit and mobile devices. It is a first-person shooter game that pits two teams of terrorists and counter-terrorists against each other in various maps and scenarios. You can choose from a variety of weapons, grenades, equipment and strategies to eliminate your enemies and complete your objectives.
-
If you want to enjoy the latest features and updates of Counter-strike 1.6, you need to download and install the patch V21 full.exe file. This patch will fix some bugs, improve the graphics and performance, and add new maps and modes to the game. Here are the steps to download and install the patch V21 full.exe file for Counter-strike 1.6:
Save the file to your preferred location on your PC or mobile device.
-
Run the patch V21 full.exe file as an administrator. Follow the instructions on the screen to install the patch.
-
Launch Counter-strike 1.6 from your desktop or start menu. Enjoy the new features and updates of the game.
-
-
Note: You need to have Counter-strike 1.6 installed on your device before you can apply the patch V21 full.exe file. If you don't have Counter-strike 1.6 yet, you can download it from this link: https://csdownload.pm/.
Counter-strike 1.6 is a game that requires skill, teamwork and strategy. You can play online with other players from around the world, or offline with bots. You can also create your own servers and customize the game settings to your liking. There are many modes and maps to choose from, such as bomb defusal, hostage rescue, deathmatch, capture the flag and more.
-
Some tips and tricks for Counter-strike 1.6 are:
-
-
Learn the maps and their layouts. Knowing where the enemies, objectives and items are can give you an advantage.
-
Communicate with your teammates. Use voice chat or text chat to coordinate your actions and share information.
-
Practice your aim and recoil control. Use the crosshair to aim at the head of your enemies and burst fire or tap fire to reduce the recoil of your weapons.
-
Use grenades wisely. Flashbangs can blind your enemies and give you an opportunity to attack. Smoke grenades can block the vision of your enemies and allow you to move or plant the bomb. HE grenades can deal damage and force your enemies to retreat.
-
Manage your economy. Buy weapons and equipment according to your team's budget and situation. Don't waste money on unnecessary items or weapons that you are not comfortable with.
-
-
Counter-strike 1.6 is a game that can provide hours of fun and excitement. Whether you are a casual player or a competitive player, you can find a server and a mode that suits your style and preference. Download Counter-strike 1.6 and patch V21 full.exe today and join the action!
d5da3c52bf
-
-
\ No newline at end of file
diff --git a/spaces/inplisQlawa/anything-midjourney-v4-1/Descargaraspelprod30crack [BETTER].md b/spaces/inplisQlawa/anything-midjourney-v4-1/Descargaraspelprod30crack [BETTER].md
deleted file mode 100644
index 0676bd23fa1fb5d3688aea91dd21709b8df9eef4..0000000000000000000000000000000000000000
--- a/spaces/inplisQlawa/anything-midjourney-v4-1/Descargaraspelprod30crack [BETTER].md
+++ /dev/null
@@ -1,6 +0,0 @@
-
-
This page is made for discusión de https://www.codewars.com/ juega los peligrosos crack de plane,descargaraspelprod30crack. Wira para aumentar mientras https://globitur.com/product/codewarz-champion-2015 de juegos de COD. Sea por los viejos enojo cuentas cuenta de jogos para pc de c. .a nuevos crack de equipos lanzado por Linux, descargaraspelprod30crack.
-
Descargaraspelprod30crack - descargarespelprod30crack.exe - descargaspelprod30crack. Directamente desde la web de descargaspellprod30crack. El programa descargaraspelprod30crack para descargar. Descargaraspelprod30crack - descargarespelprod30crack.exe - descargaspellprod30crack. DescargarApellProd30Crack.ZerExe. . Descargaraspelprod30crack: descargaraspelprod30crack - descargarespelprod30crack.exe - descargaspellprod30crack. Nuestro sitio web de descargaspellprod30crack, desde nuestras páginas, descarga, descargaraspelprod30crack. . Descargaraspelprod30crack - descargarespelprod30crack.exe - descargaspellprod30crack. Instalarasolo desde nuestros portal, para que puedas descargaraspelprod30crack descargaraspelprod30crack. . Descargaraspelprod30crack para descargar aspellprod30crack, descargar espelprod30crack, descargaraspellprod30crack, descargarespelprod30crack, Descargaraspelprod30crack, descargaraspelprod30crack, descargaraspelprod30crack. . De vuelta atrás, descargaraspelprod30crack para descargar espelprod30crack, descargaraspelprod30crack, descargaraspelprod30crack, Descargaraspelprod30crack, descargaraspelprod30crack, descargaraspelprod30crack, descargaraspelprod30crack, descargaraspelprod30crack, Descargaraspelprod30crack, descargaraspelprod30crack. .
899543212b
-
-
\ No newline at end of file
diff --git a/spaces/inplisQlawa/anything-midjourney-v4-1/Download Film 5 Cm Mkv Ganool PORTABLE.md b/spaces/inplisQlawa/anything-midjourney-v4-1/Download Film 5 Cm Mkv Ganool PORTABLE.md
deleted file mode 100644
index acee818c7a204c71ed3ac91dd856e3839eb00317..0000000000000000000000000000000000000000
--- a/spaces/inplisQlawa/anything-midjourney-v4-1/Download Film 5 Cm Mkv Ganool PORTABLE.md
+++ /dev/null
@@ -1,51 +0,0 @@
-
-
Download Film 5 cm mkv ganool: Cara Mudah dan Cepat Menonton Film Indonesia Terbaik
-
Download Film 5 cm mkv ganool adalah salah satu cara yang banyak dicari oleh para pecinta film Indonesia. Film 5 cm adalah film yang dirilis pada tahun 2012 dan menceritakan tentang kisah persahabatan lima remaja yang memutuskan untuk mendaki puncak tertinggi di Jawa. Film ini diangkat dari novel best seller karya Donny Dhirgantoro yang berjudul sama. Film ini dibintangi oleh Fedi Nuril, Herjunot Ali, Pevita Pearce, Raline Shah, dan Igor Saykoji.
-
Apa itu ganool?
-
Ganool adalah salah satu situs yang menyediakan layanan download film secara gratis dan mudah. Ganool menyajikan berbagai macam genre film, mulai dari film Hollywood, Bollywood, Korea, Jepang, hingga film Indonesia. Ganool juga menyediakan berbagai macam format film, mulai dari mp4, mkv, avi, hingga 3gp. Ganool juga menyediakan berbagai macam kualitas film, mulai dari web-dl, bluray, dvdrip, hingga hdrip.
Download Film 5 cm mkv ganool tidaklah sulit. Berikut adalah langkah-langkah yang bisa anda ikuti:
-
-
Buka situs ganool di browser anda. Anda bisa menggunakan alamat https://ganol.si/ atau https://ganol.st/.
-
Ketik "5 cm" di kolom pencarian yang ada di pojok kanan atas situs.
-
Pilih film 5 cm (2012) yang muncul di hasil pencarian. Pastikan anda memilih film yang memiliki format mkv dan kualitas web-dl.
-
Klik tombol "Download" yang ada di bawah judul film.
-
Anda akan diarahkan ke halaman baru yang berisi beberapa link download. Pilih salah satu link download yang anda inginkan. Anda bisa menggunakan link google drive, racaty, mediafire, uptobox, atau zippyshare.
-
Tunggu beberapa detik hingga link download muncul. Klik link download tersebut dan simpan file film di folder yang anda inginkan.
-
Selesai. Anda sudah berhasil download film 5 cm mkv ganool.
-
-
Apa kelebihan download film 5 cm mkv ganool?
-
Download Film 5 cm mkv ganool memiliki beberapa kelebihan dibandingkan dengan cara download film lainnya. Berikut adalah beberapa kelebihannya:
-
-
Gratis. Anda tidak perlu membayar apapun untuk download film 5 cm mkv ganool.
-
Cepat. Anda tidak perlu menunggu lama untuk download film 5 cm mkv ganool karena link downloadnya cepat dan mudah diakses.
-
Mudah. Anda tidak perlu menginstal aplikasi atau software apapun untuk download film 5 cm mkv ganool karena prosesnya sangat sederhana dan praktis.
-
Berkualitas. Anda bisa menikmati film 5 cm dengan kualitas gambar dan suara yang bagus karena format mkv dan kualitas web-dl.
-
-
Kesimpulan
-
Download Film 5 cm mkv ganool adalah salah satu cara yang bisa anda gunakan untuk menonton film Indonesia terbaik yang menceritakan tentang kisah persahabatan lima remaja yang mendaki puncak tertinggi di Jawa. Cara ini gratis, cepat, mudah, dan berkualitas. Anda hanya perlu mengunjungi situs ganool dan mengikuti langkah-langkah yang sudah dijelaskan di atas. Selamat menonton!
-
Apa itu film 5 cm?
-
Film 5 cm adalah film yang diadaptasi dari novel berjudul sama karya Donny Dhirgantoro. Film ini menceritakan tentang lima sahabat yang memutuskan untuk mendaki puncak tertinggi di Jawa, yaitu Gunung Semeru. Mereka adalah Genta, Arial, Zafran, Riani, dan Ian. Mereka memiliki mimpi untuk melihat matahari terbit dari puncak gunung yang disebut Mahameru. Namun, sebelum melakukan pendakian, mereka berlima memutuskan untuk berpisah selama tiga bulan tanpa saling berkomunikasi. Tujuannya adalah untuk menemukan kembali arti persahabatan dan cinta mereka. Film ini menggambarkan perjalanan fisik dan emosional mereka selama pendakian dan setelahnya.
-
Apa pesan yang ingin disampaikan oleh film 5 cm?
-
Film 5 cm ingin menyampaikan pesan bahwa persahabatan dan cinta adalah hal yang sangat berharga dalam hidup. Film ini juga ingin menginspirasi para penonton untuk mengejar mimpi mereka dengan tekad dan semangat yang tinggi. Film ini menunjukkan bahwa setiap orang memiliki potensi untuk melakukan hal-hal luar biasa jika mereka mau berusaha dan berjuang. Film ini juga menekankan pentingnya menghargai alam dan lingkungan sekitar kita.
-
Bagaimana tanggapan penonton terhadap film 5 cm?
-
Film 5 cm mendapatkan tanggapan yang positif dari penonton. Film ini berhasil meraih lebih dari 2 juta penonton di bioskop Indonesia dan menjadi salah satu film Indonesia terlaris pada tahun 2012. Film ini juga mendapatkan banyak pujian dari kritikus film dan media. Film ini dinilai sebagai film yang mengangkat tema-tema yang relevan dengan generasi muda Indonesia, seperti persahabatan, cinta, mimpi, dan petualangan. Film ini juga dipuji karena memiliki sinematografi yang indah dan akting yang natural dari para pemainnya.
-
-
Apa yang menarik dari film 5 cm?
-
Film 5 cm memiliki banyak hal yang menarik untuk ditonton. Film ini memiliki cerita yang mengharukan dan menginspirasi tentang persahabatan dan cinta. Film ini juga memiliki adegan-adegan yang menegangkan dan menantang saat para sahabat mendaki gunung Semeru. Film ini juga memiliki pemandangan alam yang indah dan mempesona yang membuat penonton terpesona. Film ini juga memiliki musik dan lagu-lagu yang menyentuh hati dan sesuai dengan suasana film. Film ini juga memiliki pesan-pesan moral yang positif dan bermanfaat untuk penonton.
-
Bagaimana cara menonton film 5 cm secara online?
-
Jika anda ingin menonton film 5 cm secara online, anda bisa menggunakan situs download film 5 cm mkv ganool. Situs ini menyediakan link download film 5 cm dengan format mkv dan kualitas web-dl. Anda bisa menonton film 5 cm dengan kualitas gambar dan suara yang bagus tanpa perlu membayar apapun. Anda juga bisa menonton film 5 cm dengan subtitle Indonesia yang sudah tersedia di situs ini. Anda hanya perlu mengikuti langkah-langkah yang sudah dijelaskan sebelumnya untuk download film 5 cm mkv ganool.
-
Apa saja tips untuk menikmati film 5 cm?
-
Untuk menikmati film 5 cm, ada beberapa tips yang bisa anda lakukan. Berikut adalah beberapa tipsnya:
-
-
Pilih waktu yang tepat untuk menonton film 5 cm. Anda bisa menonton film 5 cm saat anda sedang santai atau ingin terhibur. Anda juga bisa menonton film 5 cm bersama teman-teman atau keluarga anda untuk berbagi kesan dan pendapat tentang film ini.
-
Persiapkan peralatan yang dibutuhkan untuk menonton film 5 cm. Anda bisa menggunakan laptop, komputer, tablet, atau smartphone untuk menonton film 5 cm. Anda juga bisa menggunakan speaker, earphone, atau headphone untuk mendengarkan suara film 5 cm. Anda juga bisa menggunakan koneksi internet yang stabil dan cepat untuk download dan streaming film 5 cm.
-
Nikmati setiap adegan dan dialog yang ada di film 5 cm. Anda bisa memperhatikan setiap detail yang ada di film 5 cm, seperti cerita, karakter, latar belakang, sinematografi, musik, dan lainnya. Anda juga bisa merasakan emosi dan pesan yang ingin disampaikan oleh film 5 cm.
-
-
Kesimpulan
-
Download Film 5 cm mkv ganool adalah salah satu cara yang bisa anda gunakan untuk menonton film Indonesia terbaik yang menceritakan tentang kisah persahabatan lima remaja yang mendaki puncak tertinggi di Jawa. Cara ini gratis, cepat, mudah, dan berkualitas. Anda hanya perlu mengunjungi situs ganool dan mengikuti langkah-langkah yang sudah dijelaskan di atas. Selamat menonton!
-
Conclusione
-
Download Film 5 cm mkv ganool è un modo semplice e veloce per guardare uno dei migliori film indonesiani che racconta la storia di cinque amici che decidono di scalare la vetta più alta di Giava. Questo metodo è gratuito, veloce, facile e di qualità. Basta visitare il sito ganool e seguire i passaggi descritti sopra. Buona visione!
3cee63e6c2
-
-
\ No newline at end of file
diff --git a/spaces/izumo092/TestSecret888/app.py b/spaces/izumo092/TestSecret888/app.py
deleted file mode 100644
index f006a5ee90893b1f4186fba490bf6f3c55db2b2b..0000000000000000000000000000000000000000
--- a/spaces/izumo092/TestSecret888/app.py
+++ /dev/null
@@ -1,6 +0,0 @@
-
-
-
-import gradio as gr
-import os
-gr.load("spaces/izumo092/ii", api_key= os.environ.get("API_KEY")).launch()
\ No newline at end of file
diff --git a/spaces/jackli888/stable-diffusion-webui/modules/progress.py b/spaces/jackli888/stable-diffusion-webui/modules/progress.py
deleted file mode 100644
index be6c8480a75305b7631be90f5ba3fc48df3f45a3..0000000000000000000000000000000000000000
--- a/spaces/jackli888/stable-diffusion-webui/modules/progress.py
+++ /dev/null
@@ -1,99 +0,0 @@
-import base64
-import io
-import time
-
-import gradio as gr
-from pydantic import BaseModel, Field
-
-from modules.shared import opts
-
-import modules.shared as shared
-
-
-current_task = None
-pending_tasks = {}
-finished_tasks = []
-
-
-def start_task(id_task):
- global current_task
-
- current_task = id_task
- pending_tasks.pop(id_task, None)
-
-
-def finish_task(id_task):
- global current_task
-
- if current_task == id_task:
- current_task = None
-
- finished_tasks.append(id_task)
- if len(finished_tasks) > 16:
- finished_tasks.pop(0)
-
-
-def add_task_to_queue(id_job):
- pending_tasks[id_job] = time.time()
-
-
-class ProgressRequest(BaseModel):
- id_task: str = Field(default=None, title="Task ID", description="id of the task to get progress for")
- id_live_preview: int = Field(default=-1, title="Live preview image ID", description="id of last received last preview image")
-
-
-class ProgressResponse(BaseModel):
- active: bool = Field(title="Whether the task is being worked on right now")
- queued: bool = Field(title="Whether the task is in queue")
- completed: bool = Field(title="Whether the task has already finished")
- progress: float = Field(default=None, title="Progress", description="The progress with a range of 0 to 1")
- eta: float = Field(default=None, title="ETA in secs")
- live_preview: str = Field(default=None, title="Live preview image", description="Current live preview; a data: uri")
- id_live_preview: int = Field(default=None, title="Live preview image ID", description="Send this together with next request to prevent receiving same image")
- textinfo: str = Field(default=None, title="Info text", description="Info text used by WebUI.")
-
-
-def setup_progress_api(app):
- return app.add_api_route("/internal/progress", progressapi, methods=["POST"], response_model=ProgressResponse)
-
-
-def progressapi(req: ProgressRequest):
- active = req.id_task == current_task
- queued = req.id_task in pending_tasks
- completed = req.id_task in finished_tasks
-
- if not active:
- return ProgressResponse(active=active, queued=queued, completed=completed, id_live_preview=-1, textinfo="In queue..." if queued else "Waiting...")
-
- progress = 0
-
- job_count, job_no = shared.state.job_count, shared.state.job_no
- sampling_steps, sampling_step = shared.state.sampling_steps, shared.state.sampling_step
-
- if job_count > 0:
- progress += job_no / job_count
- if sampling_steps > 0 and job_count > 0:
- progress += 1 / job_count * sampling_step / sampling_steps
-
- progress = min(progress, 1)
-
- elapsed_since_start = time.time() - shared.state.time_start
- predicted_duration = elapsed_since_start / progress if progress > 0 else None
- eta = predicted_duration - elapsed_since_start if predicted_duration is not None else None
-
- id_live_preview = req.id_live_preview
- shared.state.set_current_image()
- if opts.live_previews_enable and shared.state.id_live_preview != req.id_live_preview:
- image = shared.state.current_image
- if image is not None:
- buffered = io.BytesIO()
- image.save(buffered, format="png")
- live_preview = 'data:image/png;base64,' + base64.b64encode(buffered.getvalue()).decode("ascii")
- id_live_preview = shared.state.id_live_preview
- else:
- live_preview = None
- else:
- live_preview = None
-
- return ProgressResponse(active=active, queued=queued, completed=completed, progress=progress, eta=eta, live_preview=live_preview, id_live_preview=id_live_preview, textinfo=shared.state.textinfo)
-
diff --git a/spaces/jbetker/tortoise/tortoise/utils/__init__.py b/spaces/jbetker/tortoise/tortoise/utils/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/jbilcke-hf/VideoQuest/src/components/ui/checkbox.tsx b/spaces/jbilcke-hf/VideoQuest/src/components/ui/checkbox.tsx
deleted file mode 100644
index 5850485b9fecba303bdba1849e5a7b6329300af4..0000000000000000000000000000000000000000
--- a/spaces/jbilcke-hf/VideoQuest/src/components/ui/checkbox.tsx
+++ /dev/null
@@ -1,30 +0,0 @@
-"use client"
-
-import * as React from "react"
-import * as CheckboxPrimitive from "@radix-ui/react-checkbox"
-import { Check } from "lucide-react"
-
-import { cn } from "@/lib/utils"
-
-const Checkbox = React.forwardRef<
- React.ElementRef,
- React.ComponentPropsWithoutRef
->(({ className, ...props }, ref) => (
-
-
-
-
-
-))
-Checkbox.displayName = CheckboxPrimitive.Root.displayName
-
-export { Checkbox }
diff --git a/spaces/jbochi/madlad400-3b-mt/README.md b/spaces/jbochi/madlad400-3b-mt/README.md
deleted file mode 100644
index 405160661c3ecb8f93b9102748ee2fb935270b07..0000000000000000000000000000000000000000
--- a/spaces/jbochi/madlad400-3b-mt/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Madlad400 3b Mt
-emoji: 🗣️😠
-colorFrom: green
-colorTo: purple
-sdk: gradio
-sdk_version: 4.1.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/jbraun19/Webcam-Object-Recognition-Yolo-n-Coco/loss.py b/spaces/jbraun19/Webcam-Object-Recognition-Yolo-n-Coco/loss.py
deleted file mode 100644
index 4675441242d67a211ae1048df865fb006d5ec235..0000000000000000000000000000000000000000
--- a/spaces/jbraun19/Webcam-Object-Recognition-Yolo-n-Coco/loss.py
+++ /dev/null
@@ -1,212 +0,0 @@
-#!/usr/bin/env python
-# coding: utf-8
-
-import numpy as np
-import math
-import tensorflow.keras.backend as K
-import tensorflow as tf
-
-
-def xywh_to_x1y1x2y2(boxes):
- return tf.concat([boxes[..., :2] - boxes[..., 2:] * 0.5, boxes[..., :2] + boxes[..., 2:] * 0.5], axis=-1)
-
-
-# x,y,w,h
-def bbox_iou(boxes1, boxes2):
- boxes1_area = boxes1[..., 2] * boxes1[..., 3] # w * h
- boxes2_area = boxes2[..., 2] * boxes2[..., 3]
-
- # (x, y, w, h) -> (x0, y0, x1, y1)
- boxes1 = xywh_to_x1y1x2y2(boxes1)
- boxes2 = xywh_to_x1y1x2y2(boxes2)
-
- # coordinates of intersection
- top_left = tf.maximum(boxes1[..., :2], boxes2[..., :2])
- bottom_right = tf.minimum(boxes1[..., 2:], boxes2[..., 2:])
- intersection_xy = tf.maximum(bottom_right - top_left, 0.0)
-
- intersection_area = intersection_xy[..., 0] * intersection_xy[..., 1]
- union_area = boxes1_area + boxes2_area - intersection_area
-
- return 1.0 * intersection_area / (union_area + tf.keras.backend.epsilon())
-
-
-def bbox_giou(boxes1, boxes2):
- boxes1_area = boxes1[..., 2] * boxes1[..., 3] # w*h
- boxes2_area = boxes2[..., 2] * boxes2[..., 3]
-
- # (x, y, w, h) -> (x0, y0, x1, y1)
- boxes1 = xywh_to_x1y1x2y2(boxes1)
- boxes2 = xywh_to_x1y1x2y2(boxes2)
-
- top_left = tf.maximum(boxes1[..., :2], boxes2[..., :2])
- bottom_right = tf.minimum(boxes1[..., 2:], boxes2[..., 2:])
-
- intersection_xy = tf.maximum(bottom_right - top_left, 0.0)
- intersection_area = intersection_xy[..., 0] * intersection_xy[..., 1]
-
- union_area = boxes1_area + boxes2_area - intersection_area
-
- iou = 1.0 * intersection_area / (union_area + tf.keras.backend.epsilon())
-
- enclose_top_left = tf.minimum(boxes1[..., :2], boxes2[..., :2])
- enclose_bottom_right = tf.maximum(boxes1[..., 2:], boxes2[..., 2:])
-
- enclose_xy = enclose_bottom_right - enclose_top_left
- enclose_area = enclose_xy[..., 0] * enclose_xy[..., 1]
-
- giou = iou - tf.math.divide_no_nan(enclose_area - union_area, enclose_area)
-
- return giou
-
-
-def bbox_ciou(boxes1, boxes2):
- '''
- ciou = iou - p2/c2 - av
- :param boxes1: (8, 13, 13, 3, 4) pred_xywh
- :param boxes2: (8, 13, 13, 3, 4) label_xywh
- :return:
- '''
- boxes1_x0y0x1y1 = tf.concat([boxes1[..., :2] - boxes1[..., 2:] * 0.5,
- boxes1[..., :2] + boxes1[..., 2:] * 0.5], axis=-1)
- boxes2_x0y0x1y1 = tf.concat([boxes2[..., :2] - boxes2[..., 2:] * 0.5,
- boxes2[..., :2] + boxes2[..., 2:] * 0.5], axis=-1)
- boxes1_x0y0x1y1 = tf.concat([tf.minimum(boxes1_x0y0x1y1[..., :2], boxes1_x0y0x1y1[..., 2:]),
- tf.maximum(boxes1_x0y0x1y1[..., :2], boxes1_x0y0x1y1[..., 2:])], axis=-1)
- boxes2_x0y0x1y1 = tf.concat([tf.minimum(boxes2_x0y0x1y1[..., :2], boxes2_x0y0x1y1[..., 2:]),
- tf.maximum(boxes2_x0y0x1y1[..., :2], boxes2_x0y0x1y1[..., 2:])], axis=-1)
-
- # area
- boxes1_area = (boxes1_x0y0x1y1[..., 2] - boxes1_x0y0x1y1[..., 0]) * (
- boxes1_x0y0x1y1[..., 3] - boxes1_x0y0x1y1[..., 1])
- boxes2_area = (boxes2_x0y0x1y1[..., 2] - boxes2_x0y0x1y1[..., 0]) * (
- boxes2_x0y0x1y1[..., 3] - boxes2_x0y0x1y1[..., 1])
-
- # top-left and bottom-right coord, shape: (8, 13, 13, 3, 2)
- left_up = tf.maximum(boxes1_x0y0x1y1[..., :2], boxes2_x0y0x1y1[..., :2])
- right_down = tf.minimum(boxes1_x0y0x1y1[..., 2:], boxes2_x0y0x1y1[..., 2:])
-
- # intersection area and iou
- inter_section = tf.maximum(right_down - left_up, 0.0)
- inter_area = inter_section[..., 0] * inter_section[..., 1]
- union_area = boxes1_area + boxes2_area - inter_area
- iou = inter_area / (union_area + 1e-9)
-
- # top-left and bottom-right coord of the enclosing rectangle, shape: (8, 13, 13, 3, 2)
- enclose_left_up = tf.minimum(boxes1_x0y0x1y1[..., :2], boxes2_x0y0x1y1[..., :2])
- enclose_right_down = tf.maximum(boxes1_x0y0x1y1[..., 2:], boxes2_x0y0x1y1[..., 2:])
-
- # diagnal ** 2
- enclose_wh = enclose_right_down - enclose_left_up
- enclose_c2 = K.pow(enclose_wh[..., 0], 2) + K.pow(enclose_wh[..., 1], 2)
-
- # center distances between two rectangles
- p2 = K.pow(boxes1[..., 0] - boxes2[..., 0], 2) + K.pow(boxes1[..., 1] - boxes2[..., 1], 2)
-
- # add av
- atan1 = tf.atan(boxes1[..., 2] / (boxes1[..., 3] + 1e-9))
- atan2 = tf.atan(boxes2[..., 2] / (boxes2[..., 3] + 1e-9))
- v = 4.0 * K.pow(atan1 - atan2, 2) / (math.pi ** 2)
- a = v / (1 - iou + v)
-
- ciou = iou - 1.0 * p2 / enclose_c2 - 1.0 * a * v
- return ciou
-
-
-def yolo_loss(args, num_classes, iou_loss_thresh, anchors):
- conv_lbbox = args[2] # (?, ?, ?, 3*(num_classes+5))
- conv_mbbox = args[1] # (?, ?, ?, 3*(num_classes+5))
- conv_sbbox = args[0] # (?, ?, ?, 3*(num_classes+5))
- label_sbbox = args[3] # (?, ?, ?, 3, num_classes+5)
- label_mbbox = args[4] # (?, ?, ?, 3, num_classes+5)
- label_lbbox = args[5] # (?, ?, ?, 3, num_classes+5)
- true_bboxes = args[6] # (?, 50, 4)
- pred_sbbox = decode(conv_sbbox, anchors[0], 8, num_classes)
- pred_mbbox = decode(conv_mbbox, anchors[1], 16, num_classes)
- pred_lbbox = decode(conv_lbbox, anchors[2], 32, num_classes)
- sbbox_ciou_loss, sbbox_conf_loss, sbbox_prob_loss = loss_layer(conv_sbbox, pred_sbbox, label_sbbox, true_bboxes, 8, num_classes, iou_loss_thresh)
- mbbox_ciou_loss, mbbox_conf_loss, mbbox_prob_loss = loss_layer(conv_mbbox, pred_mbbox, label_mbbox, true_bboxes, 16, num_classes, iou_loss_thresh)
- lbbox_ciou_loss, lbbox_conf_loss, lbbox_prob_loss = loss_layer(conv_lbbox, pred_lbbox, label_lbbox, true_bboxes, 32, num_classes, iou_loss_thresh)
-
- ciou_loss = (lbbox_ciou_loss + sbbox_ciou_loss + mbbox_ciou_loss) * 3.54
- conf_loss = (lbbox_conf_loss + sbbox_conf_loss + mbbox_conf_loss) * 64.3
- prob_loss = (lbbox_prob_loss + sbbox_prob_loss + mbbox_prob_loss) * 1
-
- return ciou_loss+conf_loss+prob_loss
-
-
-def loss_layer(conv, pred, label, bboxes, stride, num_class, iou_loss_thresh):
- conv_shape = tf.shape(conv)
- batch_size = conv_shape[0]
- output_size = conv_shape[1]
- input_size = stride * output_size
- conv = tf.reshape(conv, (batch_size, output_size, output_size,
- 3, 5 + num_class))
- conv_raw_prob = conv[:, :, :, :, 5:]
- conv_raw_conf = conv[:, :, :, :, 4:5]
-
- pred_xywh = pred[:, :, :, :, 0:4]
- pred_conf = pred[:, :, :, :, 4:5]
-
- label_xywh = label[:, :, :, :, 0:4]
- respond_bbox = label[:, :, :, :, 4:5]
- label_prob = label[:, :, :, :, 5:]
-
- # Coordinate loss
- ciou = tf.expand_dims(bbox_giou(pred_xywh, label_xywh), axis=-1) # (8, 13, 13, 3, 1)
- # ciou = tf.expand_dims(bbox_ciou(pred_xywh, label_xywh), axis=-1) # (8, 13, 13, 3, 1)
- input_size = tf.cast(input_size, tf.float32)
-
- # loss weight of the gt bbox: 2-(gt area/img area)
- bbox_loss_scale = 2.0 - 1.0 * label_xywh[:, :, :, :, 2:3] * label_xywh[:, :, :, :, 3:4] / (input_size ** 2)
- ciou_loss = respond_bbox * bbox_loss_scale * (1 - ciou) # iou loss for respond bbox
-
- # Classification loss for respond bbox
- prob_loss = respond_bbox * tf.nn.sigmoid_cross_entropy_with_logits(labels=label_prob, logits=conv_raw_prob)
-
- expand_pred_xywh = pred_xywh[:, :, :, :, np.newaxis, :] # (?, grid_h, grid_w, 3, 1, 4)
- expand_bboxes = bboxes[:, np.newaxis, np.newaxis, np.newaxis, :, :] # (?, 1, 1, 1, 70, 4)
- iou = bbox_iou(expand_pred_xywh, expand_bboxes) # IoU between all pred bbox and all gt (?, grid_h, grid_w, 3, 70)
- max_iou = tf.expand_dims(tf.reduce_max(iou, axis=-1), axis=-1) # max iou: (?, grid_h, grid_w, 3, 1)
-
- # ignore the bbox which is not respond bbox and max iou < threshold
- respond_bgd = (1.0 - respond_bbox) * tf.cast(max_iou < iou_loss_thresh, tf.float32)
-
- # Confidence loss
- conf_focal = tf.pow(respond_bbox - pred_conf, 2)
-
- conf_loss = conf_focal * (
- respond_bbox * tf.nn.sigmoid_cross_entropy_with_logits(labels=respond_bbox, logits=conv_raw_conf)
- +
- respond_bgd * tf.nn.sigmoid_cross_entropy_with_logits(labels=respond_bbox, logits=conv_raw_conf)
- )
-
- ciou_loss = tf.reduce_mean(tf.reduce_sum(ciou_loss, axis=[1, 2, 3, 4]))
- conf_loss = tf.reduce_mean(tf.reduce_sum(conf_loss, axis=[1, 2, 3, 4]))
- prob_loss = tf.reduce_mean(tf.reduce_sum(prob_loss, axis=[1, 2, 3, 4]))
-
- return ciou_loss, conf_loss, prob_loss
-
-
-def decode(conv_output, anchors, stride, num_class):
- conv_shape = tf.shape(conv_output)
- batch_size = conv_shape[0]
- output_size = conv_shape[1]
- anchor_per_scale = len(anchors)
- conv_output = tf.reshape(conv_output, (batch_size, output_size, output_size, anchor_per_scale, 5 + num_class))
- conv_raw_dxdy = conv_output[:, :, :, :, 0:2]
- conv_raw_dwdh = conv_output[:, :, :, :, 2:4]
- conv_raw_conf = conv_output[:, :, :, :, 4:5]
- conv_raw_prob = conv_output[:, :, :, :, 5:]
- y = tf.tile(tf.range(output_size, dtype=tf.int32)[:, tf.newaxis], [1, output_size])
- x = tf.tile(tf.range(output_size, dtype=tf.int32)[tf.newaxis, :], [output_size, 1])
- xy_grid = tf.concat([x[:, :, tf.newaxis], y[:, :, tf.newaxis]], axis=-1)
- xy_grid = tf.tile(xy_grid[tf.newaxis, :, :, tf.newaxis, :], [batch_size, 1, 1, anchor_per_scale, 1])
- xy_grid = tf.cast(xy_grid, tf.float32)
- pred_xy = (tf.sigmoid(conv_raw_dxdy) + xy_grid) * stride
- pred_wh = (tf.exp(conv_raw_dwdh) * anchors)
- pred_xywh = tf.concat([pred_xy, pred_wh], axis=-1)
- pred_conf = tf.sigmoid(conv_raw_conf)
- pred_prob = tf.sigmoid(conv_raw_prob)
- return tf.concat([pred_xywh, pred_conf, pred_prob], axis=-1)
-
diff --git a/spaces/jharrison27/gradio-blenderbot/app.py b/spaces/jharrison27/gradio-blenderbot/app.py
deleted file mode 100644
index 402decb0f85e7d8816700a68087dda65a1975594..0000000000000000000000000000000000000000
--- a/spaces/jharrison27/gradio-blenderbot/app.py
+++ /dev/null
@@ -1,52 +0,0 @@
-from transformers import BlenderbotTokenizer, BlenderbotForConditionalGeneration
-import torch
-import gradio as gr
-
-mname = "facebook/blenderbot-400M-distill"
-model = BlenderbotForConditionalGeneration.from_pretrained(mname)
-tokenizer = BlenderbotTokenizer.from_pretrained(mname)
-
-def take_last_tokens(inputs, note_history, history):
- """Filter the last 128 tokens"""
- if inputs['input_ids'].shape[1] > 128:
- inputs['input_ids'] = torch.tensor([inputs['input_ids'][0][-128:].tolist()])
- inputs['attention_mask'] = torch.tensor([inputs['attention_mask'][0][-128:].tolist()])
- note_history = [' '.join(note_history[0].split('')[2:])]
- history = history[1:]
- return inputs, note_history, history
-
-def add_note_to_history(note, note_history):
- """Add a note to the historical information"""
- note_history.append(note)
- note_history = ''.join(note_history)
- return [note_history]
-
-title = "Blenderbot Tokenizer with Conditional Generation State of the Art"
-description = """Blenderbot"""
-
-def chat(message, history):
- history = history or []
- if history:
- history_useful = [''.join([str(a[0])+''+str(a[1]) for a in history])]
- else:
- history_useful = []
- history_useful = add_note_to_history(message, history_useful)
- inputs = tokenizer(history_useful, return_tensors="pt")
- inputs, history_useful, history = take_last_tokens(inputs, history_useful, history)
- reply_ids = model.generate(**inputs)
- response = tokenizer.batch_decode(reply_ids, skip_special_tokens=True)[0]
- history_useful = add_note_to_history(response, history_useful)
- list_history = history_useful[0].split('')
- history.append((list_history[-2], list_history[-1]))
- return history, history
-
-gr.Interface(
- fn=chat,
- theme="huggingface",
- css=".footer {display:none !important}",
- inputs=["text", "state"],
- outputs=["chatbot", "state"],
- title=title,
- description=description,
- allow_flagging="never",
- ).launch()
\ No newline at end of file
diff --git a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/PIL/ImageFont.py b/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/PIL/ImageFont.py
deleted file mode 100644
index 05828a72fdf90dbe434cebf06f968ef7e91189b3..0000000000000000000000000000000000000000
--- a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/PIL/ImageFont.py
+++ /dev/null
@@ -1,997 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# PIL raster font management
-#
-# History:
-# 1996-08-07 fl created (experimental)
-# 1997-08-25 fl minor adjustments to handle fonts from pilfont 0.3
-# 1999-02-06 fl rewrote most font management stuff in C
-# 1999-03-17 fl take pth files into account in load_path (from Richard Jones)
-# 2001-02-17 fl added freetype support
-# 2001-05-09 fl added TransposedFont wrapper class
-# 2002-03-04 fl make sure we have a "L" or "1" font
-# 2002-12-04 fl skip non-directory entries in the system path
-# 2003-04-29 fl add embedded default font
-# 2003-09-27 fl added support for truetype charmap encodings
-#
-# Todo:
-# Adapt to PILFONT2 format (16-bit fonts, compressed, single file)
-#
-# Copyright (c) 1997-2003 by Secret Labs AB
-# Copyright (c) 1996-2003 by Fredrik Lundh
-#
-# See the README file for information on usage and redistribution.
-#
-
-import base64
-import os
-import sys
-import warnings
-from enum import IntEnum
-from io import BytesIO
-
-from . import Image
-from ._util import is_directory, is_path
-
-
-class Layout(IntEnum):
- BASIC = 0
- RAQM = 1
-
-
-MAX_STRING_LENGTH = 1_000_000
-
-
-try:
- from . import _imagingft as core
-except ImportError as ex:
- from ._util import DeferredError
-
- core = DeferredError(ex)
-
-
-def _string_length_check(text):
- if MAX_STRING_LENGTH is not None and len(text) > MAX_STRING_LENGTH:
- msg = "too many characters in string"
- raise ValueError(msg)
-
-
-# FIXME: add support for pilfont2 format (see FontFile.py)
-
-# --------------------------------------------------------------------
-# Font metrics format:
-# "PILfont" LF
-# fontdescriptor LF
-# (optional) key=value... LF
-# "DATA" LF
-# binary data: 256*10*2 bytes (dx, dy, dstbox, srcbox)
-#
-# To place a character, cut out srcbox and paste at dstbox,
-# relative to the character position. Then move the character
-# position according to dx, dy.
-# --------------------------------------------------------------------
-
-
-class ImageFont:
- """PIL font wrapper"""
-
- def _load_pilfont(self, filename):
- with open(filename, "rb") as fp:
- image = None
- for ext in (".png", ".gif", ".pbm"):
- if image:
- image.close()
- try:
- fullname = os.path.splitext(filename)[0] + ext
- image = Image.open(fullname)
- except Exception:
- pass
- else:
- if image and image.mode in ("1", "L"):
- break
- else:
- if image:
- image.close()
- msg = "cannot find glyph data file"
- raise OSError(msg)
-
- self.file = fullname
-
- self._load_pilfont_data(fp, image)
- image.close()
-
- def _load_pilfont_data(self, file, image):
- # read PILfont header
- if file.readline() != b"PILfont\n":
- msg = "Not a PILfont file"
- raise SyntaxError(msg)
- file.readline().split(b";")
- self.info = [] # FIXME: should be a dictionary
- while True:
- s = file.readline()
- if not s or s == b"DATA\n":
- break
- self.info.append(s)
-
- # read PILfont metrics
- data = file.read(256 * 20)
-
- # check image
- if image.mode not in ("1", "L"):
- msg = "invalid font image mode"
- raise TypeError(msg)
-
- image.load()
-
- self.font = Image.core.font(image.im, data)
-
- def getmask(self, text, mode="", *args, **kwargs):
- """
- Create a bitmap for the text.
-
- If the font uses antialiasing, the bitmap should have mode ``L`` and use a
- maximum value of 255. Otherwise, it should have mode ``1``.
-
- :param text: Text to render.
- :param mode: Used by some graphics drivers to indicate what mode the
- driver prefers; if empty, the renderer may return either
- mode. Note that the mode is always a string, to simplify
- C-level implementations.
-
- .. versionadded:: 1.1.5
-
- :return: An internal PIL storage memory instance as defined by the
- :py:mod:`PIL.Image.core` interface module.
- """
- return self.font.getmask(text, mode)
-
- def getbbox(self, text, *args, **kwargs):
- """
- Returns bounding box (in pixels) of given text.
-
- .. versionadded:: 9.2.0
-
- :param text: Text to render.
- :param mode: Used by some graphics drivers to indicate what mode the
- driver prefers; if empty, the renderer may return either
- mode. Note that the mode is always a string, to simplify
- C-level implementations.
-
- :return: ``(left, top, right, bottom)`` bounding box
- """
- _string_length_check(text)
- width, height = self.font.getsize(text)
- return 0, 0, width, height
-
- def getlength(self, text, *args, **kwargs):
- """
- Returns length (in pixels) of given text.
- This is the amount by which following text should be offset.
-
- .. versionadded:: 9.2.0
- """
- _string_length_check(text)
- width, height = self.font.getsize(text)
- return width
-
-
-##
-# Wrapper for FreeType fonts. Application code should use the
-# truetype factory function to create font objects.
-
-
-class FreeTypeFont:
- """FreeType font wrapper (requires _imagingft service)"""
-
- def __init__(self, font=None, size=10, index=0, encoding="", layout_engine=None):
- # FIXME: use service provider instead
-
- self.path = font
- self.size = size
- self.index = index
- self.encoding = encoding
-
- if layout_engine not in (Layout.BASIC, Layout.RAQM):
- layout_engine = Layout.BASIC
- if core.HAVE_RAQM:
- layout_engine = Layout.RAQM
- elif layout_engine == Layout.RAQM and not core.HAVE_RAQM:
- warnings.warn(
- "Raqm layout was requested, but Raqm is not available. "
- "Falling back to basic layout."
- )
- layout_engine = Layout.BASIC
-
- self.layout_engine = layout_engine
-
- def load_from_bytes(f):
- self.font_bytes = f.read()
- self.font = core.getfont(
- "", size, index, encoding, self.font_bytes, layout_engine
- )
-
- if is_path(font):
- if sys.platform == "win32":
- font_bytes_path = font if isinstance(font, bytes) else font.encode()
- try:
- font_bytes_path.decode("ascii")
- except UnicodeDecodeError:
- # FreeType cannot load fonts with non-ASCII characters on Windows
- # So load it into memory first
- with open(font, "rb") as f:
- load_from_bytes(f)
- return
- self.font = core.getfont(
- font, size, index, encoding, layout_engine=layout_engine
- )
- else:
- load_from_bytes(font)
-
- def __getstate__(self):
- return [self.path, self.size, self.index, self.encoding, self.layout_engine]
-
- def __setstate__(self, state):
- path, size, index, encoding, layout_engine = state
- self.__init__(path, size, index, encoding, layout_engine)
-
- def getname(self):
- """
- :return: A tuple of the font family (e.g. Helvetica) and the font style
- (e.g. Bold)
- """
- return self.font.family, self.font.style
-
- def getmetrics(self):
- """
- :return: A tuple of the font ascent (the distance from the baseline to
- the highest outline point) and descent (the distance from the
- baseline to the lowest outline point, a negative value)
- """
- return self.font.ascent, self.font.descent
-
- def getlength(self, text, mode="", direction=None, features=None, language=None):
- """
- Returns length (in pixels with 1/64 precision) of given text when rendered
- in font with provided direction, features, and language.
-
- This is the amount by which following text should be offset.
- Text bounding box may extend past the length in some fonts,
- e.g. when using italics or accents.
-
- The result is returned as a float; it is a whole number if using basic layout.
-
- Note that the sum of two lengths may not equal the length of a concatenated
- string due to kerning. If you need to adjust for kerning, include the following
- character and subtract its length.
-
- For example, instead of ::
-
- hello = font.getlength("Hello")
- world = font.getlength("World")
- hello_world = hello + world # not adjusted for kerning
- assert hello_world == font.getlength("HelloWorld") # may fail
-
- use ::
-
- hello = font.getlength("HelloW") - font.getlength("W") # adjusted for kerning
- world = font.getlength("World")
- hello_world = hello + world # adjusted for kerning
- assert hello_world == font.getlength("HelloWorld") # True
-
- or disable kerning with (requires libraqm) ::
-
- hello = draw.textlength("Hello", font, features=["-kern"])
- world = draw.textlength("World", font, features=["-kern"])
- hello_world = hello + world # kerning is disabled, no need to adjust
- assert hello_world == draw.textlength("HelloWorld", font, features=["-kern"])
-
- .. versionadded:: 8.0.0
-
- :param text: Text to measure.
- :param mode: Used by some graphics drivers to indicate what mode the
- driver prefers; if empty, the renderer may return either
- mode. Note that the mode is always a string, to simplify
- C-level implementations.
-
- :param direction: Direction of the text. It can be 'rtl' (right to
- left), 'ltr' (left to right) or 'ttb' (top to bottom).
- Requires libraqm.
-
- :param features: A list of OpenType font features to be used during text
- layout. This is usually used to turn on optional
- font features that are not enabled by default,
- for example 'dlig' or 'ss01', but can be also
- used to turn off default font features for
- example '-liga' to disable ligatures or '-kern'
- to disable kerning. To get all supported
- features, see
- https://learn.microsoft.com/en-us/typography/opentype/spec/featurelist
- Requires libraqm.
-
- :param language: Language of the text. Different languages may use
- different glyph shapes or ligatures. This parameter tells
- the font which language the text is in, and to apply the
- correct substitutions as appropriate, if available.
- It should be a `BCP 47 language code
- `_
- Requires libraqm.
-
- :return: Width for horizontal, height for vertical text.
- """
- _string_length_check(text)
- return self.font.getlength(text, mode, direction, features, language) / 64
-
- def getbbox(
- self,
- text,
- mode="",
- direction=None,
- features=None,
- language=None,
- stroke_width=0,
- anchor=None,
- ):
- """
- Returns bounding box (in pixels) of given text relative to given anchor
- when rendered in font with provided direction, features, and language.
-
- Use :py:meth:`getlength()` to get the offset of following text with
- 1/64 pixel precision. The bounding box includes extra margins for
- some fonts, e.g. italics or accents.
-
- .. versionadded:: 8.0.0
-
- :param text: Text to render.
- :param mode: Used by some graphics drivers to indicate what mode the
- driver prefers; if empty, the renderer may return either
- mode. Note that the mode is always a string, to simplify
- C-level implementations.
-
- :param direction: Direction of the text. It can be 'rtl' (right to
- left), 'ltr' (left to right) or 'ttb' (top to bottom).
- Requires libraqm.
-
- :param features: A list of OpenType font features to be used during text
- layout. This is usually used to turn on optional
- font features that are not enabled by default,
- for example 'dlig' or 'ss01', but can be also
- used to turn off default font features for
- example '-liga' to disable ligatures or '-kern'
- to disable kerning. To get all supported
- features, see
- https://learn.microsoft.com/en-us/typography/opentype/spec/featurelist
- Requires libraqm.
-
- :param language: Language of the text. Different languages may use
- different glyph shapes or ligatures. This parameter tells
- the font which language the text is in, and to apply the
- correct substitutions as appropriate, if available.
- It should be a `BCP 47 language code
- `_
- Requires libraqm.
-
- :param stroke_width: The width of the text stroke.
-
- :param anchor: The text anchor alignment. Determines the relative location of
- the anchor to the text. The default alignment is top left.
- See :ref:`text-anchors` for valid values.
-
- :return: ``(left, top, right, bottom)`` bounding box
- """
- _string_length_check(text)
- size, offset = self.font.getsize(
- text, mode, direction, features, language, anchor
- )
- left, top = offset[0] - stroke_width, offset[1] - stroke_width
- width, height = size[0] + 2 * stroke_width, size[1] + 2 * stroke_width
- return left, top, left + width, top + height
-
- def getmask(
- self,
- text,
- mode="",
- direction=None,
- features=None,
- language=None,
- stroke_width=0,
- anchor=None,
- ink=0,
- start=None,
- ):
- """
- Create a bitmap for the text.
-
- If the font uses antialiasing, the bitmap should have mode ``L`` and use a
- maximum value of 255. If the font has embedded color data, the bitmap
- should have mode ``RGBA``. Otherwise, it should have mode ``1``.
-
- :param text: Text to render.
- :param mode: Used by some graphics drivers to indicate what mode the
- driver prefers; if empty, the renderer may return either
- mode. Note that the mode is always a string, to simplify
- C-level implementations.
-
- .. versionadded:: 1.1.5
-
- :param direction: Direction of the text. It can be 'rtl' (right to
- left), 'ltr' (left to right) or 'ttb' (top to bottom).
- Requires libraqm.
-
- .. versionadded:: 4.2.0
-
- :param features: A list of OpenType font features to be used during text
- layout. This is usually used to turn on optional
- font features that are not enabled by default,
- for example 'dlig' or 'ss01', but can be also
- used to turn off default font features for
- example '-liga' to disable ligatures or '-kern'
- to disable kerning. To get all supported
- features, see
- https://learn.microsoft.com/en-us/typography/opentype/spec/featurelist
- Requires libraqm.
-
- .. versionadded:: 4.2.0
-
- :param language: Language of the text. Different languages may use
- different glyph shapes or ligatures. This parameter tells
- the font which language the text is in, and to apply the
- correct substitutions as appropriate, if available.
- It should be a `BCP 47 language code
- `_
- Requires libraqm.
-
- .. versionadded:: 6.0.0
-
- :param stroke_width: The width of the text stroke.
-
- .. versionadded:: 6.2.0
-
- :param anchor: The text anchor alignment. Determines the relative location of
- the anchor to the text. The default alignment is top left.
- See :ref:`text-anchors` for valid values.
-
- .. versionadded:: 8.0.0
-
- :param ink: Foreground ink for rendering in RGBA mode.
-
- .. versionadded:: 8.0.0
-
- :param start: Tuple of horizontal and vertical offset, as text may render
- differently when starting at fractional coordinates.
-
- .. versionadded:: 9.4.0
-
- :return: An internal PIL storage memory instance as defined by the
- :py:mod:`PIL.Image.core` interface module.
- """
- return self.getmask2(
- text,
- mode,
- direction=direction,
- features=features,
- language=language,
- stroke_width=stroke_width,
- anchor=anchor,
- ink=ink,
- start=start,
- )[0]
-
- def getmask2(
- self,
- text,
- mode="",
- direction=None,
- features=None,
- language=None,
- stroke_width=0,
- anchor=None,
- ink=0,
- start=None,
- *args,
- **kwargs,
- ):
- """
- Create a bitmap for the text.
-
- If the font uses antialiasing, the bitmap should have mode ``L`` and use a
- maximum value of 255. If the font has embedded color data, the bitmap
- should have mode ``RGBA``. Otherwise, it should have mode ``1``.
-
- :param text: Text to render.
- :param mode: Used by some graphics drivers to indicate what mode the
- driver prefers; if empty, the renderer may return either
- mode. Note that the mode is always a string, to simplify
- C-level implementations.
-
- .. versionadded:: 1.1.5
-
- :param direction: Direction of the text. It can be 'rtl' (right to
- left), 'ltr' (left to right) or 'ttb' (top to bottom).
- Requires libraqm.
-
- .. versionadded:: 4.2.0
-
- :param features: A list of OpenType font features to be used during text
- layout. This is usually used to turn on optional
- font features that are not enabled by default,
- for example 'dlig' or 'ss01', but can be also
- used to turn off default font features for
- example '-liga' to disable ligatures or '-kern'
- to disable kerning. To get all supported
- features, see
- https://learn.microsoft.com/en-us/typography/opentype/spec/featurelist
- Requires libraqm.
-
- .. versionadded:: 4.2.0
-
- :param language: Language of the text. Different languages may use
- different glyph shapes or ligatures. This parameter tells
- the font which language the text is in, and to apply the
- correct substitutions as appropriate, if available.
- It should be a `BCP 47 language code
- `_
- Requires libraqm.
-
- .. versionadded:: 6.0.0
-
- :param stroke_width: The width of the text stroke.
-
- .. versionadded:: 6.2.0
-
- :param anchor: The text anchor alignment. Determines the relative location of
- the anchor to the text. The default alignment is top left.
- See :ref:`text-anchors` for valid values.
-
- .. versionadded:: 8.0.0
-
- :param ink: Foreground ink for rendering in RGBA mode.
-
- .. versionadded:: 8.0.0
-
- :param start: Tuple of horizontal and vertical offset, as text may render
- differently when starting at fractional coordinates.
-
- .. versionadded:: 9.4.0
-
- :return: A tuple of an internal PIL storage memory instance as defined by the
- :py:mod:`PIL.Image.core` interface module, and the text offset, the
- gap between the starting coordinate and the first marking
- """
- _string_length_check(text)
- if start is None:
- start = (0, 0)
- im = None
-
- def fill(mode, size):
- nonlocal im
-
- im = Image.core.fill(mode, size)
- return im
-
- size, offset = self.font.render(
- text,
- fill,
- mode,
- direction,
- features,
- language,
- stroke_width,
- anchor,
- ink,
- start[0],
- start[1],
- Image.MAX_IMAGE_PIXELS,
- )
- Image._decompression_bomb_check(size)
- return im, offset
-
- def font_variant(
- self, font=None, size=None, index=None, encoding=None, layout_engine=None
- ):
- """
- Create a copy of this FreeTypeFont object,
- using any specified arguments to override the settings.
-
- Parameters are identical to the parameters used to initialize this
- object.
-
- :return: A FreeTypeFont object.
- """
- if font is None:
- try:
- font = BytesIO(self.font_bytes)
- except AttributeError:
- font = self.path
- return FreeTypeFont(
- font=font,
- size=self.size if size is None else size,
- index=self.index if index is None else index,
- encoding=self.encoding if encoding is None else encoding,
- layout_engine=layout_engine or self.layout_engine,
- )
-
- def get_variation_names(self):
- """
- :returns: A list of the named styles in a variation font.
- :exception OSError: If the font is not a variation font.
- """
- try:
- names = self.font.getvarnames()
- except AttributeError as e:
- msg = "FreeType 2.9.1 or greater is required"
- raise NotImplementedError(msg) from e
- return [name.replace(b"\x00", b"") for name in names]
-
- def set_variation_by_name(self, name):
- """
- :param name: The name of the style.
- :exception OSError: If the font is not a variation font.
- """
- names = self.get_variation_names()
- if not isinstance(name, bytes):
- name = name.encode()
- index = names.index(name) + 1
-
- if index == getattr(self, "_last_variation_index", None):
- # When the same name is set twice in a row,
- # there is an 'unknown freetype error'
- # https://savannah.nongnu.org/bugs/?56186
- return
- self._last_variation_index = index
-
- self.font.setvarname(index)
-
- def get_variation_axes(self):
- """
- :returns: A list of the axes in a variation font.
- :exception OSError: If the font is not a variation font.
- """
- try:
- axes = self.font.getvaraxes()
- except AttributeError as e:
- msg = "FreeType 2.9.1 or greater is required"
- raise NotImplementedError(msg) from e
- for axis in axes:
- axis["name"] = axis["name"].replace(b"\x00", b"")
- return axes
-
- def set_variation_by_axes(self, axes):
- """
- :param axes: A list of values for each axis.
- :exception OSError: If the font is not a variation font.
- """
- try:
- self.font.setvaraxes(axes)
- except AttributeError as e:
- msg = "FreeType 2.9.1 or greater is required"
- raise NotImplementedError(msg) from e
-
-
-class TransposedFont:
- """Wrapper for writing rotated or mirrored text"""
-
- def __init__(self, font, orientation=None):
- """
- Wrapper that creates a transposed font from any existing font
- object.
-
- :param font: A font object.
- :param orientation: An optional orientation. If given, this should
- be one of Image.Transpose.FLIP_LEFT_RIGHT, Image.Transpose.FLIP_TOP_BOTTOM,
- Image.Transpose.ROTATE_90, Image.Transpose.ROTATE_180, or
- Image.Transpose.ROTATE_270.
- """
- self.font = font
- self.orientation = orientation # any 'transpose' argument, or None
-
- def getmask(self, text, mode="", *args, **kwargs):
- im = self.font.getmask(text, mode, *args, **kwargs)
- if self.orientation is not None:
- return im.transpose(self.orientation)
- return im
-
- def getbbox(self, text, *args, **kwargs):
- # TransposedFont doesn't support getmask2, move top-left point to (0, 0)
- # this has no effect on ImageFont and simulates anchor="lt" for FreeTypeFont
- left, top, right, bottom = self.font.getbbox(text, *args, **kwargs)
- width = right - left
- height = bottom - top
- if self.orientation in (Image.Transpose.ROTATE_90, Image.Transpose.ROTATE_270):
- return 0, 0, height, width
- return 0, 0, width, height
-
- def getlength(self, text, *args, **kwargs):
- if self.orientation in (Image.Transpose.ROTATE_90, Image.Transpose.ROTATE_270):
- msg = "text length is undefined for text rotated by 90 or 270 degrees"
- raise ValueError(msg)
- _string_length_check(text)
- return self.font.getlength(text, *args, **kwargs)
-
-
-def load(filename):
- """
- Load a font file. This function loads a font object from the given
- bitmap font file, and returns the corresponding font object.
-
- :param filename: Name of font file.
- :return: A font object.
- :exception OSError: If the file could not be read.
- """
- f = ImageFont()
- f._load_pilfont(filename)
- return f
-
-
-def truetype(font=None, size=10, index=0, encoding="", layout_engine=None):
- """
- Load a TrueType or OpenType font from a file or file-like object,
- and create a font object.
- This function loads a font object from the given file or file-like
- object, and creates a font object for a font of the given size.
-
- Pillow uses FreeType to open font files. On Windows, be aware that FreeType
- will keep the file open as long as the FreeTypeFont object exists. Windows
- limits the number of files that can be open in C at once to 512, so if many
- fonts are opened simultaneously and that limit is approached, an
- ``OSError`` may be thrown, reporting that FreeType "cannot open resource".
- A workaround would be to copy the file(s) into memory, and open that instead.
-
- This function requires the _imagingft service.
-
- :param font: A filename or file-like object containing a TrueType font.
- If the file is not found in this filename, the loader may also
- search in other directories, such as the :file:`fonts/`
- directory on Windows or :file:`/Library/Fonts/`,
- :file:`/System/Library/Fonts/` and :file:`~/Library/Fonts/` on
- macOS.
-
- :param size: The requested size, in pixels.
- :param index: Which font face to load (default is first available face).
- :param encoding: Which font encoding to use (default is Unicode). Possible
- encodings include (see the FreeType documentation for more
- information):
-
- * "unic" (Unicode)
- * "symb" (Microsoft Symbol)
- * "ADOB" (Adobe Standard)
- * "ADBE" (Adobe Expert)
- * "ADBC" (Adobe Custom)
- * "armn" (Apple Roman)
- * "sjis" (Shift JIS)
- * "gb " (PRC)
- * "big5"
- * "wans" (Extended Wansung)
- * "joha" (Johab)
- * "lat1" (Latin-1)
-
- This specifies the character set to use. It does not alter the
- encoding of any text provided in subsequent operations.
- :param layout_engine: Which layout engine to use, if available:
- :data:`.ImageFont.Layout.BASIC` or :data:`.ImageFont.Layout.RAQM`.
- If it is available, Raqm layout will be used by default.
- Otherwise, basic layout will be used.
-
- Raqm layout is recommended for all non-English text. If Raqm layout
- is not required, basic layout will have better performance.
-
- You can check support for Raqm layout using
- :py:func:`PIL.features.check_feature` with ``feature="raqm"``.
-
- .. versionadded:: 4.2.0
- :return: A font object.
- :exception OSError: If the file could not be read.
- """
-
- def freetype(font):
- return FreeTypeFont(font, size, index, encoding, layout_engine)
-
- try:
- return freetype(font)
- except OSError:
- if not is_path(font):
- raise
- ttf_filename = os.path.basename(font)
-
- dirs = []
- if sys.platform == "win32":
- # check the windows font repository
- # NOTE: must use uppercase WINDIR, to work around bugs in
- # 1.5.2's os.environ.get()
- windir = os.environ.get("WINDIR")
- if windir:
- dirs.append(os.path.join(windir, "fonts"))
- elif sys.platform in ("linux", "linux2"):
- lindirs = os.environ.get("XDG_DATA_DIRS")
- if not lindirs:
- # According to the freedesktop spec, XDG_DATA_DIRS should
- # default to /usr/share
- lindirs = "/usr/share"
- dirs += [os.path.join(lindir, "fonts") for lindir in lindirs.split(":")]
- elif sys.platform == "darwin":
- dirs += [
- "/Library/Fonts",
- "/System/Library/Fonts",
- os.path.expanduser("~/Library/Fonts"),
- ]
-
- ext = os.path.splitext(ttf_filename)[1]
- first_font_with_a_different_extension = None
- for directory in dirs:
- for walkroot, walkdir, walkfilenames in os.walk(directory):
- for walkfilename in walkfilenames:
- if ext and walkfilename == ttf_filename:
- return freetype(os.path.join(walkroot, walkfilename))
- elif not ext and os.path.splitext(walkfilename)[0] == ttf_filename:
- fontpath = os.path.join(walkroot, walkfilename)
- if os.path.splitext(fontpath)[1] == ".ttf":
- return freetype(fontpath)
- if not ext and first_font_with_a_different_extension is None:
- first_font_with_a_different_extension = fontpath
- if first_font_with_a_different_extension:
- return freetype(first_font_with_a_different_extension)
- raise
-
-
-def load_path(filename):
- """
- Load font file. Same as :py:func:`~PIL.ImageFont.load`, but searches for a
- bitmap font along the Python path.
-
- :param filename: Name of font file.
- :return: A font object.
- :exception OSError: If the file could not be read.
- """
- for directory in sys.path:
- if is_directory(directory):
- if not isinstance(filename, str):
- filename = filename.decode("utf-8")
- try:
- return load(os.path.join(directory, filename))
- except OSError:
- pass
- msg = "cannot find font file"
- raise OSError(msg)
-
-
-def load_default():
- """Load a "better than nothing" default font.
-
- .. versionadded:: 1.1.4
-
- :return: A font object.
- """
- f = ImageFont()
- f._load_pilfont_data(
- # courB08
- BytesIO(
- base64.b64decode(
- b"""
-UElMZm9udAo7Ozs7OzsxMDsKREFUQQoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAA//8AAQAAAAAAAAABAAEA
-BgAAAAH/+gADAAAAAQAAAAMABgAGAAAAAf/6AAT//QADAAAABgADAAYAAAAA//kABQABAAYAAAAL
-AAgABgAAAAD/+AAFAAEACwAAABAACQAGAAAAAP/5AAUAAAAQAAAAFQAHAAYAAP////oABQAAABUA
-AAAbAAYABgAAAAH/+QAE//wAGwAAAB4AAwAGAAAAAf/5AAQAAQAeAAAAIQAIAAYAAAAB//kABAAB
-ACEAAAAkAAgABgAAAAD/+QAE//0AJAAAACgABAAGAAAAAP/6AAX//wAoAAAALQAFAAYAAAAB//8A
-BAACAC0AAAAwAAMABgAAAAD//AAF//0AMAAAADUAAQAGAAAAAf//AAMAAAA1AAAANwABAAYAAAAB
-//kABQABADcAAAA7AAgABgAAAAD/+QAFAAAAOwAAAEAABwAGAAAAAP/5AAYAAABAAAAARgAHAAYA
-AAAA//kABQAAAEYAAABLAAcABgAAAAD/+QAFAAAASwAAAFAABwAGAAAAAP/5AAYAAABQAAAAVgAH
-AAYAAAAA//kABQAAAFYAAABbAAcABgAAAAD/+QAFAAAAWwAAAGAABwAGAAAAAP/5AAUAAABgAAAA
-ZQAHAAYAAAAA//kABQAAAGUAAABqAAcABgAAAAD/+QAFAAAAagAAAG8ABwAGAAAAAf/8AAMAAABv
-AAAAcQAEAAYAAAAA//wAAwACAHEAAAB0AAYABgAAAAD/+gAE//8AdAAAAHgABQAGAAAAAP/7AAT/
-/gB4AAAAfAADAAYAAAAB//oABf//AHwAAACAAAUABgAAAAD/+gAFAAAAgAAAAIUABgAGAAAAAP/5
-AAYAAQCFAAAAiwAIAAYAAP////oABgAAAIsAAACSAAYABgAA////+gAFAAAAkgAAAJgABgAGAAAA
-AP/6AAUAAACYAAAAnQAGAAYAAP////oABQAAAJ0AAACjAAYABgAA////+gAFAAAAowAAAKkABgAG
-AAD////6AAUAAACpAAAArwAGAAYAAAAA//oABQAAAK8AAAC0AAYABgAA////+gAGAAAAtAAAALsA
-BgAGAAAAAP/6AAQAAAC7AAAAvwAGAAYAAP////oABQAAAL8AAADFAAYABgAA////+gAGAAAAxQAA
-AMwABgAGAAD////6AAUAAADMAAAA0gAGAAYAAP////oABQAAANIAAADYAAYABgAA////+gAGAAAA
-2AAAAN8ABgAGAAAAAP/6AAUAAADfAAAA5AAGAAYAAP////oABQAAAOQAAADqAAYABgAAAAD/+gAF
-AAEA6gAAAO8ABwAGAAD////6AAYAAADvAAAA9gAGAAYAAAAA//oABQAAAPYAAAD7AAYABgAA////
-+gAFAAAA+wAAAQEABgAGAAD////6AAYAAAEBAAABCAAGAAYAAP////oABgAAAQgAAAEPAAYABgAA
-////+gAGAAABDwAAARYABgAGAAAAAP/6AAYAAAEWAAABHAAGAAYAAP////oABgAAARwAAAEjAAYA
-BgAAAAD/+gAFAAABIwAAASgABgAGAAAAAf/5AAQAAQEoAAABKwAIAAYAAAAA//kABAABASsAAAEv
-AAgABgAAAAH/+QAEAAEBLwAAATIACAAGAAAAAP/5AAX//AEyAAABNwADAAYAAAAAAAEABgACATcA
-AAE9AAEABgAAAAH/+QAE//wBPQAAAUAAAwAGAAAAAP/7AAYAAAFAAAABRgAFAAYAAP////kABQAA
-AUYAAAFMAAcABgAAAAD/+wAFAAABTAAAAVEABQAGAAAAAP/5AAYAAAFRAAABVwAHAAYAAAAA//sA
-BQAAAVcAAAFcAAUABgAAAAD/+QAFAAABXAAAAWEABwAGAAAAAP/7AAYAAgFhAAABZwAHAAYAAP//
-//kABQAAAWcAAAFtAAcABgAAAAD/+QAGAAABbQAAAXMABwAGAAAAAP/5AAQAAgFzAAABdwAJAAYA
-AP////kABgAAAXcAAAF+AAcABgAAAAD/+QAGAAABfgAAAYQABwAGAAD////7AAUAAAGEAAABigAF
-AAYAAP////sABQAAAYoAAAGQAAUABgAAAAD/+wAFAAABkAAAAZUABQAGAAD////7AAUAAgGVAAAB
-mwAHAAYAAAAA//sABgACAZsAAAGhAAcABgAAAAD/+wAGAAABoQAAAacABQAGAAAAAP/7AAYAAAGn
-AAABrQAFAAYAAAAA//kABgAAAa0AAAGzAAcABgAA////+wAGAAABswAAAboABQAGAAD////7AAUA
-AAG6AAABwAAFAAYAAP////sABgAAAcAAAAHHAAUABgAAAAD/+wAGAAABxwAAAc0ABQAGAAD////7
-AAYAAgHNAAAB1AAHAAYAAAAA//sABQAAAdQAAAHZAAUABgAAAAH/+QAFAAEB2QAAAd0ACAAGAAAA
-Av/6AAMAAQHdAAAB3gAHAAYAAAAA//kABAABAd4AAAHiAAgABgAAAAD/+wAF//0B4gAAAecAAgAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAB
-//sAAwACAecAAAHpAAcABgAAAAD/+QAFAAEB6QAAAe4ACAAGAAAAAP/5AAYAAAHuAAAB9AAHAAYA
-AAAA//oABf//AfQAAAH5AAUABgAAAAD/+QAGAAAB+QAAAf8ABwAGAAAAAv/5AAMAAgH/AAACAAAJ
-AAYAAAAA//kABQABAgAAAAIFAAgABgAAAAH/+gAE//sCBQAAAggAAQAGAAAAAP/5AAYAAAIIAAAC
-DgAHAAYAAAAB//kABf/+Ag4AAAISAAUABgAA////+wAGAAACEgAAAhkABQAGAAAAAP/7AAX//gIZ
-AAACHgADAAYAAAAA//wABf/9Ah4AAAIjAAEABgAAAAD/+QAHAAACIwAAAioABwAGAAAAAP/6AAT/
-+wIqAAACLgABAAYAAAAA//kABP/8Ai4AAAIyAAMABgAAAAD/+gAFAAACMgAAAjcABgAGAAAAAf/5
-AAT//QI3AAACOgAEAAYAAAAB//kABP/9AjoAAAI9AAQABgAAAAL/+QAE//sCPQAAAj8AAgAGAAD/
-///7AAYAAgI/AAACRgAHAAYAAAAA//kABgABAkYAAAJMAAgABgAAAAH//AAD//0CTAAAAk4AAQAG
-AAAAAf//AAQAAgJOAAACUQADAAYAAAAB//kABP/9AlEAAAJUAAQABgAAAAH/+QAF//4CVAAAAlgA
-BQAGAAD////7AAYAAAJYAAACXwAFAAYAAP////kABgAAAl8AAAJmAAcABgAA////+QAGAAACZgAA
-Am0ABwAGAAD////5AAYAAAJtAAACdAAHAAYAAAAA//sABQACAnQAAAJ5AAcABgAA////9wAGAAAC
-eQAAAoAACQAGAAD////3AAYAAAKAAAAChwAJAAYAAP////cABgAAAocAAAKOAAkABgAA////9wAG
-AAACjgAAApUACQAGAAD////4AAYAAAKVAAACnAAIAAYAAP////cABgAAApwAAAKjAAkABgAA////
-+gAGAAACowAAAqoABgAGAAAAAP/6AAUAAgKqAAACrwAIAAYAAP////cABQAAAq8AAAK1AAkABgAA
-////9wAFAAACtQAAArsACQAGAAD////3AAUAAAK7AAACwQAJAAYAAP////gABQAAAsEAAALHAAgA
-BgAAAAD/9wAEAAACxwAAAssACQAGAAAAAP/3AAQAAALLAAACzwAJAAYAAAAA//cABAAAAs8AAALT
-AAkABgAAAAD/+AAEAAAC0wAAAtcACAAGAAD////6AAUAAALXAAAC3QAGAAYAAP////cABgAAAt0A
-AALkAAkABgAAAAD/9wAFAAAC5AAAAukACQAGAAAAAP/3AAUAAALpAAAC7gAJAAYAAAAA//cABQAA
-Au4AAALzAAkABgAAAAD/9wAFAAAC8wAAAvgACQAGAAAAAP/4AAUAAAL4AAAC/QAIAAYAAAAA//oA
-Bf//Av0AAAMCAAUABgAA////+gAGAAADAgAAAwkABgAGAAD////3AAYAAAMJAAADEAAJAAYAAP//
-//cABgAAAxAAAAMXAAkABgAA////9wAGAAADFwAAAx4ACQAGAAD////4AAYAAAAAAAoABwASAAYA
-AP////cABgAAAAcACgAOABMABgAA////+gAFAAAADgAKABQAEAAGAAD////6AAYAAAAUAAoAGwAQ
-AAYAAAAA//gABgAAABsACgAhABIABgAAAAD/+AAGAAAAIQAKACcAEgAGAAAAAP/4AAYAAAAnAAoA
-LQASAAYAAAAA//gABgAAAC0ACgAzABIABgAAAAD/+QAGAAAAMwAKADkAEQAGAAAAAP/3AAYAAAA5
-AAoAPwATAAYAAP////sABQAAAD8ACgBFAA8ABgAAAAD/+wAFAAIARQAKAEoAEQAGAAAAAP/4AAUA
-AABKAAoATwASAAYAAAAA//gABQAAAE8ACgBUABIABgAAAAD/+AAFAAAAVAAKAFkAEgAGAAAAAP/5
-AAUAAABZAAoAXgARAAYAAAAA//gABgAAAF4ACgBkABIABgAAAAD/+AAGAAAAZAAKAGoAEgAGAAAA
-AP/4AAYAAABqAAoAcAASAAYAAAAA//kABgAAAHAACgB2ABEABgAAAAD/+AAFAAAAdgAKAHsAEgAG
-AAD////4AAYAAAB7AAoAggASAAYAAAAA//gABQAAAIIACgCHABIABgAAAAD/+AAFAAAAhwAKAIwA
-EgAGAAAAAP/4AAUAAACMAAoAkQASAAYAAAAA//gABQAAAJEACgCWABIABgAAAAD/+QAFAAAAlgAK
-AJsAEQAGAAAAAP/6AAX//wCbAAoAoAAPAAYAAAAA//oABQABAKAACgClABEABgAA////+AAGAAAA
-pQAKAKwAEgAGAAD////4AAYAAACsAAoAswASAAYAAP////gABgAAALMACgC6ABIABgAA////+QAG
-AAAAugAKAMEAEQAGAAD////4AAYAAgDBAAoAyAAUAAYAAP////kABQACAMgACgDOABMABgAA////
-+QAGAAIAzgAKANUAEw==
-"""
- )
- ),
- Image.open(
- BytesIO(
- base64.b64decode(
- b"""
-iVBORw0KGgoAAAANSUhEUgAAAx4AAAAUAQAAAAArMtZoAAAEwElEQVR4nABlAJr/AHVE4czCI/4u
-Mc4b7vuds/xzjz5/3/7u/n9vMe7vnfH/9++vPn/xyf5zhxzjt8GHw8+2d83u8x27199/nxuQ6Od9
-M43/5z2I+9n9ZtmDBwMQECDRQw/eQIQohJXxpBCNVE6QCCAAAAD//wBlAJr/AgALyj1t/wINwq0g
-LeNZUworuN1cjTPIzrTX6ofHWeo3v336qPzfEwRmBnHTtf95/fglZK5N0PDgfRTslpGBvz7LFc4F
-IUXBWQGjQ5MGCx34EDFPwXiY4YbYxavpnhHFrk14CDAAAAD//wBlAJr/AgKqRooH2gAgPeggvUAA
-Bu2WfgPoAwzRAABAAAAAAACQgLz/3Uv4Gv+gX7BJgDeeGP6AAAD1NMDzKHD7ANWr3loYbxsAD791
-NAADfcoIDyP44K/jv4Y63/Z+t98Ovt+ub4T48LAAAAD//wBlAJr/AuplMlADJAAAAGuAphWpqhMx
-in0A/fRvAYBABPgBwBUgABBQ/sYAyv9g0bCHgOLoGAAAAAAAREAAwI7nr0ArYpow7aX8//9LaP/9
-SjdavWA8ePHeBIKB//81/83ndznOaXx379wAAAD//wBlAJr/AqDxW+D3AABAAbUh/QMnbQag/gAY
-AYDAAACgtgD/gOqAAAB5IA/8AAAk+n9w0AAA8AAAmFRJuPo27ciC0cD5oeW4E7KA/wD3ECMAn2tt
-y8PgwH8AfAxFzC0JzeAMtratAsC/ffwAAAD//wBlAJr/BGKAyCAA4AAAAvgeYTAwHd1kmQF5chkG
-ABoMIHcL5xVpTfQbUqzlAAAErwAQBgAAEOClA5D9il08AEh/tUzdCBsXkbgACED+woQg8Si9VeqY
-lODCn7lmF6NhnAEYgAAA/NMIAAAAAAD//2JgjLZgVGBg5Pv/Tvpc8hwGBjYGJADjHDrAwPzAjv/H
-/Wf3PzCwtzcwHmBgYGcwbZz8wHaCAQMDOwMDQ8MCBgYOC3W7mp+f0w+wHOYxO3OG+e376hsMZjk3
-AAAAAP//YmCMY2A4wMAIN5e5gQETPD6AZisDAwMDgzSDAAPjByiHcQMDAwMDg1nOze1lByRu5/47
-c4859311AYNZzg0AAAAA//9iYGDBYihOIIMuwIjGL39/fwffA8b//xv/P2BPtzzHwCBjUQAAAAD/
-/yLFBrIBAAAA//9i1HhcwdhizX7u8NZNzyLbvT97bfrMf/QHI8evOwcSqGUJAAAA//9iYBB81iSw
-pEE170Qrg5MIYydHqwdDQRMrAwcVrQAAAAD//2J4x7j9AAMDn8Q/BgYLBoaiAwwMjPdvMDBYM1Tv
-oJodAAAAAP//Yqo/83+dxePWlxl3npsel9lvLfPcqlE9725C+acfVLMEAAAA//9i+s9gwCoaaGMR
-evta/58PTEWzr21hufPjA8N+qlnBwAAAAAD//2JiWLci5v1+HmFXDqcnULE/MxgYGBj+f6CaJQAA
-AAD//2Ji2FrkY3iYpYC5qDeGgeEMAwPDvwQBBoYvcTwOVLMEAAAA//9isDBgkP///0EOg9z35v//
-Gc/eeW7BwPj5+QGZhANUswMAAAD//2JgqGBgYGBgqEMXlvhMPUsAAAAA//8iYDd1AAAAAP//AwDR
-w7IkEbzhVQAAAABJRU5ErkJggg==
-"""
- )
- )
- ),
- )
- return f
diff --git a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/attr/filters.py b/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/attr/filters.py
deleted file mode 100644
index a1e40c98db853aa375ab0b24559e0559f91e6152..0000000000000000000000000000000000000000
--- a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/attr/filters.py
+++ /dev/null
@@ -1,66 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-"""
-Commonly useful filters for `attr.asdict`.
-"""
-
-from ._make import Attribute
-
-
-def _split_what(what):
- """
- Returns a tuple of `frozenset`s of classes and attributes.
- """
- return (
- frozenset(cls for cls in what if isinstance(cls, type)),
- frozenset(cls for cls in what if isinstance(cls, str)),
- frozenset(cls for cls in what if isinstance(cls, Attribute)),
- )
-
-
-def include(*what):
- """
- Include *what*.
-
- :param what: What to include.
- :type what: `list` of classes `type`, field names `str` or
- `attrs.Attribute`\\ s
-
- :rtype: `callable`
-
- .. versionchanged:: 23.1.0 Accept strings with field names.
- """
- cls, names, attrs = _split_what(what)
-
- def include_(attribute, value):
- return (
- value.__class__ in cls
- or attribute.name in names
- or attribute in attrs
- )
-
- return include_
-
-
-def exclude(*what):
- """
- Exclude *what*.
-
- :param what: What to exclude.
- :type what: `list` of classes `type`, field names `str` or
- `attrs.Attribute`\\ s.
-
- :rtype: `callable`
-
- .. versionchanged:: 23.3.0 Accept field name string as input argument
- """
- cls, names, attrs = _split_what(what)
-
- def exclude_(attribute, value):
- return not (
- value.__class__ in cls
- or attribute.name in names
- or attribute in attrs
- )
-
- return exclude_
diff --git a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/contourpy/util/_build_config.py b/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/contourpy/util/_build_config.py
deleted file mode 100644
index f283a4bb81188d85094d0a6addd90e0f6f6e2ec2..0000000000000000000000000000000000000000
--- a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/contourpy/util/_build_config.py
+++ /dev/null
@@ -1,58 +0,0 @@
-# _build_config.py.in is converted into _build_config.py during the meson build process.
-
-from __future__ import annotations
-
-
-def build_config() -> dict[str, str]:
- """
- Return a dictionary containing build configuration settings.
-
- All dictionary keys and values are strings, for example ``False`` is
- returned as ``"False"``.
- """
- return dict(
- # Python settings
- python_version="3.9",
- python_install_dir=r"/usr/local/lib/python3.9/site-packages/",
- python_path=r"/private/var/folders/24/8k48jl6d249_n_qfxwsl6xvm0000gn/T/build-env-2akgyfne/bin/python",
-
- # Package versions
- contourpy_version="1.1.1",
- meson_version="1.2.1",
- mesonpy_version="0.14.0",
- pybind11_version="2.11.1",
-
- # Misc meson settings
- meson_backend="ninja",
- build_dir=r"/Users/runner/work/contourpy/contourpy/.mesonpy-e1d1r4o1/lib/contourpy/util",
- source_dir=r"/Users/runner/work/contourpy/contourpy/lib/contourpy/util",
- cross_build="False",
-
- # Build options
- build_options=r"-Dbuildtype=release -Db_ndebug=if-release -Db_vscrt=md -Dvsenv=True --native-file=/Users/runner/work/contourpy/contourpy/.mesonpy-e1d1r4o1/meson-python-native-file.ini",
- buildtype="release",
- cpp_std="c++17",
- debug="False",
- optimization="3",
- vsenv="True",
- b_ndebug="if-release",
- b_vscrt="from_buildtype",
-
- # C++ compiler
- compiler_name="clang",
- compiler_version="13.0.0",
- linker_id="ld64",
- compile_command="c++",
-
- # Host machine
- host_cpu="x86_64",
- host_cpu_family="x86_64",
- host_cpu_endian="little",
- host_cpu_system="darwin",
-
- # Build machine, same as host machine if not a cross_build
- build_cpu="x86_64",
- build_cpu_family="x86_64",
- build_cpu_endian="little",
- build_cpu_system="darwin",
- )
diff --git a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/dns/tokenizer.py b/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/dns/tokenizer.py
deleted file mode 100644
index 454cac4a85e609d3429df45cbdfcb4103bd19213..0000000000000000000000000000000000000000
--- a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/dns/tokenizer.py
+++ /dev/null
@@ -1,708 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2003-2017 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-"""Tokenize DNS zone file format"""
-
-import io
-import sys
-from typing import Any, List, Optional, Tuple
-
-import dns.exception
-import dns.name
-import dns.ttl
-
-_DELIMITERS = {" ", "\t", "\n", ";", "(", ")", '"'}
-_QUOTING_DELIMITERS = {'"'}
-
-EOF = 0
-EOL = 1
-WHITESPACE = 2
-IDENTIFIER = 3
-QUOTED_STRING = 4
-COMMENT = 5
-DELIMITER = 6
-
-
-class UngetBufferFull(dns.exception.DNSException):
- """An attempt was made to unget a token when the unget buffer was full."""
-
-
-class Token:
- """A DNS zone file format token.
-
- ttype: The token type
- value: The token value
- has_escape: Does the token value contain escapes?
- """
-
- def __init__(
- self,
- ttype: int,
- value: Any = "",
- has_escape: bool = False,
- comment: Optional[str] = None,
- ):
- """Initialize a token instance."""
-
- self.ttype = ttype
- self.value = value
- self.has_escape = has_escape
- self.comment = comment
-
- def is_eof(self) -> bool:
- return self.ttype == EOF
-
- def is_eol(self) -> bool:
- return self.ttype == EOL
-
- def is_whitespace(self) -> bool:
- return self.ttype == WHITESPACE
-
- def is_identifier(self) -> bool:
- return self.ttype == IDENTIFIER
-
- def is_quoted_string(self) -> bool:
- return self.ttype == QUOTED_STRING
-
- def is_comment(self) -> bool:
- return self.ttype == COMMENT
-
- def is_delimiter(self) -> bool: # pragma: no cover (we don't return delimiters yet)
- return self.ttype == DELIMITER
-
- def is_eol_or_eof(self) -> bool:
- return self.ttype == EOL or self.ttype == EOF
-
- def __eq__(self, other):
- if not isinstance(other, Token):
- return False
- return self.ttype == other.ttype and self.value == other.value
-
- def __ne__(self, other):
- if not isinstance(other, Token):
- return True
- return self.ttype != other.ttype or self.value != other.value
-
- def __str__(self):
- return '%d "%s"' % (self.ttype, self.value)
-
- def unescape(self) -> "Token":
- if not self.has_escape:
- return self
- unescaped = ""
- l = len(self.value)
- i = 0
- while i < l:
- c = self.value[i]
- i += 1
- if c == "\\":
- if i >= l: # pragma: no cover (can't happen via get())
- raise dns.exception.UnexpectedEnd
- c = self.value[i]
- i += 1
- if c.isdigit():
- if i >= l:
- raise dns.exception.UnexpectedEnd
- c2 = self.value[i]
- i += 1
- if i >= l:
- raise dns.exception.UnexpectedEnd
- c3 = self.value[i]
- i += 1
- if not (c2.isdigit() and c3.isdigit()):
- raise dns.exception.SyntaxError
- codepoint = int(c) * 100 + int(c2) * 10 + int(c3)
- if codepoint > 255:
- raise dns.exception.SyntaxError
- c = chr(codepoint)
- unescaped += c
- return Token(self.ttype, unescaped)
-
- def unescape_to_bytes(self) -> "Token":
- # We used to use unescape() for TXT-like records, but this
- # caused problems as we'd process DNS escapes into Unicode code
- # points instead of byte values, and then a to_text() of the
- # processed data would not equal the original input. For
- # example, \226 in the TXT record would have a to_text() of
- # \195\162 because we applied UTF-8 encoding to Unicode code
- # point 226.
- #
- # We now apply escapes while converting directly to bytes,
- # avoiding this double encoding.
- #
- # This code also handles cases where the unicode input has
- # non-ASCII code-points in it by converting it to UTF-8. TXT
- # records aren't defined for Unicode, but this is the best we
- # can do to preserve meaning. For example,
- #
- # foo\u200bbar
- #
- # (where \u200b is Unicode code point 0x200b) will be treated
- # as if the input had been the UTF-8 encoding of that string,
- # namely:
- #
- # foo\226\128\139bar
- #
- unescaped = b""
- l = len(self.value)
- i = 0
- while i < l:
- c = self.value[i]
- i += 1
- if c == "\\":
- if i >= l: # pragma: no cover (can't happen via get())
- raise dns.exception.UnexpectedEnd
- c = self.value[i]
- i += 1
- if c.isdigit():
- if i >= l:
- raise dns.exception.UnexpectedEnd
- c2 = self.value[i]
- i += 1
- if i >= l:
- raise dns.exception.UnexpectedEnd
- c3 = self.value[i]
- i += 1
- if not (c2.isdigit() and c3.isdigit()):
- raise dns.exception.SyntaxError
- codepoint = int(c) * 100 + int(c2) * 10 + int(c3)
- if codepoint > 255:
- raise dns.exception.SyntaxError
- unescaped += b"%c" % (codepoint)
- else:
- # Note that as mentioned above, if c is a Unicode
- # code point outside of the ASCII range, then this
- # += is converting that code point to its UTF-8
- # encoding and appending multiple bytes to
- # unescaped.
- unescaped += c.encode()
- else:
- unescaped += c.encode()
- return Token(self.ttype, bytes(unescaped))
-
-
-class Tokenizer:
- """A DNS zone file format tokenizer.
-
- A token object is basically a (type, value) tuple. The valid
- types are EOF, EOL, WHITESPACE, IDENTIFIER, QUOTED_STRING,
- COMMENT, and DELIMITER.
-
- file: The file to tokenize
-
- ungotten_char: The most recently ungotten character, or None.
-
- ungotten_token: The most recently ungotten token, or None.
-
- multiline: The current multiline level. This value is increased
- by one every time a '(' delimiter is read, and decreased by one every time
- a ')' delimiter is read.
-
- quoting: This variable is true if the tokenizer is currently
- reading a quoted string.
-
- eof: This variable is true if the tokenizer has encountered EOF.
-
- delimiters: The current delimiter dictionary.
-
- line_number: The current line number
-
- filename: A filename that will be returned by the where() method.
-
- idna_codec: A dns.name.IDNACodec, specifies the IDNA
- encoder/decoder. If None, the default IDNA 2003
- encoder/decoder is used.
- """
-
- def __init__(
- self,
- f: Any = sys.stdin,
- filename: Optional[str] = None,
- idna_codec: Optional[dns.name.IDNACodec] = None,
- ):
- """Initialize a tokenizer instance.
-
- f: The file to tokenize. The default is sys.stdin.
- This parameter may also be a string, in which case the tokenizer
- will take its input from the contents of the string.
-
- filename: the name of the filename that the where() method
- will return.
-
- idna_codec: A dns.name.IDNACodec, specifies the IDNA
- encoder/decoder. If None, the default IDNA 2003
- encoder/decoder is used.
- """
-
- if isinstance(f, str):
- f = io.StringIO(f)
- if filename is None:
- filename = ""
- elif isinstance(f, bytes):
- f = io.StringIO(f.decode())
- if filename is None:
- filename = ""
- else:
- if filename is None:
- if f is sys.stdin:
- filename = ""
- else:
- filename = ""
- self.file = f
- self.ungotten_char: Optional[str] = None
- self.ungotten_token: Optional[Token] = None
- self.multiline = 0
- self.quoting = False
- self.eof = False
- self.delimiters = _DELIMITERS
- self.line_number = 1
- assert filename is not None
- self.filename = filename
- if idna_codec is None:
- self.idna_codec: dns.name.IDNACodec = dns.name.IDNA_2003
- else:
- self.idna_codec = idna_codec
-
- def _get_char(self) -> str:
- """Read a character from input."""
-
- if self.ungotten_char is None:
- if self.eof:
- c = ""
- else:
- c = self.file.read(1)
- if c == "":
- self.eof = True
- elif c == "\n":
- self.line_number += 1
- else:
- c = self.ungotten_char
- self.ungotten_char = None
- return c
-
- def where(self) -> Tuple[str, int]:
- """Return the current location in the input.
-
- Returns a (string, int) tuple. The first item is the filename of
- the input, the second is the current line number.
- """
-
- return (self.filename, self.line_number)
-
- def _unget_char(self, c: str) -> None:
- """Unget a character.
-
- The unget buffer for characters is only one character large; it is
- an error to try to unget a character when the unget buffer is not
- empty.
-
- c: the character to unget
- raises UngetBufferFull: there is already an ungotten char
- """
-
- if self.ungotten_char is not None:
- # this should never happen!
- raise UngetBufferFull # pragma: no cover
- self.ungotten_char = c
-
- def skip_whitespace(self) -> int:
- """Consume input until a non-whitespace character is encountered.
-
- The non-whitespace character is then ungotten, and the number of
- whitespace characters consumed is returned.
-
- If the tokenizer is in multiline mode, then newlines are whitespace.
-
- Returns the number of characters skipped.
- """
-
- skipped = 0
- while True:
- c = self._get_char()
- if c != " " and c != "\t":
- if (c != "\n") or not self.multiline:
- self._unget_char(c)
- return skipped
- skipped += 1
-
- def get(self, want_leading: bool = False, want_comment: bool = False) -> Token:
- """Get the next token.
-
- want_leading: If True, return a WHITESPACE token if the
- first character read is whitespace. The default is False.
-
- want_comment: If True, return a COMMENT token if the
- first token read is a comment. The default is False.
-
- Raises dns.exception.UnexpectedEnd: input ended prematurely
-
- Raises dns.exception.SyntaxError: input was badly formed
-
- Returns a Token.
- """
-
- if self.ungotten_token is not None:
- utoken = self.ungotten_token
- self.ungotten_token = None
- if utoken.is_whitespace():
- if want_leading:
- return utoken
- elif utoken.is_comment():
- if want_comment:
- return utoken
- else:
- return utoken
- skipped = self.skip_whitespace()
- if want_leading and skipped > 0:
- return Token(WHITESPACE, " ")
- token = ""
- ttype = IDENTIFIER
- has_escape = False
- while True:
- c = self._get_char()
- if c == "" or c in self.delimiters:
- if c == "" and self.quoting:
- raise dns.exception.UnexpectedEnd
- if token == "" and ttype != QUOTED_STRING:
- if c == "(":
- self.multiline += 1
- self.skip_whitespace()
- continue
- elif c == ")":
- if self.multiline <= 0:
- raise dns.exception.SyntaxError
- self.multiline -= 1
- self.skip_whitespace()
- continue
- elif c == '"':
- if not self.quoting:
- self.quoting = True
- self.delimiters = _QUOTING_DELIMITERS
- ttype = QUOTED_STRING
- continue
- else:
- self.quoting = False
- self.delimiters = _DELIMITERS
- self.skip_whitespace()
- continue
- elif c == "\n":
- return Token(EOL, "\n")
- elif c == ";":
- while 1:
- c = self._get_char()
- if c == "\n" or c == "":
- break
- token += c
- if want_comment:
- self._unget_char(c)
- return Token(COMMENT, token)
- elif c == "":
- if self.multiline:
- raise dns.exception.SyntaxError(
- "unbalanced parentheses"
- )
- return Token(EOF, comment=token)
- elif self.multiline:
- self.skip_whitespace()
- token = ""
- continue
- else:
- return Token(EOL, "\n", comment=token)
- else:
- # This code exists in case we ever want a
- # delimiter to be returned. It never produces
- # a token currently.
- token = c
- ttype = DELIMITER
- else:
- self._unget_char(c)
- break
- elif self.quoting and c == "\n":
- raise dns.exception.SyntaxError("newline in quoted string")
- elif c == "\\":
- #
- # It's an escape. Put it and the next character into
- # the token; it will be checked later for goodness.
- #
- token += c
- has_escape = True
- c = self._get_char()
- if c == "" or (c == "\n" and not self.quoting):
- raise dns.exception.UnexpectedEnd
- token += c
- if token == "" and ttype != QUOTED_STRING:
- if self.multiline:
- raise dns.exception.SyntaxError("unbalanced parentheses")
- ttype = EOF
- return Token(ttype, token, has_escape)
-
- def unget(self, token: Token) -> None:
- """Unget a token.
-
- The unget buffer for tokens is only one token large; it is
- an error to try to unget a token when the unget buffer is not
- empty.
-
- token: the token to unget
-
- Raises UngetBufferFull: there is already an ungotten token
- """
-
- if self.ungotten_token is not None:
- raise UngetBufferFull
- self.ungotten_token = token
-
- def next(self):
- """Return the next item in an iteration.
-
- Returns a Token.
- """
-
- token = self.get()
- if token.is_eof():
- raise StopIteration
- return token
-
- __next__ = next
-
- def __iter__(self):
- return self
-
- # Helpers
-
- def get_int(self, base: int = 10) -> int:
- """Read the next token and interpret it as an unsigned integer.
-
- Raises dns.exception.SyntaxError if not an unsigned integer.
-
- Returns an int.
- """
-
- token = self.get().unescape()
- if not token.is_identifier():
- raise dns.exception.SyntaxError("expecting an identifier")
- if not token.value.isdigit():
- raise dns.exception.SyntaxError("expecting an integer")
- return int(token.value, base)
-
- def get_uint8(self) -> int:
- """Read the next token and interpret it as an 8-bit unsigned
- integer.
-
- Raises dns.exception.SyntaxError if not an 8-bit unsigned integer.
-
- Returns an int.
- """
-
- value = self.get_int()
- if value < 0 or value > 255:
- raise dns.exception.SyntaxError(
- "%d is not an unsigned 8-bit integer" % value
- )
- return value
-
- def get_uint16(self, base: int = 10) -> int:
- """Read the next token and interpret it as a 16-bit unsigned
- integer.
-
- Raises dns.exception.SyntaxError if not a 16-bit unsigned integer.
-
- Returns an int.
- """
-
- value = self.get_int(base=base)
- if value < 0 or value > 65535:
- if base == 8:
- raise dns.exception.SyntaxError(
- "%o is not an octal unsigned 16-bit integer" % value
- )
- else:
- raise dns.exception.SyntaxError(
- "%d is not an unsigned 16-bit integer" % value
- )
- return value
-
- def get_uint32(self, base: int = 10) -> int:
- """Read the next token and interpret it as a 32-bit unsigned
- integer.
-
- Raises dns.exception.SyntaxError if not a 32-bit unsigned integer.
-
- Returns an int.
- """
-
- value = self.get_int(base=base)
- if value < 0 or value > 4294967295:
- raise dns.exception.SyntaxError(
- "%d is not an unsigned 32-bit integer" % value
- )
- return value
-
- def get_uint48(self, base: int = 10) -> int:
- """Read the next token and interpret it as a 48-bit unsigned
- integer.
-
- Raises dns.exception.SyntaxError if not a 48-bit unsigned integer.
-
- Returns an int.
- """
-
- value = self.get_int(base=base)
- if value < 0 or value > 281474976710655:
- raise dns.exception.SyntaxError(
- "%d is not an unsigned 48-bit integer" % value
- )
- return value
-
- def get_string(self, max_length: Optional[int] = None) -> str:
- """Read the next token and interpret it as a string.
-
- Raises dns.exception.SyntaxError if not a string.
- Raises dns.exception.SyntaxError if token value length
- exceeds max_length (if specified).
-
- Returns a string.
- """
-
- token = self.get().unescape()
- if not (token.is_identifier() or token.is_quoted_string()):
- raise dns.exception.SyntaxError("expecting a string")
- if max_length and len(token.value) > max_length:
- raise dns.exception.SyntaxError("string too long")
- return token.value
-
- def get_identifier(self) -> str:
- """Read the next token, which should be an identifier.
-
- Raises dns.exception.SyntaxError if not an identifier.
-
- Returns a string.
- """
-
- token = self.get().unescape()
- if not token.is_identifier():
- raise dns.exception.SyntaxError("expecting an identifier")
- return token.value
-
- def get_remaining(self, max_tokens: Optional[int] = None) -> List[Token]:
- """Return the remaining tokens on the line, until an EOL or EOF is seen.
-
- max_tokens: If not None, stop after this number of tokens.
-
- Returns a list of tokens.
- """
-
- tokens = []
- while True:
- token = self.get()
- if token.is_eol_or_eof():
- self.unget(token)
- break
- tokens.append(token)
- if len(tokens) == max_tokens:
- break
- return tokens
-
- def concatenate_remaining_identifiers(self, allow_empty: bool = False) -> str:
- """Read the remaining tokens on the line, which should be identifiers.
-
- Raises dns.exception.SyntaxError if there are no remaining tokens,
- unless `allow_empty=True` is given.
-
- Raises dns.exception.SyntaxError if a token is seen that is not an
- identifier.
-
- Returns a string containing a concatenation of the remaining
- identifiers.
- """
- s = ""
- while True:
- token = self.get().unescape()
- if token.is_eol_or_eof():
- self.unget(token)
- break
- if not token.is_identifier():
- raise dns.exception.SyntaxError
- s += token.value
- if not (allow_empty or s):
- raise dns.exception.SyntaxError("expecting another identifier")
- return s
-
- def as_name(
- self,
- token: Token,
- origin: Optional[dns.name.Name] = None,
- relativize: bool = False,
- relativize_to: Optional[dns.name.Name] = None,
- ) -> dns.name.Name:
- """Try to interpret the token as a DNS name.
-
- Raises dns.exception.SyntaxError if not a name.
-
- Returns a dns.name.Name.
- """
- if not token.is_identifier():
- raise dns.exception.SyntaxError("expecting an identifier")
- name = dns.name.from_text(token.value, origin, self.idna_codec)
- return name.choose_relativity(relativize_to or origin, relativize)
-
- def get_name(
- self,
- origin: Optional[dns.name.Name] = None,
- relativize: bool = False,
- relativize_to: Optional[dns.name.Name] = None,
- ) -> dns.name.Name:
- """Read the next token and interpret it as a DNS name.
-
- Raises dns.exception.SyntaxError if not a name.
-
- Returns a dns.name.Name.
- """
-
- token = self.get()
- return self.as_name(token, origin, relativize, relativize_to)
-
- def get_eol_as_token(self) -> Token:
- """Read the next token and raise an exception if it isn't EOL or
- EOF.
-
- Returns a string.
- """
-
- token = self.get()
- if not token.is_eol_or_eof():
- raise dns.exception.SyntaxError(
- 'expected EOL or EOF, got %d "%s"' % (token.ttype, token.value)
- )
- return token
-
- def get_eol(self) -> str:
- return self.get_eol_as_token().value
-
- def get_ttl(self) -> int:
- """Read the next token and interpret it as a DNS TTL.
-
- Raises dns.exception.SyntaxError or dns.ttl.BadTTL if not an
- identifier or badly formed.
-
- Returns an int.
- """
-
- token = self.get().unescape()
- if not token.is_identifier():
- raise dns.exception.SyntaxError("expecting an identifier")
- return dns.ttl.from_text(token.value)
diff --git a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/gradio/components/label.py b/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/gradio/components/label.py
deleted file mode 100644
index f6e965b0a3f819ebadcbee490bb926245c96fd81..0000000000000000000000000000000000000000
--- a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/gradio/components/label.py
+++ /dev/null
@@ -1,177 +0,0 @@
-"""gr.Label() component."""
-
-from __future__ import annotations
-
-import operator
-import warnings
-from pathlib import Path
-from typing import Callable, Literal
-
-from gradio_client.documentation import document, set_documentation_group
-from gradio_client.serializing import (
- JSONSerializable,
-)
-
-from gradio.components.base import IOComponent, _Keywords
-from gradio.deprecation import warn_style_method_deprecation
-from gradio.events import (
- Changeable,
- EventListenerMethod,
- Selectable,
-)
-
-set_documentation_group("component")
-
-
-@document()
-class Label(Changeable, Selectable, IOComponent, JSONSerializable):
- """
- Displays a classification label, along with confidence scores of top categories, if provided.
- Preprocessing: this component does *not* accept input.
- Postprocessing: expects a {Dict[str, float]} of classes and confidences, or {str} with just the class or an {int}/{float} for regression outputs, or a {str} path to a .json file containing a json dictionary in the structure produced by Label.postprocess().
-
- Demos: main_note, titanic_survival
- Guides: image-classification-in-pytorch, image-classification-in-tensorflow, image-classification-with-vision-transformers, building-a-pictionary-app
- """
-
- CONFIDENCES_KEY = "confidences"
-
- def __init__(
- self,
- value: dict[str, float] | str | float | Callable | None = None,
- *,
- num_top_classes: int | None = None,
- label: str | None = None,
- every: float | None = None,
- show_label: bool | None = None,
- container: bool = True,
- scale: int | None = None,
- min_width: int = 160,
- visible: bool = True,
- elem_id: str | None = None,
- elem_classes: list[str] | str | None = None,
- color: str | None = None,
- **kwargs,
- ):
- """
- Parameters:
- value: Default value to show in the component. If a str or number is provided, simply displays the string or number. If a {Dict[str, float]} of classes and confidences is provided, displays the top class on top and the `num_top_classes` below, along with their confidence bars. If callable, the function will be called whenever the app loads to set the initial value of the component.
- num_top_classes: number of most confident classes to show.
- label: component name in interface.
- every: If `value` is a callable, run the function 'every' number of seconds while the client connection is open. Has no effect otherwise. Queue must be enabled. The event can be accessed (e.g. to cancel it) via this component's .load_event attribute.
- show_label: if True, will display label.
- container: If True, will place the component in a container - providing some extra padding around the border.
- scale: relative width compared to adjacent Components in a Row. For example, if Component A has scale=2, and Component B has scale=1, A will be twice as wide as B. Should be an integer.
- min_width: minimum pixel width, will wrap if not sufficient screen space to satisfy this value. If a certain scale value results in this Component being narrower than min_width, the min_width parameter will be respected first.
- visible: If False, component will be hidden.
- elem_id: An optional string that is assigned as the id of this component in the HTML DOM. Can be used for targeting CSS styles.
- elem_classes: An optional list of strings that are assigned as the classes of this component in the HTML DOM. Can be used for targeting CSS styles.
- color: The background color of the label (either a valid css color name or hexadecimal string).
- """
- self.num_top_classes = num_top_classes
- self.color = color
- self.select: EventListenerMethod
- """
- Event listener for when the user selects a category from Label.
- Uses event data gradio.SelectData to carry `value` referring to name of selected category, and `index` to refer to index.
- See EventData documentation on how to use this event data.
- """
- IOComponent.__init__(
- self,
- label=label,
- every=every,
- show_label=show_label,
- container=container,
- scale=scale,
- min_width=min_width,
- visible=visible,
- elem_id=elem_id,
- elem_classes=elem_classes,
- value=value,
- **kwargs,
- )
-
- def postprocess(self, y: dict[str, float] | str | float | None) -> dict | None:
- """
- Parameters:
- y: a dictionary mapping labels to confidence value, or just a string/numerical label by itself
- Returns:
- Object with key 'label' representing primary label, and key 'confidences' representing a list of label-confidence pairs
- """
- if y is None or y == {}:
- return {}
- if isinstance(y, str) and y.endswith(".json") and Path(y).exists():
- return self.serialize(y)
- if isinstance(y, (str, float, int)):
- return {"label": str(y)}
- if isinstance(y, dict):
- if "confidences" in y and isinstance(y["confidences"], dict):
- y = y["confidences"]
- y = {c["label"]: c["confidence"] for c in y}
- sorted_pred = sorted(y.items(), key=operator.itemgetter(1), reverse=True)
- if self.num_top_classes is not None:
- sorted_pred = sorted_pred[: self.num_top_classes]
- return {
- "label": sorted_pred[0][0],
- "confidences": [
- {"label": pred[0], "confidence": pred[1]} for pred in sorted_pred
- ],
- }
- raise ValueError(
- "The `Label` output interface expects one of: a string label, or an int label, a "
- "float label, or a dictionary whose keys are labels and values are confidences. "
- f"Instead, got a {type(y)}"
- )
-
- @staticmethod
- def update(
- value: dict[str, float]
- | str
- | float
- | Literal[_Keywords.NO_VALUE]
- | None = _Keywords.NO_VALUE,
- label: str | None = None,
- show_label: bool | None = None,
- container: bool | None = None,
- scale: int | None = None,
- min_width: int | None = None,
- visible: bool | None = None,
- color: str | Literal[_Keywords.NO_VALUE] | None = _Keywords.NO_VALUE,
- ):
- warnings.warn(
- "Using the update method is deprecated. Simply return a new object instead, e.g. `return gr.Label(...)` instead of `return gr.Label.update(...)`."
- )
- # If color is not specified (NO_VALUE) map it to None so that
- # it gets filtered out in postprocess. This will mean the color
- # will not be updated in the front-end
- if color is _Keywords.NO_VALUE:
- color = None
- # If the color was specified by the developer as None
- # Map is so that the color is updated to be transparent,
- # e.g. no background default state.
- elif color is None:
- color = "transparent"
- return {
- "label": label,
- "show_label": show_label,
- "container": container,
- "scale": scale,
- "min_width": min_width,
- "visible": visible,
- "value": value,
- "color": color,
- "__type__": "update",
- }
-
- def style(
- self,
- *,
- container: bool | None = None,
- ):
- """
- This method is deprecated. Please set these arguments in the constructor instead.
- """
- warn_style_method_deprecation()
- if container is not None:
- self.container = container
- return self
diff --git a/spaces/joe-aquino/keras_pretty_face/README.md b/spaces/joe-aquino/keras_pretty_face/README.md
deleted file mode 100644
index 0362e651bed96add1a9ceb6e476c14fd64549a2d..0000000000000000000000000000000000000000
--- a/spaces/joe-aquino/keras_pretty_face/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Keras Pretty Face
-emoji: 🌍
-colorFrom: gray
-colorTo: red
-sdk: gradio
-sdk_version: 3.19.1
-app_file: app.py
-pinned: false
-license: unknown
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/johnslegers/bilingual_stable_diffusion/css_and_js.py b/spaces/johnslegers/bilingual_stable_diffusion/css_and_js.py
deleted file mode 100644
index 64e6dd5e703281d0b11e7a9ef7f05a264fb2341c..0000000000000000000000000000000000000000
--- a/spaces/johnslegers/bilingual_stable_diffusion/css_and_js.py
+++ /dev/null
@@ -1,92 +0,0 @@
-from os import path
-import json
-
-
-def readTextFile(*args):
- dir = path.dirname(__file__)
- entry = path.join(dir, *args)
- with open(entry, "r", encoding="utf8") as f:
- data = f.read()
- return data
-
-
-def css(opt):
- styling = readTextFile("css", "styles.css")
- # TODO: @altryne restore this before merge
- if not opt.no_progressbar_hiding:
- styling += readTextFile("css", "no_progress_bar.css")
- return styling
-
-
-def js(opt):
- data = readTextFile("js", "index.js")
- data = "(z) => {" + data + "; return z ?? [] }"
- return data
-
-
-# TODO : @altryne fix this to the new JS format
-js_copy_txt2img_output = "(x) => {navigator.clipboard.writeText(document.querySelector('gradio-app').shadowRoot.querySelector('#highlight .textfield').textContent.replace(/\s+/g,' ').replace(/: /g,':'))}"
-
-
-
-js_parse_prompt ="""
-(txt2img_prompt, txt2img_width, txt2img_height, txt2img_steps, txt2img_seed, txt2img_batch_count, txt2img_cfg) => {
-
-const prompt_input = document.querySelector('gradio-app').shadowRoot.querySelector('#prompt_input [data-testid="textbox"]');
-const multiline = document.querySelector('gradio-app').shadowRoot.querySelector('#submit_on_enter label:nth-child(2)')
-if (prompt_input.scrollWidth > prompt_input.clientWidth + 10 ) {
- multiline.click();
-}
-
-
-let height_match = /(?:-h|-H|--height|height)[ :]?(?\d+) /.exec(txt2img_prompt);
-if (height_match) {
- txt2img_height = Math.round(height_match.groups.height / 64) * 64;
- txt2img_prompt = txt2img_prompt.replace(height_match[0], '');
-}
-let width_match = /(?:-w|-W|--width|width)[ :]?(?\d+) /.exec(txt2img_prompt);
-if (width_match) {
- txt2img_width = Math.round(width_match.groups.width / 64) * 64;
- txt2img_prompt = txt2img_prompt.replace(width_match[0], '');
-}
-let steps_match = /(?:-s|--steps|steps)[ :]?(?\d+) /.exec(txt2img_prompt);
-if (steps_match) {
- txt2img_steps = steps_match.groups.steps.trim();
- txt2img_prompt = txt2img_prompt.replace(steps_match[0], '');
-}
-let seed_match = /(?:-S|--seed|seed)[ :]?(?\d+) /.exec(txt2img_prompt);
-if (seed_match) {
- txt2img_seed = seed_match.groups.seed;
- txt2img_prompt = txt2img_prompt.replace(seed_match[0], '');
-}
-let batch_count_match = /(?:-n|-N|--number|number)[ :]?(?\d+) /.exec(txt2img_prompt);
-if (batch_count_match) {
- txt2img_batch_count = batch_count_match.groups.batch_count;
- txt2img_prompt = txt2img_prompt.replace(batch_count_match[0], '');
-}
-let cfg_scale_match = /(?:-c|-C|--cfg-scale|cfg_scale|cfg)[ :]?(?\d\.?\d+?) /.exec(txt2img_prompt);
-if (cfg_scale_match) {
- txt2img_cfg = parseFloat(cfg_scale_match.groups.cfgscale).toFixed(1);
- txt2img_prompt = txt2img_prompt.replace(cfg_scale_match[0], '');
-}
-let sampler_match = /(?:-A|--sampler|sampler)[ :]?(?\w+) /.exec(txt2img_prompt);
-if (sampler_match) {
-
- txt2img_prompt = txt2img_prompt.replace(sampler_match[0], '');
-}
-
-return [txt2img_prompt, parseInt(txt2img_width), parseInt(txt2img_height), parseInt(txt2img_steps), txt2img_seed, parseInt(txt2img_batch_count), parseFloat(txt2img_cfg)];
-}
-"""
-
-
-# Wrap the typical SD method call into async closure for ease of use
-# Supplies the js function with a params object
-# That includes all the passed arguments and input from Gradio: x
-# ATTENTION: x is an array of values of all components passed to your
-# python event handler
-# Example call in Gradio component's event handler (pass the result to _js arg):
-# _js=call_JS("myJsMethod", arg1="string", arg2=100, arg3=[])
-def call_JS(sd_method, **kwargs):
- param_str = json.dumps(kwargs)
- return f"async (...x) => {{ return await SD.{sd_method}({{ x, ...{param_str} }}) ?? []; }}"
diff --git a/spaces/juancopi81/whisper-youtube-2-hf_dataset/loading/loaderiterator.py b/spaces/juancopi81/whisper-youtube-2-hf_dataset/loading/loaderiterator.py
deleted file mode 100644
index 794278277d63f5f5f219832c41ceebf9f0c2aedb..0000000000000000000000000000000000000000
--- a/spaces/juancopi81/whisper-youtube-2-hf_dataset/loading/loaderiterator.py
+++ /dev/null
@@ -1,46 +0,0 @@
-from pathlib import Path
-from typing import List, Dict, Optional
-
-from loading.serialization import Serializer
-
-class LoaderIterator:
- """Iterator that loads data from multiple files in batches."""
-
- def __init__(self,
- serializer: Serializer,
- num_files_per_iteration: int,
- load_paths: Optional[List[Path]] = None) -> None:
- self.serializer = serializer
- self.num_files_per_iteration = num_files_per_iteration
- self._load_paths = load_paths
- self._current_iteration = None
-
- @property
- def load_paths(self) -> Optional[List[Path]]:
- return self._load_paths
-
- @load_paths.setter
- def load_paths(self, load_paths: List[Path]) -> None:
- self._load_paths = load_paths
-
- def __iter__(self):
- self._current_iteration = 0
- return self
-
- def __next__(self) -> List[Dict]:
- if self._did_load_all_batches():
- raise StopIteration
- data_batch = self._load_data_batch()
- self._current_iteration += 1
- return data_batch
-
- def _did_load_all_batches(self) -> bool:
- if self._current_iteration >= len(self._load_paths) / self.num_files_per_iteration:
- return True
- return False
-
- def _load_data_batch(self) -> List[Dict]:
- start_index = self._current_iteration * self.num_files_per_iteration
- stop_index = start_index + self.num_files_per_iteration
- return [self.serializer.load(load_path) for load_path in
- self._load_paths[start_index:stop_index] if load_path.exists()]
\ No newline at end of file
diff --git a/spaces/juanhuggingface/ChuanhuChatGPT_Beta/modules/models/configuration_moss.py b/spaces/juanhuggingface/ChuanhuChatGPT_Beta/modules/models/configuration_moss.py
deleted file mode 100644
index 9bad4396ecea6578c1628732d0ef077d8964d45d..0000000000000000000000000000000000000000
--- a/spaces/juanhuggingface/ChuanhuChatGPT_Beta/modules/models/configuration_moss.py
+++ /dev/null
@@ -1,118 +0,0 @@
-""" Moss model configuration"""
-
-from transformers.utils import logging
-from transformers.configuration_utils import PretrainedConfig
-
-
-logger = logging.get_logger(__name__)
-
-
-class MossConfig(PretrainedConfig):
- r"""
- This is the configuration class to store the configuration of a [`MossModel`]. It is used to instantiate a
- Moss model according to the specified arguments, defining the model architecture. Instantiating a configuration
- with the defaults will yield a similar configuration to that of the Moss
- [fnlp/moss-moon-003-base](https://huggingface.co/fnlp/moss-moon-003-base) architecture. Configuration objects
- inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the documentation from
- [`PretrainedConfig`] for more information.
-
- Args:
- vocab_size (`int`, *optional*, defaults to 107008):
- Vocabulary size of the Moss model. Defines the number of different tokens that can be represented by the
- `inputs_ids` passed when calling [`MossModel`].
- n_positions (`int`, *optional*, defaults to 2048):
- The maximum sequence length that this model might ever be used with. Typically set this to something large
- just in case (e.g., 512 or 1024 or 2048).
- n_embd (`int`, *optional*, defaults to 4096):
- Dimensionality of the embeddings and hidden states.
- n_layer (`int`, *optional*, defaults to 28):
- Number of hidden layers in the Transformer encoder.
- n_head (`int`, *optional*, defaults to 16):
- Number of attention heads for each attention layer in the Transformer encoder.
- rotary_dim (`int`, *optional*, defaults to 64):
- Number of dimensions in the embedding that Rotary Position Embedding is applied to.
- n_inner (`int`, *optional*, defaults to None):
- Dimensionality of the inner feed-forward layers. `None` will set it to 4 times n_embd
- activation_function (`str`, *optional*, defaults to `"gelu_new"`):
- Activation function, to be selected in the list `["relu", "silu", "gelu", "tanh", "gelu_new"]`.
- resid_pdrop (`float`, *optional*, defaults to 0.1):
- The dropout probability for all fully connected layers in the embeddings, encoder, and pooler.
- embd_pdrop (`int`, *optional*, defaults to 0.1):
- The dropout ratio for the embeddings.
- attn_pdrop (`float`, *optional*, defaults to 0.1):
- The dropout ratio for the attention.
- layer_norm_epsilon (`float`, *optional*, defaults to 1e-5):
- The epsilon to use in the layer normalization layers.
- initializer_range (`float`, *optional*, defaults to 0.02):
- The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
- use_cache (`bool`, *optional*, defaults to `True`):
- Whether or not the model should return the last key/values attentions (not used by all models).
-
- Example:
-
- ```python
- >>> from modeling_moss import MossModel
- >>> from configuration_moss import MossConfig
-
- >>> # Initializing a moss-moon-003-base configuration
- >>> configuration = MossConfig()
-
- >>> # Initializing a model (with random weights) from the configuration
- >>> model = MossModel(configuration)
-
- >>> # Accessing the model configuration
- >>> configuration = model.config
- ```"""
-
- model_type = "moss"
- attribute_map = {
- "max_position_embeddings": "n_positions",
- "hidden_size": "n_embd",
- "num_attention_heads": "n_head",
- "num_hidden_layers": "n_layer",
- }
-
- def __init__(
- self,
- vocab_size=107008,
- n_positions=2048,
- n_ctx=2048,
- n_embd=4096,
- n_layer=28,
- n_head=16,
- rotary_dim=64,
- n_inner=None,
- activation_function="gelu_new",
- resid_pdrop=0.0,
- embd_pdrop=0.0,
- attn_pdrop=0.0,
- layer_norm_epsilon=1e-5,
- initializer_range=0.02,
- use_cache=True,
- bos_token_id=106028,
- eos_token_id=106068,
- tie_word_embeddings=False,
- **kwargs,
- ):
- self.vocab_size = vocab_size
- self.n_ctx = n_ctx
- self.n_positions = n_positions
- self.n_embd = n_embd
- self.n_layer = n_layer
- self.n_head = n_head
- self.n_inner = n_inner
- self.rotary_dim = rotary_dim
- self.activation_function = activation_function
- self.resid_pdrop = resid_pdrop
- self.embd_pdrop = embd_pdrop
- self.attn_pdrop = attn_pdrop
- self.layer_norm_epsilon = layer_norm_epsilon
- self.initializer_range = initializer_range
- self.use_cache = use_cache
-
- self.bos_token_id = bos_token_id
- self.eos_token_id = eos_token_id
-
- super().__init__(
- bos_token_id=bos_token_id, eos_token_id=eos_token_id, tie_word_embeddings=tie_word_embeddings, **kwargs
- )
diff --git a/spaces/kangvcar/RealChar/client/web/src/components/Auth/SignIn.js b/spaces/kangvcar/RealChar/client/web/src/components/Auth/SignIn.js
deleted file mode 100644
index e4219aeedde3102bac97fc5f9ad9f384da993cc2..0000000000000000000000000000000000000000
--- a/spaces/kangvcar/RealChar/client/web/src/components/Auth/SignIn.js
+++ /dev/null
@@ -1,91 +0,0 @@
-/**
- * src/components/Auth/SignIn.jsx
- * signin and signup with google account
- *
- * created by Lynchee on 7/20/23
- */
-
-import React, { useState } from 'react';
-import auth from '../../utils/firebase';
-import { signInWithPopup, GoogleAuthProvider } from "firebase/auth";
-import './styles.css';
-
-export const sendTokenToServer = async (token) => {
- // Send token to server
- const scheme = window.location.protocol;
- var currentHost = window.location.host;
- var parts = currentHost.split(':');
- var ipAddress = parts[0];
- var newPort = '8000';
- var newHost = ipAddress + ':' + newPort;
- const url = scheme + '//' + newHost;
-
- try {
- const response = await fetch(url, {
- method: 'POST',
- headers: {
- 'Content-Type': 'application/json',
- 'Authorization': `Bearer ${token}`
- }
- });
-
- if (!response.ok) {
- console.error("Sent token failed");
- }
- } catch (error) {
- console.error("Sent token failed. ", error);
- }
-}
-
-export const signInWithGoogle = async (isLoggedIn, setToken) => {
- const provider = new GoogleAuthProvider();
- return signInWithPopup(auth, provider) // Return the promise here
- .then(async (result) => {
- // This gives you a Google Access Token. You can use it to access the Google API.
- const credential = GoogleAuthProvider.credentialFromResult(result);
- const token = await auth.currentUser.getIdToken();
-
- // The signed-in user info.
- const user = result.user;
- isLoggedIn.current = true;
- setToken(token);
- await sendTokenToServer(token);
-
- console.log("Sign-in successfully");
- }).catch((error) => {
- // Handle Errors here.
- const errorCode = error.code;
- const errorMessage = error.message;
- console.error(`Error occurred during sign in. Code: ${errorCode}, Message: ${errorMessage}`);
- // The email of the user's account used.
- const email = error.customData.email;
- // The AuthCredential type that was used.
- const credential = GoogleAuthProvider.credentialFromError(error);
- isLoggedIn.current = false;
- });
-}
-
-const SignIn = ({ isLoggedIn, setToken }) => {
- const [isLoading, setIsLoading] = useState(false);
-
- const signIn = async (e) => {
- e.preventDefault();
- setIsLoading(true);
- try {
- await signInWithGoogle(isLoggedIn, setToken);
- } catch (error) {
- console.error('Error during sign in:', error);
- }
- setIsLoading(false);
- }
-
- return (
-
- )
-}
-
-export default SignIn;
\ No newline at end of file
diff --git a/spaces/kangvcar/RealChar/realtime_ai_character/database/__init__.py b/spaces/kangvcar/RealChar/realtime_ai_character/database/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/kenjiqq/aesthetics-scorer/app.py b/spaces/kenjiqq/aesthetics-scorer/app.py
deleted file mode 100644
index c0089d6b734f73687fe7d02aa9494770e9e28178..0000000000000000000000000000000000000000
--- a/spaces/kenjiqq/aesthetics-scorer/app.py
+++ /dev/null
@@ -1,35 +0,0 @@
-import gradio as gr
-import torch
-from model import preprocess, load_model
-from transformers import CLIPModel, CLIPProcessor
-
-MODEL = "laion/CLIP-ViT-L-14-laion2B-s32B-b82K"
-DEVICE = 'cuda' if torch.cuda.is_available() else 'cpu'
-
-model = CLIPModel.from_pretrained(MODEL)
-vision_model = model.vision_model
-vision_model.to(DEVICE)
-del model
-clip_processor = CLIPProcessor.from_pretrained(MODEL)
-
-rating_model = load_model("aesthetics_scorer_rating_openclip_vit_l_14.pth").to(DEVICE)
-artifacts_model = load_model("aesthetics_scorer_artifacts_openclip_vit_l_14.pth").to(DEVICE)
-
-def predict(img):
- inputs = clip_processor(images=img, return_tensors="pt").to(DEVICE)
- with torch.no_grad():
- vision_output = vision_model(**inputs)
- pooled_output = vision_output.pooler_output
- embedding = preprocess(pooled_output)
- with torch.no_grad():
- rating = rating_model(embedding)
- artifact = artifacts_model(embedding)
- return rating.detach().cpu().item(), artifact.detach().cpu().item()
-
-gr.Interface(
- title="Aesthetics Scorer",
- description="Predicts aesthetics and artifact scores for images using CLIP-ViT-L. Demo for https://github.com/kenjiqq/aesthetics-scorer",
- fn=predict,
- inputs=gr.Image(type="pil"),
- outputs=[gr.Number(label="Rating ~1-10 (high is good)"), gr.Number(label="Artifacts ~0-5 (low is good)")]
-).launch()
\ No newline at end of file
diff --git a/spaces/kevinwang676/ChatGLM2-VC-SadTalker/Dockerfile b/spaces/kevinwang676/ChatGLM2-VC-SadTalker/Dockerfile
deleted file mode 100644
index 5ddc6e3d8b246534a58f9612a88b309fa7e10795..0000000000000000000000000000000000000000
--- a/spaces/kevinwang676/ChatGLM2-VC-SadTalker/Dockerfile
+++ /dev/null
@@ -1,59 +0,0 @@
-FROM nvidia/cuda:11.7.1-cudnn8-devel-ubuntu22.04
-ENV DEBIAN_FRONTEND=noninteractive
-RUN apt-get update && \
- apt-get upgrade -y && \
- apt-get install -y --no-install-recommends \
- git \
- zip \
- unzip \
- git-lfs \
- wget \
- curl \
- # ffmpeg \
- ffmpeg \
- x264 \
- # python build dependencies \
- build-essential \
- libssl-dev \
- zlib1g-dev \
- libbz2-dev \
- libreadline-dev \
- libsqlite3-dev \
- libncursesw5-dev \
- xz-utils \
- tk-dev \
- libxml2-dev \
- libxmlsec1-dev \
- libffi-dev \
- liblzma-dev && \
- apt-get clean && \
- rm -rf /var/lib/apt/lists/*
-
-RUN useradd -m -u 1000 user
-USER user
-ENV HOME=/home/user \
- PATH=/home/user/.local/bin:${PATH}
-WORKDIR ${HOME}/app
-
-RUN curl https://pyenv.run | bash
-ENV PATH=${HOME}/.pyenv/shims:${HOME}/.pyenv/bin:${PATH}
-ENV PYTHON_VERSION=3.10.9
-RUN pyenv install ${PYTHON_VERSION} && \
- pyenv global ${PYTHON_VERSION} && \
- pyenv rehash && \
- pip install --no-cache-dir -U pip setuptools wheel
-
-RUN pip install --no-cache-dir -U torch==1.12.1 torchvision==0.13.1
-COPY --chown=1000 requirements.txt /tmp/requirements.txt
-RUN pip install --no-cache-dir -U -r /tmp/requirements.txt
-
-COPY --chown=1000 . ${HOME}/app
-RUN ls -a
-ENV PYTHONPATH=${HOME}/app \
- PYTHONUNBUFFERED=1 \
- GRADIO_ALLOW_FLAGGING=never \
- GRADIO_NUM_PORTS=1 \
- GRADIO_SERVER_NAME=0.0.0.0 \
- GRADIO_THEME=huggingface \
- SYSTEM=spaces
-CMD ["python", "app.py"]
\ No newline at end of file
diff --git a/spaces/kevinwang676/DreamlikeArt-PhotoReal-2.0/style.css b/spaces/kevinwang676/DreamlikeArt-PhotoReal-2.0/style.css
deleted file mode 100644
index fdbef9e64cc6b9f8003698ffa38997ee22a640ac..0000000000000000000000000000000000000000
--- a/spaces/kevinwang676/DreamlikeArt-PhotoReal-2.0/style.css
+++ /dev/null
@@ -1,84 +0,0 @@
-#col-container {
- max-width: 800px;
- margin-left: auto;
- margin-right: auto;
-}
-a {
- color: inherit;
- text-decoration: underline;
-}
-.gradio-container {
- font-family: 'IBM Plex Sans', sans-serif;
-}
-.gr-button {
- color: white;
- border-color: #9d66e5;
- background: #9d66e5;
-}
-input[type='range'] {
- accent-color: #9d66e5;
-}
-.dark input[type='range'] {
- accent-color: #dfdfdf;
-}
-.container {
- max-width: 800px;
- margin: auto;
- padding-top: 1.5rem;
-}
-#gallery {
- min-height: 22rem;
- margin-bottom: 15px;
- margin-left: auto;
- margin-right: auto;
- border-bottom-right-radius: .5rem !important;
- border-bottom-left-radius: .5rem !important;
-}
-#gallery>div>.h-full {
- min-height: 20rem;
-}
-.details:hover {
- text-decoration: underline;
-}
-.gr-button {
- white-space: nowrap;
-}
-.gr-button:focus {
- border-color: rgb(147 197 253 / var(--tw-border-opacity));
- outline: none;
- box-shadow: var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow, 0 0 #0000);
- --tw-border-opacity: 1;
- --tw-ring-offset-shadow: var(--tw-ring-inset) 0 0 0 var(--tw-ring-offset-width) var(--tw-ring-offset-color);
- --tw-ring-shadow: var(--tw-ring-inset) 0 0 0 calc(3px var(--tw-ring-offset-width)) var(--tw-ring-color);
- --tw-ring-color: rgb(191 219 254 / var(--tw-ring-opacity));
- --tw-ring-opacity: .5;
-}
-#advanced-options {
- margin-bottom: 20px;
-}
-.footer {
- margin-bottom: 45px;
- margin-top: 35px;
- text-align: center;
- border-bottom: 1px solid #e5e5e5;
-}
-.footer>p {
- font-size: .8rem;
- display: inline-block;
- padding: 0 10px;
- transform: translateY(10px);
- background: white;
-}
-.dark .logo{ filter: invert(1); }
-.dark .footer {
- border-color: #303030;
-}
-.dark .footer>p {
- background: #0b0f19;
-}
-.acknowledgments h4{
- margin: 1.25em 0 .25em 0;
- font-weight: bold;
- font-size: 115%;
-}
-
diff --git a/spaces/koajoel/PolyFormer/fairseq/README.md b/spaces/koajoel/PolyFormer/fairseq/README.md
deleted file mode 100644
index dd687174808a6ff341f597eb6a4cc9a1687d74a1..0000000000000000000000000000000000000000
--- a/spaces/koajoel/PolyFormer/fairseq/README.md
+++ /dev/null
@@ -1,229 +0,0 @@
-
-
-
-
-
-
-
-
-
-
---------------------------------------------------------------------------------
-
-Fairseq(-py) is a sequence modeling toolkit that allows researchers and
-developers to train custom models for translation, summarization, language
-modeling and other text generation tasks.
-
-We provide reference implementations of various sequence modeling papers:
-
-List of implemented papers
-
-* **Convolutional Neural Networks (CNN)**
- + [Language Modeling with Gated Convolutional Networks (Dauphin et al., 2017)](examples/language_model/conv_lm/README.md)
- + [Convolutional Sequence to Sequence Learning (Gehring et al., 2017)](examples/conv_seq2seq/README.md)
- + [Classical Structured Prediction Losses for Sequence to Sequence Learning (Edunov et al., 2018)](https://github.com/pytorch/fairseq/tree/classic_seqlevel)
- + [Hierarchical Neural Story Generation (Fan et al., 2018)](examples/stories/README.md)
- + [wav2vec: Unsupervised Pre-training for Speech Recognition (Schneider et al., 2019)](examples/wav2vec/README.md)
-* **LightConv and DynamicConv models**
- + [Pay Less Attention with Lightweight and Dynamic Convolutions (Wu et al., 2019)](examples/pay_less_attention_paper/README.md)
-* **Long Short-Term Memory (LSTM) networks**
- + Effective Approaches to Attention-based Neural Machine Translation (Luong et al., 2015)
-* **Transformer (self-attention) networks**
- + Attention Is All You Need (Vaswani et al., 2017)
- + [Scaling Neural Machine Translation (Ott et al., 2018)](examples/scaling_nmt/README.md)
- + [Understanding Back-Translation at Scale (Edunov et al., 2018)](examples/backtranslation/README.md)
- + [Adaptive Input Representations for Neural Language Modeling (Baevski and Auli, 2018)](examples/language_model/README.adaptive_inputs.md)
- + [Lexically constrained decoding with dynamic beam allocation (Post & Vilar, 2018)](examples/constrained_decoding/README.md)
- + [Transformer-XL: Attentive Language Models Beyond a Fixed-Length Context (Dai et al., 2019)](examples/truncated_bptt/README.md)
- + [Adaptive Attention Span in Transformers (Sukhbaatar et al., 2019)](examples/adaptive_span/README.md)
- + [Mixture Models for Diverse Machine Translation: Tricks of the Trade (Shen et al., 2019)](examples/translation_moe/README.md)
- + [RoBERTa: A Robustly Optimized BERT Pretraining Approach (Liu et al., 2019)](examples/roberta/README.md)
- + [Facebook FAIR's WMT19 News Translation Task Submission (Ng et al., 2019)](examples/wmt19/README.md)
- + [Jointly Learning to Align and Translate with Transformer Models (Garg et al., 2019)](examples/joint_alignment_translation/README.md )
- + [Multilingual Denoising Pre-training for Neural Machine Translation (Liu et at., 2020)](examples/mbart/README.md)
- + [Neural Machine Translation with Byte-Level Subwords (Wang et al., 2020)](examples/byte_level_bpe/README.md)
- + [Unsupervised Quality Estimation for Neural Machine Translation (Fomicheva et al., 2020)](examples/unsupervised_quality_estimation/README.md)
- + [wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations (Baevski et al., 2020)](examples/wav2vec/README.md)
- + [Generating Medical Reports from Patient-Doctor Conversations Using Sequence-to-Sequence Models (Enarvi et al., 2020)](examples/pointer_generator/README.md)
- + [Linformer: Self-Attention with Linear Complexity (Wang et al., 2020)](examples/linformer/README.md)
- + [Cross-lingual Retrieval for Iterative Self-Supervised Training (Tran et al., 2020)](examples/criss/README.md)
- + [Deep Transformers with Latent Depth (Li et al., 2020)](examples/latent_depth/README.md)
- + [Unsupervised Cross-lingual Representation Learning for Speech Recognition (Conneau et al., 2020)](https://arxiv.org/abs/2006.13979)
- + [Robust wav2vec 2.0: Analyzing Domain Shift in Self-Supervised Pre-Training (Hsu, et al., 2021)](https://arxiv.org/abs/2104.01027)
- + [Unsupervised Speech Recognition (Baevski, et al., 2021)](https://arxiv.org/abs/2105.11084)
-* **Non-autoregressive Transformers**
- + Non-Autoregressive Neural Machine Translation (Gu et al., 2017)
- + Deterministic Non-Autoregressive Neural Sequence Modeling by Iterative Refinement (Lee et al. 2018)
- + Insertion Transformer: Flexible Sequence Generation via Insertion Operations (Stern et al. 2019)
- + Mask-Predict: Parallel Decoding of Conditional Masked Language Models (Ghazvininejad et al., 2019)
- + [Levenshtein Transformer (Gu et al., 2019)](examples/nonautoregressive_translation/README.md)
-* **Finetuning**
- + [Better Fine-Tuning by Reducing Representational Collapse (Aghajanyan et al. 2020)](examples/rxf/README.md)
-
-
-
-### What's New:
-
-* September 2021 [`master` branch renamed to `main`](https://github.com/github/renaming).
-* July 2021 [Released DrNMT code](examples/discriminative_reranking_nmt/README.md)
-* July 2021 [Released Robust wav2vec 2.0 model](examples/wav2vec/README.md)
-* June 2021 [Released XLMR-XL and XLMR-XXL models](examples/xlmr/README.md)
-* May 2021 [Released Unsupervised Speech Recognition code](examples/wav2vec/unsupervised/README.md)
-* March 2021 [Added full parameter and optimizer state sharding + CPU offloading](examples/fully_sharded_data_parallel/README.md)
-* February 2021 [Added LASER training code](examples/laser/README.md)
-* December 2020: [Added Adaptive Attention Span code](examples/adaptive_span/README.md)
-* December 2020: [GottBERT model and code released](examples/gottbert/README.md)
-* November 2020: Adopted the [Hydra](https://github.com/facebookresearch/hydra) configuration framework
- * [see documentation explaining how to use it for new and existing projects](docs/hydra_integration.md)
-* November 2020: [fairseq 0.10.0 released](https://github.com/pytorch/fairseq/releases/tag/v0.10.0)
-* October 2020: [Added R3F/R4F (Better Fine-Tuning) code](examples/rxf/README.md)
-* October 2020: [Deep Transformer with Latent Depth code released](examples/latent_depth/README.md)
-* October 2020: [Added CRISS models and code](examples/criss/README.md)
-
-Previous updates
-
-* September 2020: [Added Linformer code](examples/linformer/README.md)
-* September 2020: [Added pointer-generator networks](examples/pointer_generator/README.md)
-* August 2020: [Added lexically constrained decoding](examples/constrained_decoding/README.md)
-* August 2020: [wav2vec2 models and code released](examples/wav2vec/README.md)
-* July 2020: [Unsupervised Quality Estimation code released](examples/unsupervised_quality_estimation/README.md)
-* May 2020: [Follow fairseq on Twitter](https://twitter.com/fairseq)
-* April 2020: [Monotonic Multihead Attention code released](examples/simultaneous_translation/README.md)
-* April 2020: [Quant-Noise code released](examples/quant_noise/README.md)
-* April 2020: [Initial model parallel support and 11B parameters unidirectional LM released](examples/megatron_11b/README.md)
-* March 2020: [Byte-level BPE code released](examples/byte_level_bpe/README.md)
-* February 2020: [mBART model and code released](examples/mbart/README.md)
-* February 2020: [Added tutorial for back-translation](https://github.com/pytorch/fairseq/tree/main/examples/backtranslation#training-your-own-model-wmt18-english-german)
-* December 2019: [fairseq 0.9.0 released](https://github.com/pytorch/fairseq/releases/tag/v0.9.0)
-* November 2019: [VizSeq released (a visual analysis toolkit for evaluating fairseq models)](https://facebookresearch.github.io/vizseq/docs/getting_started/fairseq_example)
-* November 2019: [CamemBERT model and code released](examples/camembert/README.md)
-* November 2019: [BART model and code released](examples/bart/README.md)
-* November 2019: [XLM-R models and code released](examples/xlmr/README.md)
-* September 2019: [Nonautoregressive translation code released](examples/nonautoregressive_translation/README.md)
-* August 2019: [WMT'19 models released](examples/wmt19/README.md)
-* July 2019: fairseq relicensed under MIT license
-* July 2019: [RoBERTa models and code released](examples/roberta/README.md)
-* June 2019: [wav2vec models and code released](examples/wav2vec/README.md)
-
-
-
-### Features:
-
-* multi-GPU training on one machine or across multiple machines (data and model parallel)
-* fast generation on both CPU and GPU with multiple search algorithms implemented:
- + beam search
- + Diverse Beam Search ([Vijayakumar et al., 2016](https://arxiv.org/abs/1610.02424))
- + sampling (unconstrained, top-k and top-p/nucleus)
- + [lexically constrained decoding](examples/constrained_decoding/README.md) (Post & Vilar, 2018)
-* [gradient accumulation](https://fairseq.readthedocs.io/en/latest/getting_started.html#large-mini-batch-training-with-delayed-updates) enables training with large mini-batches even on a single GPU
-* [mixed precision training](https://fairseq.readthedocs.io/en/latest/getting_started.html#training-with-half-precision-floating-point-fp16) (trains faster with less GPU memory on [NVIDIA tensor cores](https://developer.nvidia.com/tensor-cores))
-* [extensible](https://fairseq.readthedocs.io/en/latest/overview.html): easily register new models, criterions, tasks, optimizers and learning rate schedulers
-* [flexible configuration](docs/hydra_integration.md) based on [Hydra](https://github.com/facebookresearch/hydra) allowing a combination of code, command-line and file based configuration
-* [full parameter and optimizer state sharding](examples/fully_sharded_data_parallel/README.md)
-* [offloading parameters to CPU](examples/fully_sharded_data_parallel/README.md)
-
-We also provide [pre-trained models for translation and language modeling](#pre-trained-models-and-examples)
-with a convenient `torch.hub` interface:
-
-``` python
-en2de = torch.hub.load('pytorch/fairseq', 'transformer.wmt19.en-de.single_model')
-en2de.translate('Hello world', beam=5)
-# 'Hallo Welt'
-```
-
-See the PyTorch Hub tutorials for [translation](https://pytorch.org/hub/pytorch_fairseq_translation/)
-and [RoBERTa](https://pytorch.org/hub/pytorch_fairseq_roberta/) for more examples.
-
-# Requirements and Installation
-
-* [PyTorch](http://pytorch.org/) version >= 1.5.0
-* Python version >= 3.6
-* For training new models, you'll also need an NVIDIA GPU and [NCCL](https://github.com/NVIDIA/nccl)
-* **To install fairseq** and develop locally:
-
-``` bash
-git clone https://github.com/pytorch/fairseq
-cd fairseq
-pip install --editable ./
-
-# on MacOS:
-# CFLAGS="-stdlib=libc++" pip install --editable ./
-
-# to install the latest stable release (0.10.x)
-# pip install fairseq
-```
-
-* **For faster training** install NVIDIA's [apex](https://github.com/NVIDIA/apex) library:
-
-``` bash
-git clone https://github.com/NVIDIA/apex
-cd apex
-pip install -v --no-cache-dir --global-option="--cpp_ext" --global-option="--cuda_ext" \
- --global-option="--deprecated_fused_adam" --global-option="--xentropy" \
- --global-option="--fast_multihead_attn" ./
-```
-
-* **For large datasets** install [PyArrow](https://arrow.apache.org/docs/python/install.html#using-pip): `pip install pyarrow`
-* If you use Docker make sure to increase the shared memory size either with `--ipc=host` or `--shm-size`
- as command line options to `nvidia-docker run` .
-
-# Getting Started
-
-The [full documentation](https://fairseq.readthedocs.io/) contains instructions
-for getting started, training new models and extending fairseq with new model
-types and tasks.
-
-# Pre-trained models and examples
-
-We provide pre-trained models and pre-processed, binarized test sets for several tasks listed below,
-as well as example training and evaluation commands.
-
-* [Translation](examples/translation/README.md): convolutional and transformer models are available
-* [Language Modeling](examples/language_model/README.md): convolutional and transformer models are available
-
-We also have more detailed READMEs to reproduce results from specific papers:
-
-* [Cross-lingual Retrieval for Iterative Self-Supervised Training (Tran et al., 2020)](examples/criss/README.md)
-* [wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations (Baevski et al., 2020)](examples/wav2vec/README.md)
-* [Unsupervised Quality Estimation for Neural Machine Translation (Fomicheva et al., 2020)](examples/unsupervised_quality_estimation/README.md)
-* [Training with Quantization Noise for Extreme Model Compression ({Fan*, Stock*} et al., 2020)](examples/quant_noise/README.md)
-* [Neural Machine Translation with Byte-Level Subwords (Wang et al., 2020)](examples/byte_level_bpe/README.md)
-* [Multilingual Denoising Pre-training for Neural Machine Translation (Liu et at., 2020)](examples/mbart/README.md)
-* [Reducing Transformer Depth on Demand with Structured Dropout (Fan et al., 2019)](examples/layerdrop/README.md)
-* [Jointly Learning to Align and Translate with Transformer Models (Garg et al., 2019)](examples/joint_alignment_translation/README.md)
-* [Levenshtein Transformer (Gu et al., 2019)](examples/nonautoregressive_translation/README.md)
-* [Facebook FAIR's WMT19 News Translation Task Submission (Ng et al., 2019)](examples/wmt19/README.md)
-* [RoBERTa: A Robustly Optimized BERT Pretraining Approach (Liu et al., 2019)](examples/roberta/README.md)
-* [wav2vec: Unsupervised Pre-training for Speech Recognition (Schneider et al., 2019)](examples/wav2vec/README.md)
-* [Mixture Models for Diverse Machine Translation: Tricks of the Trade (Shen et al., 2019)](examples/translation_moe/README.md)
-* [Pay Less Attention with Lightweight and Dynamic Convolutions (Wu et al., 2019)](examples/pay_less_attention_paper/README.md)
-* [Understanding Back-Translation at Scale (Edunov et al., 2018)](examples/backtranslation/README.md)
-* [Classical Structured Prediction Losses for Sequence to Sequence Learning (Edunov et al., 2018)](https://github.com/pytorch/fairseq/tree/classic_seqlevel)
-* [Hierarchical Neural Story Generation (Fan et al., 2018)](examples/stories/README.md)
-* [Scaling Neural Machine Translation (Ott et al., 2018)](examples/scaling_nmt/README.md)
-* [Convolutional Sequence to Sequence Learning (Gehring et al., 2017)](examples/conv_seq2seq/README.md)
-* [Language Modeling with Gated Convolutional Networks (Dauphin et al., 2017)](examples/language_model/README.conv.md)
-
-# Join the fairseq community
-
-* Twitter: https://twitter.com/fairseq
-* Facebook page: https://www.facebook.com/groups/fairseq.users
-* Google group: https://groups.google.com/forum/#!forum/fairseq-users
-
-# License
-
-fairseq(-py) is MIT-licensed.
-The license applies to the pre-trained models as well.
-
-# Citation
-
-Please cite as:
-
-``` bibtex
-@inproceedings{ott2019fairseq,
- title = {fairseq: A Fast, Extensible Toolkit for Sequence Modeling},
- author = {Myle Ott and Sergey Edunov and Alexei Baevski and Angela Fan and Sam Gross and Nathan Ng and David Grangier and Michael Auli},
- booktitle = {Proceedings of NAACL-HLT 2019: Demonstrations},
- year = {2019},
-}
-```
diff --git a/spaces/koajoel/PolyFormer/fairseq/examples/linformer/linformer_src/modules/multihead_linear_attention.py b/spaces/koajoel/PolyFormer/fairseq/examples/linformer/linformer_src/modules/multihead_linear_attention.py
deleted file mode 100644
index 6be1007279217c5de644e8b054f5d14a19f06c55..0000000000000000000000000000000000000000
--- a/spaces/koajoel/PolyFormer/fairseq/examples/linformer/linformer_src/modules/multihead_linear_attention.py
+++ /dev/null
@@ -1,481 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import math
-from typing import Dict, Optional, Tuple
-
-import torch
-import torch.nn.functional as F
-from fairseq import utils
-from fairseq.incremental_decoding_utils import with_incremental_state
-from fairseq.modules.quant_noise import quant_noise
-from torch import Tensor, nn
-from torch.nn import Parameter
-
-
-@with_incremental_state
-class MultiheadLinearAttention(nn.Module):
- """Multi-headed linformer attention.
-
- Projects the key and values down to the compressed dimension, before computing self-attention.
-
- See "Linformer: Self-Attention with Linear Complexity" for more details.
- """
-
- def __init__(
- self,
- embed_dim,
- num_heads,
- kdim=None,
- vdim=None,
- dropout=0.0,
- bias=True,
- add_bias_kv=False,
- add_zero_attn=False,
- self_attention=False,
- encoder_decoder_attention=False,
- q_noise=0.0,
- qn_block_size=8,
- compressed=1,
- max_seq_len=256,
- shared_kv_compressed=0,
- shared_compress_layer=None,
- freeze_compress=0,
- ):
- super().__init__()
- self.embed_dim = embed_dim
- self.kdim = kdim if kdim is not None else embed_dim
- self.vdim = vdim if vdim is not None else embed_dim
- self.qkv_same_dim = self.kdim == embed_dim and self.vdim == embed_dim
-
- self.num_heads = num_heads
- self.dropout = dropout
- self.head_dim = embed_dim // num_heads
- assert (
- self.head_dim * num_heads == self.embed_dim
- ), "embed_dim must be divisible by num_heads"
- self.scaling = self.head_dim ** -0.5
-
- self.self_attention = self_attention
- self.encoder_decoder_attention = encoder_decoder_attention
-
- assert not self.self_attention or self.qkv_same_dim, (
- "Self-attention requires query, key and " "value to be of the same size"
- )
-
- self.k_proj = quant_noise(
- nn.Linear(self.kdim, embed_dim, bias=bias), q_noise, qn_block_size
- )
- self.v_proj = quant_noise(
- nn.Linear(self.vdim, embed_dim, bias=bias), q_noise, qn_block_size
- )
- self.q_proj = quant_noise(
- nn.Linear(embed_dim, embed_dim, bias=bias), q_noise, qn_block_size
- )
-
- # used for compress sequence to subsequence
- if shared_compress_layer is None:
- self.compress_seq_len = max_seq_len // compressed
- self.compress_k = nn.Linear(max_seq_len, self.compress_seq_len, bias=False)
- if shared_kv_compressed == 0:
- self.compress_v = nn.Linear(
- max_seq_len, self.compress_seq_len, bias=False
- )
- self.layerwise_sharing = False
- else:
- self.compress_k = shared_compress_layer
- if shared_kv_compressed == 0:
- self.compress_v = shared_compress_layer
- self.layerwise_sharing = True
- self.shared_kv_compressed = shared_kv_compressed
-
- self.out_proj = quant_noise(
- nn.Linear(embed_dim, embed_dim, bias=bias), q_noise, qn_block_size
- )
-
- if add_bias_kv:
- self.bias_k = Parameter(torch.Tensor(1, 1, embed_dim))
- self.bias_v = Parameter(torch.Tensor(1, 1, embed_dim))
- else:
- self.bias_k = self.bias_v = None
-
- self.add_zero_attn = add_zero_attn
-
- self.reset_parameters()
-
- if freeze_compress == 1:
- self.compress_k.weight.requires_grad = False
- if shared_kv_compressed == 0:
- self.compress_v.weight.requires_grad = False
-
- self.onnx_trace = False
-
- def prepare_for_onnx_export_(self):
- self.onnx_trace = True
-
- def reset_parameters(self):
- if self.qkv_same_dim:
- # Empirically observed the convergence to be much better with
- # the scaled initialization
- nn.init.xavier_uniform_(self.k_proj.weight, gain=1 / math.sqrt(2))
- nn.init.xavier_uniform_(self.v_proj.weight, gain=1 / math.sqrt(2))
- nn.init.xavier_uniform_(self.q_proj.weight, gain=1 / math.sqrt(2))
- if (
- not self.layerwise_sharing
- ): # otherwise, we already initialize the parameters
- nn.init.xavier_uniform_(self.compress_k.weight, gain=1 / math.sqrt(2))
- if self.shared_kv_compressed == 0:
- nn.init.xavier_uniform_(
- self.compress_v.weight, gain=1 / math.sqrt(2)
- )
- else:
- nn.init.xavier_uniform_(self.k_proj.weight)
- nn.init.xavier_uniform_(self.v_proj.weight)
- nn.init.xavier_uniform_(self.q_proj.weight)
- if (
- not self.layerwise_sharing
- ): # otherwise, we already initialize the parameters
- nn.init.xavier_uniform_(self.compress_k.weight)
- if self.shared_kv_compressed == 0:
- nn.init.xavier_uniform_(self.compress_v.weight)
-
- nn.init.xavier_uniform_(self.out_proj.weight)
- if self.out_proj.bias is not None:
- nn.init.constant_(self.out_proj.bias, 0.0)
- if self.bias_k is not None:
- nn.init.xavier_normal_(self.bias_k)
- if self.bias_v is not None:
- nn.init.xavier_normal_(self.bias_v)
-
- def forward(
- self,
- query,
- key: Optional[Tensor],
- value: Optional[Tensor],
- key_padding_mask: Optional[Tensor] = None,
- incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None,
- need_weights: bool = True,
- static_kv: bool = False,
- attn_mask: Optional[Tensor] = None,
- before_softmax: bool = False,
- need_head_weights: bool = False,
- ) -> Tuple[Tensor, Optional[Tensor]]:
- """Input shape: Time x Batch x Channel
-
- Args:
- key_padding_mask (ByteTensor, optional): mask to exclude
- keys that are pads, of shape `(batch, src_len)`, where
- padding elements are indicated by 1s.
- need_weights (bool, optional): return the attention weights,
- averaged over heads (default: False).
- attn_mask (ByteTensor, optional): typically used to
- implement causal attention, where the mask prevents the
- attention from looking forward in time (default: None).
- before_softmax (bool, optional): return the raw attention
- weights and values before the attention softmax.
- need_head_weights (bool, optional): return the attention
- weights for each head. Implies *need_weights*. Default:
- return the average attention weights over all heads.
- """
- if need_head_weights:
- need_weights = True
-
- tgt_len, bsz, embed_dim = query.size()
- assert embed_dim == self.embed_dim
- assert list(query.size()) == [tgt_len, bsz, embed_dim]
-
- if incremental_state is not None:
- saved_state = self._get_input_buffer(incremental_state)
- if saved_state is not None and "prev_key" in saved_state:
- # previous time steps are cached - no need to recompute
- # key and value if they are static
- if static_kv:
- assert self.encoder_decoder_attention and not self.self_attention
- key = value = None
- else:
- saved_state = None
-
- if self.self_attention:
- q = self.q_proj(query)
-
- k_input = query.permute(1, 2, 0).contiguous() # B * C * T
- k_input = (
- F.linear(k_input, self.compress_k.weight[:, 0:tgt_len])
- .permute(2, 0, 1)
- .contiguous()
- )
- k = self.k_proj(k_input)
-
- v_input = query.permute(1, 2, 0).contiguous() # B * C * T
- if self.shared_kv_compressed == 0:
- v_input = (
- F.linear(v_input, self.compress_v.weight[:, 0:tgt_len])
- .permute(2, 0, 1)
- .contiguous()
- )
- if self.shared_kv_compressed == 1: # use shared kv compressed linear layer
- v_input = (
- F.linear(v_input, self.compress_k.weight[:, 0:tgt_len])
- .permute(2, 0, 1)
- .contiguous()
- )
- v = self.v_proj(v_input)
- elif self.encoder_decoder_attention:
- # encoder-decoder attention
- q = self.q_proj(query)
- if key is None:
- assert value is None
- k = v = None
- else:
- k = self.k_proj(key)
- v = self.v_proj(key)
-
- else:
- assert key is not None and value is not None
- q = self.q_proj(query)
- k = self.k_proj(key)
- v = self.v_proj(value)
- q *= self.scaling
-
- if self.bias_k is not None:
- assert self.bias_v is not None
- k = torch.cat([k, self.bias_k.repeat(1, bsz, 1)])
- v = torch.cat([v, self.bias_v.repeat(1, bsz, 1)])
- if attn_mask is not None:
- attn_mask = torch.cat(
- [attn_mask, attn_mask.new_zeros(attn_mask.size(0), 1)], dim=1
- )
- if key_padding_mask is not None:
- key_padding_mask = torch.cat(
- [
- key_padding_mask,
- key_padding_mask.new_zeros(key_padding_mask.size(0), 1),
- ],
- dim=1,
- )
-
- q = (
- q.contiguous()
- .view(tgt_len, bsz * self.num_heads, self.head_dim)
- .transpose(0, 1)
- )
- if k is not None:
- k = (
- k.contiguous()
- .view(-1, bsz * self.num_heads, self.head_dim)
- .transpose(0, 1)
- )
- if v is not None:
- v = (
- v.contiguous()
- .view(-1, bsz * self.num_heads, self.head_dim)
- .transpose(0, 1)
- )
-
- if saved_state is not None:
- # saved states are stored with shape (bsz, num_heads, seq_len, head_dim)
- if "prev_key" in saved_state:
- _prev_key = saved_state["prev_key"]
- assert _prev_key is not None
- prev_key = _prev_key.view(bsz * self.num_heads, -1, self.head_dim)
- if static_kv:
- k = prev_key
- else:
- assert k is not None
- k = torch.cat([prev_key, k], dim=1)
- if "prev_value" in saved_state:
- _prev_value = saved_state["prev_value"]
- assert _prev_value is not None
- prev_value = _prev_value.view(bsz * self.num_heads, -1, self.head_dim)
- if static_kv:
- v = prev_value
- else:
- assert v is not None
- v = torch.cat([prev_value, v], dim=1)
- prev_key_padding_mask: Optional[Tensor] = None
- if "prev_key_padding_mask" in saved_state:
- prev_key_padding_mask = saved_state["prev_key_padding_mask"]
- assert k is not None and v is not None
- key_padding_mask = MultiheadLinearAttention._append_prev_key_padding_mask(
- key_padding_mask=key_padding_mask,
- prev_key_padding_mask=prev_key_padding_mask,
- batch_size=bsz,
- src_len=k.size(1),
- static_kv=static_kv,
- )
-
- saved_state["prev_key"] = k.view(bsz, self.num_heads, -1, self.head_dim)
- saved_state["prev_value"] = v.view(bsz, self.num_heads, -1, self.head_dim)
- saved_state["prev_key_padding_mask"] = key_padding_mask
- # In this branch incremental_state is never None
- assert incremental_state is not None
- incremental_state = self._set_input_buffer(incremental_state, saved_state)
- assert k is not None
- src_len = k.size(1)
-
- if self.add_zero_attn:
- assert v is not None
- src_len += 1
- k = torch.cat([k, k.new_zeros((k.size(0), 1) + k.size()[2:])], dim=1)
- v = torch.cat([v, v.new_zeros((v.size(0), 1) + v.size()[2:])], dim=1)
- if attn_mask is not None:
- attn_mask = torch.cat(
- [attn_mask, attn_mask.new_zeros(attn_mask.size(0), 1)], dim=1
- )
-
- attn_weights = torch.bmm(q, k.transpose(1, 2))
- attn_weights = MultiheadLinearAttention.apply_sparse_mask(
- attn_weights, tgt_len, src_len, bsz
- )
-
- assert list(attn_weights.size()) == [bsz * self.num_heads, tgt_len, src_len]
-
- if attn_mask is not None:
- attn_mask = attn_mask.unsqueeze(0)
- if self.onnx_trace:
- attn_mask = attn_mask.repeat(attn_weights.size(0), 1, 1)
- attn_weights += attn_mask
-
- if before_softmax:
- return attn_weights, v
-
- attn_weights_float = utils.softmax(
- attn_weights, dim=-1, onnx_trace=self.onnx_trace
- )
- attn_weights = attn_weights_float.type_as(attn_weights)
- attn_probs = F.dropout(
- attn_weights,
- p=self.dropout,
- training=self.training,
- )
- assert v is not None
- attn = torch.bmm(attn_probs, v)
- assert list(attn.size()) == [bsz * self.num_heads, tgt_len, self.head_dim]
- if self.onnx_trace and attn.size(1) == 1:
- # when ONNX tracing a single decoder step (sequence length == 1)
- # the transpose is a no-op copy before view, thus unnecessary
- attn = attn.contiguous().view(tgt_len, bsz, embed_dim)
- else:
- attn = attn.transpose(0, 1).contiguous().view(tgt_len, bsz, embed_dim)
- attn = self.out_proj(attn)
- attn_weights: Optional[Tensor] = None
- if need_weights:
- attn_weights = attn_weights_float.view(
- bsz, self.num_heads, tgt_len, src_len
- ).transpose(1, 0)
- if not need_head_weights:
- # average attention weights over heads
- attn_weights = attn_weights.mean(dim=0)
-
- return attn, attn_weights
-
- @staticmethod
- def _append_prev_key_padding_mask(
- key_padding_mask: Optional[Tensor],
- prev_key_padding_mask: Optional[Tensor],
- batch_size: int,
- src_len: int,
- static_kv: bool,
- ) -> Optional[Tensor]:
- # saved key padding masks have shape (bsz, seq_len)
- if prev_key_padding_mask is not None and static_kv:
- new_key_padding_mask = prev_key_padding_mask
- elif prev_key_padding_mask is not None and key_padding_mask is not None:
- new_key_padding_mask = torch.cat(
- [prev_key_padding_mask.float(), key_padding_mask.float()], dim=1
- )
- # During incremental decoding, as the padding token enters and
- # leaves the frame, there will be a time when prev or current
- # is None
- elif prev_key_padding_mask is not None:
- filler = torch.zeros(
- (batch_size, src_len - prev_key_padding_mask.size(1)),
- device=prev_key_padding_mask.device,
- )
- new_key_padding_mask = torch.cat(
- [prev_key_padding_mask.float(), filler.float()], dim=1
- )
- elif key_padding_mask is not None:
- filler = torch.zeros(
- (batch_size, src_len - key_padding_mask.size(1)),
- device=key_padding_mask.device,
- )
- new_key_padding_mask = torch.cat(
- [filler.float(), key_padding_mask.float()], dim=1
- )
- else:
- new_key_padding_mask = prev_key_padding_mask
- return new_key_padding_mask
-
- @torch.jit.export
- def reorder_incremental_state(
- self,
- incremental_state: Dict[str, Dict[str, Optional[Tensor]]],
- new_order: Tensor,
- ):
- """Reorder buffered internal state (for incremental generation)."""
- input_buffer = self._get_input_buffer(incremental_state)
- if input_buffer is not None:
- for k in input_buffer.keys():
- input_buffer_k = input_buffer[k]
- if input_buffer_k is not None:
- if self.encoder_decoder_attention and input_buffer_k.size(
- 0
- ) == new_order.size(0):
- break
- input_buffer[k] = input_buffer_k.index_select(0, new_order)
- incremental_state = self._set_input_buffer(incremental_state, input_buffer)
- return incremental_state
-
- def _get_input_buffer(
- self, incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]]
- ) -> Dict[str, Optional[Tensor]]:
- result = self.get_incremental_state(incremental_state, "attn_state")
- if result is not None:
- return result
- else:
- empty_result: Dict[str, Optional[Tensor]] = {}
- return empty_result
-
- def _set_input_buffer(
- self,
- incremental_state: Dict[str, Dict[str, Optional[Tensor]]],
- buffer: Dict[str, Optional[Tensor]],
- ):
- return self.set_incremental_state(incremental_state, "attn_state", buffer)
-
- def apply_sparse_mask(attn_weights, tgt_len: int, src_len: int, bsz: int):
- return attn_weights
-
- def upgrade_state_dict_named(self, state_dict, name):
- prefix = name + "." if name != "" else ""
- items_to_add = {}
- keys_to_remove = []
- for k in state_dict.keys():
- if k.endswith(prefix + "in_proj_weight"):
- # in_proj_weight used to be q + k + v with same dimensions
- dim = int(state_dict[k].shape[0] / 3)
- items_to_add[prefix + "q_proj.weight"] = state_dict[k][:dim]
- items_to_add[prefix + "k_proj.weight"] = state_dict[k][dim : 2 * dim]
- items_to_add[prefix + "v_proj.weight"] = state_dict[k][2 * dim :]
-
- keys_to_remove.append(k)
-
- k_bias = prefix + "in_proj_bias"
- if k_bias in state_dict.keys():
- dim = int(state_dict[k].shape[0] / 3)
- items_to_add[prefix + "q_proj.bias"] = state_dict[k_bias][:dim]
- items_to_add[prefix + "k_proj.bias"] = state_dict[k_bias][
- dim : 2 * dim
- ]
- items_to_add[prefix + "v_proj.bias"] = state_dict[k_bias][2 * dim :]
-
- keys_to_remove.append(prefix + "in_proj_bias")
-
- for k in keys_to_remove:
- del state_dict[k]
-
- for key, value in items_to_add.items():
- state_dict[key] = value
diff --git a/spaces/koushik-org/Trading_QA_Bot/app.py b/spaces/koushik-org/Trading_QA_Bot/app.py
deleted file mode 100644
index e96ba927709f8c9a33d9d72da175762cfb8c86b7..0000000000000000000000000000000000000000
--- a/spaces/koushik-org/Trading_QA_Bot/app.py
+++ /dev/null
@@ -1,75 +0,0 @@
-# Imports
-import gradio as gr
-from helper_functions import *
-
-with gr.Blocks() as app:
- gr.Markdown('# Trading Q&A Bot')
- session_data = gr.State([
- [],[]
- ])
- def user(user_message, history):
- return "", history + [[user_message, None]]
-
- def bot(history, session_data_fn):
- messages_archived = session_data_fn[0]
- messages_current = session_data_fn[1]
- bot_message, messages_archived, messages_current = get_reply(history[-1][0], messages_archived, messages_current)
- history[-1][1] = bot_message
- session_data_fn[0] = messages_archived
- session_data_fn[1] = messages_current
- return history, session_data_fn
-
- def reset_memory(session_data_fn):
- messages_archived = session_data_fn[0]
- # print("Message Archived Len=", len(messages_archived))
- if(len(messages_archived)>=21):
- messages_archived = messages_archived[0:1] + messages_archived[3:]
- session_data_fn[0] = messages_archived
- return session_data_fn
-
- def clear_data(session_data_fn):
- messages_archived = [
- {"role": "system", "content": pre_text}
- ]
- messages_current = []
- session_data_fn[0] = messages_archived
- session_data_fn[1] = messages_current
- return None, session_data_fn
-
- def get_context_gr(session_data_fn):
- messages_current = session_data_fn[1]
- return str(messages_current)
-
- with gr.Tab("Chat"):
- with gr.Row():
- with gr.Column():
- msg = gr.Textbox()
- with gr.Row():
- submit = gr.Button("Submit")
- clear = gr.Button("Clear")
- with gr.Column():
- chatbot = gr.Chatbot()
-
- with gr.Tab("Prompt"):
- context = gr.Textbox()
- submit_p = gr.Button("Check Prompt")
- # Tab Chat
- msg.submit(user, [msg, chatbot], [msg, chatbot], queue=False).then(
- bot, [chatbot, session_data], [chatbot, session_data]
- ).then(
- fn = reset_memory, inputs = session_data, outputs = session_data
- )
- submit.click(user, [msg, chatbot], [msg, chatbot], queue=False).then(
- bot, [chatbot, session_data], [chatbot, session_data]
- ).then(
- fn = reset_memory, inputs = session_data, outputs = session_data
- )
- clear.click(
- fn = clear_data,
- inputs = session_data,
- outputs = [chatbot, session_data],
- queue = False
- )
- # Tab Prompt
- submit_p.click(get_context_gr, session_data, context, queue=False)
-app.launch(auth=(os.getenv("id"), os.getenv("password")), show_api=False)
\ No newline at end of file
diff --git a/spaces/krafiq/deep-neural-networks-for-navier-stokes-equations/app.py b/spaces/krafiq/deep-neural-networks-for-navier-stokes-equations/app.py
deleted file mode 100644
index 94e39310c677a502dcbd0de850aad355df808244..0000000000000000000000000000000000000000
--- a/spaces/krafiq/deep-neural-networks-for-navier-stokes-equations/app.py
+++ /dev/null
@@ -1,290 +0,0 @@
-import pandas as pd
-import tensorflow as tf
-from tensorflow.keras.models import load_model
-import cv2
-import numpy as np
-import matplotlib.pyplot as plt
-import gradio as gr
-
-# developing the flowfield space
-flow_field = np.ones((128,256), dtype = np.uint8)
-
-# Changing the left input side
-flow_field[:,0] = 3
-# Changing the right output side
-flow_field[:,-1] = 4
-# Changing the top layer
-flow_field[0,:] = 2
-# Changing the bottom layer
-flow_field[-1,:] = 2
-
-mean_u = 0.075003795
-mean_v = -0.000036
-mean_p = 0.004301
-
-std_dev_u = 0.04605
-std_dev_v = 0.013812
-std_dev_p = 0.007917
-
-def nvs_loss(y_pred, rho=10, nu=0.0001): #arbitary rho and nu(Later use values of air)
- u,v,p = tf.split(y_pred, 3, axis=3)
-
- #First order derivative
- du_dx, du_dy = tf.image.image_gradients(u) # tf.image.image_gradients returns a tuple containing two tensors: u-grad along the x dir and u-grad along the y dir
- dv_dx, dv_dy = tf.image.image_gradients(v)
- dp_dx, dp_dy = tf.image.image_gradients(p)
-
- #Second order derivatives
- du_dx2, du_dydx = tf.image.image_gradients(du_dx) # du_dydx will be unused
- du_dxdy, du_dy2 = tf.image.image_gradients(du_dy) # du_dxdy will be unused
-
- dv_dx2, dv_dydx = tf.image.image_gradients(dv_dx)
- dv_dxdy, dv_dy2 = tf.image.image_gradients(dv_dy)
-
- #Momentum equation
- er1_tensor = tf.math.multiply(u, du_dx) + tf.math.multiply(v, du_dy) + 1.0*dp_dx/rho - nu*(du_dx2 + du_dy2)
- er2_tensor = tf.math.multiply(u, dv_dx) + tf.math.multiply(v, dv_dy) + 1.0*dp_dy/rho - nu*(dv_dx2 + dv_dy2)
-
- # # #Continuity equation
- er3_tensor = du_dx + dv_dy
-
- er1 = tf.reduce_mean(er1_tensor)
- er2 = tf.reduce_mean(er2_tensor)
- er3 = tf.reduce_mean(er3_tensor)
-
- return er1*er1 + er2*er2 + er3*er3
-
- # Initiating the Loss Function-
-def custom_loss(y_true, y_pred):
- nv_loss = nvs_loss(y_pred)
- mse_loss = tf.reduce_mean(tf.square(y_true-y_pred)) # Try mse loss function here
- return mse_loss + nv_loss
-
-import torch
-import matplotlib
-def colorize(value, vmin=None, vmax=None, cmap='gray_r', invalid_val=-99, invalid_mask=None, background_color=(128, 128, 128, 255), gamma_corrected=False, value_transform=None):
- """Converts a depth map to a color image.
-
- Args:
- value (torch.Tensor, numpy.ndarry): Input depth map. Shape: (H, W) or (1, H, W) or (1, 1, H, W). All singular dimensions are squeezed
- vmin (float, optional): vmin-valued entries are mapped to start color of cmap. If None, value.min() is used. Defaults to None.
- vmax (float, optional): vmax-valued entries are mapped to end color of cmap. If None, value.max() is used. Defaults to None.
- cmap (str, optional): matplotlib colormap to use. Defaults to 'magma_r'.
- invalid_val (int, optional): Specifies value of invalid pixels that should be colored as 'background_color'. Defaults to -99.
- invalid_mask (numpy.ndarray, optional): Boolean mask for invalid regions. Defaults to None.
- background_color (tuple[int], optional): 4-tuple RGB color to give to invalid pixels. Defaults to (128, 128, 128, 255).
- gamma_corrected (bool, optional): Apply gamma correction to colored image. Defaults to False.
- value_transform (Callable, optional): Apply transform function to valid pixels before coloring. Defaults to None.
-
- Returns:
- numpy.ndarray, dtype - uint8: Colored depth map. Shape: (H, W, 4)
- """
- if isinstance(value, torch.Tensor):
- value = value.detach().cpu().numpy()
-
- value = value.squeeze()
- if invalid_mask is None:
- invalid_mask = value == invalid_val
- mask = np.logical_not(invalid_mask)
-
- # normalize
- # vmin = np.percentile(value[mask],2) if vmin is None else vmin
- # vmax = np.percentile(value[mask],85) if vmax is None else vmax
- vmin = np.min(value[mask]) if vmin is None else vmin
- vmax = np.max(value[mask]) if vmax is None else vmax
- if vmin != vmax:
- value = (value - vmin) / (vmax - vmin) # vmin..vmax
- else:
- # Avoid 0-division
- value = value * 0.
-
- # squeeze last dim if it exists
- # grey out the invalid values
-
- value[invalid_mask] = np.nan
- cmapper = matplotlib.cm.get_cmap(cmap)
- if value_transform:
- value = value_transform(value)
- # value = value / value.max()
- value = cmapper(value, bytes=True) # (nxmx4)
-
- # img = value[:, :, :]
- img = value[...]
- img[invalid_mask] = background_color
-
- # return img.transpose((2, 0, 1))
- if gamma_corrected:
- # gamma correction
- img = img / 255
- img = np.power(img, 2.2)
- img = img * 255
- img = img.astype(np.uint8)
- return img
-
-def img_preprocess(image, h, w):
- # Convert the drawn image to grayscale
- img_gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
-
- # Threshold the grayscale image to create a binary image
- _, binary_img = cv2.threshold(img_gray, 1, 255, cv2.THRESH_BINARY)
-
- # Perform flood fill starting from a point inside the shape. Fill the inside with pixel value 0
- seed_point = (int(h/2), int(w/2))
- retval, flooded_image, mask, rect = cv2.floodFill(binary_img, None, seed_point, 0)
- flooded_image = (flooded_image/255).astype(np.uint8)
- return flooded_image
-
-def patch_stiching(flooded_image, h, w, x0, y0): # ((x0, y0) = center of channel, (w1, h1) = height and width of patch)
- flow_field_updated = np.copy(flow_field)
- flow_field_updated[int(x0-w/2):int(x0+w/2),int(y0-h/2):int(y0+h/2)] = flooded_image
-
-
- # flow_field_updated is the main thing that we will use to make our predictions on -
- test_img = np.expand_dims(flow_field_updated, axis = 0)
- test_img = np.expand_dims(test_img, axis = 3) # Shape of test_img = (1, 128, 256)
- return test_img
-
-# Define grid points
-x_points = np.linspace(0, 255, 256)
-y_points = np.linspace(0, 127, 128)
-X, Y = np.meshgrid(x_points, y_points)
-
-def return_quiver_plot(u, v):
- velocity = np.sqrt(u**2 + v**2)
- ax = plt.subplot()
- ax.imshow(velocity, origin = 'lower', extent = (0,256, 0,128), cmap = 'gray')
- q = ax.quiver(X[5::8,5::8], Y[5::8,5::8], u[5::8,5::8], u[5::8,5::8], pivot = 'middle', color = 'red')
- # ax.quiverkey(q, X=0.9, Y=1.05, U=2,
- # label='m/s', labelpos='E')
- # plt.title("Velocity distribution")
- # plt.show()
- return q
-
-def squeeze_function(img):
- img = np.squeeze(img, axis = 0)
- img = np.squeeze(img, axis = 2)
- return img
-
-# Taking a shape from the user on sketchpad and placing it inside the fluid flow -
-
-h, w = 48, 48 # patch_size in which the obstacle will be drawn
-x0, y0 = 64, 128 # (x0, y0) = center of channel
-
-def fill_shape_with_pixels(img): #img is taken by gradio as uint8
- if img is None:
- return np.zeros((h, w), dtype=np.uint8) # "No input sketch"
-# Calling the the flooded image function to fill inside the obstacle
- flooded_image = img_preprocess(img, h, w)
-# Performing patch statching to put the obstacle at the required center position
- test_img = patch_stiching(flooded_image, h, w, x0, y0)
-
-# Loading and Compiling the Model
- model_path = "Pinns_Loss_file.h5"
- model = load_model(model_path, compile = False)
- model.compile(loss=custom_loss, optimizer=tf.keras.optimizers.AdamW(learning_rate = 0.0001), metrics=['mae', 'cosine_proximity'])
-
- # Making Model prediction from input sketch shape
- prediction = model.predict(test_img) # (prediction.shape = (1, 128, 256, 3))
- u_pred, v_pred, p_pred = np.split(prediction, 3, axis=3) # shape of u_pred, v_pred, p_pred = (1, 128, 256, 1)
-
- # De-Normalizing teh Data:
- u_pred = ((u_pred*std_dev_u) + mean_u)
- v_pred = ((v_pred*std_dev_v) + mean_v)
- p_pred = ((p_pred*std_dev_p) + mean_p)
-
- # Making test_img in shape required by zero_pixel_location
- req_img = squeeze_function(test_img)
-
-# Storing the location of 0 pixel values
- #req_img = req_img.astype(int)
- zero_pixel_locations = np.argwhere(req_img == 0)
-
-# Reducing the dimensions-
- u_profile = u_pred[0][:,:,0] # shape of u profile to compatible shape (H, W) = (128, 256)
- v_profile = v_pred[0][:,:,0]
- p_profile = p_pred[0][:,:,0]
- p_profile[p_profile>0.02] = 0.02
-
-# Creating a copy of the above profiles-
- u_profile_dash = np.copy(u_profile)
- v_profile_dash = np.copy(v_profile)
-
-# Creating a copy of the above profiles-
- u_profile_dash_1 = np.copy(u_profile)
- v_profile_dash_1 = np.copy(v_profile)
-
-
-# Hollowing the obstacle out from the u and v plots. Origin of imae is lop left and origin of plot is top right
- for y, x in zero_pixel_locations:
- u_profile_dash[128 - y, x] = 0
- v_profile_dash[128 - y, x] = 0
- # will be used for image
- u_profile_dash_1[y, x] = 0
- v_profile_dash_1[y, x] = 0
-
-
-# Quiver Plot
- quiver_plot = plt.figure(figsize = (14,6), edgecolor = "gray")
- velocity = np.sqrt(u_profile_dash_1**2 + v_profile_dash_1**2)
- ax = plt.subplot()
- ax.imshow(velocity, cmap = 'gray', extent = (0,256, 0,128))
- q = ax.quiver(X[5::7,5::7], Y[5::7,5::7], u_profile_dash[5::7,5::7], v_profile_dash[5::7,5::7], pivot = 'middle', color = 'red')
- ax.quiverkey(q, X=0.9, Y=1.07, U=2,
- label='m/s', labelpos='E')
- plt.title("Velocity distribution", fontsize = 11)
- plt.xlabel("Length of Channel", fontsize = 11)
- plt.ylabel("Height of Channel", fontsize = 11)
-
- # StreamLine Plot
- streamline_plot = plt.figure(figsize = (14,6), edgecolor = "gray")
- plt.streamplot(X, Y, u_profile_dash, v_profile_dash, density = 4)
- plt.axis('scaled')
- plt.title("Streamline Plot", fontsize = 11)
- plt.xlabel("Length of Channel", fontsize = 11)
- plt.ylabel("Height of Channel", fontsize = 11)
-
- # Colorize taken from ZoeDepth Model
- u_colored = colorize(u_profile, cmap = 'jet')
- #cbar_u = plt.colorbar(u_profile,fraction=0.025, pad=0.05)
- v_colored = colorize(v_profile, cmap = 'jet')
- #cbar_v = plt.colorbar(v_colored,fraction=0.025, pad=0.05)
- p_colored = colorize(p_profile, cmap = 'jet')
- #cbar_p = plt.colorbar(p_colored,fraction=0.025, pad=0.05)
-
-
- return colorize(req_img, cmap = 'jet'), quiver_plot, streamline_plot, u_colored, v_colored, p_colored
-
-# Importing gr.Blocks()
-
-with gr.Blocks(theme="Taithrah/Minimal") as demo:
- gr.Markdown(
- """
- # Channel Flow - Physics Constrained DNN for Predicting Mean Turbulent Flows
- The App solves 2-D incompressible steady state NS equations for any given 2-D closed geometry. Geometry needs to be drawn around the center of the patch.\n
- It predicts the streamlines,horizontal & vertical velocity profiles and the pressure profiles using a hybrid loss function.\n
- Model Parameters (In SI Units) - Kinematic Viscosity = 0.0001, Input horizontal velocity = 0.075, Input vertical velocity = 0
- """)
- with gr.Row():
- with gr.Column():
- input_sketch = gr.Image(label = "Draw any Obstacle contour around the patch center",
- tool="sketch", source="canvas", shape=(h, w), brush_radius = 3)
- Process_button = gr.Button("Process Flow Parameters")
-
- with gr.Column():
- filled_channel = gr.Image(label = "Drawn object within fluid domain of dimensions 128*256", container = True)
-
- with gr.Row():
- quiver_plot = gr.Plot(label = "Velocity Distribution Around The Obstacle", scale = 2)
-
- with gr.Row():
- streamline_plot = gr.Plot(label = "Stream Lines Around The Obstacle", scale = 2)
-
- with gr.Row():
- u_image = gr.Image(label = "Horizontal Velocity")
- v_image = gr.Image(label = "Vertical Velocity")
- p_image = gr.Image(label = "Pressure")
-
-
- Process_button.click(fn=fill_shape_with_pixels, inputs=input_sketch, outputs=[filled_channel, quiver_plot, streamline_plot, u_image, v_image, p_image])
-
-demo.launch(debug=True, inline = False)
\ No newline at end of file
diff --git a/spaces/kukuhtw/AutoGPT/autogpt/agent/agent.py b/spaces/kukuhtw/AutoGPT/autogpt/agent/agent.py
deleted file mode 100644
index ee7885f8844022597321fa6b492430ec34c0d6b9..0000000000000000000000000000000000000000
--- a/spaces/kukuhtw/AutoGPT/autogpt/agent/agent.py
+++ /dev/null
@@ -1,197 +0,0 @@
-from colorama import Fore, Style
-
-from autogpt.app import execute_command, get_command
-from autogpt.chat import chat_with_ai, create_chat_message
-from autogpt.config import Config
-from autogpt.json_utils.json_fix_llm import fix_json_using_multiple_techniques
-from autogpt.json_utils.utilities import validate_json
-from autogpt.logs import logger, print_assistant_thoughts
-from autogpt.speech import say_text
-from autogpt.spinner import Spinner
-from autogpt.utils import clean_input
-
-
-class Agent:
- """Agent class for interacting with Auto-GPT.
-
- Attributes:
- ai_name: The name of the agent.
- memory: The memory object to use.
- full_message_history: The full message history.
- next_action_count: The number of actions to execute.
- system_prompt: The system prompt is the initial prompt that defines everything the AI needs to know to achieve its task successfully.
- Currently, the dynamic and customizable information in the system prompt are ai_name, description and goals.
-
- triggering_prompt: The last sentence the AI will see before answering. For Auto-GPT, this prompt is:
- Determine which next command to use, and respond using the format specified above:
- The triggering prompt is not part of the system prompt because between the system prompt and the triggering
- prompt we have contextual information that can distract the AI and make it forget that its goal is to find the next task to achieve.
- SYSTEM PROMPT
- CONTEXTUAL INFORMATION (memory, previous conversations, anything relevant)
- TRIGGERING PROMPT
-
- The triggering prompt reminds the AI about its short term meta task (defining the next task)
- """
-
- def __init__(
- self,
- ai_name,
- memory,
- full_message_history,
- next_action_count,
- system_prompt,
- triggering_prompt,
- ):
- self.ai_name = ai_name
- self.memory = memory
- self.full_message_history = full_message_history
- self.next_action_count = next_action_count
- self.system_prompt = system_prompt
- self.triggering_prompt = triggering_prompt
-
- def start_interaction_loop(self):
- # Interaction Loop
- cfg = Config()
- loop_count = 0
- command_name = None
- arguments = None
- user_input = ""
-
- while True:
- # Discontinue if continuous limit is reached
- loop_count += 1
- if (
- cfg.continuous_mode
- and cfg.continuous_limit > 0
- and loop_count > cfg.continuous_limit
- ):
- logger.typewriter_log(
- "Continuous Limit Reached: ", Fore.YELLOW, f"{cfg.continuous_limit}"
- )
- break
-
- # Send message to AI, get response
- with Spinner("Thinking... "):
- assistant_reply = chat_with_ai(
- self.system_prompt,
- self.triggering_prompt,
- self.full_message_history,
- self.memory,
- cfg.fast_token_limit,
- ) # TODO: This hardcodes the model to use GPT3.5. Make this an argument
-
- assistant_reply_json = fix_json_using_multiple_techniques(assistant_reply)
-
- # Print Assistant thoughts
- if assistant_reply_json != {}:
- validate_json(assistant_reply_json, "llm_response_format_1")
- # Get command name and arguments
- try:
- print_assistant_thoughts(self.ai_name, assistant_reply_json)
- command_name, arguments = get_command(assistant_reply_json)
- # command_name, arguments = assistant_reply_json_valid["command"]["name"], assistant_reply_json_valid["command"]["args"]
- if cfg.speak_mode:
- say_text(f"I want to execute {command_name}")
- except Exception as e:
- logger.error("Error: \n", str(e))
-
- if not cfg.continuous_mode and self.next_action_count == 0:
- ### GET USER AUTHORIZATION TO EXECUTE COMMAND ###
- # Get key press: Prompt the user to press enter to continue or escape
- # to exit
- logger.typewriter_log(
- "NEXT ACTION: ",
- Fore.CYAN,
- f"COMMAND = {Fore.CYAN}{command_name}{Style.RESET_ALL} "
- f"ARGUMENTS = {Fore.CYAN}{arguments}{Style.RESET_ALL}",
- )
- print(
- "Enter 'y' to authorise command, 'y -N' to run N continuous "
- "commands, 'n' to exit program, or enter feedback for "
- f"{self.ai_name}...",
- flush=True,
- )
- while True:
- console_input = clean_input(
- Fore.MAGENTA + "Input:" + Style.RESET_ALL
- )
- if console_input.lower().strip() == "y":
- user_input = "GENERATE NEXT COMMAND JSON"
- break
- elif console_input.lower().strip() == "":
- print("Invalid input format.")
- continue
- elif console_input.lower().startswith("y -"):
- try:
- self.next_action_count = abs(
- int(console_input.split(" ")[1])
- )
- user_input = "GENERATE NEXT COMMAND JSON"
- except ValueError:
- print(
- "Invalid input format. Please enter 'y -n' where n is"
- " the number of continuous tasks."
- )
- continue
- break
- elif console_input.lower() == "n":
- user_input = "EXIT"
- break
- else:
- user_input = console_input
- command_name = "human_feedback"
- break
-
- if user_input == "GENERATE NEXT COMMAND JSON":
- logger.typewriter_log(
- "-=-=-=-=-=-=-= COMMAND AUTHORISED BY USER -=-=-=-=-=-=-=",
- Fore.MAGENTA,
- "",
- )
- elif user_input == "EXIT":
- print("Exiting...", flush=True)
- break
- else:
- # Print command
- logger.typewriter_log(
- "NEXT ACTION: ",
- Fore.CYAN,
- f"COMMAND = {Fore.CYAN}{command_name}{Style.RESET_ALL}"
- f" ARGUMENTS = {Fore.CYAN}{arguments}{Style.RESET_ALL}",
- )
-
- # Execute command
- if command_name is not None and command_name.lower().startswith("error"):
- result = (
- f"Command {command_name} threw the following error: {arguments}"
- )
- elif command_name == "human_feedback":
- result = f"Human feedback: {user_input}"
- else:
- result = (
- f"Command {command_name} returned: "
- f"{execute_command(command_name, arguments)}"
- )
- if self.next_action_count > 0:
- self.next_action_count -= 1
-
- memory_to_add = (
- f"Assistant Reply: {assistant_reply} "
- f"\nResult: {result} "
- f"\nHuman Feedback: {user_input} "
- )
-
- self.memory.add(memory_to_add)
-
- # Check if there's a result from the command append it to the message
- # history
- if result is not None:
- self.full_message_history.append(create_chat_message("system", result))
- logger.typewriter_log("SYSTEM: ", Fore.YELLOW, result)
- else:
- self.full_message_history.append(
- create_chat_message("system", "Unable to execute command")
- )
- logger.typewriter_log(
- "SYSTEM: ", Fore.YELLOW, "Unable to execute command"
- )
diff --git a/spaces/ky2k/Toxicity_Classifier_POC/.venv/lib/python3.9/site-packages/PIL/__init__.py b/spaces/ky2k/Toxicity_Classifier_POC/.venv/lib/python3.9/site-packages/PIL/__init__.py
deleted file mode 100644
index 32d2381f3c26ef15ed8a0c0071202aed68bf4f32..0000000000000000000000000000000000000000
--- a/spaces/ky2k/Toxicity_Classifier_POC/.venv/lib/python3.9/site-packages/PIL/__init__.py
+++ /dev/null
@@ -1,85 +0,0 @@
-"""Pillow (Fork of the Python Imaging Library)
-
-Pillow is the friendly PIL fork by Jeffrey A. Clark (Alex) and contributors.
- https://github.com/python-pillow/Pillow/
-
-Pillow is forked from PIL 1.1.7.
-
-PIL is the Python Imaging Library by Fredrik Lundh and contributors.
-Copyright (c) 1999 by Secret Labs AB.
-
-Use PIL.__version__ for this Pillow version.
-
-;-)
-"""
-
-from . import _version
-
-# VERSION was removed in Pillow 6.0.0.
-# PILLOW_VERSION was removed in Pillow 9.0.0.
-# Use __version__ instead.
-__version__ = _version.__version__
-del _version
-
-
-_plugins = [
- "BlpImagePlugin",
- "BmpImagePlugin",
- "BufrStubImagePlugin",
- "CurImagePlugin",
- "DcxImagePlugin",
- "DdsImagePlugin",
- "EpsImagePlugin",
- "FitsImagePlugin",
- "FitsStubImagePlugin",
- "FliImagePlugin",
- "FpxImagePlugin",
- "FtexImagePlugin",
- "GbrImagePlugin",
- "GifImagePlugin",
- "GribStubImagePlugin",
- "Hdf5StubImagePlugin",
- "IcnsImagePlugin",
- "IcoImagePlugin",
- "ImImagePlugin",
- "ImtImagePlugin",
- "IptcImagePlugin",
- "JpegImagePlugin",
- "Jpeg2KImagePlugin",
- "McIdasImagePlugin",
- "MicImagePlugin",
- "MpegImagePlugin",
- "MpoImagePlugin",
- "MspImagePlugin",
- "PalmImagePlugin",
- "PcdImagePlugin",
- "PcxImagePlugin",
- "PdfImagePlugin",
- "PixarImagePlugin",
- "PngImagePlugin",
- "PpmImagePlugin",
- "PsdImagePlugin",
- "QoiImagePlugin",
- "SgiImagePlugin",
- "SpiderImagePlugin",
- "SunImagePlugin",
- "TgaImagePlugin",
- "TiffImagePlugin",
- "WebPImagePlugin",
- "WmfImagePlugin",
- "XbmImagePlugin",
- "XpmImagePlugin",
- "XVThumbImagePlugin",
-]
-
-
-class UnidentifiedImageError(OSError):
- """
- Raised in :py:meth:`PIL.Image.open` if an image cannot be opened and identified.
-
- If a PNG image raises this error, setting :data:`.ImageFile.LOAD_TRUNCATED_IMAGES`
- to true may allow the image to be opened after all. The setting will ignore missing
- data and checksum failures.
- """
-
- pass
diff --git a/spaces/ky2k/Toxicity_Classifier_POC/.venv/lib/python3.9/site-packages/fontTools/encodings/codecs.py b/spaces/ky2k/Toxicity_Classifier_POC/.venv/lib/python3.9/site-packages/fontTools/encodings/codecs.py
deleted file mode 100644
index 3ac0268d6a11a1be99bb2cf7fde5979da2853d4a..0000000000000000000000000000000000000000
--- a/spaces/ky2k/Toxicity_Classifier_POC/.venv/lib/python3.9/site-packages/fontTools/encodings/codecs.py
+++ /dev/null
@@ -1,135 +0,0 @@
-"""Extend the Python codecs module with a few encodings that are used in OpenType (name table)
-but missing from Python. See https://github.com/fonttools/fonttools/issues/236 for details."""
-
-import codecs
-import encodings
-
-
-class ExtendCodec(codecs.Codec):
- def __init__(self, name, base_encoding, mapping):
- self.name = name
- self.base_encoding = base_encoding
- self.mapping = mapping
- self.reverse = {v: k for k, v in mapping.items()}
- self.max_len = max(len(v) for v in mapping.values())
- self.info = codecs.CodecInfo(
- name=self.name, encode=self.encode, decode=self.decode
- )
- codecs.register_error(name, self.error)
-
- def _map(self, mapper, output_type, exc_type, input, errors):
- base_error_handler = codecs.lookup_error(errors)
- length = len(input)
- out = output_type()
- while input:
- # first try to use self.error as the error handler
- try:
- part = mapper(input, self.base_encoding, errors=self.name)
- out += part
- break # All converted
- except exc_type as e:
- # else convert the correct part, handle error as requested and continue
- out += mapper(input[: e.start], self.base_encoding, self.name)
- replacement, pos = base_error_handler(e)
- out += replacement
- input = input[pos:]
- return out, length
-
- def encode(self, input, errors="strict"):
- return self._map(codecs.encode, bytes, UnicodeEncodeError, input, errors)
-
- def decode(self, input, errors="strict"):
- return self._map(codecs.decode, str, UnicodeDecodeError, input, errors)
-
- def error(self, e):
- if isinstance(e, UnicodeDecodeError):
- for end in range(e.start + 1, e.end + 1):
- s = e.object[e.start : end]
- if s in self.mapping:
- return self.mapping[s], end
- elif isinstance(e, UnicodeEncodeError):
- for end in range(e.start + 1, e.start + self.max_len + 1):
- s = e.object[e.start : end]
- if s in self.reverse:
- return self.reverse[s], end
- e.encoding = self.name
- raise e
-
-
-_extended_encodings = {
- "x_mac_japanese_ttx": (
- "shift_jis",
- {
- b"\xFC": chr(0x007C),
- b"\x7E": chr(0x007E),
- b"\x80": chr(0x005C),
- b"\xA0": chr(0x00A0),
- b"\xFD": chr(0x00A9),
- b"\xFE": chr(0x2122),
- b"\xFF": chr(0x2026),
- },
- ),
- "x_mac_trad_chinese_ttx": (
- "big5",
- {
- b"\x80": chr(0x005C),
- b"\xA0": chr(0x00A0),
- b"\xFD": chr(0x00A9),
- b"\xFE": chr(0x2122),
- b"\xFF": chr(0x2026),
- },
- ),
- "x_mac_korean_ttx": (
- "euc_kr",
- {
- b"\x80": chr(0x00A0),
- b"\x81": chr(0x20A9),
- b"\x82": chr(0x2014),
- b"\x83": chr(0x00A9),
- b"\xFE": chr(0x2122),
- b"\xFF": chr(0x2026),
- },
- ),
- "x_mac_simp_chinese_ttx": (
- "gb2312",
- {
- b"\x80": chr(0x00FC),
- b"\xA0": chr(0x00A0),
- b"\xFD": chr(0x00A9),
- b"\xFE": chr(0x2122),
- b"\xFF": chr(0x2026),
- },
- ),
-}
-
-_cache = {}
-
-
-def search_function(name):
- name = encodings.normalize_encoding(name) # Rather undocumented...
- if name in _extended_encodings:
- if name not in _cache:
- base_encoding, mapping = _extended_encodings[name]
- assert name[-4:] == "_ttx"
- # Python 2 didn't have any of the encodings that we are implementing
- # in this file. Python 3 added aliases for the East Asian ones, mapping
- # them "temporarily" to the same base encoding as us, with a comment
- # suggesting that full implementation will appear some time later.
- # As such, try the Python version of the x_mac_... first, if that is found,
- # use *that* as our base encoding. This would make our encoding upgrade
- # to the full encoding when and if Python finally implements that.
- # http://bugs.python.org/issue24041
- base_encodings = [name[:-4], base_encoding]
- for base_encoding in base_encodings:
- try:
- codecs.lookup(base_encoding)
- except LookupError:
- continue
- _cache[name] = ExtendCodec(name, base_encoding, mapping)
- break
- return _cache[name].info
-
- return None
-
-
-codecs.register(search_function)
diff --git a/spaces/leslyarun/grammar_correction/README.md b/spaces/leslyarun/grammar_correction/README.md
deleted file mode 100644
index 8ce37ccd3792957536e54f43dcaf047d628f16cb..0000000000000000000000000000000000000000
--- a/spaces/leslyarun/grammar_correction/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Grammar Correction
-emoji: 💩
-colorFrom: red
-colorTo: blue
-sdk: gradio
-sdk_version: 3.6
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/lewiswu1209/MockingBird/encoder/params_data.py b/spaces/lewiswu1209/MockingBird/encoder/params_data.py
deleted file mode 100644
index bdb1716ed45617f2b127a7fb8885afe6cc74fb71..0000000000000000000000000000000000000000
--- a/spaces/lewiswu1209/MockingBird/encoder/params_data.py
+++ /dev/null
@@ -1,29 +0,0 @@
-
-## Mel-filterbank
-mel_window_length = 25 # In milliseconds
-mel_window_step = 10 # In milliseconds
-mel_n_channels = 40
-
-
-## Audio
-sampling_rate = 16000
-# Number of spectrogram frames in a partial utterance
-partials_n_frames = 160 # 1600 ms
-# Number of spectrogram frames at inference
-inference_n_frames = 80 # 800 ms
-
-
-## Voice Activation Detection
-# Window size of the VAD. Must be either 10, 20 or 30 milliseconds.
-# This sets the granularity of the VAD. Should not need to be changed.
-vad_window_length = 30 # In milliseconds
-# Number of frames to average together when performing the moving average smoothing.
-# The larger this value, the larger the VAD variations must be to not get smoothed out.
-vad_moving_average_width = 8
-# Maximum number of consecutive silent frames a segment can have.
-vad_max_silence_length = 6
-
-
-## Audio volume normalization
-audio_norm_target_dBFS = -30
-
diff --git a/spaces/lincquiQcaudo/Top-20-Diffusion/Crystal Impact Match V2.0.23 _BEST_.md b/spaces/lincquiQcaudo/Top-20-Diffusion/Crystal Impact Match V2.0.23 _BEST_.md
deleted file mode 100644
index b9235d463fe3f8c2faf79ecccb84873b4ff443e5..0000000000000000000000000000000000000000
--- a/spaces/lincquiQcaudo/Top-20-Diffusion/Crystal Impact Match V2.0.23 _BEST_.md
+++ /dev/null
@@ -1,6 +0,0 @@
-
DgFlick Album Xpress Pro 8 Crack: How to Create Amazing Photo Albums
-
-
If you are looking for a software that can help you design and edit your own photo albums, you might want to check out DgFlick Album Xpress Pro 8. This is a powerful and easy-to-use application that lets you create stunning photo albums in minutes. You can also download DgFlick Album Xpress Pro 8 crack for free and enjoy all the features without any limitations.
-
-
What is DgFlick Album Xpress Pro 8?
-
-
DgFlick Album Xpress Pro 8 is a photo album software that allows you to create professional-looking albums with your own photos. You can choose from hundreds of templates and presets, or create your own from scratch. You can also edit your photos with a comprehensive image editor that has loads of tools and effects. You can drag and drop your photos into your albums, arrange them in any way you want, and customize the layout, background, borders, text, and more. You can also preview your albums before printing or exporting them.
DgFlick Album Xpress Pro 8 is a premium software that costs $199 for a single license. However, you can download DgFlick Album Xpress Pro 8 crack for free and use it without any restrictions. With DgFlick Album Xpress Pro 8 crack, you can access all the features and functions of the software, such as:
-
-
-
Create unlimited albums with unlimited pages
-
Use all the templates and presets available
-
Edit your photos with advanced tools and effects
-
Save your albums in various formats, such as JPG, PDF, PSD, etc.
-
Print your albums with high quality and resolution
-
Share your albums online or on social media
-
-
-
How to download and install DgFlick Album Xpress Pro 8 crack?
-
-
If you want to download and install DgFlick Album Xpress Pro 8 crack, you can follow these simple steps:
-
-
-
Click on the link below to download DgFlick Album Xpress Pro 8 crack file.
-
Extract the file using WinRAR or any other extraction tool.
-
Run the setup file and follow the instructions to install the software.
-
Copy the crack file and paste it into the installation folder.
-
Launch the software and enjoy creating amazing photo albums.
-
-
-
DgFlick Album Xpress Pro 8 crack link: https://fancli.com/292751
-
-
Conclusion
-
-
DgFlick Album Xpress Pro 8 is a great software for anyone who wants to create beautiful photo albums with their own photos. You can download DgFlick Album Xpress Pro 8 crack for free and use it without any limitations. You can also check out some other photo editing software on our website. We hope you found this article helpful and informative. If you have any questions or feedback, feel free to leave a comment below.
-
How to use DgFlick Album Xpress Pro 8 crack?
-
-
Using DgFlick Album Xpress Pro 8 crack is very simple and intuitive. You can follow these steps to create your own photo albums:
-
-
-
Launch the software and select a project type. You can choose from album, book, calendar, collage, or passport.
-
Select a size and orientation for your project. You can also customize the margins, bleed, and spine.
-
Select a cover for your project. You can choose from various designs and materials, or create your own cover.
-
Add your photos to your project. You can import them from your computer, camera, or scanner. You can also use the auto-fill option to automatically arrange your photos.
-
Edit your photos if needed. You can crop, rotate, resize, adjust color, brightness, contrast, and more. You can also apply filters, frames, stickers, and text to your photos.
-
Arrange your photos on your pages. You can drag and drop them, swap them, align them, and more. You can also change the background, border, and layout of your pages.
-
Preview your project and make any final changes. You can zoom in and out, check the quality, and add comments.
-
Save your project and export it in your preferred format. You can also print it or share it online.
-
-
-
DgFlick Album Xpress Pro 8 crack is a versatile and user-friendly software that can help you create amazing photo albums in minutes. You can download it for free and enjoy all its features without any limitations.
-
-
Frequently Asked Questions about DgFlick Album Xpress Pro 8 crack
-
-
Here are some common questions and answers about DgFlick Album Xpress Pro 8 crack:
-
-
-
Is DgFlick Album Xpress Pro 8 crack safe to use?
-
-
Yes, DgFlick Album Xpress Pro 8 crack is safe to use as long as you download it from a reliable source. However, you should always scan any file you download with an antivirus software before opening it.
-
-
Is DgFlick Album Xpress Pro 8 crack legal to use?
-
-
No, DgFlick Album Xpress Pro 8 crack is not legal to use as it violates the terms and conditions of the original software. We do not condone or encourage the use of cracked software. This article is for educational purposes only.
-
-
What are the system requirements for DgFlick Album Xpress Pro 8 crack?
-
-
The system requirements for DgFlick Album Xpress Pro 8 crack are:
-
-
-
Operating System: Windows XP/Vista/7/8/8.1/10
-
Memory (RAM): 1 GB of RAM required.
-
Hard Disk Space: 1 GB of free space required.
-
Processor: 2.8 GHz Intel Pentium 4 or later.
-
-
-
Where can I get more templates and presets for DgFlick Album Xpress Pro 8 crack?
-
-
You can get more templates and presets for DgFlick Album Xpress Pro 8 crack from the official website of DgFlick or from other online sources. However, you should be careful about the quality and compatibility of the files you download.
-
-
How can I contact the support team of DgFlick Album Xpress Pro 8 crack?
-
-
You cannot contact the support team of DgFlick Album Xpress Pro 8 crack as it is an unofficial version of the software. If you have any issues or questions about the software, you should refer to the online forums or blogs where you downloaded it from.
-
What are the advantages of using DgFlick Album Xpress Pro 8 crack?
-
-
Using DgFlick Album Xpress Pro 8 crack has many advantages over other photo album software. Some of them are:
-
-
-
It is fast and easy to use. You can create your photo albums in minutes with just a few clicks.
-
It has a large collection of templates and presets that suit any occasion and style. You can also create your own templates and presets.
-
It has a powerful image editor that can enhance your photos with various tools and effects. You can also add filters, frames, stickers, and text to your photos.
-
It has a flexible layout system that allows you to customize your pages according to your preferences. You can also change the background, border, and layout of your pages.
-
It has a high-quality output that can print or export your albums in various formats and resolutions. You can also share your albums online or on social media.
-
-
-
What are the disadvantages of using DgFlick Album Xpress Pro 8 crack?
-
-
Using DgFlick Album Xpress Pro 8 crack also has some disadvantages that you should be aware of. Some of them are:
-
-
-
It is illegal to use as it violates the terms and conditions of the original software. You may face legal consequences if you use it.
-
It may not be compatible with the latest updates and features of the original software. You may miss out on some new functions and improvements.
-
It may contain viruses or malware that can harm your computer or data. You should always scan any file you download with an antivirus software before opening it.
-
It may not have any technical support or customer service. If you have any issues or questions about the software, you may not get any help or guidance.
-
-
-
Is there an alternative to DgFlick Album Xpress Pro 8 crack?
-
-
If you are looking for an alternative to DgFlick Album Xpress Pro 8 crack, you may want to try some other photo album software that are similar or better than it. Some of them are:
-
-
-
MAGIX Photo Manager 17: This is a photo management software that can help you organize, edit, and share your photos. You can also create photo albums, slideshows, collages, and more with this software.
-
Flip PDF Professional: This is a PDF conversion software that can help you create digital photo albums from your PDF files. You can also add multimedia elements, such as audio, video, animation, and more to your albums.
-
Photo Collage Maker: This is a photo collage software that can help you create stunning photo collages with your photos. You can also add frames, backgrounds, stickers, text, and more to your collages.
-
-
-
DgFlick Album Xpress Pro 8 crack is a great software for creating amazing photo albums with your own photos. However, you should be careful about using it as it is illegal and risky. You can also try some other photo album software that are legal and safe to use.
-
How to create a photo album with DgFlick Album Xpress Pro 8 crack?
-
-
Creating a photo album with DgFlick Album Xpress Pro 8 crack is very easy and fun. You can follow these steps to create your own photo album:
-
-
-
Launch the software and select a project type. You can choose from album, book, calendar, collage, or passport.
-
Select a size and orientation for your project. You can also customize the margins, bleed, and spine.
-
Select a cover for your project. You can choose from various designs and materials, or create your own cover.
-
Add your photos to your project. You can import them from your computer, camera, or scanner. You can also use the auto-fill option to automatically arrange your photos.
-
Edit your photos if needed. You can crop, rotate, resize, adjust color, brightness, contrast, and more. You can also apply filters, frames, stickers, and text to your photos.
-
Arrange your photos on your pages. You can drag and drop them, swap them, align them, and more. You can also change the background, border, and layout of your pages.
-
Preview your project and make any final changes. You can zoom in and out, check the quality, and add comments.
-
Save your project and export it in your preferred format. You can also print it or share it online.
-
-
-
DgFlick Album Xpress Pro 8 crack is a versatile and user-friendly software that can help you create amazing photo albums in minutes. You can download it for free and enjoy all its features without any limitations.
-
-
What are the tips and tricks for using DgFlick Album Xpress Pro 8 crack?
-
-
Using DgFlick Album Xpress Pro 8 crack can be even more fun and easy if you know some tips and tricks for using it. Here are some of them:
-
-
-
You can use the shortcut keys to perform various actions faster and easier. For example, you can use Ctrl+Z to undo, Ctrl+Y to redo, Ctrl+C to copy, Ctrl+V to paste, Ctrl+A to select all, etc.
-
You can use the right-click menu to access various options and commands for your photos and pages. For example, you can right-click on a photo to edit it, rotate it, crop it, swap it, etc.
-
You can use the zoom slider to adjust the zoom level of your project. You can also use the mouse wheel to zoom in and out.
-
You can use the quality indicator to check the quality of your photos and pages. The indicator shows green for high quality, yellow for medium quality, and red for low quality.
-
You can use the comment tool to add comments to your photos and pages. You can also view and edit the comments later.
-
-
-
DgFlick Album Xpress Pro 8 crack is a great software for creating amazing photo albums with your own photos. However, you should be careful about using it as it is illegal and risky. You can also try some other photo album software that are legal and safe to use.
-
Conclusion
-
-
DgFlick Album Xpress Pro 8 crack is a powerful and easy-to-use software that can help you create stunning photo albums with your own photos. You can download it for free and use it without any limitations. However, you should be aware of the disadvantages and risks of using cracked software. It is illegal, unsafe, and unsupported. You may face legal consequences, viruses, malware, compatibility issues, and lack of technical support. Therefore, we recommend you to use the original software or some other legal and safe alternatives. We hope you found this article helpful and informative. If you have any questions or feedback, feel free to leave a comment below.
3cee63e6c2
-
-
\ No newline at end of file
diff --git a/spaces/lincquiQcaudo/Top-20-Diffusion/ESET PureFix V202exe.md b/spaces/lincquiQcaudo/Top-20-Diffusion/ESET PureFix V202exe.md
deleted file mode 100644
index 02ff02f834cc4a3f88d702ec2701bf11f928f71f..0000000000000000000000000000000000000000
--- a/spaces/lincquiQcaudo/Top-20-Diffusion/ESET PureFix V202exe.md
+++ /dev/null
@@ -1,6 +0,0 @@
-
-
-25 Mar 2018 . ESET PureFix V2.02.exe Foo. eset purefix eset purefix 2017 eset purefix download eset purefix for eset 9 eset purefix v2.03 eset purefix for eset. 4d29de3e1b
-
-
-
diff --git a/spaces/lincquiQcaudo/Top-20-Diffusion/Fisiologia Vegetal Salisbury Pdf Descargar.md b/spaces/lincquiQcaudo/Top-20-Diffusion/Fisiologia Vegetal Salisbury Pdf Descargar.md
deleted file mode 100644
index 0bfac1fa7940bc1a7b6e2f5bfc1201edde027683..0000000000000000000000000000000000000000
--- a/spaces/lincquiQcaudo/Top-20-Diffusion/Fisiologia Vegetal Salisbury Pdf Descargar.md
+++ /dev/null
@@ -1,11 +0,0 @@
-
-
Electro-química y. salivares suban fisiologia vegetal salisbury pdf descargar jai. el paso iniciante y mxico por el. salisbury colección realizado en marzo de 2006 anualment. oficios, Salisbury, J. (1990). Materials and methods. And, Fried, M. A. L., Knoester.
. Fisiologia Vegetal Salisbury Pdf Descargar 1:09. 3 years ago 1:09. Play Later. Play Later. Lists. Like. Liked. 1:09. Cardemil, L. (Eds) Fisiologa Vegetal.. Salisbury, J., Green, M., Hunt, C. & Campbell, J. (2008) Coastal acidification by rivers: A.
-
E. Mancera, E. Rejmankova, J.E. Salisbury, and E. Weil. 2004.. Curso Eco- Fisiologa. carbn vegetal y cultivos como la pia que se. webpers baf94a4655 https://trello.com/c/RyyJVPli/28-descargar-the-contact-. -fisiologia-vegetal-salisbury-scargar-zip-full-edition-ebook.
-
Aireal edicion fisiologia veg salisbury pdf descargar. Ciencia y tecnología. Enero de 2014. 102p. L. Salisbury y otras. L. Salisbury and others. L. Salisbury y otras.. Salisbury, J., Green, M., Hunt, C. & Campbell, J. (2008) Coastal.
-
-
Determinando la presencia de dyes, saborear puede ser de gran utilidad para determinar los gustos y su aceptación. Puedes ocupar alguno de los materiales que toca utilizar, tambin hacer escritos a mano; si utilizas un pincel, debes ocupar una materia. La fisiologia vegetal mientras que la fisiologia animal se hace en el animal vivo.
-
Salisbury, F. B.; Ross, C. W. Plant physiology. 4.ed. (mol L1) (Salisbury & Ross, 1991).. A SALISBURY, F. B.; ROSS, C. W. Plant physiology. 4.ed. (mol L1) (Salisbury & Ross, 1991).. Salisbury, F. B.; Ross, C. W. Plant physiology.
899543212b
-
-
\ No newline at end of file
diff --git a/spaces/lincquiQcaudo/Top-20-Diffusion/Handycafe Wifi Hotspot Crack.md b/spaces/lincquiQcaudo/Top-20-Diffusion/Handycafe Wifi Hotspot Crack.md
deleted file mode 100644
index 2f9e00b38199d72a03a1eb59b573dfdd265ca8fa..0000000000000000000000000000000000000000
--- a/spaces/lincquiQcaudo/Top-20-Diffusion/Handycafe Wifi Hotspot Crack.md
+++ /dev/null
@@ -1,6 +0,0 @@
-
-
-The Wi-Fi hotspot provides an internet connection for your mobile device. ... (You can find the VG Serial Number on the bottom of the Vehicle Gateway or in the ... 4d29de3e1b
-
-
-
diff --git a/spaces/lincquiQcaudo/Top-20-Diffusion/High Quality Download Roms Sega Model 3 40l.md b/spaces/lincquiQcaudo/Top-20-Diffusion/High Quality Download Roms Sega Model 3 40l.md
deleted file mode 100644
index a1febacbc18a2a25a2cc7ed6510c42697c287ef4..0000000000000000000000000000000000000000
--- a/spaces/lincquiQcaudo/Top-20-Diffusion/High Quality Download Roms Sega Model 3 40l.md
+++ /dev/null
@@ -1,20 +0,0 @@
-
- 
- 
- 
-
" +
- "
" +
- "
" +
- "
" +
- "
- 
- 
- 
-