diff --git "a/spaces/1acneusushi/gradio-2dmoleculeeditor/data/? Equalizer Bass Booster Pro V1.2.6\302\240Apk.md" "b/spaces/1acneusushi/gradio-2dmoleculeeditor/data/? Equalizer Bass Booster Pro V1.2.6\302\240Apk.md"
deleted file mode 100644
index 6f3c7af1a4dd08c501abf2bc474eb6d7d477547d..0000000000000000000000000000000000000000
--- "a/spaces/1acneusushi/gradio-2dmoleculeeditor/data/? Equalizer Bass Booster Pro V1.2.6\302\240Apk.md"
+++ /dev/null
@@ -1,38 +0,0 @@
-
-
How to Enhance Your Music Experience with Equalizer Bass Booster Pro v1.2.6 Apk
-
If you are looking for a way to improve the sound quality of your music on your Android device, you might want to try Equalizer Bass Booster Pro v1.2.6 Apk. This is a powerful app that lets you adjust the sound level and frequency of your music with a five band equalizer, a bass boost effect, and a virtualizer effect. You can also choose from 22 equalizer presets or customize your own effects.
Equalizer Bass Booster Pro v1.2.6 Apk works with all music and video players, as well as streaming music services. You can easily control the equalizer effect on and off with a notification shortcut or a desktop widget. You don't need to root your device to use this app.
-
With Equalizer Bass Booster Pro v1.2.6 Apk, you can enjoy a more immersive and realistic music experience with 3D surround sound and enhanced bass. Whether you are listening to music with headphones or speakers, you will notice the difference in sound quality and clarity.
-
To download Equalizer Bass Booster Pro v1.2.6 Apk, you can visit the link below and follow the instructions to install it on your device. You will need Android 4.4 or higher to run this app.
Once you have installed Equalizer Bass Booster Pro v1.2.6 Apk on your device, you can start using it to enhance your music experience. Here are some steps to follow:
-
-
-
Open the app and grant the necessary permissions.
-
Select the music or video player that you want to use with the app.
-
Play your music or video and adjust the volume level with the slider on the app.
-
Tap on the equalizer icon to open the five band equalizer. You can drag the sliders to change the sound frequency or tap on the presets to choose from different sound effects.
-
Tap on the bass boost icon to activate the bass boost effect. You can adjust the intensity of the bass with the slider.
-
Tap on the virtualizer icon to activate the virtualizer effect. This will create a 3D surround sound effect for your music or video.
-
You can also access the app settings by tapping on the menu icon. Here you can customize the notification shortcut, the desktop widget, and other options.
-
-
Enjoy your enhanced music experience with Equalizer Bass Booster Pro v1.2.6 Apk!
-
-
Why Choose Equalizer Bass Booster Pro v1.2.6 Apk
-
There are many reasons why you should choose Equalizer Bass Booster Pro v1.2.6 Apk over other similar apps. Here are some of them:
-
-
It is easy to use and compatible with all music and video players.
-
It has a powerful five band equalizer that lets you adjust the sound frequency to your preference.
-
It has a bass boost effect that enhances the low frequencies and makes your music more punchy and dynamic.
-
It has a virtualizer effect that creates a 3D surround sound effect and makes your music more immersive and realistic.
-
It has 22 equalizer presets that you can choose from or customize your own effects.
-
It has a volume booster that increases the sound level and clarity of your music or video.
-
It has a notification shortcut and a desktop widget that let you access the app quickly and easily.
-
It does not require root access and does not affect your device performance or battery life.
-
-
With Equalizer Bass Booster Pro v1.2.6 Apk, you can enjoy a better music experience on your Android device. Download it now and see the difference for yourself!
81aa517590
-
-
\ No newline at end of file
diff --git a/spaces/1acneusushi/gradio-2dmoleculeeditor/data/Download IDM Cracking City A Simple and Effective Solution to Get a Free License Code for Your IDM Software.md b/spaces/1acneusushi/gradio-2dmoleculeeditor/data/Download IDM Cracking City A Simple and Effective Solution to Get a Free License Code for Your IDM Software.md
deleted file mode 100644
index 3735bdf73857e725b45e308a35cfc5360fd7feb4..0000000000000000000000000000000000000000
--- a/spaces/1acneusushi/gradio-2dmoleculeeditor/data/Download IDM Cracking City A Simple and Effective Solution to Get a Free License Code for Your IDM Software.md
+++ /dev/null
@@ -1,29 +0,0 @@
-
-
How to Download IDM Cracking City for Free and Enjoy Fast Downloads
-
If you are looking for a way to download IDM Cracking City for free, you are in the right place. IDM Cracking City is a website that provides you with the latest IDM crack or patch that can activate your Internet Download Manager (IDM) software and let you enjoy fast and reliable downloads. In this article, we will show you how to download IDM Cracking City for free and how to use it to activate your IDM software.
-
What is IDM and Why You Need It
-
IDM is a popular download manager that can increase your download speed up to five times, resume and schedule downloads, and handle various types of files and protocols. IDM can also integrate with most browsers and support proxy servers, firewalls, redirects, cookies, authorization, audio, and video content processing. With IDM, you can download anything from the internet with ease and efficiency.
However, IDM is not a free software and you need a license code to activate it. If you do not have a license code, you will get a fake serial number or key error message and your IDM will stop working. That is why you need IDM Cracking City to get a free license code for your IDM software.
-
What is IDM Cracking City and How It Works
-
IDM Cracking City is a website that provides you with the best IDM crack or patch that can bypass the original registration of the software and generate a valid license code for your IDM software. The IDM crack or patch is a small program that modifies the original files of the software and makes it think that it is registered with a genuine license code. This way, you can use all the features and modules of IDM without any limitations or errors.
-
To use IDM Cracking City, you need to follow these steps:
-
-
Download the latest version of IDM from the official website or from here.
-
Install IDM on your computer and close it if it is running.
-
Go to IDM Cracking City and download the latest IDM crack or patch from there.
-
Extract the downloaded file and run the IDM crack or patch as administrator.
-
Select "1" to activate or "2" to reset your IDM software.
-
Wait for the process to complete and enjoy your activated IDM software.
-
-
Tips and Warnings
-
Here are some tips and warnings that you should keep in mind when using IDM Cracking City:
-
-
Before downloading the IDM crack or patch, make sure to disable your antivirus or firewall as they may detect it as a virus or trojan. This is because the IDM crack or patch modifies the original files of the software, which may trigger some security alerts. However, the IDM crack or patch is safe to use and does not harm your computer.
-
After activating your IDM software, do not update it as it may revert back to the trial version. If you want to update your IDM software, you need to download and apply the latest IDM crack or patch again.
-
If you have any problems with using IDM Cracking City, you can contact them through their website or leave a comment on their posts. They will try to help you as soon as possible.
-
-
Conclusion
-
In this article, we have shown you how to download IDM Cracking City for free and how to use it to activate your IDM software. With IDM Cracking City, you can enjoy fast and reliable downloads without paying anything. However, we recommend that you support the developers of IDM by purchasing a genuine license code if you can afford it. This way, you can get regular updates and support from them.
ddb901b051
-
-
\ No newline at end of file
diff --git a/spaces/1gistliPinn/ChatGPT4/Examples/2pm Tokyo Dome Concert Full 11 Watch the Legendary Performance of the K-pop Icons.md b/spaces/1gistliPinn/ChatGPT4/Examples/2pm Tokyo Dome Concert Full 11 Watch the Legendary Performance of the K-pop Icons.md
deleted file mode 100644
index 9da7fe204f898ecd4acf823ed8cd863de96428c1..0000000000000000000000000000000000000000
--- a/spaces/1gistliPinn/ChatGPT4/Examples/2pm Tokyo Dome Concert Full 11 Watch the Legendary Performance of the K-pop Icons.md
+++ /dev/null
@@ -1,5 +0,0 @@
-
-
No one is able to deny the popularity of TVXQ as they are considered one of the longest standing K-Pop idols who have been constantly filling the dome with their fans. 2012 marked the year where they first held their concert in the Tokyo Dome.
Download Full Ultimate 2019 Latest Version 'Adobe Flash Builder Premium Version' Premium Crack/ License Key This tool is specially designed to help developers quickly and easily create fully-working mobile games and applications for Android, iOS and BlackBerry devices. This solution provides developers with full support for Adobe Flash Builder 4.7, including the creation of ActionScript code and increased automation and customization of mobile games and applications, mobile security, debugging and application testing capabilities, and access to the Flash Builder Marketplace.
-
Adobe Flash Builder 4.6.1 Premium KeygenCodes includes FFT and FMOD. The application includes a powerful set of tools that can be used to work with both your game and mobile applications.
Adobe Flash Builder 4.6 Premium 3.0.1.667 Serial KeyAdobe Flex Builder environment together with a robust code editor. The package places the Flex Builder environment within Eclipse and provides unparalleled set of tools for creating advanced mobile applications. You can use the IDE to edit your code, debug, profile, manage the build process, and run your application on iOS or Android. This environment includes a mobile emulator that allows users to simulate the operation of the application on the target device. In addition, the application supports a local connection to a test mobile device.
-
Adobe Flash Builder 4.6.1 License Key LatestAdobe Flash Builder 4.6.1 license key is a powerful environment that is used to develop highly compatible mobile applications and games. It also provides an intuitive interface in the form of a dashboard. When you develop this application, all the features and functions can be used from a single place. As a result, the work can be done more easily and faster.
899543212b
-
-
\ No newline at end of file
diff --git a/spaces/1gistliPinn/ChatGPT4/Examples/Buddha.dll Hitman Sniper Challenge.rar VERIFIED.md b/spaces/1gistliPinn/ChatGPT4/Examples/Buddha.dll Hitman Sniper Challenge.rar VERIFIED.md
deleted file mode 100644
index 2d257cd03ba7499a44798a48daf52515701c6cc8..0000000000000000000000000000000000000000
--- a/spaces/1gistliPinn/ChatGPT4/Examples/Buddha.dll Hitman Sniper Challenge.rar VERIFIED.md
+++ /dev/null
@@ -1,8 +0,0 @@
-
-
-evanescence my immortal free mp3 download - موسيقى mp3 mp4 download songs and music. Numbered Musical Notation Preview 1. Numbered Musical ... 1fdad05405
-
-
-
diff --git a/spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/4 Images 1 Mot The Ultimate Word Game for French Speakers.md b/spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/4 Images 1 Mot The Ultimate Word Game for French Speakers.md
deleted file mode 100644
index cad775226c75f6243c1d7c40310e38e7a68fc6f6..0000000000000000000000000000000000000000
--- a/spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/4 Images 1 Mot The Ultimate Word Game for French Speakers.md
+++ /dev/null
@@ -1,104 +0,0 @@
-
-
4 Images 1 Mot: A Fun and Challenging Word Game
-
Do you love word games? Do you enjoy solving puzzles and testing your brain? If you answered yes, then you should try 4 Images 1 Mot, a game that will keep you entertained and challenged for hours. In this game, you have to guess the word that connects four images that have something in common. Sounds easy, right? Well, not always. Some puzzles are easy, but some are very tricky and require a lot of thinking. Are you ready to take on the challenge?
-
What is 4 Images 1 Mot?
-
4 Images 1 Mot is a game developed by Lotum GmbH, a German company that specializes in creating mobile games. The game was first released in 2013 and has since become a worldwide phenomenon, with more than 250 million players in 9 languages. The game is also known as 4 Pics 1 Word in English, 4 Fotos 1 Palabra in Spanish, 4 Immagini 1 Parola in Italian, and so on.
The game is very simple to play. You will see four images on the screen, and below them, a set of letters. Your task is to use those letters to form the word that links the four images. For example, if you see a picture of a dog, a bone, a tooth, and a dentist, the word would be DENT. If you get stuck, you can use hints to reveal some letters or remove some letters that are not part of the word. You can also skip the puzzle and move on to the next one.
-
Why you should download 4 Images 1 Mot
-
If you are looking for a fun and challenging word game, then you should definitely download 4 Images 1 Mot. Here are some reasons why:
-
-
The game is free to download and play. You can enjoy it without spending any money.
-
The game is suitable for all ages and levels. You can play it with your family, friends, or by yourself.
-
The game is offline-friendly. You can play it without an internet connection.
-
The game is educational. You can learn new words and improve your vocabulary.
-
The game is addictive. You will never get bored with the endless puzzles and levels.
-
-
Features of 4 Images 1 Mot
-
4 Images 1 Mot has many features that make it one of the best word games on the market. Here are some of them:
-
French puzzles made to measure just for you
-
If you are playing the French version of the game, you will be happy to know that the puzzles are specially designed for you. The developers have created puzzles that are relevant to your culture, language, and interests. You will see images of famous landmarks, celebrities, food, animals, and more.
-
Endless fun with new puzzles
-
The game has thousands of puzzles for you to solve, and new ones are added regularly. You will never run out of words to guess and images to discover. The game also has different modes and categories for you to choose from, such as daily puzzles, seasonal puzzles, themed puzzles, and more.
-
Simple
Simple and addictive gameplay
-
The game is very easy to play, but hard to master. You just need to look at the four images and find the word that connects them. The game will test your logic, creativity, and intuition. You will also have fun trying to guess the words and seeing the images. The game is so addictive that you will want to play it every day.
-
One of the most popular brain games in the world
-
4 Images 1 Mot is not only a game, but also a brain exercise. The game will challenge your mental skills and improve your cognitive abilities. You will have to think fast, use your memory, and expand your vocabulary. The game will also stimulate your curiosity and imagination. You will learn new things and discover new perspectives. 4 Images 1 Mot is one of the most popular brain games in the world, with millions of fans and positive reviews.
-
How to download 4 Images 1 Mot
-
If you are interested in playing 4 Images 1 Mot, you can download it easily from different sources. Here are some of them:
-
4 images 1 mot jeu gratuit
-4 images 1 mot solution
-4 images 1 mot apk
-4 images 1 mot android
-4 images 1 mot ios
-4 images 1 mot en ligne
-4 images 1 mot pc
-4 images 1 mot niveau
-4 images 1 mot français
-4 images 1 mot astuces
-4 images 1 mot réponses
-4 images 1 mot devinettes
-4 images 1 mot mots cachés
-4 images 1 mot énigmes
-4 images 1 mot lettres
-4 images 1 mot fun
-4 images 1 mot quiz
-4 images 1 mot casse-tête
-4 images 1 mot facile
-4 images 1 mot difficile
-4 images 1 mot avis
-4 images 1 mot commentaires
-4 images 1 mot conseils
-4 images 1 mot stratégies
-4 images 1 mot trucs
-Télécharger gratuitement le jeu de mots "4 Images et un Mot"
-Télécharger la dernière version de "4 Images et un Mot" pour Android
-Télécharger l'application "4 Images et un Mot" sur l'App Store
-Jouer à "4 Images et un Mot" sur le navigateur web
-Installer "4 Images et un Mot" sur le PC avec un émulateur Android
-Trouver les solutions de tous les niveaux de "4 Images et un Mot"
-Chercher les mots cachés dans les images de "4 Images et un Mot"
-Résoudre les énigmes de "4 Images et un Mot" avec des indices
-Former des mots avec les lettres proposées dans "4 Images et un Mot"
-S'amuser avec le jeu de devinettes "4 Images et un Mot"
-Tester sa culture générale avec le quiz "4 Images et un Mot"
-Stimuler son cerveau avec les casse-tête de "4 Images et un Mot"
-Choisir le niveau de difficulté de "4 Images et un Mot"
-Lire les avis des utilisateurs de "4 Images et un Mot"
-Donner son avis sur le jeu "4 Images et un Mot"
-Suivre les conseils des experts pour réussir à "4 Images et un Mot"
-Appliquer les stratégies gagnantes pour "4 Images et un Mot"
-Utiliser les trucs et astuces pour "4 Images et un Mot"
-
Download from Google Play Store
-
The easiest way to download 4 Images 1 Mot is from the Google Play Store. You just need to open the app on your Android device and search for 4 Images 1 Mot. You will see the game icon with a blue background and four white squares. Tap on it and then tap on Install. The game will be downloaded and installed on your device in a few minutes. You can then open it and start playing.
-
Download from APKCombo
-
If you want to download 4 Images 1 Mot from a third-party source, you can use APKCombo. This is a website that offers free APK files for Android apps and games. You can visit the website at https://apkcombo.com/ and search for 4 Images 1 Mot. You will see the game icon with a blue background and four white squares. Tap on it and then tap on Download APK. You will be asked to choose a version and a server. Choose the latest version and a fast server. The APK file will be downloaded to your device. You can then open it and install it manually.
-
Download from Poki.com
-
If you want to play 4 Images 1 Mot on your computer, you can use Poki.com. This is a website that offers free online games for different platforms. You can visit the website at https://poki.com/ and search for 4 Pics 1 Word. You will see the game icon with a blue background and four white squares. Click on it and then click on Play. The game will load on your browser and you can start playing.
-
Tips and tricks for 4 Images 1 Mot
-
If you want to improve your performance and enjoy the game more, here are some tips and tricks for you:
-
Use hints wisely
-
The game offers you two types of hints: reveal a letter or remove letters. You can use them when you are stuck or unsure of the word. However, you should use them wisely, as they cost coins that you earn by solving puzzles or watching ads. You should save your coins for harder puzzles or when you really need them.
-
Ask your friends for help
-
The game also allows you to ask your friends for help when you are stuck or unsure of the word. You can do this by tapping on the share button at the bottom of the screen. You can then choose to send the puzzle to your friends via Facebook, WhatsApp, Messenger, or other apps. Your friends can then reply with their guesses or hints.
-
Learn new words and improve your vocabulary
-
The game is not only fun, but also educational. You can learn new words and improve your vocabulary by playing it regularly. You can also use a dictionary or an online translator to look up the meaning of unfamiliar words or check their spelling. You can also try to guess the word before looking at the letters or using hints.
-
Conclusion
-
4 Images 1 Mot is a fun and challenging word game that will keep you entertained and challenged for hours. You have to guess the word that connects four images that have something in common. The game has thousands of puzzles for you to solve, with different modes and categories. The game is also simple, addictive, educational, and popular among millions of players around the world. You can download the game from different sources, such as Google Play Store, APKCombo, or Poki.com. You can also use hints, ask your friends, or learn new words to help you with the game. 4 Images 1 Mot is a game that you should not miss if you love word games. Download it now and have fun!
-
FAQs
-
Here are some frequently asked questions about 4 Images 1 Mot:
-
-
What is the difference between 4 Images 1 Mot and 4 Pics 1 Word?
-
4 Images 1 Mot and 4 Pics 1 Word are the same game, but with different names depending on the language. 4 Images 1 Mot is the French version, while 4 Pics 1 Word is the English version. The game has other versions in other languages, such as Spanish, Italian, German, and more.
-
How many levels are there in 4 Images 1 Mot?
-
There are thousands of levels in 4 Images 1 Mot, and new ones are added regularly. The game also has different modes and categories for you to choose from, such as daily puzzles, seasonal puzzles, themed puzzles, and more.
-
How can I get more coins in 4 Images 1 Mot?
-
You can get more coins in 4 Images 1 Mot by solving puzzles, watching ads, or buying them with real money. You can use coins to buy hints or skip puzzles.
-
How can I contact the developers of 4 Images 1 Mot?
Yes, 4 Images 1 Mot is safe to download and play. The game does not contain any viruses, malware, or inappropriate content. However, you should always download the game from official sources, such as Google Play Store, APKCombo, or Poki.com. You should also avoid downloading any modded or hacked versions of the game, as they may harm your device or compromise your privacy.
- 197e85843d
-
-
\ No newline at end of file
diff --git a/spaces/1phancelerku/anime-remove-background/Caa Palavras Brasileiro Um jogo de palavras divertido e educativo.md b/spaces/1phancelerku/anime-remove-background/Caa Palavras Brasileiro Um jogo de palavras divertido e educativo.md
deleted file mode 100644
index 14dc1595cf35ed7f623888a46da65c0a1e7b2398..0000000000000000000000000000000000000000
--- a/spaces/1phancelerku/anime-remove-background/Caa Palavras Brasileiro Um jogo de palavras divertido e educativo.md
+++ /dev/null
@@ -1,105 +0,0 @@
-
-
Caça Palavras Brasileiro APK: A Fun and Educational Game for All Ages
-
If you are looking for a fun and educational game that can keep you entertained for hours, you should try Caça Palavras Brasileiro APK. This is a word search game that will challenge your brain, improve your vocabulary, and teach you Portuguese. In this article, we will tell you everything you need to know about this game, including what it is, how to download and install it, how to play it, and what are the benefits of playing it.
-
What is Caça Palavras Brasileiro APK?
-
Caça Palavras Brasileiro APK is a word search game developed by Berni Mobile. It is available for Android devices and can be downloaded for free from various sources. The game has five levels of difficulty: Easy, Normal, Hard, Big, and Huge. It also has different categories of words, such as animals, fruits, colors, countries, sports, etc. The game is in Portuguese, so it is ideal for native speakers or learners of this language.
A word search game with different levels of difficulty
-
A word search game is a type of puzzle game where you have to find hidden words in a grid of letters. The words can be horizontal, vertical, diagonal, or backwards. The game has different levels of difficulty depending on the size of the grid and the number of words to find. The easy level has a 9x9 grid with 10 words, while the huge level has a 20x20 grid with 40 words. You can choose the level that suits your preference and skill.
-
A game that helps you learn Portuguese vocabulary and spelling
-
One of the main benefits of playing Caça Palavras Brasileiro APK is that it helps you learn Portuguese vocabulary and spelling. The game has hundreds of words from different categories, so you can expand your knowledge of this language. You can also learn how to spell the words correctly by looking at the grid and checking if they match the letters. The game will also show you the meaning of each word when you select it, so you can understand what it means.
-
caça palavras brasileiro apk download
-caça palavras brasileiro apk mod
-caça palavras brasileiro apk offline
-caça palavras brasileiro apk atualizado
-caça palavras brasileiro apk gratis
-caça palavras brasileiro apk para pc
-caça palavras brasileiro apk android
-caça palavras brasileiro apk online
-caça palavras brasileiro apk 2023
-caça palavras brasileiro apk hack
-caça palavras brasileiro apk premium
-caça palavras brasileiro apk infinito
-caça palavras brasileiro apk sem anúncios
-caça palavras brasileiro apk com dicas
-caça palavras brasileiro apk fácil
-caça palavras brasileiro apk difícil
-caça palavras brasileiro apk com som
-caça palavras brasileiro apk com temas
-caça palavras brasileiro apk educativo
-caça palavras brasileiro apk divertido
-caça palavras brasileiro apk desafio
-caça palavras brasileiro apk relaxante
-caça palavras brasileiro apk inteligente
-caça palavras brasileiro apk criativo
-caça palavras brasileiro apk clássico
-caça palavras brasileiro apk moderno
-caça palavras brasileiro apk colorido
-caça palavras brasileiro apk animado
-caça palavras brasileiro apk viciante
-caça palavras brasileiro apk gratuito
-baixar caça palavras brasileiro apk
-instalar caça palavras brasileiro apk
-jogar caça palavras brasileiro apk
-como baixar caça palavras brasileiro apk
-como jogar caça palavras brasileiro apk
-como instalar caça palavras brasileiro apk
-melhor caça palavras brasileiro apk
-novo caça palavras brasileiro apk
-jogo de caça palavras brasileiro apk
-aplicativo de caça palavras brasileiro apk
-app de caça palavras brasileiro apk
-versão mais recente de caça palavras brasileiro apk
-versão antiga de caça palavras brasileiro apk
-resenha de caça palavras brasileiro apk
-avaliação de caça palavras brasileiro apk
-comentários de caça palavras brasileiro apk
-dúvidas sobre caça palavras brasileiro apk
-suporte para caça palavras brasileiro apk
-contato para caça palavras brasileiro apk
-
A game that challenges your brain and improves your concentration
-
Another benefit of playing Caça Palavras Brasileiro APK is that it challenges your brain and improves your concentration. The game requires you to scan the grid carefully and find the hidden words as fast as possible. You have to pay attention to every letter and avoid getting distracted by other words or letters. The game also tests your memory, as you have to remember where you saw a word or letter before. The game will keep your brain active and alert.
-
How to download and install Caça Palavras Brasileiro APK?
-
If you want to play Caça Palavras Brasileiro APK on your Android device, you have to download and install the APK file first. An APK file is an application package file that contains all the files needed to run an app on Android. Here are the steps to download and install Caça Pal avras Brasileiro APK:
-
Download the APK file from a trusted source
-
The first step is to download the APK file from a trusted source. You can find the official link to the game on the developer's website. You can also search for other sources that offer the APK file, but make sure they are safe and reliable. You can use a browser or a downloader app to download the file. The file size is about 13 MB, so it should not take long to download.
-
Enable unknown sources in your device settings
-
The second step is to enable unknown sources in your device settings. This is necessary because Android does not allow installing apps from sources other than the Google Play Store by default. To enable unknown sources, go to your device settings and look for the security or privacy option. Then, find the option that says "allow installation of apps from unknown sources" or something similar. Toggle it on and confirm your choice.
-
Install the APK file and enjoy the game
-
The third step is to install the APK file and enjoy the game. To install the file, locate it in your device storage and tap on it. You may see a warning message that says "this type of file can harm your device". Ignore it and tap on "install anyway". The installation process should take a few seconds. Once it is done, you can open the game and start playing.
-
How to play Caça Palavras Brasileiro APK?
-
Playing Caça Palavras Brasileiro APK is very easy and fun. Here are the basic steps to play the game:
-
Choose a level of difficulty and a category
-
When you open the game, you will see a menu with five options: Easy, Normal, Hard, Big, and Huge. These are the levels of difficulty that determine the size of the grid and the number of words to find. Tap on the level you want to play. Then, you will see another menu with different categories of words, such as animals, fruits, colors, countries, sports, etc. Tap on the category you want to play.
-
Find the hidden words in the grid of letters
-
After choosing a level and a category, you will see a grid of letters with some words hidden in it. The words can be horizontal, vertical, diagonal, or backwards. You have to find all the words in the grid as fast as possible. You can see the list of words on the bottom of the screen.
-
Tap and drag your finger over the letters to select a word
-
To select a word, tap and drag your finger over the letters that form the word. The word will be highlighted in green if it is correct or red if it is wrong. The word will also disappear from the list if it is correct. You can also tap on a word in the list to see its meaning on the top of the screen.
-
Check your progress and score on the top of the screen
-
You can check your progress and score on the top of the screen. The progress bar shows how many words you have found out of the total number of words in the grid. The score shows how many points you have earned based on the time and difficulty level. You can also pause or restart the game by tapping on the buttons on the top right corner of the screen.
-
What are the benefits of playing Caça Palavras Brasileiro APK?
-
Playing Caça Palavras Brasileiro APK is not only fun, but also beneficial for your brain and your language skills. Here are some of the benefits of playing this game:
-
It improves your vocabulary and spelling skills
-
By playing this game, you can learn new words and their meanings in Portuguese. You can also improve your spelling skills by checking if the words you select match the letters in the grid. The game will help you expand your vocabulary and enhance your spelling accuracy.
-
It stimulates your brain and memory
-
By playing this game, you can stimulate your brain and memory. You have to use your logic, observation, and analysis skills to find the hidden words in the grid. You also have to use your memory to remember where you saw a word or letter before. The game will help you sharpen your cognitive abilities and boost your memory power.
-
It relaxes your mind and reduces stress
-
By playing this game, you can relax your mind and reduce stress. The game has a soothing background music and a colorful design that create a pleasant atmosphere. The game also has no time limit or pressure, so you can play at your own pace and enjoy the process. The game will help you calm your nerves and relieve your tension.
-
It entertains you and keeps you engaged
-
By playing this game, you can entertain yourself and keep yourself engaged. The game has different levels of difficulty and categories of words that offer variety and challenge. The game also has a scoring system that motivates you to improve your performance and beat your own records. The game will help you have fun and stay focused.
-
Conclusion
-
Caça Palavras Brasileiro APK is a word search game that is fun and educational for all ages. It is a game that helps you learn Portuguese vocabulary and spelling, challenges your brain and memory, relaxes your mind and reduces stress, and entertains you and keeps you engaged. You can download and install the game for free on your Android device and start playing right away. If you are looking for a game that combines learning and entertainment, you should try Caça Palavras Brasileiro APK.
-
FAQs
-
Here are some frequently asked questions about Caça Palavras Brasileiro APK:
-
Q: Is Caça Palavras Brasileiro APK safe to download and install?
-
A: Yes, Caça Palavras Brasileiro APK is safe to download and install as long as you get it from a trusted source. You should always check the reputation and reviews of the source before downloading any APK file. You should also scan the file with an antivirus app before installing it.
-
Q: Is Caça Palavras Brasileiro APK compatible with all Android devices?
-
A: Caça Palavras Brasileiro APK is compatible with most Android devices that run on Android 4.1 or higher. However, some devices may have different specifications or settings that may affect the performance or functionality of the game. You should always check the compatibility of the game with your device before installing it.
-
Q: Can I play Caça Palavras Brasileiro APK offline?
-
A: Yes, you can play Caça Palavras Brasileiro APK offline without an internet connection. The game does not require any online features or services to run. However, if you want to update the game or access some optional features, such as sharing your score or rating the game, you will need an internet connection.
-
Q: Can I play Caça Palavras Brasileiro APK in other languages?
-
A: No, Caça Palavras Brasileiro APK is only available in Portuguese. The game is designed for native speakers or learners of this language. If you want to play a word search game in another language, you will have to look for another app that offers that option.
-
Q: How can I contact the developer of Caça Palavras Brasileiro APK?
-
A: If you have any questions, suggestions, or feedback about Caça Palavras Brasileiro APK, you can contact the developer by sending an email to bernimobile@gmail.com. You can also visit their website at https://www.bernimobile.com/ or follow them on Facebook at https://www.facebook.com/bernimobile/.
197e85843d
-
-
\ No newline at end of file
diff --git a/spaces/1phancelerku/anime-remove-background/Clash Royale Elixir Infinito APK Cmo conseguir recursos ilimitados en el juego de estrategia ms popular.md b/spaces/1phancelerku/anime-remove-background/Clash Royale Elixir Infinito APK Cmo conseguir recursos ilimitados en el juego de estrategia ms popular.md
deleted file mode 100644
index 9169294ba514b150faabe51f3edb92c8a82e416b..0000000000000000000000000000000000000000
--- a/spaces/1phancelerku/anime-remove-background/Clash Royale Elixir Infinito APK Cmo conseguir recursos ilimitados en el juego de estrategia ms popular.md
+++ /dev/null
@@ -1,126 +0,0 @@
-
-
Clash Royale Elixir Infinito Apk: How to Get Unlimited Elixir, Gems and Gold in Clash Royale
-
Clash Royale is one of the most popular and addictive mobile games in the world. It is a real-time strategy game where you collect cards, build decks, and battle other players online. However, to progress faster and unlock more cards, you need to spend elixir, gems, and gold, which are the in-game currencies. These resources are limited and hard to earn, unless you are willing to spend real money on them.
But what if there was a way to get unlimited elixir, gems, and gold in Clash Royale without spending a dime? Well, that's what Clash Royale Elixir Infinito Apk is all about. In this article, we will tell you everything you need to know about this modded version of Clash Royale, including its features, how to download and install it, its pros and cons, and some tips and tricks for playing with it. Let's get started!
-
What is Clash Royale Elixir Infinito Apk?
-
Clash Royale Elixir Infinito Apk is a modified version of the original Clash Royale game that gives you unlimited elixir, gems, and gold. This means that you can play the game without any restrictions or limitations. You can upgrade your cards, unlock new ones, open chests, buy items, and more without worrying about running out of resources.
-
Clash Royale Elixir Infinito Apk is not an official app from Supercell, the developer of Clash Royale. It is a third-party app that has been created by some fans of the game who wanted to enhance their gaming experience. Therefore, it is not available on the Google Play Store or the App Store. You have to download it from an external source, which we will explain later.
-
clash royale mod apk unlimited gems and elixir
-clash royale private server with infinite elixir
-clash royale hack apk download with elixir cheat
-clash royale apk modificado com elixir infinito
-clash royale elixir infinito apk mediafire
-clash royale unlimited elixir mod apk latest version
-clash royale elixir infinito apk 2023
-clash royale mod apk elixir ilimitado y gemas
-clash royale servidor privado con elixir infinito
-clash royale hack apk descargar con truco de elixir
-clash royale apk modificado con elixir infinito
-clash royale elixir infinito apk malavida
-clash royale mod apk unlimited everything 2023
-clash royale private server apk download 2023
-clash royale hack apk no root no survey
-clash royale apk mod com elixir infinito 2023
-clash royale elixir infinito apk atualizado
-clash royale mod apk elixir ilimitado y oro
-clash royale servidor privado apk descargar 2023
-clash royale hack apk sin root ni encuestas
-clash royale papua news mod apk download
-clash royale master royale infinity apk gratis
-clash royale arctic royale apk download youtube
-clash royale mod apk unlimited cards and chests
-clash royale private server with custom cards
-clash royale hack apk online generator tool
-clash royale apk mod com cartas infinitas
-clash royale elixir infinito apk sem root
-clash royale mod apk estrategia y defensa ilimitada
-clash royale servidor privado con cartas personalizadas
-clash royale hack apk generador online de recursos
-clash royale new scientist mod apk free download
-clash royale master royale infinity latest version
-clash royale arctic royale gameplay video youtube
-clash royale mod apk unlimited troops and spells
-clash royale private server with all skins unlocked
-clash royale hack apk easy and fast method
-clash royale apk mod com tropas e feitiços infinitos
-clash royale elixir infinito apk sem anúncios
-clash royale mod apk tropas y hechizos ilimitados
-clash royale servidor privado con todos los skins desbloqueados
-clash royale hack apk método fácil y rápido
-
Features of Clash Royale Elixir Infinito Apk
-
Clash Royale Elixir Infinito Apk has many features that make it different from the original game. Here are some of them:
-
Unlimited Elixir
-
Elixir is the main resource that you use to play cards in Clash Royale. It is generated automatically during battles at a constant rate. However, with Clash Royale Elixir Infinito Apk, you have unlimited elixir at your disposal. This means that you can play any card at any time without waiting for your elixir bar to fill up. You can also spam your opponent with multiple cards and overwhelm them easily.
-
Unlimited Gems
-
Gems are the premium currency in Clash Royale. They are used to buy chests, cards, gold, and other items in the game. They are also used to speed up the unlocking process of chests and skip waiting times. However, gems are very rare and hard to obtain in the game. You can only get them by completing achievements, winning battles, or buying them with real money.
-
But with Clash Royale Elixir Infinito Apk, you have unlimited gems at your disposal. This means that you can buy anything you want in the game without spending any money. You can also open as many chests as you want and get all the cards you need. You can also speed up your progress and reach higher levels faster.
-
Unlimited Gold
-
Gold is the basic currency in Clash Royale. It is used to upgrade your cards, buy cards from the shop, and create or join clans. You can earn gold by winning battles, opening chests, donating cards, or buying it with gems.
-
But with Clash Royale Elixir Infinito Apk, you have unlimited gold at your disposal. This means that you can upgrade your cards to the maximum level without any cost. You can also buy any card you want from the shop and create or join any clan you like.
-
How to Download and Install Clash Royale Elixir Infinito Apk
-
As we mentioned earlier, Clash Royale Elixir Infinito Apk is not an official app from Supercell. It is a third-party app that has been modified by some fans of the game. Therefore, you cannot download it from the Google Play Store or the App Store. You have to download it from an external source, such as a website or a file-sharing platform.
-
However, before you download and install Clash Royale Elixir Infinito Apk, you need to make sure that your device meets the following requirements:
-
-
Your device must have Android 4.1 or higher.
-
Your device must have at least 100 MB of free storage space.
-
Your device must have a stable internet connection.
-
Your device must allow installation of apps from unknown sources.
-
-
If your device meets these requirements, then you can follow these steps to download and install Clash Royale Elixir Infinito Apk:
-
Step 1: Enable Unknown Sources
-
The first step is to enable unknown sources on your device. This will allow you to install apps that are not from the Google Play Store or the App Store. To do this, go to your device settings and look for the security option. Then, find the unknown sources option and toggle it on. You may see a warning message that says installing apps from unknown sources may harm your device. Ignore this message and tap OK.
-
Step 2: Download the Apk File
-
The next step is to download the apk file of Clash Royale Elixir Infinito Apk. You can find many websites and platforms that offer this file for free. However, be careful and choose a reliable and trustworthy source. Some sources may contain viruses or malware that can harm your device or steal your personal information.
-
One of the best sources to download Clash Royale Elixir Infinito Apk is [this website]. It is safe, secure, and fast. All you have to do is click on the download button and wait for the file to be downloaded on your device.
-
Step 3: Install the Apk File
-
The third step is to install the apk file of Clash Royale Elixir Infinito Apk. To do this, go to your file manager and locate the downloaded file. Then, tap on it and follow the instructions on the screen. You may see a pop-up message that says this app may harm your device or request certain permissions. Ignore this message and tap install.
-
Step 4: Launch the Game and Enjoy
-
The final step is to launch the game and enjoy it. To do this, go to your app drawer and look for the Clash Royale icon. Then, tap on it and wait for the game to load. You may see a loading screen that says "Clash Royale Elixir Infinito". This means that you have successfully installed the modded version of Clash Royale.
-
Now, you can play the game with unlimited elixir, gems, and gold. You can also access all the features and modes of the game without any restrictions or limitations. Have fun!
-
Pros and Cons of Clash Royale Elixir Infinito Apk
-
Clash Royale Elixir Infinito Apk has many advantages and disadvantages that you should be aware of before using it. Here are some of them:
-
Pros
-
-
You can play Clash Royale with unlimited elixir, gems, and gold.
-
You can upgrade your cards, unlock new ones, open chests, buy items, and more without any cost.
-
You can speed up your progress and reach higher levels faster.
-
You can experiment with different decks and strategies without any risk.
-
You can enjoy all the features and modes of the game without any restrictions or limitations.
-
-
Cons
-
You may face some technical issues or bugs while playing the game.
-
You may not be able to play online with other players who are using the original version of the game.
-
You may get banned or suspended by Supercell for using a modded version of the game.
-
You may lose your progress or data if you uninstall the app or switch to the original version of the game.
-
You may miss out on the updates and new features that Supercell releases for the original version of the game.
-
-
Tips and Tricks for Playing Clash Royale with Elixir Infinito Apk
-
Clash Royale Elixir Infinito Apk can make your gaming experience more fun and exciting, but it can also make it more challenging and competitive. Here are some tips and tricks that can help you play better and win more battles with this modded version of Clash Royale:
-
Use Your Elixir Wisely
-
Even though you have unlimited elixir, you still need to use it wisely. Don't just spam your cards randomly and hope for the best. You need to have a strategy and a plan for each battle. You need to know when to attack, when to defend, and when to save your elixir. You also need to know which cards work well together and which ones counter your opponent's cards. You need to balance your elixir spending and income, and avoid wasting elixir on unnecessary or ineffective moves.
-
Build a Balanced Deck
-
Having unlimited elixir, gems, and gold means that you can build any deck you want in Clash Royale. However, that doesn't mean that you should build a random or unbalanced deck. You still need to have a balanced deck that can deal with different situations and threats. You need to have a mix of cards that can attack, defend, support, and counter. You also need to have cards that can target different types of units, such as air, ground, swarm, tank, etc. You need to have cards that can synergize with each other and create powerful combos. You also need to have cards that suit your playstyle and preferences.
-
Learn from Your Opponents
-
Playing with Clash Royale Elixir Infinito Apk can give you an edge over your opponents, but it can also make them more challenging and unpredictable. You may face opponents who are also using the modded version of the game, or who are using the original version but have more skills and experience than you. Therefore, you need to learn from your opponents and adapt to their strategies and tactics. You need to observe their moves and patterns, and find their weaknesses and strengths. You also need to analyze your own mistakes and improve your performance.
-
Join a Clan and Share Cards
-
Clash Royale is not only a solo game, but also a social game. You can join a clan and interact with other players who share your passion for the game. You can chat with them, share tips and tricks, request and donate cards, participate in clan wars, and more. Joining a clan can help you improve your skills, expand your card collection, earn more rewards, and have more fun.
-
Conclusion and FAQs
-
Clash Royale Elixir Infinito Apk is a modded version of Clash Royale that gives you unlimited elixir, gems, and gold. It is a great way to enjoy the game without any restrictions or limitations. However, it also has some drawbacks and risks that you should be aware of before using it. In this article, we have explained everything you need to know about this app, including its features, how to download and install it, its pros and cons, and some tips and tricks for playing with it.
-
We hope that this article has been helpful and informative for you. If you have any questions or doubts about Clash Royale Elixir Infinito Apk, here are some FAQs that may answer them:
-
-
Question
Answer
-
Is Clash Royale Elixir Infinito Apk safe to use?
Clash Royale Elixir Infinito Apk is not an official app from Supercell. It is a third-party app that has been modified by some fans of the game. Therefore, it is not guaranteed to be safe or secure. It may contain viruses or malware that can harm your device or steal your personal information. It may also cause some technical issues or bugs while playing the game. Therefore, use it at your own risk.
-
Is Clash Royale Elixir Infinito Apk legal to use?
Clash Royale Elixir Infinit o Apk is not legal to use. It violates the terms and conditions of Supercell and Clash Royale. It also infringes the intellectual property rights of Supercell and Clash Royale. It may also be considered as cheating or hacking by other players and authorities. Therefore, using it may result in legal actions or penalties from Supercell, such as banning or suspending your account.
-
Will Clash Royale Elixir Infinito Apk work on my device?
Clash Royale Elixir Infinito Apk may or may not work on your device. It depends on various factors, such as your device model, operating system, software version, storage space, internet connection, etc. Some devices may be compatible with the app, while others may not. Some devices may run the app smoothly, while others may experience crashes or errors. Therefore, you have to try it yourself and see if it works on your device.
-
Can I play online with Clash Royale Elixir Infinito Apk?
Clash Royale Elixir Infinito Apk may or may not allow you to play online with other players. It depends on the version of the app and the server of the game. Some versions of the app may connect you to the original server of Clash Royale, where you can play with other players who are using the original version of the game. However, this may also expose you to detection and banning by Supercell. Other versions of the app may connect you to a private server of Clash Royale, where you can play with other players who are using the modded version of the game. However, this may also limit your options and features in the game.
-
Can I switch back to the original version of Clash Royale after using Clash Royale Elixir Infinito Apk?
You can switch back to the original version of Clash Royale after using Clash Royale Elixir Infinito Apk, but you may lose your progress or data in the process. To switch back, you have to uninstall the modded version of the game and install the original version from the Google Play Store or the App Store. However, this may erase your account and data in the modded version of the game. You may also not be able to restore your account and data in the original version of the game if you have not linked it to a Supercell ID or a Google Play Games account.
-
Is there any alternative to Clash Royale Elixir Infinito Apk?
If you are looking for an alternative to Clash Royale Elixir Infinito Apk, you may try some other modded versions of Clash Royale that offer similar features and benefits. However, be careful and choose a reliable and trustworthy source for downloading them. Some of them are:
-
-
-
Clash Royale Mod Apk: This is another modded version of Clash Royale that gives you unlimited resources and access to all features and modes of the game. You can download it from [this website].
-
Clash Royale Hack Apk: This is a hacked version of Clash Royale that gives you unlimited resources and allows you to customize your game settings and preferences. You can download it from [this website].
-
Clash Royale Private Server Apk: This is a private server version of Clash Royale that connects you to a different server where you can play with other players who are using the same version of the game. You can download it from [this website].
-
401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/1phancelerku/anime-remove-background/Dmod APK Download Everything You Need to Know About the New Action Game.md b/spaces/1phancelerku/anime-remove-background/Dmod APK Download Everything You Need to Know About the New Action Game.md
deleted file mode 100644
index 1488c1e0408b31c2e37fc4a6eb23b248062a29e1..0000000000000000000000000000000000000000
--- a/spaces/1phancelerku/anime-remove-background/Dmod APK Download Everything You Need to Know About the New Action Game.md
+++ /dev/null
@@ -1,152 +0,0 @@
-
-
What is dmod apk and why you should download it
-
If you are a fan of Android games, you may have heard of dmod apk. But what is it exactly and what can it do for you? In this article, we will tell you everything you need to know about this amazing app and why you should download it right away.
-
Dmod apk is an app that allows you to download and install modified versions of your favorite Android games. These modified versions, also known as mods, can give you access to unlimited resources, premium features, custom skins, and more. With dmod apk, you can enjoy your games like never before and have more fun and excitement.
Here are some of the benefits of using dmod apk over other apps:
-
-
It is free and easy to use. You don't need to pay anything or register an account to use dmod apk. You just need to download it from a reliable source and install it on your device.
-
It is safe and secure. Dmod apk does not contain any viruses or malware that can harm your device or data. It also does not require root access or any special permissions to work.
-
It is compatible and flexible. Dmod apk works with most Android devices and games. You can choose from a wide range of mods for different games and customize them according to your preferences.
-
-
Here are some of the features of dmod apk that make it unique and useful:
-
-
It has a user-friendly interface. Dmod apk has a simple and intuitive design that makes it easy to navigate and use. You can easily find the mods you want by browsing through categories or searching by keywords.
-
It has a large collection of mods. Dmod apk has thousands of mods for hundreds of games, including popular ones like PUBG, Free Fire, Clash of Clans, Subway Surfers, Candy Crush, and more. You can always find something new and interesting to try.
-
It has a fast download speed. Dmod apk downloads the mods directly from its servers, which are fast and stable. You don't have to wait for long or face any interruptions while downloading.
-
-
How to download and install dmod apk on your Android device
-
Now that you know what dmod apk is and what it can do for you, you may be wondering how to get it on your device. Don't worry, we will show you how in this section. Just follow these simple steps:
-
Before you start, make sure that your device meets these minimum requirements:
-
-
It has Android 4.4 or higher version installed.
-
It has at least 50 MB of free storage space available.
It has enabled the option to install apps from unknown sources. You can do this by going to Settings > Security > Unknown Sources and toggling it on.
-
-
Once you have checked these requirements, you can proceed with the following steps:
-
-
Download the dmod apk file from a trusted source. You can use this link to download it: dmod apk download.
-
Locate the downloaded file on your device and tap on it to open it.
-
Follow the instructions on the screen and click on Install to start the installation process.
-
Wait for a few seconds until the installation is completed and click on Open to launch the app.
-
Congratulations! You have successfully installed dmod apk on your device. You can now enjoy using it to play your favorite games.
-
-
Here are some tips on how to use dmod apk safely and effectively:
Always download the mods from the official dmod apk app or website. Do not download them from other sources as they may contain viruses or malware.
-
Always backup your original game data before installing any mods. This way, you can restore it if anything goes wrong or if you want to switch back to the original version.
-
Always check the compatibility and reviews of the mods before installing them. Some mods may not work well with your device or game version, or they may have bugs or glitches. Read the comments and ratings of other users to see if they have any issues or complaints.
-
-
How to use dmod apk to play your favorite games
-
Now that you have installed dmod apk on your device, you may be wondering how to use it to play your favorite games. Don't worry, we will show you how in this section. Just follow these simple steps:
-
First, you need to find the mods for the games you want to play. You can do this by using the dmod apk app or website. Here are some of the popular games that you can play with dmod apk:
-
-
Game
Description
-
PUBG
A battle royale game where you fight against 99 other players in a shrinking map. You can use mods to get unlimited health, ammo, weapons, skins, and more.
-
Free Fire
A similar game to PUBG but with more features and modes. You can use mods to get unlimited diamonds, coins, characters, pets, and more.
-
Clash of Clans
A strategy game where you build your own village and army and fight against other players. You can use mods to get unlimited gems, gold, elixir, dark elixir, troops, and more.
-
Subway Surfers
A running game where you dodge obstacles and collect coins and power-ups. You can use mods to get unlimited keys, coins, hoverboards, characters, and more.
-
Candy Crush
A puzzle game where you match candies and clear levels. You can use mods to get unlimited lives, moves, boosters, and more.
-
-
To download and install the mods for these games, you can follow these steps:
-
-
Open the dmod apk app or website and search for the game you want to play.
-
Select the mod you want to download and click on Download. You will be redirected to a page where you need to complete a verification process. This is to ensure that you are not a robot and to protect the mod from being abused.
-
Complete the verification process by following the instructions on the screen. This may involve completing a survey, watching a video, or installing an app.
-
Once you have completed the verification process, you will be able to download the mod file. Locate the downloaded file on your device and tap on it to open it.
-
Follow the instructions on the screen and click on Install to start the installation process.
-
Wait for a few seconds until the installation is completed and click on Open to launch the game with the mod enabled.
-
Congratulations! You have successfully installed the mod for your game. You can now enjoy playing it with enhanced features and items.
-
-
To use the mods in your games, you can follow these steps:
-
-
Open the game with the mod enabled and start playing as usual.
-
To access the mod menu, you need to tap on a special button or icon on the screen. This may vary depending on the game and the mod. For example, in PUBG, you may need to tap on the floating icon on the top left corner of the screen.
-
Once you have opened the mod menu, you will see a list of options and features that you can enable or disable. You can also adjust the settings and values of some features according to your preferences.
-
Select the features that you want to use and close the mod menu. You will see the effects of the features in your game. For example, in Free Fire, you may see your health bar increase or your enemies become visible through walls.
-
Enjoy playing your game with the mod enabled and have more fun and excitement.
-
-
How to troubleshoot common issues with dmod apk
-
While dmod apk is a great app that can enhance your gaming experience, it may also cause some issues or problems sometimes. Don't worry, we will show you how to troubleshoot some of the common issues with dmod apk in this section. Here are some of the common issues and how to fix them:
-
-
Error: App not installed. This error may occur when you try to install dmod apk or a mod file on your device. This may be due to several reasons, such as insufficient storage space, corrupted file, incompatible device, or security settings. To fix this error, you can try these solutions:
-
Clear some storage space on your device by deleting unwanted files or apps.
-
Download the file again from a reliable source and make sure it is not corrupted or damaged.
-
Check if your device meets the minimum requirements for installing dmod apk or the mod file.
-
Enable the option to install apps from unknown sources by going to Settings > Security > Unknown Sources and toggling it on.
-
-
-
Error: Game not working or crashing. This error may occur when you try to play a game with a mod enabled. This may be due to several reasons, such as outdated mod, incompatible game version, conflicting features, or bugs or glitches. To fix this error, you can try these solutions:
-
Update the mod to the latest version by using the dmod apk app or website.
-
Update the game to the latest version by using the Google Play Store or other sources.
-
Disable or adjust some features that may cause conflicts or errors in your game.
-
Report any bugs or glitches to the developers of dmod apk or the mod file.
-
-
-
Error: Mod not working or showing. This error may occur when you try to use a mod in your game but it does not work or show up. This may be due to several reasons, such as incorrect installation, wrong file format, missing files, or disabled features. To fix this error, you can try these solutions:
-
Reinstall the mod by following the steps in section 3 of this article.
-
Make sure that the mod file is in APK format and not ZIP or RAR format.
-
Make sure that all the files and folders of the mod are present and intact on your device.
-
Enable the features that you want to use by opening the mod menu and selecting them.
-
-
-
-
Conclusion
-
In conclusion, dmod apk is an app that allows you to download and install modified versions of your favorite Android games. These mods can give you access to unlimited resources, premium features, custom skins, and more. With dmod apk, you can enjoy your games like never before and have more fun and excitement.
-
If you want to try dmod apk for yourself, you can download it from this link: dmod apk download. You can also visit their website for more information and updates: dmod apk website.
-
We hope that this article has helped you understand what dmod apk is and how to use it. If you have any questions or feedback, please feel free to leave a comment below. We would love to hear from you.
-
FAQs
-
Here are some of the frequently asked questions about dmod apk:
-
-
Is dmod apk legal?
-
Dmod apk is legal as long as you use it for personal and educational purposes only. However, using it for commercial or malicious purposes may violate the terms and conditions of the original game developers and publishers. Therefore, we advise you to use dmod apk at your own risk and discretion.
-
Is dmod apk safe?
-
Dmod apk is safe as long as you download it from a trusted source and install it on your device. It does not contain any viruses or malware that can harm your device or data. It also does not require root access or any special permissions to work. However, some mods may contain harmful or inappropriate content that may affect your game or device. Therefore, we advise you to check the compatibility and reviews of the mods before installing them.
-
Can dmod apk ban my game account?
-
Dmod apk does not ban your game account directly, but it may increase the risk of getting banned by the game servers or authorities. This is because some mods may give you an unfair advantage over other players or violate the game rules and policies. Therefore, we advise you to use dmod apk with caution and moderation, and avoid using it in online or multiplayer modes.
-
How can I update dmod apk?
-
You can update dmod apk by using the dmod apk app or website. You can check for updates by opening the app or visiting the website and looking for the latest version. You can also enable the auto-update option in the app settings to get notified and download the updates automatically.
-
How can I contact dmod apk?
-
You can contact dmod apk by using their email address or social media accounts. You can find their contact information on their website or app. You can also leave a comment or feedback on their website or app. They are always happy to hear from their users and provide support and assistance.
- 401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/1phancelerku/anime-remove-background/Download SuperStar JYPNATION and Collect Over 700 Cards of Your Favorite Artists.md b/spaces/1phancelerku/anime-remove-background/Download SuperStar JYPNATION and Collect Over 700 Cards of Your Favorite Artists.md
deleted file mode 100644
index 81cb9bd9329dd70f80fc2e89c937f8a3545614ed..0000000000000000000000000000000000000000
--- a/spaces/1phancelerku/anime-remove-background/Download SuperStar JYPNATION and Collect Over 700 Cards of Your Favorite Artists.md
+++ /dev/null
@@ -1,210 +0,0 @@
-
-
How to Download Superstar Jypnation
-
Do you love K-pop music and rhythm games? If so, you should definitely try out superstar jypnation, a fun and exciting music game with your favorite artists from JYP Entertainment. In this article, we will show you how to download superstar jypnation on your device, whether it's Android, iOS, or PC. We will also tell you about the features of the game, such as the artists, songs, cards, rankings, and more. Plus, we will give you some tips and tricks to help you play better and score higher. So, let's get started!
-
Features of Superstar Jypnation
-
Superstar jypnation is a rhythm game that lets you play along with the songs from JYP Entertainment's artists. The game has many features that make it fun and addictive, such as:
24 group artists from JYP Entertainment: You can choose from a variety of artists, such as J.Y. Park, Wonder Girls, Sunmi, 2AM, 2PM, miss A, JJ Project, Baek A Yeon, 15&, GOT7, DAY6, TWICE, Stray Kids, YUBIN, ITZY, and NiziU.
-
270+ songs from JYP Entertainment's artists: You can play songs from different genres and eras, from the debut songs to the latest hits. You can also unlock more songs as you progress in the game.
-
660+ cards to collect: You can collect cards that feature the images of your favorite artists. Each card has different attributes and abilities that affect your score. You can also equip and upgrade your cards to make them more powerful.
-
Weekly Ranking, Best Record for each song, and many more competitions inside: You can compete with other players around the world and see how you rank in different categories. You can also check your best record for each song and try to beat it.
-
-
Participating Artists
-
Superstar jypnation has 24 group artists from JYP Entertainment that you can choose from. Each artist has their own songs and cards that you can play with. Here is the list of the participating artists:
-
-
-
Artist
-
Debut Year
-
Genre
-
-
-
J.Y. Park
-
1994
-
K-pop, R&B
-
-
-
Wonder Girls
-
2007
-
K-pop, Retro-pop
-
-
-
Sunmi
-
2007
-
K-pop, Dance-pop
-
-
-
2AM
-
2008
-
K-pop, Ballad
-
-
-
2PM
-
2008
-
K-pop, Dance-pop
-
-
-
miss A
-
2010
-
K-pop, Dance-pop
-
-
-
JJ Project
-
2012
-
K-pop, Hip-hop
-
-
-
Baek A Yeon
-
2012
-
K-pop, Ballad
-
-
-
15&
-
2012
-
K-pop, R&B
-
-
-
GOT7
-
2014
-
K-pop, Hip-hop
-
-
-
DAY6
-
2015
-
K-rock, Pop-rock
-
-
-
TWICE
-
2015
-
K-pop, Bubblegum pop
-
-
-
Stray Kids
-
2018
-
K-pop, Hip-hop
-
-
-
YUBIN
-
2018
-
K-pop, Retro-pop
-
-
-
ITZY
-
2019
-
K-pop, Teen pop
-
-
-
NiziU
-
2020
-
J-pop, K-pop
-
-
-
Songs and Levels
-
Superstar jypnation has over 270 songs from JYP Entertainment's artists that you can play in the game. Each song has three levels of difficulty: Easy, Normal, and Hard. The higher the difficulty, the more notes you have to tap and the faster they move. You can choose the level that suits your skill and preference. You can also unlock more songs by completing missions and achievements in the game.
-
Cards and Abilities
-
Superstar jypnation has over 660 cards that you can collect in the game. Each card features an image of an artist from JYP Entertainment. The cards have different attributes, such as Vocal, Dance, Rhythm, and Center. The cards also have different abilities, such as Score Up, Perfect Lock, Combo Bonus, and more. The cards can help you improve your score and performance in the game.
-
You can equip up to five cards for each artist in your deck. The cards you equip will affect the score you get for each note you tap. You can also enhance your cards by using other cards or materials as fodder. Enhancing your cards will increase their level and stats. You can also upgrade your cards by using duplicates or special items. Upgrading your cards will increase their rank and rarity.
-
Rankings and Competitions
-
Superstar jypnation has various rankings and competitions that you can participate in. You can compete with other players around the world and see how you rank in different categories, such as:
-
-
Weekly Ranking: You can compete with other players in your league and try to get the highest score for each song. The higher your score, the higher your rank. You can also get rewards based on your rank at the end of each week.
-
Best Record for each song: You can check your best record for each song and try to beat it. You can also see the best records of other players and compare them with yours.
-
World Record for each song: You can check the world record for each song and see who holds it. You can also try to break the world record and make history.
-
Superstar League: You can compete with other players in a special league that features a random song every day. You can get rewards based on your score and rank at the end of each week.
-
Arena Mode: You can compete with other players in a real-time mode that features three songs in a row. You can get rewards based on your score and rank at the end of each match.
-
-
How to Download Superstar Jypnation on Android
-
If you have an Android device, you can download superstar jypnation from Google Play Store. Here are the steps to do so:
-
-
Open Google Play Store on your device.
-
Search for "superstar jypnation" in the search bar.
-
Select the game from the search results and tap on "Install".
-
Wait for the game to download and install on your device.
-
Open the game and enjoy playing!
-
-
How to Download Superstar Jypnation on iOS
-
If you have an iOS device, you can download superstar jypnation from App Store. Here are the steps to do so:
-
How to download superstar jypnation on android
-How to download superstar jypnation on ios
-How to download superstar jypnation on pc
-How to download superstar jypnation songs
-How to download superstar jypnation apk
-How to download superstar jypnation mod
-How to download superstar jypnation update
-How to download superstar jypnation for free
-How to download superstar jypnation on mac
-How to download superstar jypnation on laptop
-How to download superstar jypnation on windows 10
-How to download superstar jypnation on chromebook
-How to download superstar jypnation on bluestacks
-How to download superstar jypnation on nox player
-How to download superstar jypnation on memu play
-How to download superstar jypnation on ldplayer
-How to download superstar jypnation on qooapp
-How to download superstar jypnation on google play store
-How to download superstar jypnation on app store
-How to download superstar jypnation on amazon appstore
-How to download superstar jypnation offline
-How to download superstar jypnation without wifi
-How to download superstar jypnation without vpn
-How to download superstar jypnation without ads
-How to download superstar jypnation without root
-How to download superstar jypnation with data transfer
-How to download superstar jypnation with cardbook sync
-How to download superstar jypnation with all songs unlocked
-How to download superstar jypnation with unlimited diamonds
-How to download superstar jypnation with cheat engine
-How to install superstar jypnation on android phone
-How to install superstar jypnation on iphone or ipad
-How to install superstar jypnation on windows pc or macbook
-How to install superstar jypnation from apk file
-How to install superstar jypnation from modded apk file
-How to install superstar jypnation from qooapp apk file
-How to install superstar jypnation from google play store apk file
-How to install superstar jypnation from app store ipa file
-How to install superstar jypnation from amazon appstore apk file
-How to install superstar jypnation using emulator software
-
-
Open App Store on your device.
-
Search for "superstar jypnation" in the search bar.
-
Select the game from the search results and tap on "Get".
-
Wait for the game to download and install on your device.
-
Open the game and enjoy playing!
-
-
How to Download Superstar Jypnation on PC
-
If you want to play superstar jypnation on your PC, you will need to use an emulator that can run Android apps on your computer. One of the best emulators for this purpose is MuMu Player, which is fast, stable, and easy to use. Here are the steps to download superstar jypnation on PC using MuMu Player:
Install MuMu Player on your PC by following the instructions on the screen.
-
Open MuMu Player and click on the Google Play icon on the home screen.
-
Sign in with your Google account or create a new one.
-
Search for "superstar jypnation" in the Google Play Store and install it.
-
Open the game and enjoy playing!
-
-
Tips and Tricks for Superstar Jypnation
-
Now that you know how to download superstar jypnation on your device, you might want to learn some tips and tricks to improve your gameplay and score higher. Here are some of them:
-
-
Practice makes perfect: The best way to get better at the game is to practice as much as you can. Try to play different songs and levels and learn the patterns and timings of the notes. You can also use the practice mode to replay any part of the song you want.
-
Use headphones or earphones: Playing with headphones or earphones can help you hear the music better and focus on the rhythm. It can also block out any distractions or noises around you.
-
Adjust the speed and sync settings: You can adjust the speed and sync settings of the game to suit your preference and device. The speed setting controls how fast the notes move on the screen. The sync setting controls how well the notes match with the music. You can find these settings in the options menu.
-
Equip and upgrade your cards wisely: You can equip up to five cards for each artist in your deck. You should equip cards that have high attributes and abilities that match with the song you are playing. For example, if the song has more vocal notes, you should equip cards that have high vocal attributes and score up abilities. You should also upgrade your cards regularly to increase their level, stats, rank, and rarity.
-
Use items and rewards: You can use items and rewards to help you play better and get more benefits. For example, you can use headphones to play more songs, diamonds to buy more cards or items, RP to enhance or upgrade your cards, emeralds to buy special items or rewards, etc. You can get these items and rewards by completing missions, achievements, events, or daily login bonuses.
-
-
Conclusion
-
Superstar jypnation is a great game for K-pop fans and rhythm game lovers. It has many features that make it fun and addictive, such as 24 group artists from JYP Entertainment, 270+ songs from different genres and eras, 660+ cards to collect and enhance, and various rankings and competitions to join. You can download superstar jypnation on your Android, iOS, or PC device easily by following our step-by-step guide. You can also use our tips and tricks to improve your gameplay and score higher. So, what are you waiting for? Download superstar jypnation today and enjoy playing with your favorite artists!
-
FAQs
-
Here are some frequently asked questions and answers about superstar jypnation:
-
-
Q: How can I change my profile picture in the game?
-
A: You can change your profile picture in the game by tapping on your profile icon on the top left corner of the screen. Then, tap on "Change Profile" and choose an image from your device or take a photo with your camera.
-
Q: How can I change my nickname in the game?
-
A: You can change your nickname in the game by tapping on your profile icon on the top left corner of the screen. Then, tap on "Change Nickname" and enter a new nickname. You can only change your nickname once for free, so choose wisely.
-
Q: How can I add friends in the game?
-
A: You can add friends in the game by tapping on the friends icon on the bottom right corner of the screen. Then, tap on "Add Friend" and enter their nickname or user code. You can also accept friend requests from other players or send friend requests to players you meet in the game.
-
Q: How can I contact customer service in the game?
-
A: You can contact customer service in the game by tapping on the settings icon on the top right corner of the screen. Then, tap on "Customer Service" and choose a topic that matches your issue or inquiry. You can also send an email to support.superstar.jyp @dalcomsoft.com for more assistance.
-
Q: How can I update the game to the latest version?
-
A: You can update the game to the latest version by visiting the Google Play Store or App Store and checking for updates. You can also turn on the auto-update option in your device settings to update the game automatically. You should always update the game to enjoy the latest features and bug fixes.
- 197e85843d
-
-
\ No newline at end of file
diff --git a/spaces/A666sxr/Genshin_TTS/commons.py b/spaces/A666sxr/Genshin_TTS/commons.py
deleted file mode 100644
index 9ad0444b61cbadaa388619986c2889c707d873ce..0000000000000000000000000000000000000000
--- a/spaces/A666sxr/Genshin_TTS/commons.py
+++ /dev/null
@@ -1,161 +0,0 @@
-import math
-import numpy as np
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-
-def init_weights(m, mean=0.0, std=0.01):
- classname = m.__class__.__name__
- if classname.find("Conv") != -1:
- m.weight.data.normal_(mean, std)
-
-
-def get_padding(kernel_size, dilation=1):
- return int((kernel_size*dilation - dilation)/2)
-
-
-def convert_pad_shape(pad_shape):
- l = pad_shape[::-1]
- pad_shape = [item for sublist in l for item in sublist]
- return pad_shape
-
-
-def intersperse(lst, item):
- result = [item] * (len(lst) * 2 + 1)
- result[1::2] = lst
- return result
-
-
-def kl_divergence(m_p, logs_p, m_q, logs_q):
- """KL(P||Q)"""
- kl = (logs_q - logs_p) - 0.5
- kl += 0.5 * (torch.exp(2. * logs_p) + ((m_p - m_q)**2)) * torch.exp(-2. * logs_q)
- return kl
-
-
-def rand_gumbel(shape):
- """Sample from the Gumbel distribution, protect from overflows."""
- uniform_samples = torch.rand(shape) * 0.99998 + 0.00001
- return -torch.log(-torch.log(uniform_samples))
-
-
-def rand_gumbel_like(x):
- g = rand_gumbel(x.size()).to(dtype=x.dtype, device=x.device)
- return g
-
-
-def slice_segments(x, ids_str, segment_size=4):
- ret = torch.zeros_like(x[:, :, :segment_size])
- for i in range(x.size(0)):
- idx_str = ids_str[i]
- idx_end = idx_str + segment_size
- ret[i] = x[i, :, idx_str:idx_end]
- return ret
-
-
-def rand_slice_segments(x, x_lengths=None, segment_size=4):
- b, d, t = x.size()
- if x_lengths is None:
- x_lengths = t
- ids_str_max = x_lengths - segment_size + 1
- ids_str = (torch.rand([b]).to(device=x.device) * ids_str_max).to(dtype=torch.long)
- ret = slice_segments(x, ids_str, segment_size)
- return ret, ids_str
-
-
-def get_timing_signal_1d(
- length, channels, min_timescale=1.0, max_timescale=1.0e4):
- position = torch.arange(length, dtype=torch.float)
- num_timescales = channels // 2
- log_timescale_increment = (
- math.log(float(max_timescale) / float(min_timescale)) /
- (num_timescales - 1))
- inv_timescales = min_timescale * torch.exp(
- torch.arange(num_timescales, dtype=torch.float) * -log_timescale_increment)
- scaled_time = position.unsqueeze(0) * inv_timescales.unsqueeze(1)
- signal = torch.cat([torch.sin(scaled_time), torch.cos(scaled_time)], 0)
- signal = F.pad(signal, [0, 0, 0, channels % 2])
- signal = signal.view(1, channels, length)
- return signal
-
-
-def add_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4):
- b, channels, length = x.size()
- signal = get_timing_signal_1d(length, channels, min_timescale, max_timescale)
- return x + signal.to(dtype=x.dtype, device=x.device)
-
-
-def cat_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4, axis=1):
- b, channels, length = x.size()
- signal = get_timing_signal_1d(length, channels, min_timescale, max_timescale)
- return torch.cat([x, signal.to(dtype=x.dtype, device=x.device)], axis)
-
-
-def subsequent_mask(length):
- mask = torch.tril(torch.ones(length, length)).unsqueeze(0).unsqueeze(0)
- return mask
-
-
-@torch.jit.script
-def fused_add_tanh_sigmoid_multiply(input_a, input_b, n_channels):
- n_channels_int = n_channels[0]
- in_act = input_a + input_b
- t_act = torch.tanh(in_act[:, :n_channels_int, :])
- s_act = torch.sigmoid(in_act[:, n_channels_int:, :])
- acts = t_act * s_act
- return acts
-
-
-def convert_pad_shape(pad_shape):
- l = pad_shape[::-1]
- pad_shape = [item for sublist in l for item in sublist]
- return pad_shape
-
-
-def shift_1d(x):
- x = F.pad(x, convert_pad_shape([[0, 0], [0, 0], [1, 0]]))[:, :, :-1]
- return x
-
-
-def sequence_mask(length, max_length=None):
- if max_length is None:
- max_length = length.max()
- x = torch.arange(max_length, dtype=length.dtype, device=length.device)
- return x.unsqueeze(0) < length.unsqueeze(1)
-
-
-def generate_path(duration, mask):
- """
- duration: [b, 1, t_x]
- mask: [b, 1, t_y, t_x]
- """
- device = duration.device
-
- b, _, t_y, t_x = mask.shape
- cum_duration = torch.cumsum(duration, -1)
-
- cum_duration_flat = cum_duration.view(b * t_x)
- path = sequence_mask(cum_duration_flat, t_y).to(mask.dtype)
- path = path.view(b, t_x, t_y)
- path = path - F.pad(path, convert_pad_shape([[0, 0], [1, 0], [0, 0]]))[:, :-1]
- path = path.unsqueeze(1).transpose(2,3) * mask
- return path
-
-
-def clip_grad_value_(parameters, clip_value, norm_type=2):
- if isinstance(parameters, torch.Tensor):
- parameters = [parameters]
- parameters = list(filter(lambda p: p.grad is not None, parameters))
- norm_type = float(norm_type)
- if clip_value is not None:
- clip_value = float(clip_value)
-
- total_norm = 0
- for p in parameters:
- param_norm = p.grad.data.norm(norm_type)
- total_norm += param_norm.item() ** norm_type
- if clip_value is not None:
- p.grad.data.clamp_(min=-clip_value, max=clip_value)
- total_norm = total_norm ** (1. / norm_type)
- return total_norm
diff --git a/spaces/AIConsultant/MusicGen/audiocraft/models/musicgen.py b/spaces/AIConsultant/MusicGen/audiocraft/models/musicgen.py
deleted file mode 100644
index 1d4b2292eaec5016e208bbdf61ec5c99b40b67da..0000000000000000000000000000000000000000
--- a/spaces/AIConsultant/MusicGen/audiocraft/models/musicgen.py
+++ /dev/null
@@ -1,409 +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.
-
-"""
-Main model for using MusicGen. This will combine all the required components
-and provide easy access to the generation API.
-"""
-
-import typing as tp
-import warnings
-
-import torch
-
-from .encodec import CompressionModel
-from .lm import LMModel
-from .builders import get_debug_compression_model, get_debug_lm_model
-from .loaders import load_compression_model, load_lm_model
-from ..data.audio_utils import convert_audio
-from ..modules.conditioners import ConditioningAttributes, WavCondition
-from ..utils.autocast import TorchAutocast
-
-
-MelodyList = tp.List[tp.Optional[torch.Tensor]]
-MelodyType = tp.Union[torch.Tensor, MelodyList]
-
-
-# backward compatible names mapping
-_HF_MODEL_CHECKPOINTS_MAP = {
- "small": "GrandaddyShmax/musicgen-small",
- "medium": "GrandaddyShmax/musicgen-medium",
- "large": "GrandaddyShmax/musicgen-large",
- "melody": "GrandaddyShmax/musicgen-melody",
-}
-
-
-class MusicGen:
- """MusicGen main model with convenient generation API.
-
- Args:
- name (str): name of the model.
- compression_model (CompressionModel): Compression model
- used to map audio to invertible discrete representations.
- lm (LMModel): Language model over discrete representations.
- max_duration (float, optional): maximum duration the model can produce,
- otherwise, inferred from the training params.
- """
- def __init__(self, name: str, compression_model: CompressionModel, lm: LMModel,
- max_duration: tp.Optional[float] = None):
- self.name = name
- self.compression_model = compression_model
- self.lm = lm
- if max_duration is None:
- if hasattr(lm, 'cfg'):
- max_duration = lm.cfg.dataset.segment_duration # type: ignore
- else:
- raise ValueError("You must provide max_duration when building directly MusicGen")
- assert max_duration is not None
- self.max_duration: float = max_duration
- self.device = next(iter(lm.parameters())).device
- self.generation_params: dict = {}
- self.set_generation_params(duration=15) # 15 seconds by default
- self._progress_callback: tp.Optional[tp.Callable[[int, int], None]] = None
- if self.device.type == 'cpu':
- self.autocast = TorchAutocast(enabled=False)
- else:
- self.autocast = TorchAutocast(
- enabled=True, device_type=self.device.type, dtype=torch.float16)
-
- @property
- def frame_rate(self) -> float:
- """Roughly the number of AR steps per seconds."""
- return self.compression_model.frame_rate
-
- @property
- def sample_rate(self) -> int:
- """Sample rate of the generated audio."""
- return self.compression_model.sample_rate
-
- @property
- def audio_channels(self) -> int:
- """Audio channels of the generated audio."""
- return self.compression_model.channels
-
- @staticmethod
- def get_pretrained(name: str = 'GrandaddyShmax/musicgen-melody', device=None):
- """Return pretrained model, we provide four models:
- - facebook/musicgen-small (300M), text to music,
- # see: https://huggingface.co/facebook/musicgen-small
- - facebook/musicgen-medium (1.5B), text to music,
- # see: https://huggingface.co/facebook/musicgen-medium
- - facebook/musicgen-melody (1.5B) text to music and text+melody to music,
- # see: https://huggingface.co/facebook/musicgen-melody
- - facebook/musicgen-large (3.3B), text to music,
- # see: https://huggingface.co/facebook/musicgen-large
- """
- if device is None:
- if torch.cuda.device_count():
- device = 'cuda'
- else:
- device = 'cpu'
-
- if name == 'debug':
- # used only for unit tests
- compression_model = get_debug_compression_model(device)
- lm = get_debug_lm_model(device)
- return MusicGen(name, compression_model, lm, max_duration=30)
-
- lm = load_lm_model(name, device=device)
- compression_model = load_compression_model(name, device=device)
- if 'self_wav' in lm.condition_provider.conditioners:
- lm.condition_provider.conditioners['self_wav'].match_len_on_eval = True
-
- return MusicGen(name, compression_model, lm)
-
- def set_generation_params(self, use_sampling: bool = True, top_k: int = 250,
- top_p: float = 0.0, temperature: float = 1.0,
- duration: float = 30.0, cfg_coef: float = 3.0,
- two_step_cfg: bool = False, extend_stride: float = 18):
- """Set the generation parameters for MusicGen.
-
- Args:
- use_sampling (bool, optional): Use sampling if True, else do argmax decoding. Defaults to True.
- top_k (int, optional): top_k used for sampling. Defaults to 250.
- top_p (float, optional): top_p used for sampling, when set to 0 top_k is used. Defaults to 0.0.
- temperature (float, optional): Softmax temperature parameter. Defaults to 1.0.
- duration (float, optional): Duration of the generated waveform. Defaults to 30.0.
- cfg_coef (float, optional): Coefficient used for classifier free guidance. Defaults to 3.0.
- two_step_cfg (bool, optional): If True, performs 2 forward for Classifier Free Guidance,
- instead of batching together the two. This has some impact on how things
- are padded but seems to have little impact in practice.
- extend_stride: when doing extended generation (i.e. more than 30 seconds), by how much
- should we extend the audio each time. Larger values will mean less context is
- preserved, and shorter value will require extra computations.
- """
- assert extend_stride < self.max_duration, "Cannot stride by more than max generation duration."
- self.extend_stride = extend_stride
- self.duration = duration
- self.generation_params = {
- 'use_sampling': use_sampling,
- 'temp': temperature,
- 'top_k': top_k,
- 'top_p': top_p,
- 'cfg_coef': cfg_coef,
- 'two_step_cfg': two_step_cfg,
- }
-
- def set_custom_progress_callback(self, progress_callback: tp.Optional[tp.Callable[[int, int], None]] = None):
- """Override the default progress callback."""
- self._progress_callback = progress_callback
-
- def generate_unconditional(self, num_samples: int, progress: bool = False, return_tokens: bool = False) -> tp.Union[torch.Tensor, tp.Tuple[torch.Tensor, torch.Tensor]]:
- """Generate samples in an unconditional manner.
-
- Args:
- num_samples (int): Number of samples to be generated.
- progress (bool, optional): Flag to display progress of the generation process. Defaults to False.
- """
- descriptions: tp.List[tp.Optional[str]] = [None] * num_samples
- attributes, prompt_tokens = self._prepare_tokens_and_attributes(descriptions, None)
- tokens = self._generate_tokens(attributes, prompt_tokens, progress)
- if return_tokens:
- return self.generate_audio(tokens), tokens
- return self.generate_audio(tokens)
-
- def generate(self, descriptions: tp.List[str], progress: bool = False, return_tokens: bool = False) \
- -> tp.Union[torch.Tensor, tp.Tuple[torch.Tensor, torch.Tensor]]:
- """Generate samples conditioned on text.
-
- Args:
- descriptions (list of str): A list of strings used as text conditioning.
- progress (bool, optional): Flag to display progress of the generation process. Defaults to False.
- """
- attributes, prompt_tokens = self._prepare_tokens_and_attributes(descriptions, None)
- assert prompt_tokens is None
- tokens = self._generate_tokens(attributes, prompt_tokens, progress)
- if return_tokens:
- return self.generate_audio(tokens), tokens
- return self.generate_audio(tokens)
-
- def generate_with_chroma(self, descriptions: tp.List[str], melody_wavs: MelodyType, melody_sample_rate: int, progress: bool = False, return_tokens: bool = False) -> tp.Union[torch.Tensor, tp.Tuple[torch.Tensor, torch.Tensor]]:
- """Generate samples conditioned on text and melody.
-
- Args:
- descriptions (list of str): A list of strings used as text conditioning.
- melody_wavs: (torch.Tensor or list of Tensor): A batch of waveforms used as
- melody conditioning. Should have shape [B, C, T] with B matching the description length,
- C=1 or 2. It can be [C, T] if there is a single description. It can also be
- a list of [C, T] tensors.
- melody_sample_rate: (int): Sample rate of the melody waveforms.
- progress (bool, optional): Flag to display progress of the generation process. Defaults to False.
- """
- if isinstance(melody_wavs, torch.Tensor):
- if melody_wavs.dim() == 2:
- melody_wavs = melody_wavs[None]
- if melody_wavs.dim() != 3:
- raise ValueError("Melody wavs should have a shape [B, C, T].")
- melody_wavs = list(melody_wavs)
- else:
- for melody in melody_wavs:
- if melody is not None:
- assert melody.dim() == 2, "One melody in the list has the wrong number of dims."
-
- melody_wavs = [
- convert_audio(wav, melody_sample_rate, self.sample_rate, self.audio_channels)
- if wav is not None else None
- for wav in melody_wavs]
- attributes, prompt_tokens = self._prepare_tokens_and_attributes(descriptions=descriptions, prompt=None,
- melody_wavs=melody_wavs)
- assert prompt_tokens is None
- tokens = self._generate_tokens(attributes, prompt_tokens, progress)
- if return_tokens:
- return self.generate_audio(tokens), tokens
- return self.generate_audio(tokens)
-
- def generate_continuation(self, prompt: torch.Tensor, prompt_sample_rate: int,
- descriptions: tp.Optional[tp.List[tp.Optional[str]]] = None,
- progress: bool = False, return_tokens: bool = False) \
- -> tp.Union[torch.Tensor, tp.Tuple[torch.Tensor, torch.Tensor]]:
- """Generate samples conditioned on audio prompts.
-
- Args:
- prompt (torch.Tensor): A batch of waveforms used for continuation.
- Prompt should be [B, C, T], or [C, T] if only one sample is generated.
- prompt_sample_rate (int): Sampling rate of the given audio waveforms.
- descriptions (list of str, optional): A list of strings used as text conditioning. Defaults to None.
- progress (bool, optional): Flag to display progress of the generation process. Defaults to False.
- """
- if prompt.dim() == 2:
- prompt = prompt[None]
- if prompt.dim() != 3:
- raise ValueError("prompt should have 3 dimensions: [B, C, T] (C = 1).")
- prompt = convert_audio(prompt, prompt_sample_rate, self.sample_rate, self.audio_channels)
- if descriptions is None:
- descriptions = [None] * len(prompt)
- attributes, prompt_tokens = self._prepare_tokens_and_attributes(descriptions, prompt)
- assert prompt_tokens is not None
- tokens = self._generate_tokens(attributes, prompt_tokens, progress)
- if return_tokens:
- return self.generate_audio(tokens), tokens
- return self.generate_audio(tokens)
-
- @torch.no_grad()
- def _prepare_tokens_and_attributes(
- self,
- descriptions: tp.Sequence[tp.Optional[str]],
- prompt: tp.Optional[torch.Tensor],
- melody_wavs: tp.Optional[MelodyList] = None,
- ) -> tp.Tuple[tp.List[ConditioningAttributes], tp.Optional[torch.Tensor]]:
- """Prepare model inputs.
-
- Args:
- descriptions (list of str): A list of strings used as text conditioning.
- prompt (torch.Tensor): A batch of waveforms used for continuation.
- melody_wavs (torch.Tensor, optional): A batch of waveforms
- used as melody conditioning. Defaults to None.
- """
- attributes = [
- ConditioningAttributes(text={'description': description})
- for description in descriptions]
-
- if melody_wavs is None:
- for attr in attributes:
- attr.wav['self_wav'] = WavCondition(
- torch.zeros((1, 1, 1), device=self.device),
- torch.tensor([0], device=self.device),
- sample_rate=[self.sample_rate],
- path=[None])
- else:
- if 'self_wav' not in self.lm.condition_provider.conditioners:
- raise RuntimeError("This model doesn't support melody conditioning. "
- "Use the `melody` model.")
- assert len(melody_wavs) == len(descriptions), \
- f"number of melody wavs must match number of descriptions! " \
- f"got melody len={len(melody_wavs)}, and descriptions len={len(descriptions)}"
- for attr, melody in zip(attributes, melody_wavs):
- if melody is None:
- attr.wav['self_wav'] = WavCondition(
- torch.zeros((1, 1, 1), device=self.device),
- torch.tensor([0], device=self.device),
- sample_rate=[self.sample_rate],
- path=[None])
- else:
- attr.wav['self_wav'] = WavCondition(
- melody[None].to(device=self.device),
- torch.tensor([melody.shape[-1]], device=self.device),
- sample_rate=[self.sample_rate],
- path=[None],
- )
-
- if prompt is not None:
- if descriptions is not None:
- assert len(descriptions) == len(prompt), "Prompt and nb. descriptions doesn't match"
- prompt = prompt.to(self.device)
- prompt_tokens, scale = self.compression_model.encode(prompt)
- assert scale is None
- else:
- prompt_tokens = None
- return attributes, prompt_tokens
-
- def _generate_tokens(self, attributes: tp.List[ConditioningAttributes],
- prompt_tokens: tp.Optional[torch.Tensor], progress: bool = False) -> torch.Tensor:
- """Generate discrete audio tokens given audio prompt and/or conditions.
-
- Args:
- attributes (list of ConditioningAttributes): Conditions used for generation (text/melody).
- prompt_tokens (torch.Tensor, optional): Audio prompt used for continuation.
- progress (bool, optional): Flag to display progress of the generation process. Defaults to False.
- Returns:
- torch.Tensor: Generated audio, of shape [B, C, T], T is defined by the generation params.
- """
- i = 0
- prompt_list = attributes[0].text['description']
- total_gen_len = int(self.duration * self.frame_rate)
- max_prompt_len = int(min(self.duration, self.max_duration) * self.frame_rate)
- current_gen_offset: int = 0
-
- def _progress_callback(generated_tokens: int, tokens_to_generate: int):
- generated_tokens += current_gen_offset
- if current_gen_offset > 0:
- generated_tokens += (self.max_duration - self.extend_stride) * self.frame_rate
- if self._progress_callback is not None:
- # Note that total_gen_len might be quite wrong depending on the
- # codebook pattern used, but with delay it is almost accurate.
- self._progress_callback(generated_tokens, total_gen_len)
- else:
- print(f'{generated_tokens: 6d} / {total_gen_len: 6d}', end='\r')
-
- if prompt_tokens is not None:
- assert max_prompt_len >= prompt_tokens.shape[-1], \
- "Prompt is longer than audio to generate"
-
- callback = None
- if progress:
- callback = _progress_callback
-
- if self.duration <= self.max_duration:
- # generate by sampling from LM, simple case.
- with self.autocast:
- attributes[0].text['description'] = prompt_list[0]
- gen_tokens = self.lm.generate(
- prompt_tokens, attributes,
- callback=callback, max_gen_len=total_gen_len, **self.generation_params)
-
- else:
- # now this gets a bit messier, we need to handle prompts,
- # melody conditioning etc.
- ref_wavs = [attr.wav['self_wav'] for attr in attributes]
- all_tokens = []
- if prompt_tokens is None:
- prompt_length = 0
- else:
- all_tokens.append(prompt_tokens)
- prompt_length = prompt_tokens.shape[-1]
-
- stride_tokens = int(self.frame_rate * self.extend_stride)
-
- while current_gen_offset + prompt_length < total_gen_len:
- time_offset = current_gen_offset / self.frame_rate
- chunk_duration = min(self.duration - time_offset, self.max_duration)
- max_gen_len = int(chunk_duration * self.frame_rate)
- for attr, ref_wav in zip(attributes, ref_wavs):
- wav_length = ref_wav.length.item()
- if wav_length == 0:
- continue
- # We will extend the wav periodically if it not long enough.
- # we have to do it here rather than in conditioners.py as otherwise
- # we wouldn't have the full wav.
- initial_position = int(time_offset * self.sample_rate)
- wav_target_length = int(self.max_duration * self.sample_rate)
- positions = torch.arange(initial_position,
- initial_position + wav_target_length, device=self.device)
- attr.wav['self_wav'] = WavCondition(
- ref_wav[0][..., positions % wav_length],
- torch.full_like(ref_wav[1], wav_target_length),
- [self.sample_rate] * ref_wav[0].size(0),
- [None], [0.])
- with self.autocast:
- if i >= len(prompt_list):
- i = len(prompt_list) - 1
- attributes[0].text['description'] = prompt_list[i]
- gen_tokens = self.lm.generate(
- prompt_tokens, attributes,
- callback=callback, max_gen_len=max_gen_len, **self.generation_params)
- i = i + 1
- if prompt_tokens is None:
- all_tokens.append(gen_tokens)
- else:
- all_tokens.append(gen_tokens[:, :, prompt_tokens.shape[-1]:])
- prompt_tokens = gen_tokens[:, :, stride_tokens:]
- prompt_length = prompt_tokens.shape[-1]
- current_gen_offset += stride_tokens
-
- gen_tokens = torch.cat(all_tokens, dim=-1)
- return gen_tokens
-
- def generate_audio(self, gen_tokens: torch.Tensor):
- """Generate Audio from tokens"""
- assert gen_tokens.dim() == 3
- with torch.no_grad():
- gen_audio = self.compression_model.decode(gen_tokens, None)
- return gen_audio
-
- def to(self, device: str):
- self.compression_model.to(device)
- self.lm.to(device)
- return self
\ No newline at end of file
diff --git a/spaces/AIGC-Audio/AudioGPT/text_to_audio/Make_An_Audio/ldm/modules/midas/__init__.py b/spaces/AIGC-Audio/AudioGPT/text_to_audio/Make_An_Audio/ldm/modules/midas/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/AILab-CVC/SEED-LLaMA/scripts/seed_tokenizer_inference.py b/spaces/AILab-CVC/SEED-LLaMA/scripts/seed_tokenizer_inference.py
deleted file mode 100644
index 46b757ec327d1ed8108ec8cff9daeb267028750e..0000000000000000000000000000000000000000
--- a/spaces/AILab-CVC/SEED-LLaMA/scripts/seed_tokenizer_inference.py
+++ /dev/null
@@ -1,33 +0,0 @@
-import hydra
-from omegaconf import OmegaConf
-from PIL import Image
-import pyrootutils
-import os
-
-pyrootutils.setup_root(__file__, indicator='.project-root', pythonpath=True)
-
-tokenizer_cfg_path = 'configs/tokenizer/seed_llama_tokenizer.yaml'
-transform_cfg_path = 'configs/transform/clip_transform.yaml'
-
-image_path = 'images/cat.jpg'
-save_dir = './'
-save_path = os.path.join(save_dir, os.path.basename(image_path))
-
-os.makedirs(save_dir, exist_ok=True)
-
-device = 'cuda'
-
-tokenizer_cfg = OmegaConf.load(tokenizer_cfg_path)
-tokenizer = hydra.utils.instantiate(tokenizer_cfg, device=device, load_diffusion=True)
-
-transform_cfg = OmegaConf.load(transform_cfg_path)
-transform = hydra.utils.instantiate(transform_cfg)
-
-image = Image.open(image_path).convert('RGB')
-
-image_tensor = transform(image).to(device)
-image_ids = tokenizer.encode_image(image_torch=image_tensor)
-
-images = tokenizer.decode_image(image_ids)
-
-images[0].save(save_path)
\ No newline at end of file
diff --git a/spaces/AIxPha/Real-CUGAN/README.md b/spaces/AIxPha/Real-CUGAN/README.md
deleted file mode 100644
index d673114edadba73e80f33a3c71bc0dbee8758cc8..0000000000000000000000000000000000000000
--- a/spaces/AIxPha/Real-CUGAN/README.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-title: Real CUGAN
-emoji: 🐢
-colorFrom: gray
-colorTo: green
-sdk: gradio
-sdk_version: 3.6
-app_file: app.py
-pinned: false
-license: gpl-3.0
-duplicated_from: DianXian/Real-CUGAN
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/Aaaaaaaabdualh/topic2poem/README.md b/spaces/Aaaaaaaabdualh/topic2poem/README.md
deleted file mode 100644
index 21782276176ef29031dd0c6c6566c31f11730da0..0000000000000000000000000000000000000000
--- a/spaces/Aaaaaaaabdualh/topic2poem/README.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-title: Topic2poem
-emoji: 💻
-colorFrom: pink
-colorTo: purple
-sdk: gradio
-sdk_version: 3.2
-app_file: app.py
-pinned: false
-license: afl-3.0
-duplicated_from: mareloraby/topic2poem
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/AgentVerse/agentVerse/agentverse/environments/simulation_env/sde_team.py b/spaces/AgentVerse/agentVerse/agentverse/environments/simulation_env/sde_team.py
deleted file mode 100644
index 325c1eac08a8566079e7047411ca76d3e44b7de9..0000000000000000000000000000000000000000
--- a/spaces/AgentVerse/agentVerse/agentverse/environments/simulation_env/sde_team.py
+++ /dev/null
@@ -1,137 +0,0 @@
-import asyncio
-import logging
-from typing import Any, Dict, List
-import json
-
-from agentverse.agents.simulation_agent.conversation import BaseAgent
-
-# from agentverse.environments.simulation_env.rules.base import Rule
-from agentverse.environments.simulation_env.rules.base import SimulationRule as Rule
-from agentverse.message import Message
-
-from .. import env_registry as EnvironmentRegistry
-from ..base import BaseEnvironment
-
-from agentverse.initialization import load_tools
-
-
-@EnvironmentRegistry.register("sde_team")
-class SdeTeamEnvironment(BaseEnvironment):
- """
- A basic environment implementing the logic of conversation to craft code.
-
- Args:
- agents: List of agents
- rule: Rule for the environment
- max_turns: Maximum number of turns
- cnt_turn: Current turn number
- last_messages: Messages from last turn
- rule_params: Variables set by the rule
- """
-
- agents: List[BaseAgent]
- rule: Rule
- max_turns: int = 10
- cnt_turn: int = 0
- last_messages: List[Message] = []
- rule_params: Dict = {}
- task_name: str = "test"
-
- def __init__(self, rule, **kwargs):
- rule_config = rule
- order_config = rule_config.get("order", {"type": "sde_team"})
- visibility_config = rule_config.get("visibility", {"type": "base"})
- selector_config = rule_config.get("selector", {"type": "sde_team"})
- updater_config = rule_config.get("updater", {"type": "sde_team"})
- describer_config = rule_config.get("describer", {"type": "base"})
- rule = Rule(
- order_config,
- visibility_config,
- selector_config,
- updater_config,
- describer_config,
- )
- super().__init__(rule=rule, **kwargs)
- self.rule_params["first_round"] = True
- self.rule_params["end_flag"] = False
-
- # # Test code
- self.rule_params["name_to_tools"] = {
- tool.name: tool
- for tool in load_tools(
- [
- {
- "tool_name": "code_interpreter",
- "tool_url": "http://127.0.0.1:8079/tools/code_interpreter/",
- }
- ]
- )
- }
- tool = self.rule_params["name_to_tools"]["execute_unit_tests"]
- # print(type(tool))
-
- # d = {
- # "func_impl": "def f(x):\n\treturn x + 1",
- # "tests": ["assert f(1) == 2"]
- # }
- # # input_str = json.dumps(d)
- # json.loads(input_str)
- # tool.run(input_str, verbose=True)
- # exit()
-
- async def step(self) -> List[Message]:
- """Run one step of the environment"""
-
- # Get the next agent index
- agent_ids = self.rule.get_next_agent_idx(self) # order
-
- # Generate current environment description
- # env_descriptions = self.rule.get_env_description(self) # describer
-
- # # Generate the next message
- # messages = await asyncio.gather(
- # *[self.agents[i].astep(env_descriptions[i]) for i in agent_ids]
- # ) # call chatgpt api
-
- messages = await asyncio.gather(*[self.agents[i].astep("") for i in agent_ids])
-
- # Track the messages to get the role of the sender
- self.last_messages = messages
-
- # Some rules will select certain messages from all the messages
- selected_messages = self.rule.select_message(self, messages) # selector
- self.last_messages = selected_messages
- self.print_messages(selected_messages)
-
- # Update the memory of the agents
- self.rule.update_memory(self) # updater: update memory
-
- # Update the set of visible agents for each agent
- self.rule.update_visible_agents(self) # change receiver
-
- self.cnt_turn += 1
-
- return selected_messages
-
- def print_messages(self, messages: List[Message]) -> None:
- for message in messages:
- if message is not None:
- logging.info(f"{message.sender}: {message.content}")
-
- def reset(self) -> None:
- """Reset the environment"""
- self.cnt_turn = 0
- self.rule.reset()
- for agent in self.agents:
- agent.reset()
-
- def is_done(self) -> bool:
- """Check if the environment is done"""
- if self.cnt_turn >= self.max_turns or self.rule_params["end_flag"]:
- # with open("record_human_eval.txt", "a") as f:
- # wd = dict()
- # wd['task_id'] = self.task_name
- # wd['code'] = self.rule_params['code']
- # f.write(json.dumps(wd))
- return True
- return False
diff --git a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/plugins/dropdown-plugin.js b/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/plugins/dropdown-plugin.js
deleted file mode 100644
index 58eda7d70194e94de5bb9f3cc827f30d68da4e59..0000000000000000000000000000000000000000
--- a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/plugins/dropdown-plugin.js
+++ /dev/null
@@ -1,18 +0,0 @@
-import DropDown from './behaviors/dropdown/DropDown.js';
-
-class DropDownPlugin extends Phaser.Plugins.BasePlugin {
- constructor(pluginManager) {
- super(pluginManager);
- }
-
- start() {
- var eventEmitter = this.game.events;
- eventEmitter.on('destroy', this.destroy, this);
- }
-
- add(gameObject, config) {
- return new DropDown(gameObject, config);
- }
-}
-
-export default DropDownPlugin;
\ No newline at end of file
diff --git a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/circlemaskimage/CircleMaskImage.d.ts b/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/circlemaskimage/CircleMaskImage.d.ts
deleted file mode 100644
index bb69ef4fe2799c2489d4206c1e992b1d5712e4c2..0000000000000000000000000000000000000000
--- a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/circlemaskimage/CircleMaskImage.d.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-import CircleMaskImage from '../../../plugins/circlemaskimage';
-export default CircleMaskImage;
\ No newline at end of file
diff --git a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/colorinput/colorinputbase/Factory.js b/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/colorinput/colorinputbase/Factory.js
deleted file mode 100644
index d81af7fa2efcb971a7a4473a2f82e1c1010832e9..0000000000000000000000000000000000000000
--- a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/colorinput/colorinputbase/Factory.js
+++ /dev/null
@@ -1,13 +0,0 @@
-import ColorInputBase from './ColorInputBase.js';
-import ObjectFactory from '../../ObjectFactory.js';
-import SetValue from '../../../../plugins/utils/object/SetValue.js';
-
-ObjectFactory.register('colorInputLite', function (config) {
- var gameObject = new ColorInputBase(this.scene, config);
- this.scene.add.existing(gameObject);
- return gameObject;
-});
-
-SetValue(window, 'RexPlugins.UI.ColorInputBase', ColorInputBase);
-
-export default ColorInputBase;
\ No newline at end of file
diff --git a/spaces/Amrrs/DragGan-Inversion/stylegan_human/alignment.py b/spaces/Amrrs/DragGan-Inversion/stylegan_human/alignment.py
deleted file mode 100644
index 46f58c79061ed8030562300f131f97f04e5ea42f..0000000000000000000000000000000000000000
--- a/spaces/Amrrs/DragGan-Inversion/stylegan_human/alignment.py
+++ /dev/null
@@ -1,233 +0,0 @@
-# Copyright (c) SenseTime Research. All rights reserved.
-
-
-import os
-import argparse
-import numpy as np
-import torch
-from torch.utils.data import DataLoader
-from torchvision.transforms import transforms
-from utils.ImagesDataset import ImagesDataset
-
-import cv2
-import time
-import copy
-import imutils
-
-# for openpose body keypoint detector : # (src:https://github.com/Hzzone/pytorch-openpose)
-from openpose.src import util
-from openpose.src.body import Body
-
-# for paddlepaddle human segmentation : #(src: https://github.com/PaddlePaddle/PaddleSeg/blob/release/2.5/contrib/PP-HumanSeg/)
-from PP_HumanSeg.deploy.infer import Predictor as PP_HumenSeg_Predictor
-
-import math
-
-
-def angle_between_points(p0, p1, p2):
- if p0[1] == -1 or p1[1] == -1 or p2[1] == -1:
- return -1
- a = (p1[0]-p0[0])**2 + (p1[1]-p0[1])**2
- b = (p1[0]-p2[0])**2 + (p1[1]-p2[1])**2
- c = (p2[0]-p0[0])**2 + (p2[1]-p0[1])**2
- if a * b == 0:
- return -1
- return math.acos((a+b-c) / math.sqrt(4*a*b)) * 180 / math.pi
-
-
-def crop_img_with_padding(img, keypoints, rect):
- person_xmin, person_xmax, ymin, ymax = rect
- img_h, img_w, _ = img.shape # find body center using keypoints
- middle_shoulder_x = keypoints[1][0]
- middle_hip_x = (keypoints[8][0] + keypoints[11][0]) // 2
- mid_x = (middle_hip_x + middle_shoulder_x) // 2
- mid_y = (ymin + ymax) // 2
- # find which side (l or r) is further than center x, use the further side
- if abs(mid_x-person_xmin) > abs(person_xmax-mid_x): # left further
- xmin = person_xmin
- xmax = mid_x + (mid_x-person_xmin)
- else:
- # may be negtive
- # in this case, the script won't output any image, leave the case like this
- # since we don't want to pad human body
- xmin = mid_x - (person_xmax-mid_x)
- xmax = person_xmax
-
- w = xmax - xmin
- h = ymax - ymin
- # pad rectangle to w:h = 1:2 ## calculate desired border length
- if h / w >= 2: # pad horizontally
- target_w = h // 2
- xmin_prime = int(mid_x - target_w / 2)
- xmax_prime = int(mid_x + target_w / 2)
- if xmin_prime < 0:
- pad_left = abs(xmin_prime) # - xmin
- xmin = 0
- else:
- pad_left = 0
- xmin = xmin_prime
- if xmax_prime > img_w:
- pad_right = xmax_prime - img_w
- xmax = img_w
- else:
- pad_right = 0
- xmax = xmax_prime
-
- cropped_img = img[int(ymin):int(ymax), int(xmin):int(xmax)]
- im_pad = cv2.copyMakeBorder(cropped_img, 0, 0, int(
- pad_left), int(pad_right), cv2.BORDER_REPLICATE)
- else: # pad vertically
- target_h = w * 2
- ymin_prime = mid_y - (target_h / 2)
- ymax_prime = mid_y + (target_h / 2)
- if ymin_prime < 0:
- pad_up = abs(ymin_prime) # - ymin
- ymin = 0
- else:
- pad_up = 0
- ymin = ymin_prime
- if ymax_prime > img_h:
- pad_down = ymax_prime - img_h
- ymax = img_h
- else:
- pad_down = 0
- ymax = ymax_prime
- print(ymin, ymax, xmin, xmax, img.shape)
-
- cropped_img = img[int(ymin):int(ymax), int(xmin):int(xmax)]
- im_pad = cv2.copyMakeBorder(cropped_img, int(pad_up), int(pad_down), 0,
- 0, cv2.BORDER_REPLICATE)
- result = cv2.resize(im_pad, (512, 1024), interpolation=cv2.INTER_AREA)
- return result
-
-
-def run(args):
- os.makedirs(args.output_folder, exist_ok=True)
- dataset = ImagesDataset(
- args.image_folder, transforms.Compose([transforms.ToTensor()]))
- dataloader = DataLoader(dataset, batch_size=1, shuffle=False)
-
- body_estimation = Body('openpose/model/body_pose_model.pth')
-
- total = len(dataloader)
- print('Num of dataloader : ', total)
- os.makedirs(f'{args.output_folder}', exist_ok=True)
- # os.makedirs(f'{args.output_folder}/middle_result', exist_ok=True)
-
- # initialzide HumenSeg
- human_seg_args = {}
- human_seg_args['cfg'] = 'PP_HumanSeg/export_model/deeplabv3p_resnet50_os8_humanseg_512x512_100k_with_softmax/deploy.yaml'
- human_seg_args['input_shape'] = [1024, 512]
- human_seg_args['save_dir'] = args.output_folder
- human_seg_args['soft_predict'] = False
- human_seg_args['use_gpu'] = True
- human_seg_args['test_speed'] = False
- human_seg_args['use_optic_flow'] = False
- human_seg_args['add_argmax'] = True
- human_seg_args = argparse.Namespace(**human_seg_args)
- human_seg = PP_HumenSeg_Predictor(human_seg_args)
-
- from tqdm import tqdm
- for fname, image in tqdm(dataloader):
- # try:
- # tensor to numpy image
- fname = fname[0]
- print(f'Processing \'{fname}\'.')
-
- image = (image.permute(0, 2, 3, 1) * 255).clamp(0, 255)
- image = image.squeeze(0).numpy() # --> tensor to numpy, (H,W,C)
- # avoid super high res img
- if image.shape[0] >= 2000: # height ### for shein image
- ratio = image.shape[0]/1200 # height
- dim = (int(image.shape[1]/ratio), 1200) # (width, height)
- image = cv2.resize(image, dim, interpolation=cv2.INTER_AREA)
- image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
-
- # create segmentation
- # mybg = cv2.imread('mybg.png')
- comb, segmentation, bg, ori_img = human_seg.run(image, None) # mybg)
- # cv2.imwrite('comb.png',comb) # [0,255]
- # cv2.imwrite('alpha.png',segmentation*255) # segmentation [0,1] --> [0.255]
- # cv2.imwrite('bg.png',bg) #[0,255]
- # cv2.imwrite('ori_img.png',ori_img) # [0,255]
-
- masks_np = (segmentation * 255) # .byte().cpu().numpy() #1024,512,1
- mask0_np = masks_np[:, :, 0].astype(np.uint8) # [0, :, :]
- contours = cv2.findContours(
- mask0_np, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
- cnts = imutils.grab_contours(contours)
- c = max(cnts, key=cv2.contourArea)
- extTop = tuple(c[c[:, :, 1].argmin()][0])
- extBot = tuple(c[c[:, :, 1].argmax()][0])
- extBot = list(extBot)
- extTop = list(extTop)
- pad_range = int((extBot[1]-extTop[1])*0.05)
- # seg mask already reaches to the edge
- if (int(extTop[1]) <= 5 and int(extTop[1]) > 0) and (comb.shape[0] > int(extBot[1]) and int(extBot[1]) >= comb.shape[0]-5):
- # pad with pure white, top 100 px, bottom 100 px
- comb = cv2.copyMakeBorder(
- comb, pad_range+5, pad_range+5, 0, 0, cv2.BORDER_CONSTANT, value=[255, 255, 255])
- elif int(extTop[1]) <= 0 or int(extBot[1]) >= comb.shape[0]:
- print('PAD: body out of boundary', fname) # should not happened
- return {}
- else:
- # 105 instead of 100: give some extra space
- comb = cv2.copyMakeBorder(
- comb, pad_range+5, pad_range+5, 0, 0, cv2.BORDER_REPLICATE)
- extBot[1] = extBot[1] + pad_range+5
- extTop[1] = extTop[1] + pad_range+5
-
- extLeft = tuple(c[c[:, :, 0].argmin()][0])
- extRight = tuple(c[c[:, :, 0].argmax()][0])
- extLeft = list(extLeft)
- extRight = list(extRight)
- person_ymin = int(extTop[1])-pad_range # 100
- person_ymax = int(extBot[1])+pad_range # 100 #height
- if person_ymin < 0 or person_ymax > comb.shape[0]: # out of range
- return {}
- person_xmin = int(extLeft[0])
- person_xmax = int(extRight[0])
- rect = [person_xmin, person_xmax, person_ymin, person_ymax]
- # recimg = copy.deepcopy(comb)
- # cv2.rectangle(recimg,(person_xmin,person_ymin),(person_xmax,person_ymax),(0,255,0),2)
- # cv2.imwrite(f'{args.output_folder}/middle_result/{fname}_rec.png',recimg)
-
- # detect keypoints
- keypoints, subset = body_estimation(comb)
- # print(keypoints, subset, len(subset))
- if len(subset) != 1 or (len(subset) == 1 and subset[0][-1] < 15):
- print(
- f'Processing \'{fname}\'. Please import image contains one person only. Also can check segmentation mask. ')
- continue
-
- # canvas = copy.deepcopy(comb)
- # canvas = util.draw_bodypose(canvas, keypoints, subset, show_number=True)
- # cv2.imwrite(f'{args.output_folder}/middle_result/{fname}_keypoints.png',canvas)
-
- comb = crop_img_with_padding(comb, keypoints, rect)
-
- cv2.imwrite(f'{args.output_folder}/{fname}.png', comb)
- print(f' -- Finished processing \'{fname}\'. --')
- # except:
- # print(f'Processing \'{fname}\'. Not satisfied the alignment strategy.')
-
-
-if __name__ == '__main__':
- torch.backends.cudnn.benchmark = True
- torch.backends.cudnn.deterministic = False
-
- t1 = time.time()
- arg_formatter = argparse.ArgumentDefaultsHelpFormatter
- description = 'StyleGAN-Human data process'
- parser = argparse.ArgumentParser(formatter_class=arg_formatter,
- description=description)
- parser.add_argument('--image-folder', type=str, dest='image_folder')
- parser.add_argument('--output-folder',
- dest='output_folder', default='results', type=str)
- # parser.add_argument('--cfg', dest='cfg for segmentation', default='PP_HumanSeg/export_model/ppseg_lite_portrait_398x224_with_softmax/deploy.yaml', type=str)
-
- print('parsing arguments')
- cmd_args = parser.parse_args()
- run(cmd_args)
-
- print('total time elapsed: ', str(time.time() - t1))
diff --git a/spaces/Amrrs/DragGan-Inversion/stylegan_human/torch_utils/ops/__init__.py b/spaces/Amrrs/DragGan-Inversion/stylegan_human/torch_utils/ops/__init__.py
deleted file mode 100644
index 55929854a284626862af6666d3d981e83ad486fa..0000000000000000000000000000000000000000
--- a/spaces/Amrrs/DragGan-Inversion/stylegan_human/torch_utils/ops/__init__.py
+++ /dev/null
@@ -1,3 +0,0 @@
-# Copyright (c) SenseTime Research. All rights reserved.
-
-# empty
diff --git a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/commands/__init__.py b/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/commands/__init__.py
deleted file mode 100644
index 4ad4af9199bbe297dbc6679fd9ecb46baa976053..0000000000000000000000000000000000000000
--- a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/commands/__init__.py
+++ /dev/null
@@ -1,27 +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 abc import ABC, abstractmethod
-from argparse import ArgumentParser
-
-
-class BaseDiffusersCLICommand(ABC):
- @staticmethod
- @abstractmethod
- def register_subcommand(parser: ArgumentParser):
- raise NotImplementedError()
-
- @abstractmethod
- def run(self):
- raise NotImplementedError()
diff --git a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/tests/others/test_ema.py b/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/tests/others/test_ema.py
deleted file mode 100644
index 32f7ae8a9a8e02abb60c59d54873015a443aa53b..0000000000000000000000000000000000000000
--- a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/tests/others/test_ema.py
+++ /dev/null
@@ -1,159 +0,0 @@
-# coding=utf-8
-# Copyright 2023 HuggingFace Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import tempfile
-import unittest
-
-import torch
-
-from diffusers import UNet2DConditionModel
-from diffusers.training_utils import EMAModel
-from diffusers.utils.testing_utils import enable_full_determinism, skip_mps, torch_device
-
-
-enable_full_determinism()
-
-
-class EMAModelTests(unittest.TestCase):
- model_id = "hf-internal-testing/tiny-stable-diffusion-pipe"
- batch_size = 1
- prompt_length = 77
- text_encoder_hidden_dim = 32
- num_in_channels = 4
- latent_height = latent_width = 64
- generator = torch.manual_seed(0)
-
- def get_models(self, decay=0.9999):
- unet = UNet2DConditionModel.from_pretrained(self.model_id, subfolder="unet")
- unet = unet.to(torch_device)
- ema_unet = EMAModel(unet.parameters(), decay=decay, model_cls=UNet2DConditionModel, model_config=unet.config)
- return unet, ema_unet
-
- def get_dummy_inputs(self):
- noisy_latents = torch.randn(
- self.batch_size, self.num_in_channels, self.latent_height, self.latent_width, generator=self.generator
- ).to(torch_device)
- timesteps = torch.randint(0, 1000, size=(self.batch_size,), generator=self.generator).to(torch_device)
- encoder_hidden_states = torch.randn(
- self.batch_size, self.prompt_length, self.text_encoder_hidden_dim, generator=self.generator
- ).to(torch_device)
- return noisy_latents, timesteps, encoder_hidden_states
-
- def simulate_backprop(self, unet):
- updated_state_dict = {}
- for k, param in unet.state_dict().items():
- updated_param = torch.randn_like(param) + (param * torch.randn_like(param))
- updated_state_dict.update({k: updated_param})
- unet.load_state_dict(updated_state_dict)
- return unet
-
- def test_optimization_steps_updated(self):
- unet, ema_unet = self.get_models()
- # Take the first (hypothetical) EMA step.
- ema_unet.step(unet.parameters())
- assert ema_unet.optimization_step == 1
-
- # Take two more.
- for _ in range(2):
- ema_unet.step(unet.parameters())
- assert ema_unet.optimization_step == 3
-
- def test_shadow_params_not_updated(self):
- unet, ema_unet = self.get_models()
- # Since the `unet` is not being updated (i.e., backprop'd)
- # there won't be any difference between the `params` of `unet`
- # and `ema_unet` even if we call `ema_unet.step(unet.parameters())`.
- ema_unet.step(unet.parameters())
- orig_params = list(unet.parameters())
- for s_param, param in zip(ema_unet.shadow_params, orig_params):
- assert torch.allclose(s_param, param)
-
- # The above holds true even if we call `ema.step()` multiple times since
- # `unet` params are still not being updated.
- for _ in range(4):
- ema_unet.step(unet.parameters())
- for s_param, param in zip(ema_unet.shadow_params, orig_params):
- assert torch.allclose(s_param, param)
-
- def test_shadow_params_updated(self):
- unet, ema_unet = self.get_models()
- # Here we simulate the parameter updates for `unet`. Since there might
- # be some parameters which are initialized to zero we take extra care to
- # initialize their values to something non-zero before the multiplication.
- unet_pseudo_updated_step_one = self.simulate_backprop(unet)
-
- # Take the EMA step.
- ema_unet.step(unet_pseudo_updated_step_one.parameters())
-
- # Now the EMA'd parameters won't be equal to the original model parameters.
- orig_params = list(unet_pseudo_updated_step_one.parameters())
- for s_param, param in zip(ema_unet.shadow_params, orig_params):
- assert ~torch.allclose(s_param, param)
-
- # Ensure this is the case when we take multiple EMA steps.
- for _ in range(4):
- ema_unet.step(unet.parameters())
- for s_param, param in zip(ema_unet.shadow_params, orig_params):
- assert ~torch.allclose(s_param, param)
-
- def test_consecutive_shadow_params_updated(self):
- # If we call EMA step after a backpropagation consecutively for two times,
- # the shadow params from those two steps should be different.
- unet, ema_unet = self.get_models()
-
- # First backprop + EMA
- unet_step_one = self.simulate_backprop(unet)
- ema_unet.step(unet_step_one.parameters())
- step_one_shadow_params = ema_unet.shadow_params
-
- # Second backprop + EMA
- unet_step_two = self.simulate_backprop(unet_step_one)
- ema_unet.step(unet_step_two.parameters())
- step_two_shadow_params = ema_unet.shadow_params
-
- for step_one, step_two in zip(step_one_shadow_params, step_two_shadow_params):
- assert ~torch.allclose(step_one, step_two)
-
- def test_zero_decay(self):
- # If there's no decay even if there are backprops, EMA steps
- # won't take any effect i.e., the shadow params would remain the
- # same.
- unet, ema_unet = self.get_models(decay=0.0)
- unet_step_one = self.simulate_backprop(unet)
- ema_unet.step(unet_step_one.parameters())
- step_one_shadow_params = ema_unet.shadow_params
-
- unet_step_two = self.simulate_backprop(unet_step_one)
- ema_unet.step(unet_step_two.parameters())
- step_two_shadow_params = ema_unet.shadow_params
-
- for step_one, step_two in zip(step_one_shadow_params, step_two_shadow_params):
- assert torch.allclose(step_one, step_two)
-
- @skip_mps
- def test_serialization(self):
- unet, ema_unet = self.get_models()
- noisy_latents, timesteps, encoder_hidden_states = self.get_dummy_inputs()
-
- with tempfile.TemporaryDirectory() as tmpdir:
- ema_unet.save_pretrained(tmpdir)
- loaded_unet = UNet2DConditionModel.from_pretrained(tmpdir, model_cls=UNet2DConditionModel)
- loaded_unet = loaded_unet.to(unet.device)
-
- # Since no EMA step has been performed the outputs should match.
- output = unet(noisy_latents, timesteps, encoder_hidden_states).sample
- output_loaded = loaded_unet(noisy_latents, timesteps, encoder_hidden_states).sample
-
- assert torch.allclose(output, output_loaded, atol=1e-4)
diff --git a/spaces/AndyCer/TheBloke-stable-vicuna-13B-HF/app.py b/spaces/AndyCer/TheBloke-stable-vicuna-13B-HF/app.py
deleted file mode 100644
index 7239a6282fcebda631c725b867b40980d06b0a1d..0000000000000000000000000000000000000000
--- a/spaces/AndyCer/TheBloke-stable-vicuna-13B-HF/app.py
+++ /dev/null
@@ -1,3 +0,0 @@
-import gradio as gr
-
-gr.Interface.load("models/TheBloke/stable-vicuna-13B-HF").launch()
\ No newline at end of file
diff --git a/spaces/Anthony7906/MengHuiMXD_GPT/readme/README_en.md b/spaces/Anthony7906/MengHuiMXD_GPT/readme/README_en.md
deleted file mode 100644
index a906ecb3ebc411f5cdeb33d661266a489a20c3b0..0000000000000000000000000000000000000000
--- a/spaces/Anthony7906/MengHuiMXD_GPT/readme/README_en.md
+++ /dev/null
@@ -1,127 +0,0 @@
-
- Streaming / Unlimited conversations / Save history / Preset prompts / Chat with files / Web search
- LaTeX rendering / Table rendering / Code highlighting
- Auto dark mode / Adaptive web interface / WeChat-like theme
- Multi-parameters tuning / Multi-API-Key support / Multi-user support
- Compatible with GPT-4 / Local deployment for LLMs
-
-
-## Usage Tips
-
-- To better control the ChatGPT, use System Prompt.
-- To use a Prompt Template, select the Prompt Template Collection file first, and then choose certain prompt from the drop-down menu.
-- To try again if the response is unsatisfactory, use `🔄 Regenerate` button.
-- To start a new line in the input box, press Shift + Enter keys.
-- To quickly switch between input history, press ↑ and ↓ key in the input box.
-- To deploy the program onto a server, change the last line of the program to `demo.launch(server_name="0.0.0.0", server_port=)`.
-- To get a public shared link, change the last line of the program to `demo.launch(share=True)`. Please be noted that the program must be running in order to be accessed via a public link.
-- To use it in Hugging Face Spaces: It is recommended to **Duplicate Space** and run the program in your own Space for a faster and more secure experience.
-
-## Installation
-
-```shell
-git clone https://github.com/GaiZhenbiao/ChuanhuChatGPT.git
-cd ChuanhuChatGPT
-pip install -r requirements.txt
-```
-
-Then make a copy of `config_example.json`, rename it to `config.json`, and then fill in your API-Key and other settings in the file.
-
-```shell
-python ChuanhuChatbot.py
-```
-
-A browser window will open and you will be able to chat with ChatGPT.
-
-> **Note**
->
-> Please check our [wiki page](https://github.com/GaiZhenbiao/ChuanhuChatGPT/wiki/使用教程) for detailed instructions.
-
-## Troubleshooting
-
-When you encounter problems, you should try manually pulling the latest changes of this project first. The steps are as follows:
-
-1. Download the latest code archive by clicking on `Download ZIP` on the webpage, or
- ```shell
- git pull https://github.com/GaiZhenbiao/ChuanhuChatGPT.git main -f
- ```
-2. Try installing the dependencies again (as this project may have introduced new dependencies)
- ```
- pip install -r requirements.txt
- ```
-3. Update Gradio
- ```
- pip install gradio --upgrade --force-reinstall
- ```
-
-Generally, you can solve most problems by following these steps.
-
-If the problem still exists, please refer to this page: [Frequently Asked Questions (FAQ)](https://github.com/GaiZhenbiao/ChuanhuChatGPT/wiki/常见问题)
-
-This page lists almost all the possible problems and solutions. Please read it carefully.
-
-## More Information
-
-More information could be found in our [wiki](https://github.com/GaiZhenbiao/ChuanhuChatGPT/wiki):
-
-- [How to contribute a translation](https://github.com/GaiZhenbiao/ChuanhuChatGPT/wiki/Localization)
-- [How to make a contribution](https://github.com/GaiZhenbiao/ChuanhuChatGPT/wiki/贡献指南)
-- [How to cite the project](https://github.com/GaiZhenbiao/ChuanhuChatGPT/wiki/使用许可#如何引用该项目)
-- [Project changelog](https://github.com/GaiZhenbiao/ChuanhuChatGPT/wiki/更新日志)
-- [Project license](https://github.com/GaiZhenbiao/ChuanhuChatGPT/wiki/使用许可)
-
-## Starchart
-
-[](https://star-history.com/#GaiZhenbiao/ChuanhuChatGPT&Date)
-
-## Contributors
-
-
-
-
-
-## Sponsor
-
-🐯 If you find this project helpful, feel free to buy me a coke or a cup of coffee~
-
-
-
-
diff --git a/spaces/AriaMei/TTSdemo/losses.py b/spaces/AriaMei/TTSdemo/losses.py
deleted file mode 100644
index fb22a0e834dd87edaa37bb8190eee2c3c7abe0d5..0000000000000000000000000000000000000000
--- a/spaces/AriaMei/TTSdemo/losses.py
+++ /dev/null
@@ -1,61 +0,0 @@
-import torch
-from torch.nn import functional as F
-
-import commons
-
-
-def feature_loss(fmap_r, fmap_g):
- loss = 0
- for dr, dg in zip(fmap_r, fmap_g):
- for rl, gl in zip(dr, dg):
- rl = rl.float().detach()
- gl = gl.float()
- loss += torch.mean(torch.abs(rl - gl))
-
- return loss * 2
-
-
-def discriminator_loss(disc_real_outputs, disc_generated_outputs):
- loss = 0
- r_losses = []
- g_losses = []
- for dr, dg in zip(disc_real_outputs, disc_generated_outputs):
- dr = dr.float()
- dg = dg.float()
- r_loss = torch.mean((1-dr)**2)
- g_loss = torch.mean(dg**2)
- loss += (r_loss + g_loss)
- r_losses.append(r_loss.item())
- g_losses.append(g_loss.item())
-
- return loss, r_losses, g_losses
-
-
-def generator_loss(disc_outputs):
- loss = 0
- gen_losses = []
- for dg in disc_outputs:
- dg = dg.float()
- l = torch.mean((1-dg)**2)
- gen_losses.append(l)
- loss += l
-
- return loss, gen_losses
-
-
-def kl_loss(z_p, logs_q, m_p, logs_p, z_mask):
- """
- z_p, logs_q: [b, h, t_t]
- m_p, logs_p: [b, h, t_t]
- """
- z_p = z_p.float()
- logs_q = logs_q.float()
- m_p = m_p.float()
- logs_p = logs_p.float()
- z_mask = z_mask.float()
-
- kl = logs_p - logs_q - 0.5
- kl += 0.5 * ((z_p - m_p)**2) * torch.exp(-2. * logs_p)
- kl = torch.sum(kl * z_mask)
- l = kl / torch.sum(z_mask)
- return l
diff --git a/spaces/Awiny/Image2Paragraph/models/grit_src/grit/modeling/backbone/utils.py b/spaces/Awiny/Image2Paragraph/models/grit_src/grit/modeling/backbone/utils.py
deleted file mode 100644
index e71db21f1223c87cceeb422a70888f7bac42bb18..0000000000000000000000000000000000000000
--- a/spaces/Awiny/Image2Paragraph/models/grit_src/grit/modeling/backbone/utils.py
+++ /dev/null
@@ -1,186 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-# This code is from https://github.com/facebookresearch/detectron2/blob/main/detectron2/modeling/backbone/utils.py
-import math
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-__all__ = [
- "window_partition",
- "window_unpartition",
- "add_decomposed_rel_pos",
- "get_abs_pos",
- "PatchEmbed",
-]
-
-def window_partition(x, window_size):
- """
- Partition into non-overlapping windows with padding if needed.
- Args:
- x (tensor): input tokens with [B, H, W, C].
- window_size (int): window size.
-
- Returns:
- windows: windows after partition with [B * num_windows, window_size, window_size, C].
- (Hp, Wp): padded height and width before partition
- """
- B, H, W, C = x.shape
-
- pad_h = (window_size - H % window_size) % window_size
- pad_w = (window_size - W % window_size) % window_size
- if pad_h > 0 or pad_w > 0:
- x = F.pad(x, (0, 0, 0, pad_w, 0, pad_h))
- Hp, Wp = H + pad_h, W + pad_w
-
- x = x.view(B, Hp // window_size, window_size, Wp // window_size, window_size, C)
- windows = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, C)
- return windows, (Hp, Wp)
-
-
-def window_unpartition(windows, window_size, pad_hw, hw):
- """
- Window unpartition into original sequences and removing padding.
- Args:
- x (tensor): input tokens with [B * num_windows, window_size, window_size, C].
- window_size (int): window size.
- pad_hw (Tuple): padded height and width (Hp, Wp).
- hw (Tuple): original height and width (H, W) before padding.
-
- Returns:
- x: unpartitioned sequences with [B, H, W, C].
- """
- Hp, Wp = pad_hw
- H, W = hw
- B = windows.shape[0] // (Hp * Wp // window_size // window_size)
- x = windows.view(B, Hp // window_size, Wp // window_size, window_size, window_size, -1)
- x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, Hp, Wp, -1)
-
- if Hp > H or Wp > W:
- x = x[:, :H, :W, :].contiguous()
- return x
-
-
-def get_rel_pos(q_size, k_size, rel_pos):
- """
- Get relative positional embeddings according to the relative positions of
- query and key sizes.
- Args:
- q_size (int): size of query q.
- k_size (int): size of key k.
- rel_pos (Tensor): relative position embeddings (L, C).
-
- Returns:
- Extracted positional embeddings according to relative positions.
- """
- max_rel_dist = int(2 * max(q_size, k_size) - 1)
- # Interpolate rel pos if needed.
- if rel_pos.shape[0] != max_rel_dist:
- # Interpolate rel pos.
- rel_pos_resized = F.interpolate(
- rel_pos.reshape(1, rel_pos.shape[0], -1).permute(0, 2, 1),
- size=max_rel_dist,
- mode="linear",
- )
- rel_pos_resized = rel_pos_resized.reshape(-1, max_rel_dist).permute(1, 0)
- else:
- rel_pos_resized = rel_pos
-
- # Scale the coords with short length if shapes for q and k are different.
- q_coords = torch.arange(q_size)[:, None] * max(k_size / q_size, 1.0)
- k_coords = torch.arange(k_size)[None, :] * max(q_size / k_size, 1.0)
- relative_coords = (q_coords - k_coords) + (k_size - 1) * max(q_size / k_size, 1.0)
-
- return rel_pos_resized[relative_coords.long()]
-
-
-def add_decomposed_rel_pos(attn, q, rel_pos_h, rel_pos_w, q_size, k_size):
- """
- Calculate decomposed Relative Positional Embeddings from :paper:`mvitv2`.
- https://github.com/facebookresearch/mvit/blob/19786631e330df9f3622e5402b4a419a263a2c80/mvit/models/attention.py # noqa B950
- Args:
- attn (Tensor): attention map.
- q (Tensor): query q in the attention layer with shape (B, q_h * q_w, C).
- rel_pos_h (Tensor): relative position embeddings (Lh, C) for height axis.
- rel_pos_w (Tensor): relative position embeddings (Lw, C) for width axis.
- q_size (Tuple): spatial sequence size of query q with (q_h, q_w).
- k_size (Tuple): spatial sequence size of key k with (k_h, k_w).
-
- Returns:
- attn (Tensor): attention map with added relative positional embeddings.
- """
- q_h, q_w = q_size
- k_h, k_w = k_size
- Rh = get_rel_pos(q_h, k_h, rel_pos_h)
- Rw = get_rel_pos(q_w, k_w, rel_pos_w)
-
- B, _, dim = q.shape
- r_q = q.reshape(B, q_h, q_w, dim)
- rel_h = torch.einsum("bhwc,hkc->bhwk", r_q, Rh)
- rel_w = torch.einsum("bhwc,wkc->bhwk", r_q, Rw)
-
- attn = (
- attn.view(B, q_h, q_w, k_h, k_w) + rel_h[:, :, :, :, None] + rel_w[:, :, :, None, :]
- ).view(B, q_h * q_w, k_h * k_w)
-
- return attn
-
-
-def get_abs_pos(abs_pos, has_cls_token, hw):
- """
- Calculate absolute positional embeddings. If needed, resize embeddings and remove cls_token
- dimension for the original embeddings.
- Args:
- abs_pos (Tensor): absolute positional embeddings with (1, num_position, C).
- has_cls_token (bool): If true, has 1 embedding in abs_pos for cls token.
- hw (Tuple): size of input image tokens.
-
- Returns:
- Absolute positional embeddings after processing with shape (1, H, W, C)
- """
- h, w = hw
- if has_cls_token:
- abs_pos = abs_pos[:, 1:]
- xy_num = abs_pos.shape[1]
- size = int(math.sqrt(xy_num))
- assert size * size == xy_num
-
- if size != h or size != w:
- new_abs_pos = F.interpolate(
- abs_pos.reshape(1, size, size, -1).permute(0, 3, 1, 2),
- size=(h, w),
- mode="bicubic",
- align_corners=False,
- )
-
- return new_abs_pos.permute(0, 2, 3, 1)
- else:
- return abs_pos.reshape(1, h, w, -1)
-
-
-class PatchEmbed(nn.Module):
- """
- Image to Patch Embedding.
- """
-
- def __init__(
- self, kernel_size=(16, 16), stride=(16, 16), padding=(0, 0), in_chans=3, embed_dim=768
- ):
- """
- Args:
- kernel_size (Tuple): kernel size of the projection layer.
- stride (Tuple): stride of the projection layer.
- padding (Tuple): padding size of the projection layer.
- in_chans (int): Number of input image channels.
- embed_dim (int): embed_dim (int): Patch embedding dimension.
- """
- super().__init__()
-
- self.proj = nn.Conv2d(
- in_chans, embed_dim, kernel_size=kernel_size, stride=stride, padding=padding
- )
-
- def forward(self, x):
- x = self.proj(x)
- # B C H W -> B H W C
- x = x.permute(0, 2, 3, 1)
- return x
diff --git a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/configs/COCO-Detection/fcos_R_50_FPN_1x.py b/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/configs/COCO-Detection/fcos_R_50_FPN_1x.py
deleted file mode 100644
index 86f83c68786f5995c462ade5f3067072d69f047e..0000000000000000000000000000000000000000
--- a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/configs/COCO-Detection/fcos_R_50_FPN_1x.py
+++ /dev/null
@@ -1,11 +0,0 @@
-from ..common.optim import SGD as optimizer
-from ..common.coco_schedule import lr_multiplier_1x as lr_multiplier
-from ..common.data.coco import dataloader
-from ..common.models.fcos import model
-from ..common.train import train
-
-dataloader.train.mapper.use_instance_mask = False
-optimizer.lr = 0.01
-
-model.backbone.bottom_up.freeze_at = 2
-train.init_checkpoint = "detectron2://ImageNetPretrained/MSRA/R-50.pkl"
diff --git a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/data/build.py b/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/data/build.py
deleted file mode 100644
index a31369d1693f86154a7a9249fc043d49f3e9f390..0000000000000000000000000000000000000000
--- a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/data/build.py
+++ /dev/null
@@ -1,542 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import itertools
-import logging
-import numpy as np
-import operator
-import pickle
-from typing import Any, Callable, Dict, List, Optional, Union
-import torch
-import torch.utils.data as torchdata
-from tabulate import tabulate
-from termcolor import colored
-
-from detectron2.config import configurable
-from detectron2.structures import BoxMode
-from detectron2.utils.comm import get_world_size
-from detectron2.utils.env import seed_all_rng
-from detectron2.utils.file_io import PathManager
-from detectron2.utils.logger import _log_api_usage, log_first_n
-
-from .catalog import DatasetCatalog, MetadataCatalog
-from .common import AspectRatioGroupedDataset, DatasetFromList, MapDataset, ToIterableDataset
-from .dataset_mapper import DatasetMapper
-from .detection_utils import check_metadata_consistency
-from .samplers import (
- InferenceSampler,
- RandomSubsetTrainingSampler,
- RepeatFactorTrainingSampler,
- TrainingSampler,
-)
-
-"""
-This file contains the default logic to build a dataloader for training or testing.
-"""
-
-__all__ = [
- "build_batch_data_loader",
- "build_detection_train_loader",
- "build_detection_test_loader",
- "get_detection_dataset_dicts",
- "load_proposals_into_dataset",
- "print_instances_class_histogram",
-]
-
-
-def filter_images_with_only_crowd_annotations(dataset_dicts):
- """
- Filter out images with none annotations or only crowd annotations
- (i.e., images without non-crowd annotations).
- A common training-time preprocessing on COCO dataset.
-
- Args:
- dataset_dicts (list[dict]): annotations in Detectron2 Dataset format.
-
- Returns:
- list[dict]: the same format, but filtered.
- """
- num_before = len(dataset_dicts)
-
- def valid(anns):
- for ann in anns:
- if ann.get("iscrowd", 0) == 0:
- return True
- return False
-
- dataset_dicts = [x for x in dataset_dicts if valid(x["annotations"])]
- num_after = len(dataset_dicts)
- logger = logging.getLogger(__name__)
- logger.info(
- "Removed {} images with no usable annotations. {} images left.".format(
- num_before - num_after, num_after
- )
- )
- return dataset_dicts
-
-
-def filter_images_with_few_keypoints(dataset_dicts, min_keypoints_per_image):
- """
- Filter out images with too few number of keypoints.
-
- Args:
- dataset_dicts (list[dict]): annotations in Detectron2 Dataset format.
-
- Returns:
- list[dict]: the same format as dataset_dicts, but filtered.
- """
- num_before = len(dataset_dicts)
-
- def visible_keypoints_in_image(dic):
- # Each keypoints field has the format [x1, y1, v1, ...], where v is visibility
- annotations = dic["annotations"]
- return sum(
- (np.array(ann["keypoints"][2::3]) > 0).sum()
- for ann in annotations
- if "keypoints" in ann
- )
-
- dataset_dicts = [
- x for x in dataset_dicts if visible_keypoints_in_image(x) >= min_keypoints_per_image
- ]
- num_after = len(dataset_dicts)
- logger = logging.getLogger(__name__)
- logger.info(
- "Removed {} images with fewer than {} keypoints.".format(
- num_before - num_after, min_keypoints_per_image
- )
- )
- return dataset_dicts
-
-
-def load_proposals_into_dataset(dataset_dicts, proposal_file):
- """
- Load precomputed object proposals into the dataset.
-
- The proposal file should be a pickled dict with the following keys:
-
- - "ids": list[int] or list[str], the image ids
- - "boxes": list[np.ndarray], each is an Nx4 array of boxes corresponding to the image id
- - "objectness_logits": list[np.ndarray], each is an N sized array of objectness scores
- corresponding to the boxes.
- - "bbox_mode": the BoxMode of the boxes array. Defaults to ``BoxMode.XYXY_ABS``.
-
- Args:
- dataset_dicts (list[dict]): annotations in Detectron2 Dataset format.
- proposal_file (str): file path of pre-computed proposals, in pkl format.
-
- Returns:
- list[dict]: the same format as dataset_dicts, but added proposal field.
- """
- logger = logging.getLogger(__name__)
- logger.info("Loading proposals from: {}".format(proposal_file))
-
- with PathManager.open(proposal_file, "rb") as f:
- proposals = pickle.load(f, encoding="latin1")
-
- # Rename the key names in D1 proposal files
- rename_keys = {"indexes": "ids", "scores": "objectness_logits"}
- for key in rename_keys:
- if key in proposals:
- proposals[rename_keys[key]] = proposals.pop(key)
-
- # Fetch the indexes of all proposals that are in the dataset
- # Convert image_id to str since they could be int.
- img_ids = set({str(record["image_id"]) for record in dataset_dicts})
- id_to_index = {str(id): i for i, id in enumerate(proposals["ids"]) if str(id) in img_ids}
-
- # Assuming default bbox_mode of precomputed proposals are 'XYXY_ABS'
- bbox_mode = BoxMode(proposals["bbox_mode"]) if "bbox_mode" in proposals else BoxMode.XYXY_ABS
-
- for record in dataset_dicts:
- # Get the index of the proposal
- i = id_to_index[str(record["image_id"])]
-
- boxes = proposals["boxes"][i]
- objectness_logits = proposals["objectness_logits"][i]
- # Sort the proposals in descending order of the scores
- inds = objectness_logits.argsort()[::-1]
- record["proposal_boxes"] = boxes[inds]
- record["proposal_objectness_logits"] = objectness_logits[inds]
- record["proposal_bbox_mode"] = bbox_mode
-
- return dataset_dicts
-
-
-def print_instances_class_histogram(dataset_dicts, class_names):
- """
- Args:
- dataset_dicts (list[dict]): list of dataset dicts.
- class_names (list[str]): list of class names (zero-indexed).
- """
- num_classes = len(class_names)
- hist_bins = np.arange(num_classes + 1)
- histogram = np.zeros((num_classes,), dtype=np.int)
- for entry in dataset_dicts:
- annos = entry["annotations"]
- classes = np.asarray(
- [x["category_id"] for x in annos if not x.get("iscrowd", 0)], dtype=np.int
- )
- if len(classes):
- assert classes.min() >= 0, f"Got an invalid category_id={classes.min()}"
- assert (
- classes.max() < num_classes
- ), f"Got an invalid category_id={classes.max()} for a dataset of {num_classes} classes"
- histogram += np.histogram(classes, bins=hist_bins)[0]
-
- N_COLS = min(6, len(class_names) * 2)
-
- def short_name(x):
- # make long class names shorter. useful for lvis
- if len(x) > 13:
- return x[:11] + ".."
- return x
-
- data = list(
- itertools.chain(*[[short_name(class_names[i]), int(v)] for i, v in enumerate(histogram)])
- )
- total_num_instances = sum(data[1::2])
- data.extend([None] * (N_COLS - (len(data) % N_COLS)))
- if num_classes > 1:
- data.extend(["total", total_num_instances])
- data = itertools.zip_longest(*[data[i::N_COLS] for i in range(N_COLS)])
- table = tabulate(
- data,
- headers=["category", "#instances"] * (N_COLS // 2),
- tablefmt="pipe",
- numalign="left",
- stralign="center",
- )
- log_first_n(
- logging.INFO,
- "Distribution of instances among all {} categories:\n".format(num_classes)
- + colored(table, "cyan"),
- key="message",
- )
-
-
-def get_detection_dataset_dicts(
- names,
- filter_empty=True,
- min_keypoints=0,
- proposal_files=None,
- check_consistency=True,
-):
- """
- Load and prepare dataset dicts for instance detection/segmentation and semantic segmentation.
-
- Args:
- names (str or list[str]): a dataset name or a list of dataset names
- filter_empty (bool): whether to filter out images without instance annotations
- min_keypoints (int): filter out images with fewer keypoints than
- `min_keypoints`. Set to 0 to do nothing.
- proposal_files (list[str]): if given, a list of object proposal files
- that match each dataset in `names`.
- check_consistency (bool): whether to check if datasets have consistent metadata.
-
- Returns:
- list[dict]: a list of dicts following the standard dataset dict format.
- """
- if isinstance(names, str):
- names = [names]
- assert len(names), names
- dataset_dicts = [DatasetCatalog.get(dataset_name) for dataset_name in names]
- for dataset_name, dicts in zip(names, dataset_dicts):
- assert len(dicts), "Dataset '{}' is empty!".format(dataset_name)
-
- if proposal_files is not None:
- assert len(names) == len(proposal_files)
- # load precomputed proposals from proposal files
- dataset_dicts = [
- load_proposals_into_dataset(dataset_i_dicts, proposal_file)
- for dataset_i_dicts, proposal_file in zip(dataset_dicts, proposal_files)
- ]
-
- if isinstance(dataset_dicts[0], torchdata.Dataset):
- return torchdata.ConcatDataset(dataset_dicts)
-
- dataset_dicts = list(itertools.chain.from_iterable(dataset_dicts))
-
- has_instances = "annotations" in dataset_dicts[0]
- if filter_empty and has_instances:
- dataset_dicts = filter_images_with_only_crowd_annotations(dataset_dicts)
- if min_keypoints > 0 and has_instances:
- dataset_dicts = filter_images_with_few_keypoints(dataset_dicts, min_keypoints)
-
- if check_consistency and has_instances:
- try:
- class_names = MetadataCatalog.get(names[0]).thing_classes
- check_metadata_consistency("thing_classes", names)
- print_instances_class_histogram(dataset_dicts, class_names)
- except AttributeError: # class names are not available for this dataset
- pass
-
- assert len(dataset_dicts), "No valid data found in {}.".format(",".join(names))
- return dataset_dicts
-
-
-def build_batch_data_loader(
- dataset,
- sampler,
- total_batch_size,
- *,
- aspect_ratio_grouping=False,
- num_workers=0,
- collate_fn=None,
-):
- """
- Build a batched dataloader. The main differences from `torch.utils.data.DataLoader` are:
- 1. support aspect ratio grouping options
- 2. use no "batch collation", because this is common for detection training
-
- Args:
- dataset (torch.utils.data.Dataset): a pytorch map-style or iterable dataset.
- sampler (torch.utils.data.sampler.Sampler or None): a sampler that produces indices.
- Must be provided iff. ``dataset`` is a map-style dataset.
- total_batch_size, aspect_ratio_grouping, num_workers, collate_fn: see
- :func:`build_detection_train_loader`.
-
- Returns:
- iterable[list]. Length of each list is the batch size of the current
- GPU. Each element in the list comes from the dataset.
- """
- world_size = get_world_size()
- assert (
- total_batch_size > 0 and total_batch_size % world_size == 0
- ), "Total batch size ({}) must be divisible by the number of gpus ({}).".format(
- total_batch_size, world_size
- )
- batch_size = total_batch_size // world_size
-
- if isinstance(dataset, torchdata.IterableDataset):
- assert sampler is None, "sampler must be None if dataset is IterableDataset"
- else:
- dataset = ToIterableDataset(dataset, sampler)
-
- if aspect_ratio_grouping:
- data_loader = torchdata.DataLoader(
- dataset,
- num_workers=num_workers,
- collate_fn=operator.itemgetter(0), # don't batch, but yield individual elements
- worker_init_fn=worker_init_reset_seed,
- ) # yield individual mapped dict
- data_loader = AspectRatioGroupedDataset(data_loader, batch_size)
- if collate_fn is None:
- return data_loader
- return MapDataset(data_loader, collate_fn)
- else:
- return torchdata.DataLoader(
- dataset,
- batch_size=batch_size,
- drop_last=True,
- num_workers=num_workers,
- collate_fn=trivial_batch_collator if collate_fn is None else collate_fn,
- worker_init_fn=worker_init_reset_seed,
- )
-
-
-def _train_loader_from_config(cfg, mapper=None, *, dataset=None, sampler=None):
- if dataset is None:
- dataset = get_detection_dataset_dicts(
- cfg.DATASETS.TRAIN,
- filter_empty=cfg.DATALOADER.FILTER_EMPTY_ANNOTATIONS,
- min_keypoints=cfg.MODEL.ROI_KEYPOINT_HEAD.MIN_KEYPOINTS_PER_IMAGE
- if cfg.MODEL.KEYPOINT_ON
- else 0,
- proposal_files=cfg.DATASETS.PROPOSAL_FILES_TRAIN if cfg.MODEL.LOAD_PROPOSALS else None,
- )
- _log_api_usage("dataset." + cfg.DATASETS.TRAIN[0])
-
- if mapper is None:
- mapper = DatasetMapper(cfg, True)
-
- if sampler is None:
- sampler_name = cfg.DATALOADER.SAMPLER_TRAIN
- logger = logging.getLogger(__name__)
- logger.info("Using training sampler {}".format(sampler_name))
- if sampler_name == "TrainingSampler":
- sampler = TrainingSampler(len(dataset))
- elif sampler_name == "RepeatFactorTrainingSampler":
- repeat_factors = RepeatFactorTrainingSampler.repeat_factors_from_category_frequency(
- dataset, cfg.DATALOADER.REPEAT_THRESHOLD
- )
- sampler = RepeatFactorTrainingSampler(repeat_factors)
- elif sampler_name == "RandomSubsetTrainingSampler":
- sampler = RandomSubsetTrainingSampler(len(dataset), cfg.DATALOADER.RANDOM_SUBSET_RATIO)
- else:
- raise ValueError("Unknown training sampler: {}".format(sampler_name))
-
- return {
- "dataset": dataset,
- "sampler": sampler,
- "mapper": mapper,
- "total_batch_size": cfg.SOLVER.IMS_PER_BATCH,
- "aspect_ratio_grouping": cfg.DATALOADER.ASPECT_RATIO_GROUPING,
- "num_workers": cfg.DATALOADER.NUM_WORKERS,
- }
-
-
-@configurable(from_config=_train_loader_from_config)
-def build_detection_train_loader(
- dataset,
- *,
- mapper,
- sampler=None,
- total_batch_size,
- aspect_ratio_grouping=True,
- num_workers=0,
- collate_fn=None,
-):
- """
- Build a dataloader for object detection with some default features.
-
- Args:
- dataset (list or torch.utils.data.Dataset): a list of dataset dicts,
- or a pytorch dataset (either map-style or iterable). It can be obtained
- by using :func:`DatasetCatalog.get` or :func:`get_detection_dataset_dicts`.
- mapper (callable): a callable which takes a sample (dict) from dataset and
- returns the format to be consumed by the model.
- When using cfg, the default choice is ``DatasetMapper(cfg, is_train=True)``.
- sampler (torch.utils.data.sampler.Sampler or None): a sampler that produces
- indices to be applied on ``dataset``.
- If ``dataset`` is map-style, the default sampler is a :class:`TrainingSampler`,
- which coordinates an infinite random shuffle sequence across all workers.
- Sampler must be None if ``dataset`` is iterable.
- total_batch_size (int): total batch size across all workers.
- aspect_ratio_grouping (bool): whether to group images with similar
- aspect ratio for efficiency. When enabled, it requires each
- element in dataset be a dict with keys "width" and "height".
- num_workers (int): number of parallel data loading workers
- collate_fn: a function that determines how to do batching, same as the argument of
- `torch.utils.data.DataLoader`. Defaults to do no collation and return a list of
- data. No collation is OK for small batch size and simple data structures.
- If your batch size is large and each sample contains too many small tensors,
- it's more efficient to collate them in data loader.
-
- Returns:
- torch.utils.data.DataLoader:
- a dataloader. Each output from it is a ``list[mapped_element]`` of length
- ``total_batch_size / num_workers``, where ``mapped_element`` is produced
- by the ``mapper``.
- """
- if isinstance(dataset, list):
- dataset = DatasetFromList(dataset, copy=False)
- if mapper is not None:
- dataset = MapDataset(dataset, mapper)
-
- if isinstance(dataset, torchdata.IterableDataset):
- assert sampler is None, "sampler must be None if dataset is IterableDataset"
- else:
- if sampler is None:
- sampler = TrainingSampler(len(dataset))
- assert isinstance(sampler, torchdata.Sampler), f"Expect a Sampler but got {type(sampler)}"
- return build_batch_data_loader(
- dataset,
- sampler,
- total_batch_size,
- aspect_ratio_grouping=aspect_ratio_grouping,
- num_workers=num_workers,
- collate_fn=collate_fn,
- )
-
-
-def _test_loader_from_config(cfg, dataset_name, mapper=None):
- """
- Uses the given `dataset_name` argument (instead of the names in cfg), because the
- standard practice is to evaluate each test set individually (not combining them).
- """
- if isinstance(dataset_name, str):
- dataset_name = [dataset_name]
-
- dataset = get_detection_dataset_dicts(
- dataset_name,
- filter_empty=False,
- proposal_files=[
- cfg.DATASETS.PROPOSAL_FILES_TEST[list(cfg.DATASETS.TEST).index(x)] for x in dataset_name
- ]
- if cfg.MODEL.LOAD_PROPOSALS
- else None,
- )
- if mapper is None:
- mapper = DatasetMapper(cfg, False)
- return {
- "dataset": dataset,
- "mapper": mapper,
- "num_workers": cfg.DATALOADER.NUM_WORKERS,
- "sampler": InferenceSampler(len(dataset)),
- }
-
-
-@configurable(from_config=_test_loader_from_config)
-def build_detection_test_loader(
- dataset: Union[List[Any], torchdata.Dataset],
- *,
- mapper: Callable[[Dict[str, Any]], Any],
- sampler: Optional[torchdata.Sampler] = None,
- batch_size: int = 1,
- num_workers: int = 0,
- collate_fn: Optional[Callable[[List[Any]], Any]] = None,
-) -> torchdata.DataLoader:
- """
- Similar to `build_detection_train_loader`, with default batch size = 1,
- and sampler = :class:`InferenceSampler`. This sampler coordinates all workers
- to produce the exact set of all samples.
-
- Args:
- dataset: a list of dataset dicts,
- or a pytorch dataset (either map-style or iterable). They can be obtained
- by using :func:`DatasetCatalog.get` or :func:`get_detection_dataset_dicts`.
- mapper: a callable which takes a sample (dict) from dataset
- and returns the format to be consumed by the model.
- When using cfg, the default choice is ``DatasetMapper(cfg, is_train=False)``.
- sampler: a sampler that produces
- indices to be applied on ``dataset``. Default to :class:`InferenceSampler`,
- which splits the dataset across all workers. Sampler must be None
- if `dataset` is iterable.
- batch_size: the batch size of the data loader to be created.
- Default to 1 image per worker since this is the standard when reporting
- inference time in papers.
- num_workers: number of parallel data loading workers
- collate_fn: same as the argument of `torch.utils.data.DataLoader`.
- Defaults to do no collation and return a list of data.
-
- Returns:
- DataLoader: a torch DataLoader, that loads the given detection
- dataset, with test-time transformation and batching.
-
- Examples:
- ::
- data_loader = build_detection_test_loader(
- DatasetRegistry.get("my_test"),
- mapper=DatasetMapper(...))
-
- # or, instantiate with a CfgNode:
- data_loader = build_detection_test_loader(cfg, "my_test")
- """
- if isinstance(dataset, list):
- dataset = DatasetFromList(dataset, copy=False)
- if mapper is not None:
- dataset = MapDataset(dataset, mapper)
- if isinstance(dataset, torchdata.IterableDataset):
- assert sampler is None, "sampler must be None if dataset is IterableDataset"
- else:
- if sampler is None:
- sampler = InferenceSampler(len(dataset))
- return torchdata.DataLoader(
- dataset,
- batch_size=batch_size,
- sampler=sampler,
- drop_last=False,
- num_workers=num_workers,
- collate_fn=trivial_batch_collator if collate_fn is None else collate_fn,
- )
-
-
-def trivial_batch_collator(batch):
- """
- A batch collator that does nothing.
- """
- return batch
-
-
-def worker_init_reset_seed(worker_id):
- initial_seed = torch.initial_seed() % 2 ** 31
- seed_all_rng(initial_seed + worker_id)
diff --git a/spaces/Benson/text-generation/Dockerfile b/spaces/Benson/text-generation/Dockerfile
deleted file mode 100644
index 14271315789e0c87a912ea3cc090345eb9d90595..0000000000000000000000000000000000000000
--- a/spaces/Benson/text-generation/Dockerfile
+++ /dev/null
@@ -1,28 +0,0 @@
-# Use the official Python 3.9 image
-FROM python:3.9
-
-# Set the working directory to /code
-WORKDIR /code
-
-# Copy the current directory contents into the container at /code
-COPY ./requirements.txt /code/requirements.txt
-
-# Install requirements.txt
-RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
-
-# Set up a new user named "user" with user ID 1000
-RUN useradd -m -u 1000 user
-# Switch to the "user" user
-USER user
-# Set home to the user's home directory
-ENV HOME=/home/user \
- PATH=/home/user/.local/bin:$PATH
-
-# Set the working directory to the user's home directory
-WORKDIR $HOME/app
-
-# Copy the current directory contents into the container at $HOME/app setting the owner to the user
-COPY --chown=user . $HOME/app
-
-# Start the FastAPI app on port 7860, the default port expected by Spaces
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
diff --git a/spaces/Benson/text-generation/Examples/Baloncesto Estrellas Multijugador Mod Apk Dinero Ilimitado Y Oro.md b/spaces/Benson/text-generation/Examples/Baloncesto Estrellas Multijugador Mod Apk Dinero Ilimitado Y Oro.md
deleted file mode 100644
index 52d8eadfe0e604bdbb7455303dcc5b2989be8d82..0000000000000000000000000000000000000000
--- a/spaces/Benson/text-generation/Examples/Baloncesto Estrellas Multijugador Mod Apk Dinero Ilimitado Y Oro.md
+++ /dev/null
@@ -1,50 +0,0 @@
-
-
Estrellas de baloncesto multijugador Mod APK: Dinero ilimitado y oro
-
¿Te gusta jugar al baloncesto en tu dispositivo móvil? ¿Quieres experimentar la emoción de los partidos en línea 1v1 contra jugadores reales de todo el mundo? ¿Quieres tener recursos ilimitados para personalizar a tu personaje y desbloquear nuevas pelotas de baloncesto? Si respondiste sí a cualquiera de estas preguntas, entonces usted debe tratar de estrellas de baloncesto multijugador mod APK. Esta es una versión modificada del popular juego de baloncesto de Miniclip que te da dinero y oro ilimitados, así como otras características increíbles que mejorarán tu experiencia de juego. En este artículo, le diremos qué es Basketball Stars, qué es un mod APK, por qué debe usar Basketball Stars mod multijugador APK, qué características ofrece y cómo descargarlo e instalarlo en su dispositivo.
-
Introducción
-
¿Qué son las estrellas del baloncesto?
-
Basketball Stars es un juego de baloncesto gratuito de Miniclip que te permite jugar partidos en línea 1v1 contra jugadores reales de todo el mundo. Puedes elegir entre diferentes modos de juego, como Attacker-Defender, Shooting Race o Dunk Contest. También puedes personalizar a tu personaje con diferentes atuendos, accesorios, peinados, tatuajes y más. También puede recoger y actualizar diferentes balones de baloncesto con efectos y habilidades únicas. Basketball Stars es un juego divertido y adictivo que pondrá a prueba tus habilidades y reflejos en la cancha.
-
baloncesto estrellas multijugador mod apk dinero ilimitado y oro
¿Por qué utilizar las estrellas de baloncesto multijugador mod APK?
-
Estrellas de baloncesto multijugador mod APK es uno de los mejores APK mod para estrellas de baloncesto que se pueden encontrar en línea. Te da dinero ilimitado y oro que puedes usar para comprar lo que quieras en el juego. También puedes disfrutar de un juego premium y controles que te harán sentir como un profesional en la cancha. También puedes experimentar gráficos 3D realistas que te sumergirán en el mundo del juego. También puedes elegir entre dos diferentes modos de juego multijugador en línea que te desafiarán de diferentes maneras. También puede recoger fácilmente el juego y jugar en cualquier momento, en cualquier lugar. También puedes personalizar a tu personaje con cientos de opciones y desbloquear nuevas pelotas de baloncesto con efectos especiales. Estrellas de baloncesto multijugador mod APK es un deber-tener para cualquier aficionado al baloncesto que quiere tener más diversión y emoción en el juego.
-
Características de Estrellas de baloncesto multijugador mod APK
-
Dinero y oro ilimitados
-
Una de las principales características de Baloncesto Estrellas multijugador mod APK es que le da dinero ilimitado y oro que se puede utilizar para comprar cualquier cosa que quieras en el juego. El dinero y el oro son las principales monedas en las Estrellas del Baloncesto que necesitas para desbloquear nuevos objetos, mejorar tus pelotas de baloncesto, entrar en el juego
Premium y controles
-
Otra característica de Estrellas de baloncesto multijugador mod APK es que le da premium gameplay y controles que te harán sentir como un profesional en la cancha. Puedes disfrutar de controles suaves y sensibles que te permitirán driblar, disparar, bloquear, robar y encestar con facilidad. También puedes usar diferentes movimientos y trucos para superar a tu oponente y ganar más puntos. También puede ajustar la sensibilidad y el ángulo de la cámara para adaptarse a sus preferencias. Estrellas de baloncesto multijugador mod APK le dará la mejor experiencia de juego posible.
-
Gráficos 3D realistas
-
-
Dos diferentes modos de juego multijugador en línea
-
Estrellas de baloncesto multijugador mod APK también ofrece dos diferentes modos de juego multijugador en línea que le desafiará de diferentes maneras. Puedes elegir entre Attacker-Defender o Shooting Race. En Attacker-Defender, tienes que anotar tantos puntos como puedas mientras defiendes tu canasta de tu oponente. En Shooting Race, tienes que anotar tantas canastas como puedas antes de que se acabe el tiempo. Ambos modos de juego son rápidos y competitivos, y requieren habilidad y estrategia para ganar. También puedes jugar con tus amigos o con jugadores aleatorios de todo el mundo. Estrellas de baloncesto multijugador mod APK pondrá a prueba sus habilidades de baloncesto y reflejos.
-
Fácil de recoger, difícil de dominar
-
Estrellas de baloncesto multijugador mod APK también es fácil de recoger, pero difícil de dominar. Puedes aprender lo básico del juego en pocos minutos, pero necesitarás horas de práctica y dedicación para convertirte en una estrella del baloncesto. También puedes mejorar tus habilidades jugando contra diferentes oponentes con diferentes estilos y habilidades. También puedes ganar recompensas y logros al completar varios desafíos y misiones. Estrellas de baloncesto multijugador mod APK es un juego que te mantendrá enganchado durante mucho tiempo.
-
Amplias opciones de personalización
-
Estrellas de baloncesto multijugador mod APK también le da amplias opciones de personalización que le permitirá crear su propio personaje único. Puedes elegir entre cientos de trajes, accesorios, peinados, tatuajes y más. También puedes mezclar y combinar diferentes elementos para crear tu propio estilo y personalidad. También puedes cambiar la apariencia de tu personaje cuando quieras. Estrellas de baloncesto multijugador mod APK le permitirá expresarse en la cancha.
-
Colección de baloncesto desbloqueable
-
-
Cómo descargar e instalar Baloncesto Estrellas multijugador mod APK
-
Paso 1: Descargar el archivo mod APK de una fuente de confianza
-
El primer paso para descargar e instalar Baloncesto Estrellas multijugador mod APK es encontrar una fuente de confianza que ofrece la última versión del archivo APK mod. Puede buscar en línea para varios sitios web que proporcionan archivos APK mod para diferentes juegos, pero tenga cuidado con los enlaces falsos o maliciosos que pueden dañar su dispositivo o robar sus datos. También puede utilizar este enlace para descargar el archivo mod APK para Basketball Stars directamente.
-
Paso 2: Habilitar fuentes desconocidas en la configuración del dispositivo
-
El segundo paso para descargar e instalar Estrellas de baloncesto multijugador mod APK es habilitar fuentes desconocidas en la configuración de su dispositivo. Esto le permitirá instalar aplicaciones desde fuentes distintas de Google Play Store o App Store. Para hacer esto, vaya a la configuración del dispositivo, luego la seguridad o la privacidad, luego cambie las fuentes desconocidas o permita desde esta fuente. Esto puede variar dependiendo del modelo de dispositivo y del sistema operativo.
-
Paso 3: Instalar el archivo APK mod y lanzar el juego
-
El tercer paso para descargar e instalar Baloncesto Estrellas multijugador mod APK es instalar el archivo APK mod y lanzar el juego. Para hacer esto, localizar el archivo APK mod descargado en el almacenamiento del dispositivo, a continuación, toque en él para iniciar el proceso de instalación. Sigue las instrucciones de la pantalla hasta que se complete la instalación. Luego, inicia el juego desde el cajón de la app o la pantalla de inicio. Disfruta jugando Basketball Stars con dinero ilimitado y oro
Conclusión
-
-
Preguntas frecuentes
-
Aquí hay algunas preguntas frecuentes sobre Basketball Stars mod multijugador APK:
-
-
-
Q: ¿Está libre el mod multijugador Basketball Stars?
-
A: Sí, Estrellas de baloncesto multijugador mod APK es libre de descargar y usar. No necesitas pagar nada para disfrutar del juego con dinero y oro ilimitados.
-
Q: ¿Es seguro el mod multijugador APK de Basketball Stars?
-
A: Sí, Estrellas de baloncesto multijugador mod APK es seguro de usar. No contiene virus, malware, spyware u otros componentes dañinos que puedan dañar su dispositivo o comprometer su privacidad. Sin embargo, siempre debe descargarlo de una fuente confiable y escanearlo con un software antivirus antes de instalarlo.
-
Q: ¿Es Basketball Stars multijugador mod APK compatible con mi dispositivo?
-
A: Estrellas de baloncesto multijugador mod APK es compatible con la mayoría de los dispositivos Android que tienen Android 4.1 o superior. Sin embargo, algunos dispositivos pueden no ser compatibles con el juego o el mod APK debido a limitaciones de hardware o software.
-
Q: ¿Voy a ser prohibido para el uso de estrellas de baloncesto multijugador mod APK?
-
A: No, no se le prohibió el uso de estrellas de baloncesto multijugador mod APK. El mod APK no interfiere con los servidores del juego o el sistema de emparejamiento en línea. Puedes jugar el juego normalmente sin ningún riesgo de ser prohibido.
-
Q: ¿Cómo puedo actualizar Basketball Stars mod multijugador APK?
-
A: Para actualizar Estrellas de baloncesto multijugador mod APK, es necesario descargar la última versión del archivo mod APK de la misma fuente que lo descargó desde antes. A continuación, es necesario desinstalar la versión anterior del mod APK e instalar el nuevo. No necesita preocuparse por perder su progreso o datos, ya que se almacenan en su dispositivo y no en el archivo APK mod.
-
64aa2da5cf
-
-
\ No newline at end of file
diff --git a/spaces/Big-Web/MMSD/env/Lib/site-packages/boto3/docs/method.py b/spaces/Big-Web/MMSD/env/Lib/site-packages/boto3/docs/method.py
deleted file mode 100644
index b7520088c2ad0ac9767245c77338d317668c44ba..0000000000000000000000000000000000000000
--- a/spaces/Big-Web/MMSD/env/Lib/site-packages/boto3/docs/method.py
+++ /dev/null
@@ -1,78 +0,0 @@
-# Copyright 2015 Amazon.com, Inc. or its affiliates. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"). You
-# may not use this file except in compliance with the License. A copy of
-# the License is located at
-#
-# https://aws.amazon.com/apache2.0/
-#
-# or in the "license" file accompanying this file. This file is
-# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
-# ANY KIND, either express or implied. See the License for the specific
-# language governing permissions and limitations under the License.
-from botocore.docs.method import document_model_driven_method
-
-
-def document_model_driven_resource_method(
- section,
- method_name,
- operation_model,
- event_emitter,
- method_description=None,
- example_prefix=None,
- include_input=None,
- include_output=None,
- exclude_input=None,
- exclude_output=None,
- document_output=True,
- resource_action_model=None,
- include_signature=True,
-):
-
- document_model_driven_method(
- section=section,
- method_name=method_name,
- operation_model=operation_model,
- event_emitter=event_emitter,
- method_description=method_description,
- example_prefix=example_prefix,
- include_input=include_input,
- include_output=include_output,
- exclude_input=exclude_input,
- exclude_output=exclude_output,
- document_output=document_output,
- include_signature=include_signature,
- )
-
- # If this action returns a resource modify the return example to
- # appropriately reflect that.
- if resource_action_model.resource:
- if 'return' in section.available_sections:
- section.delete_section('return')
- resource_type = resource_action_model.resource.type
-
- new_return_section = section.add_new_section('return')
- return_resource_type = '{}.{}'.format(
- operation_model.service_model.service_name, resource_type
- )
-
- return_type = f':py:class:`{return_resource_type}`'
- return_description = f'{resource_type} resource'
-
- if _method_returns_resource_list(resource_action_model.resource):
- return_type = f'list({return_type})'
- return_description = f'A list of {resource_type} resources'
-
- new_return_section.style.new_line()
- new_return_section.write(f':rtype: {return_type}')
- new_return_section.style.new_line()
- new_return_section.write(f':returns: {return_description}')
- new_return_section.style.new_line()
-
-
-def _method_returns_resource_list(resource):
- for identifier in resource.identifiers:
- if identifier.path and '[]' in identifier.path:
- return True
-
- return False
diff --git a/spaces/Big-Web/MMSD/env/Lib/site-packages/urllib3/fields.py b/spaces/Big-Web/MMSD/env/Lib/site-packages/urllib3/fields.py
deleted file mode 100644
index 9d630f491d9a39644ae65564dac88eb51f0bbe78..0000000000000000000000000000000000000000
--- a/spaces/Big-Web/MMSD/env/Lib/site-packages/urllib3/fields.py
+++ /dev/null
@@ -1,274 +0,0 @@
-from __future__ import absolute_import
-
-import email.utils
-import mimetypes
-import re
-
-from .packages import six
-
-
-def guess_content_type(filename, default="application/octet-stream"):
- """
- Guess the "Content-Type" of a file.
-
- :param filename:
- The filename to guess the "Content-Type" of using :mod:`mimetypes`.
- :param default:
- If no "Content-Type" can be guessed, default to `default`.
- """
- if filename:
- return mimetypes.guess_type(filename)[0] or default
- return default
-
-
-def format_header_param_rfc2231(name, value):
- """
- Helper function to format and quote a single header parameter using the
- strategy defined in RFC 2231.
-
- Particularly useful for header parameters which might contain
- non-ASCII values, like file names. This follows
- `RFC 2388 Section 4.4 `_.
-
- :param name:
- The name of the parameter, a string expected to be ASCII only.
- :param value:
- The value of the parameter, provided as ``bytes`` or `str``.
- :ret:
- An RFC-2231-formatted unicode string.
- """
- if isinstance(value, six.binary_type):
- value = value.decode("utf-8")
-
- if not any(ch in value for ch in '"\\\r\n'):
- result = u'%s="%s"' % (name, value)
- try:
- result.encode("ascii")
- except (UnicodeEncodeError, UnicodeDecodeError):
- pass
- else:
- return result
-
- if six.PY2: # Python 2:
- value = value.encode("utf-8")
-
- # encode_rfc2231 accepts an encoded string and returns an ascii-encoded
- # string in Python 2 but accepts and returns unicode strings in Python 3
- value = email.utils.encode_rfc2231(value, "utf-8")
- value = "%s*=%s" % (name, value)
-
- if six.PY2: # Python 2:
- value = value.decode("utf-8")
-
- return value
-
-
-_HTML5_REPLACEMENTS = {
- u"\u0022": u"%22",
- # Replace "\" with "\\".
- u"\u005C": u"\u005C\u005C",
-}
-
-# All control characters from 0x00 to 0x1F *except* 0x1B.
-_HTML5_REPLACEMENTS.update(
- {
- six.unichr(cc): u"%{:02X}".format(cc)
- for cc in range(0x00, 0x1F + 1)
- if cc not in (0x1B,)
- }
-)
-
-
-def _replace_multiple(value, needles_and_replacements):
- def replacer(match):
- return needles_and_replacements[match.group(0)]
-
- pattern = re.compile(
- r"|".join([re.escape(needle) for needle in needles_and_replacements.keys()])
- )
-
- result = pattern.sub(replacer, value)
-
- return result
-
-
-def format_header_param_html5(name, value):
- """
- Helper function to format and quote a single header parameter using the
- HTML5 strategy.
-
- Particularly useful for header parameters which might contain
- non-ASCII values, like file names. This follows the `HTML5 Working Draft
- Section 4.10.22.7`_ and matches the behavior of curl and modern browsers.
-
- .. _HTML5 Working Draft Section 4.10.22.7:
- https://w3c.github.io/html/sec-forms.html#multipart-form-data
-
- :param name:
- The name of the parameter, a string expected to be ASCII only.
- :param value:
- The value of the parameter, provided as ``bytes`` or `str``.
- :ret:
- A unicode string, stripped of troublesome characters.
- """
- if isinstance(value, six.binary_type):
- value = value.decode("utf-8")
-
- value = _replace_multiple(value, _HTML5_REPLACEMENTS)
-
- return u'%s="%s"' % (name, value)
-
-
-# For backwards-compatibility.
-format_header_param = format_header_param_html5
-
-
-class RequestField(object):
- """
- A data container for request body parameters.
-
- :param name:
- The name of this request field. Must be unicode.
- :param data:
- The data/value body.
- :param filename:
- An optional filename of the request field. Must be unicode.
- :param headers:
- An optional dict-like object of headers to initially use for the field.
- :param header_formatter:
- An optional callable that is used to encode and format the headers. By
- default, this is :func:`format_header_param_html5`.
- """
-
- def __init__(
- self,
- name,
- data,
- filename=None,
- headers=None,
- header_formatter=format_header_param_html5,
- ):
- self._name = name
- self._filename = filename
- self.data = data
- self.headers = {}
- if headers:
- self.headers = dict(headers)
- self.header_formatter = header_formatter
-
- @classmethod
- def from_tuples(cls, fieldname, value, header_formatter=format_header_param_html5):
- """
- A :class:`~urllib3.fields.RequestField` factory from old-style tuple parameters.
-
- Supports constructing :class:`~urllib3.fields.RequestField` from
- parameter of key/value strings AND key/filetuple. A filetuple is a
- (filename, data, MIME type) tuple where the MIME type is optional.
- For example::
-
- 'foo': 'bar',
- 'fakefile': ('foofile.txt', 'contents of foofile'),
- 'realfile': ('barfile.txt', open('realfile').read()),
- 'typedfile': ('bazfile.bin', open('bazfile').read(), 'image/jpeg'),
- 'nonamefile': 'contents of nonamefile field',
-
- Field names and filenames must be unicode.
- """
- if isinstance(value, tuple):
- if len(value) == 3:
- filename, data, content_type = value
- else:
- filename, data = value
- content_type = guess_content_type(filename)
- else:
- filename = None
- content_type = None
- data = value
-
- request_param = cls(
- fieldname, data, filename=filename, header_formatter=header_formatter
- )
- request_param.make_multipart(content_type=content_type)
-
- return request_param
-
- def _render_part(self, name, value):
- """
- Overridable helper function to format a single header parameter. By
- default, this calls ``self.header_formatter``.
-
- :param name:
- The name of the parameter, a string expected to be ASCII only.
- :param value:
- The value of the parameter, provided as a unicode string.
- """
-
- return self.header_formatter(name, value)
-
- def _render_parts(self, header_parts):
- """
- Helper function to format and quote a single header.
-
- Useful for single headers that are composed of multiple items. E.g.,
- 'Content-Disposition' fields.
-
- :param header_parts:
- A sequence of (k, v) tuples or a :class:`dict` of (k, v) to format
- as `k1="v1"; k2="v2"; ...`.
- """
- parts = []
- iterable = header_parts
- if isinstance(header_parts, dict):
- iterable = header_parts.items()
-
- for name, value in iterable:
- if value is not None:
- parts.append(self._render_part(name, value))
-
- return u"; ".join(parts)
-
- def render_headers(self):
- """
- Renders the headers for this request field.
- """
- lines = []
-
- sort_keys = ["Content-Disposition", "Content-Type", "Content-Location"]
- for sort_key in sort_keys:
- if self.headers.get(sort_key, False):
- lines.append(u"%s: %s" % (sort_key, self.headers[sort_key]))
-
- for header_name, header_value in self.headers.items():
- if header_name not in sort_keys:
- if header_value:
- lines.append(u"%s: %s" % (header_name, header_value))
-
- lines.append(u"\r\n")
- return u"\r\n".join(lines)
-
- def make_multipart(
- self, content_disposition=None, content_type=None, content_location=None
- ):
- """
- Makes this request field into a multipart request field.
-
- This method overrides "Content-Disposition", "Content-Type" and
- "Content-Location" headers to the request parameter.
-
- :param content_type:
- The 'Content-Type' of the request body.
- :param content_location:
- The 'Content-Location' of the request body.
-
- """
- self.headers["Content-Disposition"] = content_disposition or u"form-data"
- self.headers["Content-Disposition"] += u"; ".join(
- [
- u"",
- self._render_parts(
- ((u"name", self._name), (u"filename", self._filename))
- ),
- ]
- )
- self.headers["Content-Type"] = content_type
- self.headers["Content-Location"] = content_location
diff --git a/spaces/CVPR/LIVE/thrust/thrust/limits.h b/spaces/CVPR/LIVE/thrust/thrust/limits.h
deleted file mode 100644
index f83dde9c370a73dff878a21a0ca919c8d0859f18..0000000000000000000000000000000000000000
--- a/spaces/CVPR/LIVE/thrust/thrust/limits.h
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright (c) 2018 NVIDIA Corporation
-// Author: Bryce Adelstein Lelbach
-//
-// Distributed under the Boost Software License v1.0 (boost.org/LICENSE_1_0.txt)
-
-#pragma once
-
-#include
-
-#include
-
-namespace thrust
-{
-
-template
-struct numeric_limits : std::numeric_limits {};
-
-} // end namespace thrust
-
diff --git a/spaces/CVPR/WALT/mmdet/models/losses/utils.py b/spaces/CVPR/WALT/mmdet/models/losses/utils.py
deleted file mode 100644
index 4756d7fcefd7cda1294c2662b4ca3e90c0a8e124..0000000000000000000000000000000000000000
--- a/spaces/CVPR/WALT/mmdet/models/losses/utils.py
+++ /dev/null
@@ -1,100 +0,0 @@
-import functools
-
-import mmcv
-import torch.nn.functional as F
-
-
-def reduce_loss(loss, reduction):
- """Reduce loss as specified.
-
- Args:
- loss (Tensor): Elementwise loss tensor.
- reduction (str): Options are "none", "mean" and "sum".
-
- Return:
- Tensor: Reduced loss tensor.
- """
- reduction_enum = F._Reduction.get_enum(reduction)
- # none: 0, elementwise_mean:1, sum: 2
- if reduction_enum == 0:
- return loss
- elif reduction_enum == 1:
- return loss.mean()
- elif reduction_enum == 2:
- return loss.sum()
-
-
-@mmcv.jit(derivate=True, coderize=True)
-def weight_reduce_loss(loss, weight=None, reduction='mean', avg_factor=None):
- """Apply element-wise weight and reduce loss.
-
- Args:
- loss (Tensor): Element-wise loss.
- weight (Tensor): Element-wise weights.
- reduction (str): Same as built-in losses of PyTorch.
- avg_factor (float): Avarage factor when computing the mean of losses.
-
- Returns:
- Tensor: Processed loss values.
- """
- # if weight is specified, apply element-wise weight
- if weight is not None:
- loss = loss * weight
-
- # if avg_factor is not specified, just reduce the loss
- if avg_factor is None:
- loss = reduce_loss(loss, reduction)
- else:
- # if reduction is mean, then average the loss by avg_factor
- if reduction == 'mean':
- loss = loss.sum() / avg_factor
- # if reduction is 'none', then do nothing, otherwise raise an error
- elif reduction != 'none':
- raise ValueError('avg_factor can not be used with reduction="sum"')
- return loss
-
-
-def weighted_loss(loss_func):
- """Create a weighted version of a given loss function.
-
- To use this decorator, the loss function must have the signature like
- `loss_func(pred, target, **kwargs)`. The function only needs to compute
- element-wise loss without any reduction. This decorator will add weight
- and reduction arguments to the function. The decorated function will have
- the signature like `loss_func(pred, target, weight=None, reduction='mean',
- avg_factor=None, **kwargs)`.
-
- :Example:
-
- >>> import torch
- >>> @weighted_loss
- >>> def l1_loss(pred, target):
- >>> return (pred - target).abs()
-
- >>> pred = torch.Tensor([0, 2, 3])
- >>> target = torch.Tensor([1, 1, 1])
- >>> weight = torch.Tensor([1, 0, 1])
-
- >>> l1_loss(pred, target)
- tensor(1.3333)
- >>> l1_loss(pred, target, weight)
- tensor(1.)
- >>> l1_loss(pred, target, reduction='none')
- tensor([1., 1., 2.])
- >>> l1_loss(pred, target, weight, avg_factor=2)
- tensor(1.5000)
- """
-
- @functools.wraps(loss_func)
- def wrapper(pred,
- target,
- weight=None,
- reduction='mean',
- avg_factor=None,
- **kwargs):
- # get element-wise loss
- loss = loss_func(pred, target, **kwargs)
- loss = weight_reduce_loss(loss, weight, reduction, avg_factor)
- return loss
-
- return wrapper
diff --git a/spaces/CVPR/lama-example/fetch_data/places_standard_evaluation_prepare_data.sh b/spaces/CVPR/lama-example/fetch_data/places_standard_evaluation_prepare_data.sh
deleted file mode 100644
index 15d753cc2ccb17754ee3d23a45c73a8bbb3dbd06..0000000000000000000000000000000000000000
--- a/spaces/CVPR/lama-example/fetch_data/places_standard_evaluation_prepare_data.sh
+++ /dev/null
@@ -1,52 +0,0 @@
-# 0. folder preparation
-mkdir -p places_standard_dataset/evaluation/hires/
-mkdir -p places_standard_dataset/evaluation/random_thick_512/
-mkdir -p places_standard_dataset/evaluation/random_thin_512/
-mkdir -p places_standard_dataset/evaluation/random_medium_512/
-mkdir -p places_standard_dataset/evaluation/random_thick_256/
-mkdir -p places_standard_dataset/evaluation/random_thin_256/
-mkdir -p places_standard_dataset/evaluation/random_medium_256/
-
-# 1. sample 2000 new images
-OUT=$(python3 fetch_data/eval_sampler.py)
-echo ${OUT}
-
-FILELIST=$(cat places_standard_dataset/original/eval_random_files.txt)
-for i in $FILELIST
-do
- $(cp ${i} places_standard_dataset/evaluation/hires/)
-done
-
-
-# 2. generate all kinds of masks
-
-# all 512
-python3 bin/gen_mask_dataset.py \
-$(pwd)/configs/data_gen/random_thick_512.yaml \
-places_standard_dataset/evaluation/hires \
-places_standard_dataset/evaluation/random_thick_512/
-
-python3 bin/gen_mask_dataset.py \
-$(pwd)/configs/data_gen/random_thin_512.yaml \
-places_standard_dataset/evaluation/hires \
-places_standard_dataset/evaluation/random_thin_512/
-
-python3 bin/gen_mask_dataset.py \
-$(pwd)/configs/data_gen/random_medium_512.yaml \
-places_standard_dataset/evaluation/hires \
-places_standard_dataset/evaluation/random_medium_512/
-
-python3 bin/gen_mask_dataset.py \
-$(pwd)/configs/data_gen/random_thick_256.yaml \
-places_standard_dataset/evaluation/hires \
-places_standard_dataset/evaluation/random_thick_256/
-
-python3 bin/gen_mask_dataset.py \
-$(pwd)/configs/data_gen/random_thin_256.yaml \
-places_standard_dataset/evaluation/hires \
-places_standard_dataset/evaluation/random_thin_256/
-
-python3 bin/gen_mask_dataset.py \
-$(pwd)/configs/data_gen/random_medium_256.yaml \
-places_standard_dataset/evaluation/hires \
-places_standard_dataset/evaluation/random_medium_256/
diff --git a/spaces/CVPR/lama-example/saicinpainting/training/losses/perceptual.py b/spaces/CVPR/lama-example/saicinpainting/training/losses/perceptual.py
deleted file mode 100644
index 8c055c2b327ce7943682af5c5f9394b9fcbec506..0000000000000000000000000000000000000000
--- a/spaces/CVPR/lama-example/saicinpainting/training/losses/perceptual.py
+++ /dev/null
@@ -1,113 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import torchvision
-
-from models.ade20k import ModelBuilder
-from saicinpainting.utils import check_and_warn_input_range
-
-
-IMAGENET_MEAN = torch.FloatTensor([0.485, 0.456, 0.406])[None, :, None, None]
-IMAGENET_STD = torch.FloatTensor([0.229, 0.224, 0.225])[None, :, None, None]
-
-
-class PerceptualLoss(nn.Module):
- def __init__(self, normalize_inputs=True):
- super(PerceptualLoss, self).__init__()
-
- self.normalize_inputs = normalize_inputs
- self.mean_ = IMAGENET_MEAN
- self.std_ = IMAGENET_STD
-
- vgg = torchvision.models.vgg19(pretrained=True).features
- vgg_avg_pooling = []
-
- for weights in vgg.parameters():
- weights.requires_grad = False
-
- for module in vgg.modules():
- if module.__class__.__name__ == 'Sequential':
- continue
- elif module.__class__.__name__ == 'MaxPool2d':
- vgg_avg_pooling.append(nn.AvgPool2d(kernel_size=2, stride=2, padding=0))
- else:
- vgg_avg_pooling.append(module)
-
- self.vgg = nn.Sequential(*vgg_avg_pooling)
-
- def do_normalize_inputs(self, x):
- return (x - self.mean_.to(x.device)) / self.std_.to(x.device)
-
- def partial_losses(self, input, target, mask=None):
- check_and_warn_input_range(target, 0, 1, 'PerceptualLoss target in partial_losses')
-
- # we expect input and target to be in [0, 1] range
- losses = []
-
- if self.normalize_inputs:
- features_input = self.do_normalize_inputs(input)
- features_target = self.do_normalize_inputs(target)
- else:
- features_input = input
- features_target = target
-
- for layer in self.vgg[:30]:
-
- features_input = layer(features_input)
- features_target = layer(features_target)
-
- if layer.__class__.__name__ == 'ReLU':
- loss = F.mse_loss(features_input, features_target, reduction='none')
-
- if mask is not None:
- cur_mask = F.interpolate(mask, size=features_input.shape[-2:],
- mode='bilinear', align_corners=False)
- loss = loss * (1 - cur_mask)
-
- loss = loss.mean(dim=tuple(range(1, len(loss.shape))))
- losses.append(loss)
-
- return losses
-
- def forward(self, input, target, mask=None):
- losses = self.partial_losses(input, target, mask=mask)
- return torch.stack(losses).sum(dim=0)
-
- def get_global_features(self, input):
- check_and_warn_input_range(input, 0, 1, 'PerceptualLoss input in get_global_features')
-
- if self.normalize_inputs:
- features_input = self.do_normalize_inputs(input)
- else:
- features_input = input
-
- features_input = self.vgg(features_input)
- return features_input
-
-
-class ResNetPL(nn.Module):
- def __init__(self, weight=1,
- weights_path=None, arch_encoder='resnet50dilated', segmentation=True):
- super().__init__()
- self.impl = ModelBuilder.get_encoder(weights_path=weights_path,
- arch_encoder=arch_encoder,
- arch_decoder='ppm_deepsup',
- fc_dim=2048,
- segmentation=segmentation)
- self.impl.eval()
- for w in self.impl.parameters():
- w.requires_grad_(False)
-
- self.weight = weight
-
- def forward(self, pred, target):
- pred = (pred - IMAGENET_MEAN.to(pred)) / IMAGENET_STD.to(pred)
- target = (target - IMAGENET_MEAN.to(target)) / IMAGENET_STD.to(target)
-
- pred_feats = self.impl(pred, return_feature_maps=True)
- target_feats = self.impl(target, return_feature_maps=True)
-
- result = torch.stack([F.mse_loss(cur_pred, cur_target)
- for cur_pred, cur_target
- in zip(pred_feats, target_feats)]).sum() * self.weight
- return result
diff --git a/spaces/CVPR/regionclip-demo/detectron2/solver/__init__.py b/spaces/CVPR/regionclip-demo/detectron2/solver/__init__.py
deleted file mode 100644
index 9a2dbd35bb24f0d4a979bc8f304142376d87e7ec..0000000000000000000000000000000000000000
--- a/spaces/CVPR/regionclip-demo/detectron2/solver/__init__.py
+++ /dev/null
@@ -1,5 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-from .build import build_lr_scheduler, build_optimizer, get_default_optimizer_params
-from .lr_scheduler import WarmupCosineLR, WarmupMultiStepLR, LRMultiplier, WarmupParamScheduler
-
-__all__ = [k for k in globals().keys() if not k.startswith("_")]
diff --git a/spaces/ChrisPreston/diff-svc_minato_aqua/run.py b/spaces/ChrisPreston/diff-svc_minato_aqua/run.py
deleted file mode 100644
index 0935dee5ffc8670b6a68a9466179bd926c6de8c6..0000000000000000000000000000000000000000
--- a/spaces/ChrisPreston/diff-svc_minato_aqua/run.py
+++ /dev/null
@@ -1,17 +0,0 @@
-import importlib
-
-from utils.hparams import set_hparams, hparams
-
-set_hparams(print_hparams=False)
-
-
-def run_task():
- assert hparams['task_cls'] != ''
- pkg = ".".join(hparams["task_cls"].split(".")[:-1])
- cls_name = hparams["task_cls"].split(".")[-1]
- task_cls = getattr(importlib.import_module(pkg), cls_name)
- task_cls.start()
-
-
-if __name__ == '__main__':
- run_task()
diff --git a/spaces/CofAI/chat/client/css/theme-toggler.css b/spaces/CofAI/chat/client/css/theme-toggler.css
deleted file mode 100644
index b673b5920a24693e7ea15b873e46731b388ec527..0000000000000000000000000000000000000000
--- a/spaces/CofAI/chat/client/css/theme-toggler.css
+++ /dev/null
@@ -1,33 +0,0 @@
-.theme-toggler-container {
- margin: 24px 0px 8px 0px;
- justify-content: center;
-}
-
-.theme-toggler-container.checkbox input + label,
-.theme-toggler-container.checkbox input:checked + label:after {
- background: var(--colour-1);
-}
-
-.theme-toggler-container.checkbox input + label:after,
-.theme-toggler-container.checkbox input:checked + label {
- background: var(--colour-3);
-}
-
-.theme-toggler-container.checkbox span {
- font-size: 0.75rem;
-}
-
-.theme-toggler-container.checkbox label {
- width: 24px;
- height: 16px;
-}
-
-.theme-toggler-container.checkbox label:after {
- left: 2px;
- width: 10px;
- height: 10px;
-}
-
-.theme-toggler-container.checkbox input:checked + label:after {
- left: calc(100% - 2px - 10px);
-}
\ No newline at end of file
diff --git a/spaces/CristianGonzalez281098/Cheto/README.md b/spaces/CristianGonzalez281098/Cheto/README.md
deleted file mode 100644
index 69959527bdce515bfe2bb3204a23b6a49ea193b2..0000000000000000000000000000000000000000
--- a/spaces/CristianGonzalez281098/Cheto/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Cheto
-emoji: 📚
-colorFrom: pink
-colorTo: blue
-sdk: gradio
-sdk_version: 2.9.0
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces#reference
diff --git a/spaces/DHEIVER/analise_imagem_mama/README.md b/spaces/DHEIVER/analise_imagem_mama/README.md
deleted file mode 100644
index 1c28a3c55ae115b61478bc0b5368dae6575354e4..0000000000000000000000000000000000000000
--- a/spaces/DHEIVER/analise_imagem_mama/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Analise Imagem Mama
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: gradio
-sdk_version: 3.38.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/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/gradio/pipelines.py b/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/gradio/pipelines.py
deleted file mode 100644
index 144f1f7ecd59c2c9c71fbd836061de9ed4b1f71b..0000000000000000000000000000000000000000
--- a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/gradio/pipelines.py
+++ /dev/null
@@ -1,225 +0,0 @@
-"""This module should not be used directly as its API is subject to change. Instead,
-please use the `gr.Interface.from_pipeline()` function."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from gradio import components
-
-if TYPE_CHECKING: # Only import for type checking (is False at runtime).
- from transformers import pipelines
-
-
-def load_from_pipeline(pipeline: pipelines.base.Pipeline) -> dict:
- """
- Gets the appropriate Interface kwargs for a given Hugging Face transformers.Pipeline.
- pipeline (transformers.Pipeline): the transformers.Pipeline from which to create an interface
- Returns:
- (dict): a dictionary of kwargs that can be used to construct an Interface object
- """
- try:
- import transformers
- from transformers import pipelines
- except ImportError as ie:
- raise ImportError(
- "transformers not installed. Please try `pip install transformers`"
- ) from ie
- if not isinstance(pipeline, pipelines.base.Pipeline):
- raise ValueError("pipeline must be a transformers.Pipeline")
-
- # Handle the different pipelines. The has_attr() checks to make sure the pipeline exists in the
- # version of the transformers library that the user has installed.
- if hasattr(transformers, "AudioClassificationPipeline") and isinstance(
- pipeline, pipelines.audio_classification.AudioClassificationPipeline
- ):
- pipeline_info = {
- "inputs": components.Audio(
- source="microphone", type="filepath", label="Input"
- ),
- "outputs": components.Label(label="Class"),
- "preprocess": lambda i: {"inputs": i},
- "postprocess": lambda r: {i["label"].split(", ")[0]: i["score"] for i in r},
- }
- elif hasattr(transformers, "AutomaticSpeechRecognitionPipeline") and isinstance(
- pipeline,
- pipelines.automatic_speech_recognition.AutomaticSpeechRecognitionPipeline,
- ):
- pipeline_info = {
- "inputs": components.Audio(
- source="microphone", type="filepath", label="Input"
- ),
- "outputs": components.Textbox(label="Output"),
- "preprocess": lambda i: {"inputs": i},
- "postprocess": lambda r: r["text"],
- }
- elif hasattr(transformers, "FeatureExtractionPipeline") and isinstance(
- pipeline, pipelines.feature_extraction.FeatureExtractionPipeline
- ):
- pipeline_info = {
- "inputs": components.Textbox(label="Input"),
- "outputs": components.Dataframe(label="Output"),
- "preprocess": lambda x: {"inputs": x},
- "postprocess": lambda r: r[0],
- }
- elif hasattr(transformers, "FillMaskPipeline") and isinstance(
- pipeline, pipelines.fill_mask.FillMaskPipeline
- ):
- pipeline_info = {
- "inputs": components.Textbox(label="Input"),
- "outputs": components.Label(label="Classification"),
- "preprocess": lambda x: {"inputs": x},
- "postprocess": lambda r: {i["token_str"]: i["score"] for i in r},
- }
- elif hasattr(transformers, "ImageClassificationPipeline") and isinstance(
- pipeline, pipelines.image_classification.ImageClassificationPipeline
- ):
- pipeline_info = {
- "inputs": components.Image(type="filepath", label="Input Image"),
- "outputs": components.Label(type="confidences", label="Classification"),
- "preprocess": lambda i: {"images": i},
- "postprocess": lambda r: {i["label"].split(", ")[0]: i["score"] for i in r},
- }
- elif hasattr(transformers, "QuestionAnsweringPipeline") and isinstance(
- pipeline, pipelines.question_answering.QuestionAnsweringPipeline
- ):
- pipeline_info = {
- "inputs": [
- components.Textbox(lines=7, label="Context"),
- components.Textbox(label="Question"),
- ],
- "outputs": [
- components.Textbox(label="Answer"),
- components.Label(label="Score"),
- ],
- "preprocess": lambda c, q: {"context": c, "question": q},
- "postprocess": lambda r: (r["answer"], r["score"]),
- }
- elif hasattr(transformers, "SummarizationPipeline") and isinstance(
- pipeline, pipelines.text2text_generation.SummarizationPipeline
- ):
- pipeline_info = {
- "inputs": components.Textbox(lines=7, label="Input"),
- "outputs": components.Textbox(label="Summary"),
- "preprocess": lambda x: {"inputs": x},
- "postprocess": lambda r: r[0]["summary_text"],
- }
- elif hasattr(transformers, "TextClassificationPipeline") and isinstance(
- pipeline, pipelines.text_classification.TextClassificationPipeline
- ):
- pipeline_info = {
- "inputs": components.Textbox(label="Input"),
- "outputs": components.Label(label="Classification"),
- "preprocess": lambda x: [x],
- "postprocess": lambda r: {i["label"].split(", ")[0]: i["score"] for i in r},
- }
- elif hasattr(transformers, "TextGenerationPipeline") and isinstance(
- pipeline, pipelines.text_generation.TextGenerationPipeline
- ):
- pipeline_info = {
- "inputs": components.Textbox(label="Input"),
- "outputs": components.Textbox(label="Output"),
- "preprocess": lambda x: {"text_inputs": x},
- "postprocess": lambda r: r[0]["generated_text"],
- }
- elif hasattr(transformers, "TranslationPipeline") and isinstance(
- pipeline, pipelines.text2text_generation.TranslationPipeline
- ):
- pipeline_info = {
- "inputs": components.Textbox(label="Input"),
- "outputs": components.Textbox(label="Translation"),
- "preprocess": lambda x: [x],
- "postprocess": lambda r: r[0]["translation_text"],
- }
- elif hasattr(transformers, "Text2TextGenerationPipeline") and isinstance(
- pipeline, pipelines.text2text_generation.Text2TextGenerationPipeline
- ):
- pipeline_info = {
- "inputs": components.Textbox(label="Input"),
- "outputs": components.Textbox(label="Generated Text"),
- "preprocess": lambda x: [x],
- "postprocess": lambda r: r[0]["generated_text"],
- }
- elif hasattr(transformers, "ZeroShotClassificationPipeline") and isinstance(
- pipeline, pipelines.zero_shot_classification.ZeroShotClassificationPipeline
- ):
- pipeline_info = {
- "inputs": [
- components.Textbox(label="Input"),
- components.Textbox(label="Possible class names (" "comma-separated)"),
- components.Checkbox(label="Allow multiple true classes"),
- ],
- "outputs": components.Label(label="Classification"),
- "preprocess": lambda i, c, m: {
- "sequences": i,
- "candidate_labels": c,
- "multi_label": m,
- },
- "postprocess": lambda r: {
- r["labels"][i]: r["scores"][i] for i in range(len(r["labels"]))
- },
- }
- elif hasattr(transformers, "DocumentQuestionAnsweringPipeline") and isinstance(
- pipeline,
- pipelines.document_question_answering.DocumentQuestionAnsweringPipeline, # type: ignore
- ):
- pipeline_info = {
- "inputs": [
- components.Image(type="filepath", label="Input Document"),
- components.Textbox(label="Question"),
- ],
- "outputs": components.Label(label="Label"),
- "preprocess": lambda img, q: {"image": img, "question": q},
- "postprocess": lambda r: {i["answer"]: i["score"] for i in r},
- }
- elif hasattr(transformers, "VisualQuestionAnsweringPipeline") and isinstance(
- pipeline, pipelines.visual_question_answering.VisualQuestionAnsweringPipeline
- ):
- pipeline_info = {
- "inputs": [
- components.Image(type="filepath", label="Input Image"),
- components.Textbox(label="Question"),
- ],
- "outputs": components.Label(label="Score"),
- "preprocess": lambda img, q: {"image": img, "question": q},
- "postprocess": lambda r: {i["answer"]: i["score"] for i in r},
- }
- elif hasattr(transformers, "ImageToTextPipeline") and isinstance(
- pipeline, pipelines.image_to_text.ImageToTextPipeline # type: ignore
- ):
- pipeline_info = {
- "inputs": components.Image(type="filepath", label="Input Image"),
- "outputs": components.Textbox(label="Text"),
- "preprocess": lambda i: {"images": i},
- "postprocess": lambda r: r[0]["generated_text"],
- }
- else:
- raise ValueError(f"Unsupported pipeline type: {type(pipeline)}")
-
- # define the function that will be called by the Interface
- def fn(*params):
- data = pipeline_info["preprocess"](*params)
- # special cases that needs to be handled differently
- if isinstance(
- pipeline,
- (
- pipelines.text_classification.TextClassificationPipeline,
- pipelines.text2text_generation.Text2TextGenerationPipeline,
- pipelines.text2text_generation.TranslationPipeline,
- ),
- ):
- data = pipeline(*data)
- else:
- data = pipeline(**data)
- output = pipeline_info["postprocess"](data)
- return output
-
- interface_info = pipeline_info.copy()
- interface_info["fn"] = fn
- del interface_info["preprocess"]
- del interface_info["postprocess"]
-
- # define the title/description of the Interface
- interface_info["title"] = pipeline.model.__class__.__name__
-
- return interface_info
diff --git a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/h11/_state.py b/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/h11/_state.py
deleted file mode 100644
index 3593430a74f21f6e0c2faf495e1627551eebfc30..0000000000000000000000000000000000000000
--- a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/h11/_state.py
+++ /dev/null
@@ -1,367 +0,0 @@
-################################################################
-# The core state machine
-################################################################
-#
-# Rule 1: everything that affects the state machine and state transitions must
-# live here in this file. As much as possible goes into the table-based
-# representation, but for the bits that don't quite fit, the actual code and
-# state must nonetheless live here.
-#
-# Rule 2: this file does not know about what role we're playing; it only knows
-# about HTTP request/response cycles in the abstract. This ensures that we
-# don't cheat and apply different rules to local and remote parties.
-#
-#
-# Theory of operation
-# ===================
-#
-# Possibly the simplest way to think about this is that we actually have 5
-# different state machines here. Yes, 5. These are:
-#
-# 1) The client state, with its complicated automaton (see the docs)
-# 2) The server state, with its complicated automaton (see the docs)
-# 3) The keep-alive state, with possible states {True, False}
-# 4) The SWITCH_CONNECT state, with possible states {False, True}
-# 5) The SWITCH_UPGRADE state, with possible states {False, True}
-#
-# For (3)-(5), the first state listed is the initial state.
-#
-# (1)-(3) are stored explicitly in member variables. The last
-# two are stored implicitly in the pending_switch_proposals set as:
-# (state of 4) == (_SWITCH_CONNECT in pending_switch_proposals)
-# (state of 5) == (_SWITCH_UPGRADE in pending_switch_proposals)
-#
-# And each of these machines has two different kinds of transitions:
-#
-# a) Event-triggered
-# b) State-triggered
-#
-# Event triggered is the obvious thing that you'd think it is: some event
-# happens, and if it's the right event at the right time then a transition
-# happens. But there are somewhat complicated rules for which machines can
-# "see" which events. (As a rule of thumb, if a machine "sees" an event, this
-# means two things: the event can affect the machine, and if the machine is
-# not in a state where it expects that event then it's an error.) These rules
-# are:
-#
-# 1) The client machine sees all h11.events objects emitted by the client.
-#
-# 2) The server machine sees all h11.events objects emitted by the server.
-#
-# It also sees the client's Request event.
-#
-# And sometimes, server events are annotated with a _SWITCH_* event. For
-# example, we can have a (Response, _SWITCH_CONNECT) event, which is
-# different from a regular Response event.
-#
-# 3) The keep-alive machine sees the process_keep_alive_disabled() event
-# (which is derived from Request/Response events), and this event
-# transitions it from True -> False, or from False -> False. There's no way
-# to transition back.
-#
-# 4&5) The _SWITCH_* machines transition from False->True when we get a
-# Request that proposes the relevant type of switch (via
-# process_client_switch_proposals), and they go from True->False when we
-# get a Response that has no _SWITCH_* annotation.
-#
-# So that's event-triggered transitions.
-#
-# State-triggered transitions are less standard. What they do here is couple
-# the machines together. The way this works is, when certain *joint*
-# configurations of states are achieved, then we automatically transition to a
-# new *joint* state. So, for example, if we're ever in a joint state with
-#
-# client: DONE
-# keep-alive: False
-#
-# then the client state immediately transitions to:
-#
-# client: MUST_CLOSE
-#
-# This is fundamentally different from an event-based transition, because it
-# doesn't matter how we arrived at the {client: DONE, keep-alive: False} state
-# -- maybe the client transitioned SEND_BODY -> DONE, or keep-alive
-# transitioned True -> False. Either way, once this precondition is satisfied,
-# this transition is immediately triggered.
-#
-# What if two conflicting state-based transitions get enabled at the same
-# time? In practice there's only one case where this arises (client DONE ->
-# MIGHT_SWITCH_PROTOCOL versus DONE -> MUST_CLOSE), and we resolve it by
-# explicitly prioritizing the DONE -> MIGHT_SWITCH_PROTOCOL transition.
-#
-# Implementation
-# --------------
-#
-# The event-triggered transitions for the server and client machines are all
-# stored explicitly in a table. Ditto for the state-triggered transitions that
-# involve just the server and client state.
-#
-# The transitions for the other machines, and the state-triggered transitions
-# that involve the other machines, are written out as explicit Python code.
-#
-# It'd be nice if there were some cleaner way to do all this. This isn't
-# *too* terrible, but I feel like it could probably be better.
-#
-# WARNING
-# -------
-#
-# The script that generates the state machine diagrams for the docs knows how
-# to read out the EVENT_TRIGGERED_TRANSITIONS and STATE_TRIGGERED_TRANSITIONS
-# tables. But it can't automatically read the transitions that are written
-# directly in Python code. So if you touch those, you need to also update the
-# script to keep it in sync!
-from typing import cast, Dict, Optional, Set, Tuple, Type, Union
-
-from ._events import *
-from ._util import LocalProtocolError, Sentinel
-
-# Everything in __all__ gets re-exported as part of the h11 public API.
-__all__ = [
- "CLIENT",
- "SERVER",
- "IDLE",
- "SEND_RESPONSE",
- "SEND_BODY",
- "DONE",
- "MUST_CLOSE",
- "CLOSED",
- "MIGHT_SWITCH_PROTOCOL",
- "SWITCHED_PROTOCOL",
- "ERROR",
-]
-
-
-class CLIENT(Sentinel, metaclass=Sentinel):
- pass
-
-
-class SERVER(Sentinel, metaclass=Sentinel):
- pass
-
-
-# States
-class IDLE(Sentinel, metaclass=Sentinel):
- pass
-
-
-class SEND_RESPONSE(Sentinel, metaclass=Sentinel):
- pass
-
-
-class SEND_BODY(Sentinel, metaclass=Sentinel):
- pass
-
-
-class DONE(Sentinel, metaclass=Sentinel):
- pass
-
-
-class MUST_CLOSE(Sentinel, metaclass=Sentinel):
- pass
-
-
-class CLOSED(Sentinel, metaclass=Sentinel):
- pass
-
-
-class ERROR(Sentinel, metaclass=Sentinel):
- pass
-
-
-# Switch types
-class MIGHT_SWITCH_PROTOCOL(Sentinel, metaclass=Sentinel):
- pass
-
-
-class SWITCHED_PROTOCOL(Sentinel, metaclass=Sentinel):
- pass
-
-
-class _SWITCH_UPGRADE(Sentinel, metaclass=Sentinel):
- pass
-
-
-class _SWITCH_CONNECT(Sentinel, metaclass=Sentinel):
- pass
-
-
-EventTransitionType = Dict[
- Type[Sentinel],
- Dict[
- Type[Sentinel],
- Dict[Union[Type[Event], Tuple[Type[Event], Type[Sentinel]]], Type[Sentinel]],
- ],
-]
-
-EVENT_TRIGGERED_TRANSITIONS: EventTransitionType = {
- CLIENT: {
- IDLE: {Request: SEND_BODY, ConnectionClosed: CLOSED},
- SEND_BODY: {Data: SEND_BODY, EndOfMessage: DONE},
- DONE: {ConnectionClosed: CLOSED},
- MUST_CLOSE: {ConnectionClosed: CLOSED},
- CLOSED: {ConnectionClosed: CLOSED},
- MIGHT_SWITCH_PROTOCOL: {},
- SWITCHED_PROTOCOL: {},
- ERROR: {},
- },
- SERVER: {
- IDLE: {
- ConnectionClosed: CLOSED,
- Response: SEND_BODY,
- # Special case: server sees client Request events, in this form
- (Request, CLIENT): SEND_RESPONSE,
- },
- SEND_RESPONSE: {
- InformationalResponse: SEND_RESPONSE,
- Response: SEND_BODY,
- (InformationalResponse, _SWITCH_UPGRADE): SWITCHED_PROTOCOL,
- (Response, _SWITCH_CONNECT): SWITCHED_PROTOCOL,
- },
- SEND_BODY: {Data: SEND_BODY, EndOfMessage: DONE},
- DONE: {ConnectionClosed: CLOSED},
- MUST_CLOSE: {ConnectionClosed: CLOSED},
- CLOSED: {ConnectionClosed: CLOSED},
- SWITCHED_PROTOCOL: {},
- ERROR: {},
- },
-}
-
-StateTransitionType = Dict[
- Tuple[Type[Sentinel], Type[Sentinel]], Dict[Type[Sentinel], Type[Sentinel]]
-]
-
-# NB: there are also some special-case state-triggered transitions hard-coded
-# into _fire_state_triggered_transitions below.
-STATE_TRIGGERED_TRANSITIONS: StateTransitionType = {
- # (Client state, Server state) -> new states
- # Protocol negotiation
- (MIGHT_SWITCH_PROTOCOL, SWITCHED_PROTOCOL): {CLIENT: SWITCHED_PROTOCOL},
- # Socket shutdown
- (CLOSED, DONE): {SERVER: MUST_CLOSE},
- (CLOSED, IDLE): {SERVER: MUST_CLOSE},
- (ERROR, DONE): {SERVER: MUST_CLOSE},
- (DONE, CLOSED): {CLIENT: MUST_CLOSE},
- (IDLE, CLOSED): {CLIENT: MUST_CLOSE},
- (DONE, ERROR): {CLIENT: MUST_CLOSE},
-}
-
-
-class ConnectionState:
- def __init__(self) -> None:
- # Extra bits of state that don't quite fit into the state model.
-
- # If this is False then it enables the automatic DONE -> MUST_CLOSE
- # transition. Don't set this directly; call .keep_alive_disabled()
- self.keep_alive = True
-
- # This is a subset of {UPGRADE, CONNECT}, containing the proposals
- # made by the client for switching protocols.
- self.pending_switch_proposals: Set[Type[Sentinel]] = set()
-
- self.states: Dict[Type[Sentinel], Type[Sentinel]] = {CLIENT: IDLE, SERVER: IDLE}
-
- def process_error(self, role: Type[Sentinel]) -> None:
- self.states[role] = ERROR
- self._fire_state_triggered_transitions()
-
- def process_keep_alive_disabled(self) -> None:
- self.keep_alive = False
- self._fire_state_triggered_transitions()
-
- def process_client_switch_proposal(self, switch_event: Type[Sentinel]) -> None:
- self.pending_switch_proposals.add(switch_event)
- self._fire_state_triggered_transitions()
-
- def process_event(
- self,
- role: Type[Sentinel],
- event_type: Type[Event],
- server_switch_event: Optional[Type[Sentinel]] = None,
- ) -> None:
- _event_type: Union[Type[Event], Tuple[Type[Event], Type[Sentinel]]] = event_type
- if server_switch_event is not None:
- assert role is SERVER
- if server_switch_event not in self.pending_switch_proposals:
- raise LocalProtocolError(
- "Received server {} event without a pending proposal".format(
- server_switch_event
- )
- )
- _event_type = (event_type, server_switch_event)
- if server_switch_event is None and _event_type is Response:
- self.pending_switch_proposals = set()
- self._fire_event_triggered_transitions(role, _event_type)
- # Special case: the server state does get to see Request
- # events.
- if _event_type is Request:
- assert role is CLIENT
- self._fire_event_triggered_transitions(SERVER, (Request, CLIENT))
- self._fire_state_triggered_transitions()
-
- def _fire_event_triggered_transitions(
- self,
- role: Type[Sentinel],
- event_type: Union[Type[Event], Tuple[Type[Event], Type[Sentinel]]],
- ) -> None:
- state = self.states[role]
- try:
- new_state = EVENT_TRIGGERED_TRANSITIONS[role][state][event_type]
- except KeyError:
- event_type = cast(Type[Event], event_type)
- raise LocalProtocolError(
- "can't handle event type {} when role={} and state={}".format(
- event_type.__name__, role, self.states[role]
- )
- ) from None
- self.states[role] = new_state
-
- def _fire_state_triggered_transitions(self) -> None:
- # We apply these rules repeatedly until converging on a fixed point
- while True:
- start_states = dict(self.states)
-
- # It could happen that both these special-case transitions are
- # enabled at the same time:
- #
- # DONE -> MIGHT_SWITCH_PROTOCOL
- # DONE -> MUST_CLOSE
- #
- # For example, this will always be true of a HTTP/1.0 client
- # requesting CONNECT. If this happens, the protocol switch takes
- # priority. From there the client will either go to
- # SWITCHED_PROTOCOL, in which case it's none of our business when
- # they close the connection, or else the server will deny the
- # request, in which case the client will go back to DONE and then
- # from there to MUST_CLOSE.
- if self.pending_switch_proposals:
- if self.states[CLIENT] is DONE:
- self.states[CLIENT] = MIGHT_SWITCH_PROTOCOL
-
- if not self.pending_switch_proposals:
- if self.states[CLIENT] is MIGHT_SWITCH_PROTOCOL:
- self.states[CLIENT] = DONE
-
- if not self.keep_alive:
- for role in (CLIENT, SERVER):
- if self.states[role] is DONE:
- self.states[role] = MUST_CLOSE
-
- # Tabular state-triggered transitions
- joint_state = (self.states[CLIENT], self.states[SERVER])
- changes = STATE_TRIGGERED_TRANSITIONS.get(joint_state, {})
- self.states.update(changes)
-
- if self.states == start_states:
- # Fixed point reached
- return
-
- def start_next_cycle(self) -> None:
- if self.states != {CLIENT: DONE, SERVER: DONE}:
- raise LocalProtocolError(
- "not in a reusable state. self.states={}".format(self.states)
- )
- # Can't reach DONE/DONE with any of these active, but still, let's be
- # sure.
- assert self.keep_alive
- assert not self.pending_switch_proposals
- self.states = {CLIENT: IDLE, SERVER: IDLE}
diff --git a/spaces/DaleChen/AutoGPT/.github/PULL_REQUEST_TEMPLATE.md b/spaces/DaleChen/AutoGPT/.github/PULL_REQUEST_TEMPLATE.md
deleted file mode 100644
index a4f28a3d27d66d79cb95f2b8b847832172bb5f11..0000000000000000000000000000000000000000
--- a/spaces/DaleChen/AutoGPT/.github/PULL_REQUEST_TEMPLATE.md
+++ /dev/null
@@ -1,40 +0,0 @@
-
-
-
-
-### Background
-
-
-### Changes
-
-
-### Documentation
-
-
-### Test Plan
-
-
-### PR Quality Checklist
-- [ ] My pull request is atomic and focuses on a single change.
-- [ ] I have thoroughly tested my changes with multiple different prompts.
-- [ ] I have considered potential risks and mitigations for my changes.
-- [ ] I have documented my changes clearly and comprehensively.
-- [ ] I have not snuck in any "extra" small tweaks changes
-
-
-
-
diff --git a/spaces/Datasculptor/MusicGen/audiocraft/data/audio_utils.py b/spaces/Datasculptor/MusicGen/audiocraft/data/audio_utils.py
deleted file mode 100644
index 76d4bc2a33ce722d879db2af33cd1336bd6b1fb3..0000000000000000000000000000000000000000
--- a/spaces/Datasculptor/MusicGen/audiocraft/data/audio_utils.py
+++ /dev/null
@@ -1,174 +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 sys
-import typing as tp
-
-import julius
-import torch
-import torchaudio
-
-
-def convert_audio_channels(wav: torch.Tensor, channels: int = 2) -> torch.Tensor:
- """Convert audio to the given number of channels.
-
- Args:
- wav (torch.Tensor): Audio wave of shape [B, C, T].
- channels (int): Expected number of channels as output.
- Returns:
- torch.Tensor: Downmixed or unchanged audio wave [B, C, T].
- """
- *shape, src_channels, length = wav.shape
- if src_channels == channels:
- pass
- elif channels == 1:
- # Case 1:
- # The caller asked 1-channel audio, and the stream has multiple
- # channels, downmix all channels.
- wav = wav.mean(dim=-2, keepdim=True)
- elif src_channels == 1:
- # Case 2:
- # The caller asked for multiple channels, but the input file has
- # a single channel, replicate the audio over all channels.
- wav = wav.expand(*shape, channels, length)
- elif src_channels >= channels:
- # Case 3:
- # The caller asked for multiple channels, and the input file has
- # more channels than requested. In that case return the first channels.
- wav = wav[..., :channels, :]
- else:
- # Case 4: What is a reasonable choice here?
- raise ValueError('The audio file has less channels than requested but is not mono.')
- return wav
-
-
-def convert_audio(wav: torch.Tensor, from_rate: float,
- to_rate: float, to_channels: int) -> torch.Tensor:
- """Convert audio to new sample rate and number of audio channels.
- """
- wav = julius.resample_frac(wav, int(from_rate), int(to_rate))
- wav = convert_audio_channels(wav, to_channels)
- return wav
-
-
-def normalize_loudness(wav: torch.Tensor, sample_rate: int, loudness_headroom_db: float = 14,
- loudness_compressor: bool = False, energy_floor: float = 2e-3):
- """Normalize an input signal to a user loudness in dB LKFS.
- Audio loudness is defined according to the ITU-R BS.1770-4 recommendation.
-
- Args:
- wav (torch.Tensor): Input multichannel audio data.
- sample_rate (int): Sample rate.
- loudness_headroom_db (float): Target loudness of the output in dB LUFS.
- loudness_compressor (bool): Uses tanh for soft clipping.
- energy_floor (float): anything below that RMS level will not be rescaled.
- Returns:
- output (torch.Tensor): Loudness normalized output data.
- """
- energy = wav.pow(2).mean().sqrt().item()
- if energy < energy_floor:
- return wav
- transform = torchaudio.transforms.Loudness(sample_rate)
- input_loudness_db = transform(wav).item()
- # calculate the gain needed to scale to the desired loudness level
- delta_loudness = -loudness_headroom_db - input_loudness_db
- gain = 10.0 ** (delta_loudness / 20.0)
- output = gain * wav
- if loudness_compressor:
- output = torch.tanh(output)
- assert output.isfinite().all(), (input_loudness_db, wav.pow(2).mean().sqrt())
- return output
-
-
-def _clip_wav(wav: torch.Tensor, log_clipping: bool = False, stem_name: tp.Optional[str] = None) -> None:
- """Utility function to clip the audio with logging if specified."""
- max_scale = wav.abs().max()
- if log_clipping and max_scale > 1:
- clamp_prob = (wav.abs() > 1).float().mean().item()
- print(f"CLIPPING {stem_name or ''} happening with proba (a bit of clipping is okay):",
- clamp_prob, "maximum scale: ", max_scale.item(), file=sys.stderr)
- wav.clamp_(-1, 1)
-
-
-def normalize_audio(wav: torch.Tensor, normalize: bool = True,
- strategy: str = 'peak', peak_clip_headroom_db: float = 1,
- rms_headroom_db: float = 18, loudness_headroom_db: float = 14,
- loudness_compressor: bool = False, log_clipping: bool = False,
- sample_rate: tp.Optional[int] = None,
- stem_name: tp.Optional[str] = None) -> torch.Tensor:
- """Normalize the audio according to the prescribed strategy (see after).
-
- Args:
- wav (torch.Tensor): Audio data.
- normalize (bool): if `True` (default), normalizes according to the prescribed
- strategy (see after). If `False`, the strategy is only used in case clipping
- would happen.
- strategy (str): Can be either 'clip', 'peak', or 'rms'. Default is 'peak',
- i.e. audio is normalized by its largest value. RMS normalizes by root-mean-square
- with extra headroom to avoid clipping. 'clip' just clips.
- peak_clip_headroom_db (float): Headroom in dB when doing 'peak' or 'clip' strategy.
- rms_headroom_db (float): Headroom in dB when doing 'rms' strategy. This must be much larger
- than the `peak_clip` one to avoid further clipping.
- loudness_headroom_db (float): Target loudness for loudness normalization.
- loudness_compressor (bool): If True, uses tanh based soft clipping.
- log_clipping (bool): If True, basic logging on stderr when clipping still
- occurs despite strategy (only for 'rms').
- sample_rate (int): Sample rate for the audio data (required for loudness).
- stem_name (Optional[str]): Stem name for clipping logging.
- Returns:
- torch.Tensor: Normalized audio.
- """
- scale_peak = 10 ** (-peak_clip_headroom_db / 20)
- scale_rms = 10 ** (-rms_headroom_db / 20)
- if strategy == 'peak':
- rescaling = (scale_peak / wav.abs().max())
- if normalize or rescaling < 1:
- wav = wav * rescaling
- elif strategy == 'clip':
- wav = wav.clamp(-scale_peak, scale_peak)
- elif strategy == 'rms':
- mono = wav.mean(dim=0)
- rescaling = scale_rms / mono.pow(2).mean().sqrt()
- if normalize or rescaling < 1:
- wav = wav * rescaling
- _clip_wav(wav, log_clipping=log_clipping, stem_name=stem_name)
- elif strategy == 'loudness':
- assert sample_rate is not None, "Loudness normalization requires sample rate."
- wav = normalize_loudness(wav, sample_rate, loudness_headroom_db, loudness_compressor)
- _clip_wav(wav, log_clipping=log_clipping, stem_name=stem_name)
- else:
- assert wav.abs().max() < 1
- assert strategy == '' or strategy == 'none', f"Unexpected strategy: '{strategy}'"
- return wav
-
-
-def f32_pcm(wav: torch.Tensor) -> torch.Tensor:
- """Convert audio to float 32 bits PCM format.
- """
- if wav.dtype.is_floating_point:
- return wav
- else:
- assert wav.dtype == torch.int16
- return wav.float() / 2**15
-
-
-def i16_pcm(wav: torch.Tensor) -> torch.Tensor:
- """Convert audio to int 16 bits PCM format.
-
- ..Warning:: There exist many formula for doing this convertion. None are perfect
- due to the asymetry of the int16 range. One either have possible clipping, DC offset,
- or inconsistancies with f32_pcm. If the given wav doesn't have enough headroom,
- it is possible that `i16_pcm(f32_pcm)) != Identity`.
- """
- if wav.dtype.is_floating_point:
- assert wav.abs().max() <= 1
- candidate = (wav * 2 ** 15).round()
- if candidate.max() >= 2 ** 15: # clipping would occur
- candidate = (wav * (2 ** 15 - 1)).round()
- return candidate.short()
- else:
- assert wav.dtype == torch.int16
- return wav
diff --git a/spaces/Datasculptor/sd-prism/share_btn.py b/spaces/Datasculptor/sd-prism/share_btn.py
deleted file mode 100644
index 797a92ed18e2616a5dbbbc60bf8db22d9e07d902..0000000000000000000000000000000000000000
--- a/spaces/Datasculptor/sd-prism/share_btn.py
+++ /dev/null
@@ -1,100 +0,0 @@
-community_icon_html = """"""
-
-loading_icon_html = """"""
-
-share_js = """async () => {
- async function uploadFile(file){
- const UPLOAD_URL = 'https://huggingface.co/uploads';
- const response = await fetch(UPLOAD_URL, {
- method: 'POST',
- headers: {
- 'Content-Type': file.type,
- 'X-Requested-With': 'XMLHttpRequest',
- },
- body: file, /// <- File inherits from Blob
- });
- const url = await response.text();
- return url;
- }
-
- async function getInputImgFile(imgEl){
- const res = await fetch(imgEl.src);
- const blob = await res.blob();
- const imgId = Date.now() % 200;
- const isPng = imgEl.src.startsWith(`data:image/png`);
- if(isPng){
- const fileName = `sd-perception-${{imgId}}.png`;
- return new File([blob], fileName, { type: 'image/png' });
- }else{
- const fileName = `sd-perception-${{imgId}}.jpg`;
- return new File([blob], fileName, { type: 'image/jpeg' });
- }
- }
-
- const gradioEl = document.querySelector('body > gradio-app');
- // const gradioEl = document.querySelector("gradio-app").shadowRoot;
- const inputImgEl = gradioEl.querySelector('#input-img img');
- const imgEls = gradioEl.querySelectorAll('#generated-gallery img');
- const promptTxt = gradioEl.querySelector('#translated textarea').value;
- let titleTxt = promptTxt;
- if(titleTxt.length > 100){
- titleTxt = titleTxt.slice(0, 100) + ' ...';
- }
- const shareBtnEl = gradioEl.querySelector('#share-btn');
- const shareIconEl = gradioEl.querySelector('#share-btn-share-icon');
- const loadingIconEl = gradioEl.querySelector('#share-btn-loading-icon');
-
- if(!imgEls.length){
- return;
- };
-
- shareBtnEl.style.pointerEvents = 'none';
- shareIconEl.style.display = 'none';
- loadingIconEl.style.removeProperty('display');
-
- const files = await Promise.all(
- [...imgEls].map(async (imgEl) => {
- const res = await fetch(imgEl.src);
- const blob = await res.blob();
- const imgId = Date.now() % 200;
- const fileName = `sd-perception-${{imgId}}.jpg`;
- return new File([blob], fileName, { type: 'image/jpeg' });
- })
- );
- const inputFile = await getInputImgFile(inputImgEl);
- files.push(inputFile);
-
- const urls = await Promise.all(files.map((f) => uploadFile(f)));
- const urlInputImg = urls.pop();
- const htmlImgs = urls.map(url => ``);
- const htmlImgsMd = htmlImgs.join(`\n`);
-
- const descriptionMd = `#### Input img:
-
-
-#### Caption:
-${promptTxt}
-
-#### Generations:
-
-${htmlImgsMd}
-
`;
-
- const params = new URLSearchParams({
- title: titleTxt,
- description: descriptionMd,
- });
-
- const paramsStr = params.toString();
- window.open(`https://huggingface.co/spaces/pharma/sd-prism/discussions/new?${paramsStr}`, '_blank');
-
- shareBtnEl.style.removeProperty('pointer-events');
- shareIconEl.style.removeProperty('display');
- loadingIconEl.style.display = 'none';
-}"""
\ No newline at end of file
diff --git a/spaces/Detomo/aisatsu-app-api/utils.py b/spaces/Detomo/aisatsu-app-api/utils.py
deleted file mode 100644
index b129cff699059570b4459625a44f1ab8a366eb51..0000000000000000000000000000000000000000
--- a/spaces/Detomo/aisatsu-app-api/utils.py
+++ /dev/null
@@ -1,47 +0,0 @@
-from io import BytesIO
-import base64
-from PIL import Image
-import cv2
-import numpy as np
-from gtts import gTTS
-
-def tts(text: str, language="ja") -> object:
- """Converts text into autoplay html.
- Args:
- text (str): generated answer of bot
- language (str): language of text
- Returns:
- html: autoplay object
- """
- tts_object = gTTS(text=text, lang=language, slow=False)
- bytes_object = BytesIO()
- tts_object.write_to_fp(bytes_object)
- bytes_object.seek(0)
- b64 = base64.b64encode(bytes_object.getvalue()).decode()
- return b64
-
-
-def read_image_file(file) -> Image.Image:
- image = Image.open(BytesIO(file))
- return image
-
-
-def pil_to_base64(img, format="jpeg"):
- buffer = BytesIO()
- img.save(buffer, format)
- img_str = base64.b64encode(buffer.getvalue()).decode("ascii")
- return img_str
-
-
-def base64_to_pil(img_str):
- if "base64," in img_str:
- img_str = img_str.split(",")[1]
- img_raw = base64.b64decode(img_str)
- img = Image.open(BytesIO(img_raw))
- return img
-
-
-def get_hist(image):
- hist = cv2.calcHist([np.array(image)], [0, 1, 2], None, [8, 8, 8], [0, 256, 0, 256, 0, 256])
- hist = cv2.normalize(hist, hist).flatten()
- return hist
\ No newline at end of file
diff --git a/spaces/DragGan/DragGan-Inversion/stylegan_human/torch_utils/ops/bias_act.cpp b/spaces/DragGan/DragGan-Inversion/stylegan_human/torch_utils/ops/bias_act.cpp
deleted file mode 100644
index aef47317a3ae018de6ea620060337bcf44b2d649..0000000000000000000000000000000000000000
--- a/spaces/DragGan/DragGan-Inversion/stylegan_human/torch_utils/ops/bias_act.cpp
+++ /dev/null
@@ -1,101 +0,0 @@
-// Copyright (c) SenseTime Research. All rights reserved.
-
-// 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.
-
-#include
-#include
-#include
-#include "bias_act.h"
-
-//------------------------------------------------------------------------
-
-static bool has_same_layout(torch::Tensor x, torch::Tensor y)
-{
- if (x.dim() != y.dim())
- return false;
- for (int64_t i = 0; i < x.dim(); i++)
- {
- if (x.size(i) != y.size(i))
- return false;
- if (x.size(i) >= 2 && x.stride(i) != y.stride(i))
- return false;
- }
- return true;
-}
-
-//------------------------------------------------------------------------
-
-static torch::Tensor bias_act(torch::Tensor x, torch::Tensor b, torch::Tensor xref, torch::Tensor yref, torch::Tensor dy, int grad, int dim, int act, float alpha, float gain, float clamp)
-{
- // Validate arguments.
- TORCH_CHECK(x.is_cuda(), "x must reside on CUDA device");
- TORCH_CHECK(b.numel() == 0 || (b.dtype() == x.dtype() && b.device() == x.device()), "b must have the same dtype and device as x");
- TORCH_CHECK(xref.numel() == 0 || (xref.sizes() == x.sizes() && xref.dtype() == x.dtype() && xref.device() == x.device()), "xref must have the same shape, dtype, and device as x");
- TORCH_CHECK(yref.numel() == 0 || (yref.sizes() == x.sizes() && yref.dtype() == x.dtype() && yref.device() == x.device()), "yref must have the same shape, dtype, and device as x");
- TORCH_CHECK(dy.numel() == 0 || (dy.sizes() == x.sizes() && dy.dtype() == x.dtype() && dy.device() == x.device()), "dy must have the same dtype and device as x");
- TORCH_CHECK(x.numel() <= INT_MAX, "x is too large");
- TORCH_CHECK(b.dim() == 1, "b must have rank 1");
- TORCH_CHECK(b.numel() == 0 || (dim >= 0 && dim < x.dim()), "dim is out of bounds");
- TORCH_CHECK(b.numel() == 0 || b.numel() == x.size(dim), "b has wrong number of elements");
- TORCH_CHECK(grad >= 0, "grad must be non-negative");
-
- // Validate layout.
- TORCH_CHECK(x.is_non_overlapping_and_dense(), "x must be non-overlapping and dense");
- TORCH_CHECK(b.is_contiguous(), "b must be contiguous");
- TORCH_CHECK(xref.numel() == 0 || has_same_layout(xref, x), "xref must have the same layout as x");
- TORCH_CHECK(yref.numel() == 0 || has_same_layout(yref, x), "yref must have the same layout as x");
- TORCH_CHECK(dy.numel() == 0 || has_same_layout(dy, x), "dy must have the same layout as x");
-
- // Create output tensor.
- const at::cuda::OptionalCUDAGuard device_guard(device_of(x));
- torch::Tensor y = torch::empty_like(x);
- TORCH_CHECK(has_same_layout(y, x), "y must have the same layout as x");
-
- // Initialize CUDA kernel parameters.
- bias_act_kernel_params p;
- p.x = x.data_ptr();
- p.b = (b.numel()) ? b.data_ptr() : NULL;
- p.xref = (xref.numel()) ? xref.data_ptr() : NULL;
- p.yref = (yref.numel()) ? yref.data_ptr() : NULL;
- p.dy = (dy.numel()) ? dy.data_ptr() : NULL;
- p.y = y.data_ptr();
- p.grad = grad;
- p.act = act;
- p.alpha = alpha;
- p.gain = gain;
- p.clamp = clamp;
- p.sizeX = (int)x.numel();
- p.sizeB = (int)b.numel();
- p.stepB = (b.numel()) ? (int)x.stride(dim) : 1;
-
- // Choose CUDA kernel.
- void* kernel;
- AT_DISPATCH_FLOATING_TYPES_AND_HALF(x.scalar_type(), "upfirdn2d_cuda", [&]
- {
- kernel = choose_bias_act_kernel(p);
- });
- TORCH_CHECK(kernel, "no CUDA kernel found for the specified activation func");
-
- // Launch CUDA kernel.
- p.loopX = 4;
- int blockSize = 4 * 32;
- int gridSize = (p.sizeX - 1) / (p.loopX * blockSize) + 1;
- void* args[] = {&p};
- AT_CUDA_CHECK(cudaLaunchKernel(kernel, gridSize, blockSize, args, 0, at::cuda::getCurrentCUDAStream()));
- return y;
-}
-
-//------------------------------------------------------------------------
-
-PYBIND11_MODULE(TORCH_EXTENSION_NAME, m)
-{
- m.def("bias_act", &bias_act);
-}
-
-//------------------------------------------------------------------------
diff --git a/spaces/DragGan/DragGan-Inversion/stylegan_human/training/networks_stylegan2.py b/spaces/DragGan/DragGan-Inversion/stylegan_human/training/networks_stylegan2.py
deleted file mode 100644
index 923f150ef7352ed85b4be2ff8d9f8a6193aac1e9..0000000000000000000000000000000000000000
--- a/spaces/DragGan/DragGan-Inversion/stylegan_human/training/networks_stylegan2.py
+++ /dev/null
@@ -1,974 +0,0 @@
-# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-#
-# NVIDIA CORPORATION and its licensors retain all intellectual property
-# and proprietary rights in and to this software, related documentation
-# and any modifications thereto. Any use, reproduction, disclosure or
-# distribution of this software and related documentation without an express
-# license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-"""Network architectures from the paper
-"Analyzing and Improving the Image Quality of StyleGAN".
-Matches the original implementation of configs E-F by Karras et al. at
-https://github.com/NVlabs/stylegan2/blob/master/training/networks_stylegan2.py"""
-
-import numpy as np
-import torch
-import torch.nn.functional as F
-from torch_utils import misc
-from torch_utils import persistence
-from torch_utils.ops import conv2d_resample
-from torch_utils.ops import upfirdn2d
-from torch_utils.ops import bias_act
-from torch_utils.ops import fma
-
-# ----------------------------------------------------------------------------
-
-
-@misc.profiled_function
-def normalize_2nd_moment(x, dim=1, eps=1e-8):
- return x * (x.square().mean(dim=dim, keepdim=True) + eps).rsqrt()
-
-# ----------------------------------------------------------------------------
-
-
-@misc.profiled_function
-def modulated_conv2d(
- # Input tensor of shape [batch_size, in_channels, in_height, in_width].
- x,
- # Weight tensor of shape [out_channels, in_channels, kernel_height, kernel_width].
- weight,
- # Modulation coefficients of shape [batch_size, in_channels].
- styles,
- noise=None, # Optional noise tensor to add to the output activations.
- up=1, # Integer upsampling factor.
- down=1, # Integer downsampling factor.
- padding=0, # Padding with respect to the upsampled image.
- # Low-pass filter to apply when resampling activations. Must be prepared beforehand by calling upfirdn2d.setup_filter().
- resample_filter=None,
- demodulate=True, # Apply weight demodulation?
- # False = convolution, True = correlation (matches torch.nn.functional.conv2d).
- flip_weight=True,
- # Perform modulation, convolution, and demodulation as a single fused operation?
- fused_modconv=True,
-):
- batch_size = x.shape[0]
- out_channels, in_channels, kh, kw = weight.shape
- misc.assert_shape(weight, [out_channels, in_channels, kh, kw]) # [OIkk]
- misc.assert_shape(x, [batch_size, in_channels, None, None]) # [NIHW]
- misc.assert_shape(styles, [batch_size, in_channels]) # [NI]
-
- # Pre-normalize inputs to avoid FP16 overflow.
- if x.dtype == torch.float16 and demodulate:
- weight = weight * (1 / np.sqrt(in_channels * kh * kw) /
- weight.norm(float('inf'), dim=[1, 2, 3], keepdim=True)) # max_Ikk
- styles = styles / \
- styles.norm(float('inf'), dim=1, keepdim=True) # max_I
-
- # Calculate per-sample weights and demodulation coefficients.
- w = None
- dcoefs = None
- if demodulate or fused_modconv:
- w = weight.unsqueeze(0) # [NOIkk]
- w = w * styles.reshape(batch_size, 1, -1, 1, 1) # [NOIkk]
- if demodulate:
- dcoefs = (w.square().sum(dim=[2, 3, 4]) + 1e-8).rsqrt() # [NO]
- if demodulate and fused_modconv:
- w = w * dcoefs.reshape(batch_size, -1, 1, 1, 1) # [NOIkk]
-
- # Execute by scaling the activations before and after the convolution.
- if not fused_modconv:
- x = x * styles.to(x.dtype).reshape(batch_size, -1, 1, 1)
- x = conv2d_resample.conv2d_resample(x=x, w=weight.to(
- x.dtype), f=resample_filter, up=up, down=down, padding=padding, flip_weight=flip_weight)
- if demodulate and noise is not None:
- x = fma.fma(x, dcoefs.to(x.dtype).reshape(
- batch_size, -1, 1, 1), noise.to(x.dtype))
- elif demodulate:
- x = x * dcoefs.to(x.dtype).reshape(batch_size, -1, 1, 1)
- elif noise is not None:
- x = x.add_(noise.to(x.dtype))
- return x
-
- # Execute as one fused op using grouped convolution.
- with misc.suppress_tracer_warnings(): # this value will be treated as a constant
- batch_size = int(batch_size)
- misc.assert_shape(x, [batch_size, in_channels, None, None])
- x = x.reshape(1, -1, *x.shape[2:])
- w = w.reshape(-1, in_channels, kh, kw)
- x = conv2d_resample.conv2d_resample(x=x, w=w.to(
- x.dtype), f=resample_filter, up=up, down=down, padding=padding, groups=batch_size, flip_weight=flip_weight)
- x = x.reshape(batch_size, -1, *x.shape[2:])
- if noise is not None:
- x = x.add_(noise)
- return x
-
-# ----------------------------------------------------------------------------
-
-
-@persistence.persistent_class
-class FullyConnectedLayer(torch.nn.Module):
- def __init__(self,
- in_features, # Number of input features.
- out_features, # Number of output features.
- bias=True, # Apply additive bias before the activation function?
- # Activation function: 'relu', 'lrelu', etc.
- activation='linear',
- lr_multiplier=1, # Learning rate multiplier.
- bias_init=0, # Initial value for the additive bias.
- ):
- super().__init__()
- self.in_features = in_features
- self.out_features = out_features
- self.activation = activation
- self.weight = torch.nn.Parameter(torch.randn(
- [out_features, in_features]) / lr_multiplier)
- self.bias = torch.nn.Parameter(torch.full(
- [out_features], np.float32(bias_init))) if bias else None
- self.weight_gain = lr_multiplier / np.sqrt(in_features)
- self.bias_gain = lr_multiplier
-
- def forward(self, x):
- w = self.weight.to(x.dtype) * self.weight_gain
- b = self.bias
- if b is not None:
- b = b.to(x.dtype)
- if self.bias_gain != 1:
- b = b * self.bias_gain
-
- if self.activation == 'linear' and b is not None:
- x = torch.addmm(b.unsqueeze(0), x, w.t())
- else:
- x = x.matmul(w.t())
- x = bias_act.bias_act(x, b, act=self.activation)
- return x
-
- def extra_repr(self):
- return f'in_features={self.in_features:d}, out_features={self.out_features:d}, activation={self.activation:s}'
-
-# ----------------------------------------------------------------------------
-
-
-@persistence.persistent_class
-class Conv2dLayer(torch.nn.Module):
- def __init__(self,
- in_channels, # Number of input channels.
- out_channels, # Number of output channels.
- # Width and height of the convolution kernel.
- kernel_size,
- bias=True, # Apply additive bias before the activation function?
- # Activation function: 'relu', 'lrelu', etc.
- activation='linear',
- up=1, # Integer upsampling factor.
- down=1, # Integer downsampling factor.
- # Low-pass filter to apply when resampling activations.
- resample_filter=[1, 3, 3, 1],
- # Clamp the output to +-X, None = disable clamping.
- conv_clamp=None,
- channels_last=False, # Expect the input to have memory_format=channels_last?
- trainable=True, # Update the weights of this layer during training?
- ):
- super().__init__()
- self.in_channels = in_channels
- self.out_channels = out_channels
- self.activation = activation
- self.up = up
- self.down = down
- self.conv_clamp = conv_clamp
- self.register_buffer(
- 'resample_filter', upfirdn2d.setup_filter(resample_filter))
- self.padding = kernel_size // 2
- self.weight_gain = 1 / np.sqrt(in_channels * (kernel_size ** 2))
- self.act_gain = bias_act.activation_funcs[activation].def_gain
-
- memory_format = torch.channels_last if channels_last else torch.contiguous_format
- weight = torch.randn([out_channels, in_channels, kernel_size, kernel_size]).to(
- memory_format=memory_format)
- bias = torch.zeros([out_channels]) if bias else None
- if trainable:
- self.weight = torch.nn.Parameter(weight)
- self.bias = torch.nn.Parameter(bias) if bias is not None else None
- else:
- self.register_buffer('weight', weight)
- if bias is not None:
- self.register_buffer('bias', bias)
- else:
- self.bias = None
-
- def forward(self, x, gain=1):
- w = self.weight * self.weight_gain
- b = self.bias.to(x.dtype) if self.bias is not None else None
- flip_weight = (self.up == 1) # slightly faster
- x = conv2d_resample.conv2d_resample(x=x, w=w.to(
- x.dtype), f=self.resample_filter, up=self.up, down=self.down, padding=self.padding, flip_weight=flip_weight)
-
- act_gain = self.act_gain * gain
- act_clamp = self.conv_clamp * gain if self.conv_clamp is not None else None
- x = bias_act.bias_act(x, b, act=self.activation,
- gain=act_gain, clamp=act_clamp)
- return x
-
- def extra_repr(self):
- return ' '.join([
- f'in_channels={self.in_channels:d}, out_channels={self.out_channels:d}, activation={self.activation:s},',
- f'up={self.up}, down={self.down}'])
-
-# ----------------------------------------------------------------------------
-
-
-@persistence.persistent_class
-class MappingNetwork(torch.nn.Module):
- def __init__(self,
- # Input latent (Z) dimensionality, 0 = no latent.
- z_dim,
- # Conditioning label (C) dimensionality, 0 = no label.
- c_dim,
- # Intermediate latent (W) dimensionality.
- w_dim,
- # Number of intermediate latents to output, None = do not broadcast.
- num_ws,
- num_layers=8, # Number of mapping layers.
- # Label embedding dimensionality, None = same as w_dim.
- embed_features=None,
- # Number of intermediate features in the mapping layers, None = same as w_dim.
- layer_features=None,
- # Activation function: 'relu', 'lrelu', etc.
- activation='lrelu',
- # Learning rate multiplier for the mapping layers.
- lr_multiplier=0.01,
- # Decay for tracking the moving average of W during training, None = do not track.
- w_avg_beta=0.998,
- ):
- super().__init__()
- self.z_dim = z_dim
- self.c_dim = c_dim
- self.w_dim = w_dim
- self.num_ws = num_ws
- self.num_layers = num_layers
- self.w_avg_beta = w_avg_beta
-
- if embed_features is None:
- embed_features = w_dim
- if c_dim == 0:
- embed_features = 0
- if layer_features is None:
- layer_features = w_dim
- features_list = [z_dim + embed_features] + \
- [layer_features] * (num_layers - 1) + [w_dim]
-
- if c_dim > 0:
- self.embed = FullyConnectedLayer(c_dim, embed_features)
- for idx in range(num_layers):
- in_features = features_list[idx]
- out_features = features_list[idx + 1]
- layer = FullyConnectedLayer(
- in_features, out_features, activation=activation, lr_multiplier=lr_multiplier)
- setattr(self, f'fc{idx}', layer)
-
- if num_ws is not None and w_avg_beta is not None:
- self.register_buffer('w_avg', torch.zeros([w_dim]))
-
- def forward(self, z, c, truncation_psi=1, truncation_cutoff=None, update_emas=False):
- # Embed, normalize, and concat inputs.
- x = None
- with torch.autograd.profiler.record_function('input'):
- if self.z_dim > 0:
- misc.assert_shape(z, [None, self.z_dim])
- x = normalize_2nd_moment(z.to(torch.float32))
- if self.c_dim > 0:
- misc.assert_shape(c, [None, self.c_dim])
- y = normalize_2nd_moment(self.embed(c.to(torch.float32)))
- x = torch.cat([x, y], dim=1) if x is not None else y
-
- # Main layers.
- for idx in range(self.num_layers):
- layer = getattr(self, f'fc{idx}')
- x = layer(x)
-
- # Update moving average of W.
- if update_emas and self.w_avg_beta is not None:
- with torch.autograd.profiler.record_function('update_w_avg'):
- self.w_avg.copy_(x.detach().mean(
- dim=0).lerp(self.w_avg, self.w_avg_beta))
-
- # Broadcast.
- if self.num_ws is not None:
- with torch.autograd.profiler.record_function('broadcast'):
- x = x.unsqueeze(1).repeat([1, self.num_ws, 1])
-
- # Apply truncation.
- if truncation_psi != 1:
- with torch.autograd.profiler.record_function('truncate'):
- assert self.w_avg_beta is not None
- if self.num_ws is None or truncation_cutoff is None:
- x = self.w_avg.lerp(x, truncation_psi)
- else:
- x[:, :truncation_cutoff] = self.w_avg.lerp(
- x[:, :truncation_cutoff], truncation_psi)
- return x
-
- def extra_repr(self):
- return f'z_dim={self.z_dim:d}, c_dim={self.c_dim:d}, w_dim={self.w_dim:d}, num_ws={self.num_ws:d}'
-
-# ----------------------------------------------------------------------------
-
-
-@persistence.persistent_class
-class SynthesisLayer(torch.nn.Module):
- def __init__(self,
- in_channels, # Number of input channels.
- out_channels, # Number of output channels.
- # Intermediate latent (W) dimensionality.
- w_dim,
- resolution, # Resolution of this layer.
- kernel_size=3, # Convolution kernel size.
- up=1, # Integer upsampling factor.
- use_noise=True, # Enable noise input?
- # Activation function: 'relu', 'lrelu', etc.
- activation='lrelu',
- # Low-pass filter to apply when resampling activations.
- resample_filter=[1, 3, 3, 1],
- # Clamp the output of convolution layers to +-X, None = disable clamping.
- conv_clamp=None,
- channels_last=False, # Use channels_last format for the weights?
- ):
- super().__init__()
- self.in_channels = in_channels
- self.out_channels = out_channels
- self.w_dim = w_dim
- self.resolution = resolution
- self.up = up
- self.use_noise = use_noise
- self.activation = activation
- self.conv_clamp = conv_clamp
- self.register_buffer(
- 'resample_filter', upfirdn2d.setup_filter(resample_filter))
- self.padding = kernel_size // 2
- self.act_gain = bias_act.activation_funcs[activation].def_gain
-
- self.affine = FullyConnectedLayer(w_dim, in_channels, bias_init=1)
- memory_format = torch.channels_last if channels_last else torch.contiguous_format
- self.weight = torch.nn.Parameter(torch.randn(
- [out_channels, in_channels, kernel_size, kernel_size]).to(memory_format=memory_format))
- if use_noise:
- self.register_buffer(
- 'noise_const', torch.randn([resolution, resolution]))
- self.noise_strength = torch.nn.Parameter(torch.zeros([]))
- self.bias = torch.nn.Parameter(torch.zeros([out_channels]))
-
- def forward(self, x, w, noise_mode='random', fused_modconv=True, gain=1):
- assert noise_mode in ['random', 'const', 'none']
- in_resolution = self.resolution // self.up
- misc.assert_shape(x, [None, self.in_channels,
- in_resolution, in_resolution])
- styles = self.affine(w)
-
- noise = None
- if self.use_noise and noise_mode == 'random':
- noise = torch.randn([x.shape[0], 1, self.resolution,
- self.resolution], device=x.device) * self.noise_strength
- if self.use_noise and noise_mode == 'const':
- noise = self.noise_const * self.noise_strength
-
- flip_weight = (self.up == 1) # slightly faster
- x = modulated_conv2d(x=x, weight=self.weight, styles=styles, noise=noise, up=self.up,
- padding=self.padding, resample_filter=self.resample_filter, flip_weight=flip_weight, fused_modconv=fused_modconv)
-
- act_gain = self.act_gain * gain
- act_clamp = self.conv_clamp * gain if self.conv_clamp is not None else None
- x = bias_act.bias_act(x, self.bias.to(
- x.dtype), act=self.activation, gain=act_gain, clamp=act_clamp)
- return x
-
- def extra_repr(self):
- return ' '.join([
- f'in_channels={self.in_channels:d}, out_channels={self.out_channels:d}, w_dim={self.w_dim:d},',
- f'resolution={self.resolution:d}, up={self.up}, activation={self.activation:s}'])
-
-# ----------------------------------------------------------------------------
-
-
-@persistence.persistent_class
-class ToRGBLayer(torch.nn.Module):
- def __init__(self, in_channels, out_channels, w_dim, kernel_size=1, conv_clamp=None, channels_last=False):
- super().__init__()
- self.in_channels = in_channels
- self.out_channels = out_channels
- self.w_dim = w_dim
- self.conv_clamp = conv_clamp
- self.affine = FullyConnectedLayer(w_dim, in_channels, bias_init=1)
- memory_format = torch.channels_last if channels_last else torch.contiguous_format
- self.weight = torch.nn.Parameter(torch.randn(
- [out_channels, in_channels, kernel_size, kernel_size]).to(memory_format=memory_format))
- self.bias = torch.nn.Parameter(torch.zeros([out_channels]))
- self.weight_gain = 1 / np.sqrt(in_channels * (kernel_size ** 2))
-
- def forward(self, x, w, fused_modconv=True):
- styles = self.affine(w) * self.weight_gain
- x = modulated_conv2d(x=x, weight=self.weight, styles=styles,
- demodulate=False, fused_modconv=fused_modconv)
- x = bias_act.bias_act(x, self.bias.to(x.dtype), clamp=self.conv_clamp)
- return x
-
- def extra_repr(self):
- return f'in_channels={self.in_channels:d}, out_channels={self.out_channels:d}, w_dim={self.w_dim:d}'
-
-# ----------------------------------------------------------------------------
-
-
-@persistence.persistent_class
-class SynthesisBlock(torch.nn.Module):
- def __init__(self,
- # Number of input channels, 0 = first block.
- in_channels,
- # Number of output channels.
- out_channels,
- # Intermediate latent (W) dimensionality.
- w_dim,
- # Resolution of this block.
- resolution,
- # Number of output color channels.
- img_channels,
- is_last, # Is this the last block?
- # Architecture: 'orig', 'skip', 'resnet'.
- architecture='skip',
- # Low-pass filter to apply when resampling activations.
- resample_filter=[1, 3, 3, 1],
- # Clamp the output of convolution layers to +-X, None = disable clamping.
- conv_clamp=256,
- use_fp16=False, # Use FP16 for this block?
- fp16_channels_last=False, # Use channels-last memory format with FP16?
- # Default value of fused_modconv. 'inference_only' = True for inference, False for training.
- fused_modconv_default=True,
- # Arguments for SynthesisLayer.
- **layer_kwargs,
- ):
- assert architecture in ['orig', 'skip', 'resnet']
- super().__init__()
- self.in_channels = in_channels
- self.w_dim = w_dim
- self.resolution = resolution
- self.img_channels = img_channels
- self.is_last = is_last
- self.architecture = architecture
- self.use_fp16 = use_fp16
- self.channels_last = (use_fp16 and fp16_channels_last)
- self.fused_modconv_default = fused_modconv_default
- self.register_buffer(
- 'resample_filter', upfirdn2d.setup_filter(resample_filter))
- self.num_conv = 0
- self.num_torgb = 0
-
- if in_channels == 0:
- self.const = torch.nn.Parameter(torch.randn(
- [out_channels, resolution, resolution]))
-
- if in_channels != 0:
- self.conv0 = SynthesisLayer(in_channels, out_channels, w_dim=w_dim, resolution=resolution, up=2,
- resample_filter=resample_filter, conv_clamp=conv_clamp, channels_last=self.channels_last, **layer_kwargs)
- self.num_conv += 1
-
- self.conv1 = SynthesisLayer(out_channels, out_channels, w_dim=w_dim, resolution=resolution,
- conv_clamp=conv_clamp, channels_last=self.channels_last, **layer_kwargs)
- self.num_conv += 1
-
- if is_last or architecture == 'skip':
- self.torgb = ToRGBLayer(out_channels, img_channels, w_dim=w_dim,
- conv_clamp=conv_clamp, channels_last=self.channels_last)
- self.num_torgb += 1
-
- if in_channels != 0 and architecture == 'resnet':
- self.skip = Conv2dLayer(in_channels, out_channels, kernel_size=1, bias=False, up=2,
- resample_filter=resample_filter, channels_last=self.channels_last)
-
- def forward(self, x, img, ws, force_fp32=False, fused_modconv=None, update_emas=False, **layer_kwargs):
- _ = update_emas # unused
- misc.assert_shape(
- ws, [None, self.num_conv + self.num_torgb, self.w_dim])
- w_iter = iter(ws.unbind(dim=1))
- if ws.device.type != 'cuda':
- force_fp32 = True
- dtype = torch.float16 if self.use_fp16 and not force_fp32 else torch.float32
- memory_format = torch.channels_last if self.channels_last and not force_fp32 else torch.contiguous_format
- if fused_modconv is None:
- fused_modconv = self.fused_modconv_default
- if fused_modconv == 'inference_only':
- fused_modconv = (not self.training)
-
- # Input.
- if self.in_channels == 0:
- x = self.const.to(dtype=dtype, memory_format=memory_format)
- x = x.unsqueeze(0).repeat([ws.shape[0], 1, 1, 1])
- else:
- misc.assert_shape(x, [None, self.in_channels,
- self.resolution // 2, self.resolution // 2])
- x = x.to(dtype=dtype, memory_format=memory_format)
-
- # Main layers.
- if self.in_channels == 0:
- x = self.conv1(x, next(w_iter),
- fused_modconv=fused_modconv, **layer_kwargs)
- elif self.architecture == 'resnet':
- y = self.skip(x, gain=np.sqrt(0.5))
- x = self.conv0(x, next(w_iter),
- fused_modconv=fused_modconv, **layer_kwargs)
- x = self.conv1(x, next(w_iter), fused_modconv=fused_modconv,
- gain=np.sqrt(0.5), **layer_kwargs)
- x = y.add_(x)
- else:
- x = self.conv0(x, next(w_iter),
- fused_modconv=fused_modconv, **layer_kwargs)
- x = self.conv1(x, next(w_iter),
- fused_modconv=fused_modconv, **layer_kwargs)
-
- # ToRGB.
- if img is not None:
- misc.assert_shape(
- img, [None, self.img_channels, self.resolution // 2, self.resolution // 2])
- img = upfirdn2d.upsample2d(img, self.resample_filter)
- if self.is_last or self.architecture == 'skip':
- y = self.torgb(x, next(w_iter), fused_modconv=fused_modconv)
- y = y.to(dtype=torch.float32,
- memory_format=torch.contiguous_format)
- img = img.add_(y) if img is not None else y
-
- assert x.dtype == dtype
- assert img is None or img.dtype == torch.float32
- return x, img
-
- def extra_repr(self):
- return f'resolution={self.resolution:d}, architecture={self.architecture:s}'
-
-# ----------------------------------------------------------------------------
-
-
-@persistence.persistent_class
-class SynthesisNetwork(torch.nn.Module):
- def __init__(self,
- # Intermediate latent (W) dimensionality.
- w_dim,
- img_resolution, # Output image resolution.
- img_channels, # Number of color channels.
- # Overall multiplier for the number of channels.
- channel_base=32768,
- # Maximum number of channels in any layer.
- channel_max=512,
- # Use FP16 for the N highest resolutions.
- num_fp16_res=4,
- **block_kwargs, # Arguments for SynthesisBlock.
- ):
- assert img_resolution >= 4 and img_resolution & (
- img_resolution - 1) == 0
- super().__init__()
- self.w_dim = w_dim
- self.img_resolution = img_resolution
- self.img_resolution_log2 = int(np.log2(img_resolution))
- self.img_channels = img_channels
- self.num_fp16_res = num_fp16_res
- self.block_resolutions = [
- 2 ** i for i in range(2, self.img_resolution_log2 + 1)]
- channels_dict = {res: min(channel_base // res, channel_max)
- for res in self.block_resolutions}
- fp16_resolution = max(
- 2 ** (self.img_resolution_log2 + 1 - num_fp16_res), 8)
-
- self.num_ws = 0
- for res in self.block_resolutions:
- in_channels = channels_dict[res // 2] if res > 4 else 0
- out_channels = channels_dict[res]
- use_fp16 = (res >= fp16_resolution)
- is_last = (res == self.img_resolution)
- block = SynthesisBlock(in_channels, out_channels, w_dim=w_dim, resolution=res,
- img_channels=img_channels, is_last=is_last, use_fp16=use_fp16, **block_kwargs)
- self.num_ws += block.num_conv
- if is_last:
- self.num_ws += block.num_torgb
- setattr(self, f'b{res}', block)
-
- def forward(self, ws, return_feature=False, **block_kwargs):
- block_ws = []
- features = []
- with torch.autograd.profiler.record_function('split_ws'):
- misc.assert_shape(ws, [None, self.num_ws, self.w_dim])
- ws = ws.to(torch.float32)
- w_idx = 0
- for res in self.block_resolutions:
- block = getattr(self, f'b{res}')
- block_ws.append(
- ws.narrow(1, w_idx, block.num_conv + block.num_torgb))
- w_idx += block.num_conv
-
- x = img = None
- for res, cur_ws in zip(self.block_resolutions, block_ws):
- block = getattr(self, f'b{res}')
- x, img = block(x, img, cur_ws, **block_kwargs)
- features.append(x)
- if return_feature:
- return img, features
- else:
- return img
-
- def extra_repr(self):
- return ' '.join([
- f'w_dim={self.w_dim:d}, num_ws={self.num_ws:d},',
- f'img_resolution={self.img_resolution:d}, img_channels={self.img_channels:d},',
- f'num_fp16_res={self.num_fp16_res:d}'])
-
-# ----------------------------------------------------------------------------
-
-
-@persistence.persistent_class
-class Generator(torch.nn.Module):
- def __init__(self,
- z_dim, # Input latent (Z) dimensionality.
- # Conditioning label (C) dimensionality.
- c_dim,
- # Intermediate latent (W) dimensionality.
- w_dim,
- img_resolution, # Output resolution.
- img_channels, # Number of output color channels.
- mapping_kwargs={}, # Arguments for MappingNetwork.
- synthesis_kwargs={}, # Arguments for SynthesisNetwork.
- resize=None,
- # **synthesis_kwargs, # Arguments for SynthesisNetwork.
- ):
- super().__init__()
- self.z_dim = z_dim
- self.c_dim = c_dim
- self.w_dim = w_dim
- self.img_resolution = img_resolution
- self.img_channels = img_channels
- self.synthesis = SynthesisNetwork(
- w_dim=w_dim, img_resolution=img_resolution, img_channels=img_channels, **synthesis_kwargs)
- self.num_ws = self.synthesis.num_ws
- self.mapping = MappingNetwork(
- z_dim=z_dim, c_dim=c_dim, w_dim=w_dim, num_ws=self.num_ws, **mapping_kwargs)
- self.resize = resize
-
- def forward(self, z, c, truncation_psi=1, truncation_cutoff=None, update_emas=False, input_is_w=False, return_feature=False, **synthesis_kwargs):
- if input_is_w:
- ws = z
- if ws.dim() == 2:
- ws = ws.unsqueeze(1).repeat([1, self.mapping.num_ws, 1])
- else:
- ws = self.mapping(z, c, truncation_psi=truncation_psi,
- truncation_cutoff=truncation_cutoff, update_emas=update_emas)
- img = self.synthesis(ws, update_emas=update_emas,
- return_feature=return_feature, **synthesis_kwargs)
- if self.resize is not None:
- img = imresize(img, [self.resize, self.resize])
- return img
-
-
-def imresize(image, size):
- dim = image.dim()
- if dim == 3:
- image = image.unsqueeze(1)
- b, _, h, w = image.shape
- if size[0] > h:
- image = F.interpolate(image, size, mode='bilinear')
- elif size[0] < h:
- image = F.interpolate(image, size, mode='area')
- if dim == 3:
- image = image.squeeze(1)
- return image
-
-# ----------------------------------------------------------------------------
-
-
-@persistence.persistent_class
-class DiscriminatorBlock(torch.nn.Module):
- def __init__(self,
- # Number of input channels, 0 = first block.
- in_channels,
- # Number of intermediate channels.
- tmp_channels,
- # Number of output channels.
- out_channels,
- # Resolution of this block.
- resolution,
- # Number of input color channels.
- img_channels,
- # Index of the first layer.
- first_layer_idx,
- # Architecture: 'orig', 'skip', 'resnet'.
- architecture='resnet',
- # Activation function: 'relu', 'lrelu', etc.
- activation='lrelu',
- # Low-pass filter to apply when resampling activations.
- resample_filter=[1, 3, 3, 1],
- # Clamp the output of convolution layers to +-X, None = disable clamping.
- conv_clamp=None,
- use_fp16=False, # Use FP16 for this block?
- fp16_channels_last=False, # Use channels-last memory format with FP16?
- # Freeze-D: Number of layers to freeze.
- freeze_layers=0,
- ):
- assert in_channels in [0, tmp_channels]
- assert architecture in ['orig', 'skip', 'resnet']
- super().__init__()
- self.in_channels = in_channels
- self.resolution = resolution
- self.img_channels = img_channels
- self.first_layer_idx = first_layer_idx
- self.architecture = architecture
- self.use_fp16 = use_fp16
- self.channels_last = (use_fp16 and fp16_channels_last)
- self.register_buffer(
- 'resample_filter', upfirdn2d.setup_filter(resample_filter))
-
- self.num_layers = 0
-
- def trainable_gen():
- while True:
- layer_idx = self.first_layer_idx + self.num_layers
- trainable = (layer_idx >= freeze_layers)
- self.num_layers += 1
- yield trainable
- trainable_iter = trainable_gen()
-
- if in_channels == 0 or architecture == 'skip':
- self.fromrgb = Conv2dLayer(img_channels, tmp_channels, kernel_size=1, activation=activation,
- trainable=next(trainable_iter), conv_clamp=conv_clamp, channels_last=self.channels_last)
-
- self.conv0 = Conv2dLayer(tmp_channels, tmp_channels, kernel_size=3, activation=activation,
- trainable=next(trainable_iter), conv_clamp=conv_clamp, channels_last=self.channels_last)
-
- self.conv1 = Conv2dLayer(tmp_channels, out_channels, kernel_size=3, activation=activation, down=2,
- trainable=next(trainable_iter), resample_filter=resample_filter, conv_clamp=conv_clamp, channels_last=self.channels_last)
-
- if architecture == 'resnet':
- self.skip = Conv2dLayer(tmp_channels, out_channels, kernel_size=1, bias=False, down=2,
- trainable=next(trainable_iter), resample_filter=resample_filter, channels_last=self.channels_last)
-
- def forward(self, x, img, force_fp32=False):
- if (x if x is not None else img).device.type != 'cuda':
- force_fp32 = True
- dtype = torch.float16 if self.use_fp16 and not force_fp32 else torch.float32
- memory_format = torch.channels_last if self.channels_last and not force_fp32 else torch.contiguous_format
-
- # Input.
- if x is not None:
- misc.assert_shape(x, [None, self.in_channels,
- self.resolution, self.resolution])
- x = x.to(dtype=dtype, memory_format=memory_format)
-
- # FromRGB.
- if self.in_channels == 0 or self.architecture == 'skip':
- misc.assert_shape(
- img, [None, self.img_channels, self.resolution, self.resolution])
- img = img.to(dtype=dtype, memory_format=memory_format)
- y = self.fromrgb(img)
- x = x + y if x is not None else y
- img = upfirdn2d.downsample2d(
- img, self.resample_filter) if self.architecture == 'skip' else None
-
- # Main layers.
- if self.architecture == 'resnet':
- y = self.skip(x, gain=np.sqrt(0.5))
- x = self.conv0(x)
- x = self.conv1(x, gain=np.sqrt(0.5))
- x = y.add_(x)
- else:
- x = self.conv0(x)
- x = self.conv1(x)
-
- assert x.dtype == dtype
- return x, img
-
- def extra_repr(self):
- return f'resolution={self.resolution:d}, architecture={self.architecture:s}'
-
-# ----------------------------------------------------------------------------
-
-
-@persistence.persistent_class
-class MinibatchStdLayer(torch.nn.Module):
- def __init__(self, group_size, num_channels=1):
- super().__init__()
- self.group_size = group_size
- self.num_channels = num_channels
-
- def forward(self, x):
- N, C, H, W = x.shape
- with misc.suppress_tracer_warnings(): # as_tensor results are registered as constants
- G = torch.min(torch.as_tensor(self.group_size), torch.as_tensor(
- N)) if self.group_size is not None else N
- F = self.num_channels
- c = C // F
-
- # [GnFcHW] Split minibatch N into n groups of size G, and channels C into F groups of size c.
- y = x.reshape(G, -1, F, c, H, W)
- # [GnFcHW] Subtract mean over group.
- y = y - y.mean(dim=0)
- # [nFcHW] Calc variance over group.
- y = y.square().mean(dim=0)
- y = (y + 1e-8).sqrt() # [nFcHW] Calc stddev over group.
- # [nF] Take average over channels and pixels.
- y = y.mean(dim=[2, 3, 4])
- y = y.reshape(-1, F, 1, 1) # [nF11] Add missing dimensions.
- # [NFHW] Replicate over group and pixels.
- y = y.repeat(G, 1, H, W)
- # [NCHW] Append to input as new channels.
- x = torch.cat([x, y], dim=1)
- return x
-
- def extra_repr(self):
- return f'group_size={self.group_size}, num_channels={self.num_channels:d}'
-
-# ----------------------------------------------------------------------------
-
-
-@persistence.persistent_class
-class DiscriminatorEpilogue(torch.nn.Module):
- def __init__(self,
- in_channels, # Number of input channels.
- # Dimensionality of mapped conditioning label, 0 = no label.
- cmap_dim,
- resolution, # Resolution of this block.
- # Number of input color channels.
- img_channels,
- # Architecture: 'orig', 'skip', 'resnet'.
- architecture='resnet',
- # Group size for the minibatch standard deviation layer, None = entire minibatch.
- mbstd_group_size=4,
- # Number of features for the minibatch standard deviation layer, 0 = disable.
- mbstd_num_channels=1,
- # Activation function: 'relu', 'lrelu', etc.
- activation='lrelu',
- # Clamp the output of convolution layers to +-X, None = disable clamping.
- conv_clamp=None,
- ):
- assert architecture in ['orig', 'skip', 'resnet']
- super().__init__()
- self.in_channels = in_channels
- self.cmap_dim = cmap_dim
- self.resolution = resolution
- self.img_channels = img_channels
- self.architecture = architecture
-
- if architecture == 'skip':
- self.fromrgb = Conv2dLayer(
- img_channels, in_channels, kernel_size=1, activation=activation)
- self.mbstd = MinibatchStdLayer(
- group_size=mbstd_group_size, num_channels=mbstd_num_channels) if mbstd_num_channels > 0 else None
- self.conv = Conv2dLayer(in_channels + mbstd_num_channels, in_channels,
- kernel_size=3, activation=activation, conv_clamp=conv_clamp)
- self.fc = FullyConnectedLayer(
- in_channels * (resolution ** 2), in_channels, activation=activation)
- self.out = FullyConnectedLayer(
- in_channels, 1 if cmap_dim == 0 else cmap_dim)
-
- def forward(self, x, img, cmap, force_fp32=False):
- misc.assert_shape(x, [None, self.in_channels,
- self.resolution, self.resolution]) # [NCHW]
- _ = force_fp32 # unused
- dtype = torch.float32
- memory_format = torch.contiguous_format
-
- # FromRGB.
- x = x.to(dtype=dtype, memory_format=memory_format)
- if self.architecture == 'skip':
- misc.assert_shape(
- img, [None, self.img_channels, self.resolution, self.resolution])
- img = img.to(dtype=dtype, memory_format=memory_format)
- x = x + self.fromrgb(img)
-
- # Main layers.
- if self.mbstd is not None:
- x = self.mbstd(x)
- x = self.conv(x)
- x = self.fc(x.flatten(1))
- x = self.out(x)
-
- # Conditioning.
- if self.cmap_dim > 0:
- misc.assert_shape(cmap, [None, self.cmap_dim])
- x = (x * cmap).sum(dim=1, keepdim=True) * \
- (1 / np.sqrt(self.cmap_dim))
-
- assert x.dtype == dtype
- return x
-
- def extra_repr(self):
- return f'resolution={self.resolution:d}, architecture={self.architecture:s}'
-
-# ----------------------------------------------------------------------------
-
-
-@persistence.persistent_class
-class Discriminator(torch.nn.Module):
- def __init__(self,
- # Conditioning label (C) dimensionality.
- c_dim,
- img_resolution, # Input resolution.
- # Number of input color channels.
- img_channels,
- # Architecture: 'orig', 'skip', 'resnet'.
- architecture='resnet',
- # Overall multiplier for the number of channels.
- channel_base=32768,
- # Maximum number of channels in any layer.
- channel_max=512,
- # Use FP16 for the N highest resolutions.
- num_fp16_res=4,
- # Clamp the output of convolution layers to +-X, None = disable clamping.
- conv_clamp=256,
- # Dimensionality of mapped conditioning label, None = default.
- cmap_dim=None,
- block_kwargs={}, # Arguments for DiscriminatorBlock.
- mapping_kwargs={}, # Arguments for MappingNetwork.
- # Arguments for DiscriminatorEpilogue.
- epilogue_kwargs={},
- ):
- super().__init__()
- self.c_dim = c_dim
- self.img_resolution = img_resolution
- self.img_resolution_log2 = int(np.log2(img_resolution))
- self.img_channels = img_channels
- self.block_resolutions = [
- 2 ** i for i in range(self.img_resolution_log2, 2, -1)]
- channels_dict = {res: min(channel_base // res, channel_max)
- for res in self.block_resolutions + [4]}
- fp16_resolution = max(
- 2 ** (self.img_resolution_log2 + 1 - num_fp16_res), 8)
-
- if cmap_dim is None:
- cmap_dim = channels_dict[4]
- if c_dim == 0:
- cmap_dim = 0
-
- common_kwargs = dict(img_channels=img_channels,
- architecture=architecture, conv_clamp=conv_clamp)
- cur_layer_idx = 0
- for res in self.block_resolutions:
- in_channels = channels_dict[res] if res < img_resolution else 0
- tmp_channels = channels_dict[res]
- out_channels = channels_dict[res // 2]
- use_fp16 = (res >= fp16_resolution)
- block = DiscriminatorBlock(in_channels, tmp_channels, out_channels, resolution=res,
- first_layer_idx=cur_layer_idx, use_fp16=use_fp16, **block_kwargs, **common_kwargs)
- setattr(self, f'b{res}', block)
- cur_layer_idx += block.num_layers
- if c_dim > 0:
- self.mapping = MappingNetwork(
- z_dim=0, c_dim=c_dim, w_dim=cmap_dim, num_ws=None, w_avg_beta=None, **mapping_kwargs)
- self.b4 = DiscriminatorEpilogue(
- channels_dict[4], cmap_dim=cmap_dim, resolution=4, **epilogue_kwargs, **common_kwargs)
-
- def forward(self, img, c, update_emas=False, **block_kwargs):
- _ = update_emas # unused
- x = None
- for res in self.block_resolutions:
- block = getattr(self, f'b{res}')
- x, img = block(x, img, **block_kwargs)
-
- cmap = None
- if self.c_dim > 0:
- cmap = self.mapping(None, c)
- x = self.b4(x, img, cmap)
- return x
-
- def extra_repr(self):
- return f'c_dim={self.c_dim:d}, img_resolution={self.img_resolution:d}, img_channels={self.img_channels:d}'
-
-# ----------------------------------------------------------------------------
diff --git a/spaces/EXPOSUREEE/Ai-Image-Enhancer/realesrgan/archs/srvgg_arch.py b/spaces/EXPOSUREEE/Ai-Image-Enhancer/realesrgan/archs/srvgg_arch.py
deleted file mode 100644
index 39460965c9c5ee9cd6eb41c50d33574cb8ba6e50..0000000000000000000000000000000000000000
--- a/spaces/EXPOSUREEE/Ai-Image-Enhancer/realesrgan/archs/srvgg_arch.py
+++ /dev/null
@@ -1,69 +0,0 @@
-from basicsr.utils.registry import ARCH_REGISTRY
-from torch import nn as nn
-from torch.nn import functional as F
-
-
-@ARCH_REGISTRY.register()
-class SRVGGNetCompact(nn.Module):
- """A compact VGG-style network structure for super-resolution.
-
- It is a compact network structure, which performs upsampling in the last layer and no convolution is
- conducted on the HR feature space.
-
- Args:
- num_in_ch (int): Channel number of inputs. Default: 3.
- num_out_ch (int): Channel number of outputs. Default: 3.
- num_feat (int): Channel number of intermediate features. Default: 64.
- num_conv (int): Number of convolution layers in the body network. Default: 16.
- upscale (int): Upsampling factor. Default: 4.
- act_type (str): Activation type, options: 'relu', 'prelu', 'leakyrelu'. Default: prelu.
- """
-
- def __init__(self, num_in_ch=3, num_out_ch=3, num_feat=64, num_conv=16, upscale=4, act_type='prelu'):
- super(SRVGGNetCompact, self).__init__()
- self.num_in_ch = num_in_ch
- self.num_out_ch = num_out_ch
- self.num_feat = num_feat
- self.num_conv = num_conv
- self.upscale = upscale
- self.act_type = act_type
-
- self.body = nn.ModuleList()
- # the first conv
- self.body.append(nn.Conv2d(num_in_ch, num_feat, 3, 1, 1))
- # the first activation
- if act_type == 'relu':
- activation = nn.ReLU(inplace=True)
- elif act_type == 'prelu':
- activation = nn.PReLU(num_parameters=num_feat)
- elif act_type == 'leakyrelu':
- activation = nn.LeakyReLU(negative_slope=0.1, inplace=True)
- self.body.append(activation)
-
- # the body structure
- for _ in range(num_conv):
- self.body.append(nn.Conv2d(num_feat, num_feat, 3, 1, 1))
- # activation
- if act_type == 'relu':
- activation = nn.ReLU(inplace=True)
- elif act_type == 'prelu':
- activation = nn.PReLU(num_parameters=num_feat)
- elif act_type == 'leakyrelu':
- activation = nn.LeakyReLU(negative_slope=0.1, inplace=True)
- self.body.append(activation)
-
- # the last conv
- self.body.append(nn.Conv2d(num_feat, num_out_ch * upscale * upscale, 3, 1, 1))
- # upsample
- self.upsampler = nn.PixelShuffle(upscale)
-
- def forward(self, x):
- out = x
- for i in range(0, len(self.body)):
- out = self.body[i](out)
-
- out = self.upsampler(out)
- # add the nearest upsampled image, so that the network learns the residual
- base = F.interpolate(x, scale_factor=self.upscale, mode='nearest')
- out += base
- return out
diff --git a/spaces/EronSamez/RVC_HFmeu/tools/infer/trans_weights.py b/spaces/EronSamez/RVC_HFmeu/tools/infer/trans_weights.py
deleted file mode 100644
index 1c54eefd6e7c678238d31e251a2e15479bf35d5b..0000000000000000000000000000000000000000
--- a/spaces/EronSamez/RVC_HFmeu/tools/infer/trans_weights.py
+++ /dev/null
@@ -1,18 +0,0 @@
-import pdb
-
-import torch
-
-# a=torch.load(r"E:\codes\py39\vits_vc_gpu_train\logs\ft-mi-suc\G_1000.pth")["model"]#sim_nsf#
-# a=torch.load(r"E:\codes\py39\vits_vc_gpu_train\logs\ft-mi-freeze-vocoder-flow-enc_q\G_1000.pth")["model"]#sim_nsf#
-# a=torch.load(r"E:\codes\py39\vits_vc_gpu_train\logs\ft-mi-freeze-vocoder\G_1000.pth")["model"]#sim_nsf#
-# a=torch.load(r"E:\codes\py39\vits_vc_gpu_train\logs\ft-mi-test\G_1000.pth")["model"]#sim_nsf#
-a = torch.load(
- r"E:\codes\py39\vits_vc_gpu_train\logs\ft-mi-no_opt-no_dropout\G_1000.pth"
-)[
- "model"
-] # sim_nsf#
-for key in a.keys():
- a[key] = a[key].half()
-# torch.save(a,"ft-mi-freeze-vocoder_true_1k.pt")#
-# torch.save(a,"ft-mi-sim1k.pt")#
-torch.save(a, "ft-mi-no_opt-no_dropout.pt") #
diff --git a/spaces/FYP-23-S1-21/Refineverse_Plugin/templates/ProjectBreakdownUI.html b/spaces/FYP-23-S1-21/Refineverse_Plugin/templates/ProjectBreakdownUI.html
deleted file mode 100644
index 65b54ecbfb58ce55f2be84e92ce61dd73ebfa387..0000000000000000000000000000000000000000
--- a/spaces/FYP-23-S1-21/Refineverse_Plugin/templates/ProjectBreakdownUI.html
+++ /dev/null
@@ -1,171 +0,0 @@
-
-
-
- Project Task Breakdown
-
-
-
-
-
-
-
-
-
-
-
-
Project Task Breakdown
-
-
-
-
-
-
-
-
Breakdown Summary
-
-
-
-
-
-
User Story
-
Project Task
-
-
-
-
-
- {% for row in rows %}
-
-
-
{{ row[0] }}
-
{{ row[1] }}
-
- {% endfor %}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/spaces/Gen-Sim/Gen-Sim/cliport/generated_tasks/create_pyramid_with_color_coded_ells.py b/spaces/Gen-Sim/Gen-Sim/cliport/generated_tasks/create_pyramid_with_color_coded_ells.py
deleted file mode 100644
index 392494eb59d1a1c08ebd5698822e45f63c8dd021..0000000000000000000000000000000000000000
--- a/spaces/Gen-Sim/Gen-Sim/cliport/generated_tasks/create_pyramid_with_color_coded_ells.py
+++ /dev/null
@@ -1,58 +0,0 @@
-import numpy as np
-import os
-import pybullet as p
-import random
-from cliport.tasks import primitives
-from cliport.tasks.grippers import Spatula
-from cliport.tasks.task import Task
-from cliport.utils import utils
-import numpy as np
-from cliport.tasks.task import Task
-from cliport.utils import utils
-import pybullet as p
-
-class CreatePyramidWithColorCodedElls(Task):
- """Pick up ell-shaped objects of different colors and stack them onto a pallet in the shape of a pyramid."""
-
- def __init__(self):
- super().__init__()
- self.max_steps = 20
- self.lang_template = "stack the {color} ell on the pyramid"
- self.task_completed_desc = "done stacking ell pyramid."
- self.additional_reset()
-
- def reset(self, env):
- super().reset(env)
-
- # Add pallet.
- pallet_size = (0.15, 0.15, 0.01)
- pallet_urdf = 'pallet/pallet.urdf'
- pallet_pose = self.get_random_pose(env, pallet_size)
- env.add_object(pallet_urdf, pallet_pose, category='fixed')
-
- # Ell colors.
- colors = [
- utils.COLORS['red'], utils.COLORS['blue'],
- utils.COLORS['yellow'], utils.COLORS['green']
- ]
- color_names = ['red', 'blue', 'yellow', 'green']
-
- # Add Ells.
- ell_size = (0.04, 0.04, 0.04)
- ell_urdf = 'insertion/ell.urdf'
- objs = []
- for i in range(4):
- ell_pose = self.get_random_pose(env, ell_size)
- ell_id = env.add_object(ell_urdf, ell_pose, color=colors[i])
- objs.append(ell_id)
-
- # Associate placement locations for goals.
- place_pos = [(0, -0.05, 0.03), (0, 0, 0.03),
- (0, 0.05, 0.03), (0, 0, 0.08)]
- targs = [(utils.apply(pallet_pose, i), pallet_pose[1]) for i in place_pos]
-
- # Goal: Ells are stacked in a pyramid (bottom row: red, middle row: blue, top row: yellow, green).
- for i in range(4):
- self.add_goal(objs=[objs[i]], matches=np.ones((1, 1)), targ_poses=[targs[i]], replace=False,
- rotations=True, metric='pose', params=None, step_max_reward=1 / 4, symmetries=[np.pi/2],
- language_goal=self.lang_template.format(color=color_names[i]))
\ No newline at end of file
diff --git a/spaces/Gen-Sim/Gen-Sim/cliport/generated_tasks/insert_ell_along_square_path.py b/spaces/Gen-Sim/Gen-Sim/cliport/generated_tasks/insert_ell_along_square_path.py
deleted file mode 100644
index b1dbce4c230b14bbfdd888392a1727673addd7c7..0000000000000000000000000000000000000000
--- a/spaces/Gen-Sim/Gen-Sim/cliport/generated_tasks/insert_ell_along_square_path.py
+++ /dev/null
@@ -1,59 +0,0 @@
-import numpy as np
-import os
-import pybullet as p
-import random
-from cliport.tasks import primitives
-from cliport.tasks.grippers import Spatula
-from cliport.tasks.task import Task
-from cliport.utils import utils
-import numpy as np
-from cliport.tasks.task import Task
-from cliport.utils import utils
-import pybullet as p
-
-class InsertEllAlongSquarePath(Task):
- """Pick up each ell block and insert it into the fixture of the same color. However, the robot must move each ell block along the marked square path to reach the fixture."""
-
- def __init__(self):
- super().__init__()
- self.max_steps = 20
- self.lang_template = "move the {color} ell block into the {color} fixture"
- self.task_completed_desc = "done inserting ell blocks."
- self.additional_reset()
-
- def reset(self, env):
- super().reset(env)
-
- # Ell block colors.
- colors = ['red', 'blue', 'green', 'yellow']
-
- # Add ell blocks and fixtures.
- ell_size = (0.04, 0.04, 0.04)
- ell_urdf = 'insertion/ell.urdf'
- fixture_urdf = 'insertion/fixture.urdf'
- ell_blocks = []
- fixtures = []
- for color in colors:
- # Add ell block
- ell_pose = self.get_random_pose(env, ell_size)
- ell_id = env.add_object(ell_urdf, ell_pose, color=utils.COLORS[color])
- ell_blocks.append(ell_id)
-
- # Add fixture
- fixture_pose = self.get_random_pose(env, ell_size)
- fixture_id = env.add_object(fixture_urdf, fixture_pose, color=utils.COLORS[color])
- fixtures.append(fixture_id)
-
- # Goal: each ell block is inserted into the fixture of the same color.
- for i in range(len(colors)):
- self.add_goal(objs=[ell_blocks[i]], matches=np.ones((1, 1)), targ_poses=[p.getBasePositionAndOrientation(fixtures[i])], replace=False,
- rotations=True, metric='pose', params=None, step_max_reward=1/len(colors),
- language_goal=self.lang_template.format(color=colors[i]))
-
- # Add square path marked by small blocks.
- path_block_size = (0.02, 0.02, 0.02)
- path_block_urdf = 'block/small.urdf'
- path_block_color = utils.COLORS['gray']
- for _ in range(16):
- path_block_pose = self.get_random_pose(env, path_block_size)
- env.add_object(path_block_urdf, path_block_pose, color=path_block_color)
\ No newline at end of file
diff --git a/spaces/GilbertClaus/VideoCutter/bunkrr.py b/spaces/GilbertClaus/VideoCutter/bunkrr.py
deleted file mode 100644
index 9b87e04e4b2478c09fd94dffa979df299c832c5e..0000000000000000000000000000000000000000
--- a/spaces/GilbertClaus/VideoCutter/bunkrr.py
+++ /dev/null
@@ -1,36 +0,0 @@
-from bs4 import BeautifulSoup
-import re
-from others import *
-
-def get_info_bunkrr(soup: BeautifulSoup):
- # Mencari judul video di elemen
- title = soup.find("title")
- if title:
- video_title = title.text
-
- # Ubah '&' menjadi '&'
- video_title = video_title.replace('&', '&')
-
- # Jika ada karakter '-' maka cari '-' paling belakang dan hapus mulai dari itu sampai ke belakang
- if '-' in video_title:
- last_dash_index = video_title.rfind('-')
- video_title = video_title[:last_dash_index]
-
- # Sisa dari karakter '-' ubah menjadi ' '
- video_title = video_title.replace('-', ' ')
-
- # Mencari link download yang berawalan https dan berakhiran .mp4
- link_download = soup.find("source", src=re.compile(r'^https.*\.mp4$'))
- if link_download:
- link_download = link_download['src']
-
- # Ubah '&' menjadi '&'
- link_download = link_download.replace('&', '&')
- print(link_download)
- else:
- link_download = ''
-
- return video_title, link_download
- else:
- print("Tidak ditemukan elemen <title>")
- return '', ''
\ No newline at end of file
diff --git a/spaces/Giozh/openai-reverse-proxy/Dockerfile b/spaces/Giozh/openai-reverse-proxy/Dockerfile
deleted file mode 100644
index 4cb0ce42128d9a2ad33a395883f5e5455a38c707..0000000000000000000000000000000000000000
--- a/spaces/Giozh/openai-reverse-proxy/Dockerfile
+++ /dev/null
@@ -1,11 +0,0 @@
-FROM node:18-bullseye-slim
-RUN apt-get update && \
- apt-get install -y git
-RUN git clone https://gitgud.io/khanon/oai-reverse-proxy.git /app
-WORKDIR /app
-RUN npm install
-COPY Dockerfile greeting.md* .env* ./
-RUN npm run build
-EXPOSE 7860
-ENV NODE_ENV=production
-CMD [ "npm", "start" ]
\ No newline at end of file
diff --git a/spaces/GipAdonimus/Real-Time-Voice-Cloning/encoder/preprocess.py b/spaces/GipAdonimus/Real-Time-Voice-Cloning/encoder/preprocess.py
deleted file mode 100644
index 551a8b29c4d84c0e1430f285a1c8b5e10c98ee5f..0000000000000000000000000000000000000000
--- a/spaces/GipAdonimus/Real-Time-Voice-Cloning/encoder/preprocess.py
+++ /dev/null
@@ -1,175 +0,0 @@
-from multiprocess.pool import ThreadPool
-from encoder.params_data import *
-from encoder.config import librispeech_datasets, anglophone_nationalites
-from datetime import datetime
-from encoder import audio
-from pathlib import Path
-from tqdm import tqdm
-import numpy as np
-
-
-class DatasetLog:
- """
- Registers metadata about the dataset in a text file.
- """
- def __init__(self, root, name):
- self.text_file = open(Path(root, "Log_%s.txt" % name.replace("/", "_")), "w")
- self.sample_data = dict()
-
- start_time = str(datetime.now().strftime("%A %d %B %Y at %H:%M"))
- self.write_line("Creating dataset %s on %s" % (name, start_time))
- self.write_line("-----")
- self._log_params()
-
- def _log_params(self):
- from encoder import params_data
- self.write_line("Parameter values:")
- for param_name in (p for p in dir(params_data) if not p.startswith("__")):
- value = getattr(params_data, param_name)
- self.write_line("\t%s: %s" % (param_name, value))
- self.write_line("-----")
-
- def write_line(self, line):
- self.text_file.write("%s\n" % line)
-
- def add_sample(self, **kwargs):
- for param_name, value in kwargs.items():
- if not param_name in self.sample_data:
- self.sample_data[param_name] = []
- self.sample_data[param_name].append(value)
-
- def finalize(self):
- self.write_line("Statistics:")
- for param_name, values in self.sample_data.items():
- self.write_line("\t%s:" % param_name)
- self.write_line("\t\tmin %.3f, max %.3f" % (np.min(values), np.max(values)))
- self.write_line("\t\tmean %.3f, median %.3f" % (np.mean(values), np.median(values)))
- self.write_line("-----")
- end_time = str(datetime.now().strftime("%A %d %B %Y at %H:%M"))
- self.write_line("Finished on %s" % end_time)
- self.text_file.close()
-
-
-def _init_preprocess_dataset(dataset_name, datasets_root, out_dir) -> (Path, DatasetLog):
- dataset_root = datasets_root.joinpath(dataset_name)
- if not dataset_root.exists():
- print("Couldn\'t find %s, skipping this dataset." % dataset_root)
- return None, None
- return dataset_root, DatasetLog(out_dir, dataset_name)
-
-
-def _preprocess_speaker_dirs(speaker_dirs, dataset_name, datasets_root, out_dir, extension,
- skip_existing, logger):
- print("%s: Preprocessing data for %d speakers." % (dataset_name, len(speaker_dirs)))
-
- # Function to preprocess utterances for one speaker
- def preprocess_speaker(speaker_dir: Path):
- # Give a name to the speaker that includes its dataset
- speaker_name = "_".join(speaker_dir.relative_to(datasets_root).parts)
-
- # Create an output directory with that name, as well as a txt file containing a
- # reference to each source file.
- speaker_out_dir = out_dir.joinpath(speaker_name)
- speaker_out_dir.mkdir(exist_ok=True)
- sources_fpath = speaker_out_dir.joinpath("_sources.txt")
-
- # There's a possibility that the preprocessing was interrupted earlier, check if
- # there already is a sources file.
- if sources_fpath.exists():
- try:
- with sources_fpath.open("r") as sources_file:
- existing_fnames = {line.split(",")[0] for line in sources_file}
- except:
- existing_fnames = {}
- else:
- existing_fnames = {}
-
- # Gather all audio files for that speaker recursively
- sources_file = sources_fpath.open("a" if skip_existing else "w")
- for in_fpath in speaker_dir.glob("**/*.%s" % extension):
- # Check if the target output file already exists
- out_fname = "_".join(in_fpath.relative_to(speaker_dir).parts)
- out_fname = out_fname.replace(".%s" % extension, ".npy")
- if skip_existing and out_fname in existing_fnames:
- continue
-
- # Load and preprocess the waveform
- wav = audio.preprocess_wav(in_fpath)
- if len(wav) == 0:
- continue
-
- # Create the mel spectrogram, discard those that are too short
- frames = audio.wav_to_mel_spectrogram(wav)
- if len(frames) < partials_n_frames:
- continue
-
- out_fpath = speaker_out_dir.joinpath(out_fname)
- np.save(out_fpath, frames)
- logger.add_sample(duration=len(wav) / sampling_rate)
- sources_file.write("%s,%s\n" % (out_fname, in_fpath))
-
- sources_file.close()
-
- # Process the utterances for each speaker
- with ThreadPool(8) as pool:
- list(tqdm(pool.imap(preprocess_speaker, speaker_dirs), dataset_name, len(speaker_dirs),
- unit="speakers"))
- logger.finalize()
- print("Done preprocessing %s.\n" % dataset_name)
-
-
-def preprocess_librispeech(datasets_root: Path, out_dir: Path, skip_existing=False):
- for dataset_name in librispeech_datasets["train"]["other"]:
- # Initialize the preprocessing
- dataset_root, logger = _init_preprocess_dataset(dataset_name, datasets_root, out_dir)
- if not dataset_root:
- return
-
- # Preprocess all speakers
- speaker_dirs = list(dataset_root.glob("*"))
- _preprocess_speaker_dirs(speaker_dirs, dataset_name, datasets_root, out_dir, "flac",
- skip_existing, logger)
-
-
-def preprocess_voxceleb1(datasets_root: Path, out_dir: Path, skip_existing=False):
- # Initialize the preprocessing
- dataset_name = "VoxCeleb1"
- dataset_root, logger = _init_preprocess_dataset(dataset_name, datasets_root, out_dir)
- if not dataset_root:
- return
-
- # Get the contents of the meta file
- with dataset_root.joinpath("vox1_meta.csv").open("r") as metafile:
- metadata = [line.split("\t") for line in metafile][1:]
-
- # Select the ID and the nationality, filter out non-anglophone speakers
- nationalities = {line[0]: line[3] for line in metadata}
- keep_speaker_ids = [speaker_id for speaker_id, nationality in nationalities.items() if
- nationality.lower() in anglophone_nationalites]
- print("VoxCeleb1: using samples from %d (presumed anglophone) speakers out of %d." %
- (len(keep_speaker_ids), len(nationalities)))
-
- # Get the speaker directories for anglophone speakers only
- speaker_dirs = dataset_root.joinpath("wav").glob("*")
- speaker_dirs = [speaker_dir for speaker_dir in speaker_dirs if
- speaker_dir.name in keep_speaker_ids]
- print("VoxCeleb1: found %d anglophone speakers on the disk, %d missing (this is normal)." %
- (len(speaker_dirs), len(keep_speaker_ids) - len(speaker_dirs)))
-
- # Preprocess all speakers
- _preprocess_speaker_dirs(speaker_dirs, dataset_name, datasets_root, out_dir, "wav",
- skip_existing, logger)
-
-
-def preprocess_voxceleb2(datasets_root: Path, out_dir: Path, skip_existing=False):
- # Initialize the preprocessing
- dataset_name = "VoxCeleb2"
- dataset_root, logger = _init_preprocess_dataset(dataset_name, datasets_root, out_dir)
- if not dataset_root:
- return
-
- # Get the speaker directories
- # Preprocess all speakers
- speaker_dirs = list(dataset_root.joinpath("dev", "aac").glob("*"))
- _preprocess_speaker_dirs(speaker_dirs, dataset_name, datasets_root, out_dir, "m4a",
- skip_existing, logger)
diff --git a/spaces/Goblin-of-Games/README/README.md b/spaces/Goblin-of-Games/README/README.md
deleted file mode 100644
index ced63da3d1aeb683b47bc1c65b0776c33080052e..0000000000000000000000000000000000000000
--- a/spaces/Goblin-of-Games/README/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
-Name: Goblin of Games
-
-Address: Ago Palace way, Lagos,Nigeria
-
-Phone: +2349032425535
-
-Email: oluwanifemiadelakun001@gmail.com
-
-Website: https://oluwanifemiadelaku.wixsite.com/goblin-of-games
-
-About Us:
-
-Goblin of Games is a leading developer and publisher of fantasy-themed video games. With a team of experienced game developers and designers, we create immersive and engaging gaming experiences for players of all ages. From role-playing games to strategy games and beyond, we strive to push the boundaries of what is possible in the world of fantasy gaming. Come join us on our journey and discover the magic of Goblin of Games.
\ No newline at end of file
diff --git a/spaces/Gradio-Blocks/uniformer_image_segmentation/configs/deeplabv3/deeplabv3_r50-d8_512x512_80k_ade20k.py b/spaces/Gradio-Blocks/uniformer_image_segmentation/configs/deeplabv3/deeplabv3_r50-d8_512x512_80k_ade20k.py
deleted file mode 100644
index 78f4d0d9de3d6b8dd2b097531317956d8e3b19f1..0000000000000000000000000000000000000000
--- a/spaces/Gradio-Blocks/uniformer_image_segmentation/configs/deeplabv3/deeplabv3_r50-d8_512x512_80k_ade20k.py
+++ /dev/null
@@ -1,6 +0,0 @@
-_base_ = [
- '../_base_/models/deeplabv3_r50-d8.py', '../_base_/datasets/ade20k.py',
- '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-model = dict(
- decode_head=dict(num_classes=150), auxiliary_head=dict(num_classes=150))
diff --git a/spaces/Gradio-Blocks/uniformer_image_segmentation/mmseg/models/backbones/uniformer.py b/spaces/Gradio-Blocks/uniformer_image_segmentation/mmseg/models/backbones/uniformer.py
deleted file mode 100644
index f599e981d0a31d5cd5dae01595dc1ff30513ccc5..0000000000000000000000000000000000000000
--- a/spaces/Gradio-Blocks/uniformer_image_segmentation/mmseg/models/backbones/uniformer.py
+++ /dev/null
@@ -1,422 +0,0 @@
-# --------------------------------------------------------
-# UniFormer
-# Copyright (c) 2022 SenseTime X-Lab
-# Licensed under The MIT License [see LICENSE for details]
-# Written by Kunchang Li
-# --------------------------------------------------------
-
-from collections import OrderedDict
-import math
-
-from functools import partial
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import torch.utils.checkpoint as checkpoint
-import numpy as np
-from timm.models.layers import DropPath, to_2tuple, trunc_normal_
-
-from mmcv_custom import load_checkpoint
-from mmseg.utils import get_root_logger
-from ..builder import BACKBONES
-
-
-class Mlp(nn.Module):
- def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):
- super().__init__()
- out_features = out_features or in_features
- hidden_features = hidden_features or in_features
- self.fc1 = nn.Linear(in_features, hidden_features)
- self.act = act_layer()
- self.fc2 = nn.Linear(hidden_features, out_features)
- self.drop = nn.Dropout(drop)
-
- def forward(self, x):
- x = self.fc1(x)
- x = self.act(x)
- x = self.drop(x)
- x = self.fc2(x)
- x = self.drop(x)
- return x
-
-
-class CMlp(nn.Module):
- def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):
- super().__init__()
- out_features = out_features or in_features
- hidden_features = hidden_features or in_features
- self.fc1 = nn.Conv2d(in_features, hidden_features, 1)
- self.act = act_layer()
- self.fc2 = nn.Conv2d(hidden_features, out_features, 1)
- self.drop = nn.Dropout(drop)
-
- def forward(self, x):
- x = self.fc1(x)
- x = self.act(x)
- x = self.drop(x)
- x = self.fc2(x)
- x = self.drop(x)
- return x
-
-
-class CBlock(nn.Module):
- def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop=0., attn_drop=0.,
- drop_path=0., act_layer=nn.GELU, norm_layer=nn.LayerNorm):
- super().__init__()
- self.pos_embed = nn.Conv2d(dim, dim, 3, padding=1, groups=dim)
- self.norm1 = nn.BatchNorm2d(dim)
- self.conv1 = nn.Conv2d(dim, dim, 1)
- self.conv2 = nn.Conv2d(dim, dim, 1)
- self.attn = nn.Conv2d(dim, dim, 5, padding=2, groups=dim)
- # NOTE: drop path for stochastic depth, we shall see if this is better than dropout here
- self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
- self.norm2 = nn.BatchNorm2d(dim)
- mlp_hidden_dim = int(dim * mlp_ratio)
- self.mlp = CMlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)
-
- def forward(self, x):
- x = x + self.pos_embed(x)
- x = x + self.drop_path(self.conv2(self.attn(self.conv1(self.norm1(x)))))
- x = x + self.drop_path(self.mlp(self.norm2(x)))
- return x
-
-
-class Attention(nn.Module):
- def __init__(self, dim, num_heads=8, qkv_bias=False, qk_scale=None, attn_drop=0., proj_drop=0.):
- super().__init__()
- self.num_heads = num_heads
- head_dim = dim // num_heads
- # NOTE scale factor was wrong in my original version, can set manually to be compat with prev weights
- self.scale = qk_scale or head_dim ** -0.5
-
- self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
- self.attn_drop = nn.Dropout(attn_drop)
- self.proj = nn.Linear(dim, dim)
- self.proj_drop = nn.Dropout(proj_drop)
-
- def forward(self, x):
- B, N, C = x.shape
- qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
- q, k, v = qkv[0], qkv[1], qkv[2] # make torchscript happy (cannot use tensor as tuple)
-
- attn = (q @ k.transpose(-2, -1)) * self.scale
- attn = attn.softmax(dim=-1)
- attn = self.attn_drop(attn)
-
- x = (attn @ v).transpose(1, 2).reshape(B, N, C)
- x = self.proj(x)
- x = self.proj_drop(x)
- return x
-
-
-class SABlock(nn.Module):
- def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop=0., attn_drop=0.,
- drop_path=0., act_layer=nn.GELU, norm_layer=nn.LayerNorm):
- super().__init__()
- self.pos_embed = nn.Conv2d(dim, dim, 3, padding=1, groups=dim)
- self.norm1 = norm_layer(dim)
- self.attn = Attention(
- dim,
- num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale,
- attn_drop=attn_drop, proj_drop=drop)
- # NOTE: drop path for stochastic depth, we shall see if this is better than dropout here
- self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
- self.norm2 = norm_layer(dim)
- mlp_hidden_dim = int(dim * mlp_ratio)
- self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)
-
- def forward(self, x):
- x = x + self.pos_embed(x)
- B, N, H, W = x.shape
- x = x.flatten(2).transpose(1, 2)
- x = x + self.drop_path(self.attn(self.norm1(x)))
- x = x + self.drop_path(self.mlp(self.norm2(x)))
- x = x.transpose(1, 2).reshape(B, N, H, W)
- return x
-
-
-def window_partition(x, window_size):
- """
- Args:
- x: (B, H, W, C)
- window_size (int): window size
- Returns:
- windows: (num_windows*B, window_size, window_size, C)
- """
- B, H, W, C = x.shape
- x = x.view(B, H // window_size, window_size, W // window_size, window_size, C)
- windows = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, C)
- return windows
-
-
-def window_reverse(windows, window_size, H, W):
- """
- Args:
- windows: (num_windows*B, window_size, window_size, C)
- window_size (int): Window size
- H (int): Height of image
- W (int): Width of image
- Returns:
- x: (B, H, W, C)
- """
- B = int(windows.shape[0] / (H * W / window_size / window_size))
- x = windows.view(B, H // window_size, W // window_size, window_size, window_size, -1)
- x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, H, W, -1)
- return x
-
-
-class SABlock_Windows(nn.Module):
- def __init__(self, dim, num_heads, window_size=14, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop=0., attn_drop=0.,
- drop_path=0., act_layer=nn.GELU, norm_layer=nn.LayerNorm):
- super().__init__()
- self.window_size=window_size
- self.pos_embed = nn.Conv2d(dim, dim, 3, padding=1, groups=dim)
- self.norm1 = norm_layer(dim)
- self.attn = Attention(
- dim,
- num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale,
- attn_drop=attn_drop, proj_drop=drop)
- # NOTE: drop path for stochastic depth, we shall see if this is better than dropout here
- self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
- self.norm2 = norm_layer(dim)
- mlp_hidden_dim = int(dim * mlp_ratio)
- self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)
-
- def forward(self, x):
- x = x + self.pos_embed(x)
- x = x.permute(0, 2, 3, 1)
- B, H, W, C = x.shape
- shortcut = x
- x = self.norm1(x)
-
- pad_l = pad_t = 0
- pad_r = (self.window_size - W % self.window_size) % self.window_size
- pad_b = (self.window_size - H % self.window_size) % self.window_size
- x = F.pad(x, (0, 0, pad_l, pad_r, pad_t, pad_b))
- _, Hp, Wp, _ = x.shape
-
- x_windows = window_partition(x, self.window_size) # nW*B, window_size, window_size, C
- x_windows = x_windows.view(-1, self.window_size * self.window_size, C) # nW*B, window_size*window_size, C
-
- # W-MSA/SW-MSA
- attn_windows = self.attn(x_windows) # nW*B, window_size*window_size, C
-
- # merge windows
- attn_windows = attn_windows.view(-1, self.window_size, self.window_size, C)
- x = window_reverse(attn_windows, self.window_size, Hp, Wp) # B H' W' C
-
- # reverse cyclic shift
- if pad_r > 0 or pad_b > 0:
- x = x[:, :H, :W, :].contiguous()
-
- x = shortcut + self.drop_path(x)
- x = x + self.drop_path(self.mlp(self.norm2(x)))
- x = x.permute(0, 3, 1, 2).reshape(B, C, H, W)
- return x
-
-
-class PatchEmbed(nn.Module):
- """ Image to Patch Embedding
- """
- def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768):
- super().__init__()
- img_size = to_2tuple(img_size)
- patch_size = to_2tuple(patch_size)
- num_patches = (img_size[1] // patch_size[1]) * (img_size[0] // patch_size[0])
- self.img_size = img_size
- self.patch_size = patch_size
- self.num_patches = num_patches
- self.norm = nn.LayerNorm(embed_dim)
- self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size)
-
- def forward(self, x):
- B, _, H, W = x.shape
- x = self.proj(x)
- B, _, H, W = x.shape
- x = x.flatten(2).transpose(1, 2)
- x = self.norm(x)
- x = x.reshape(B, H, W, -1).permute(0, 3, 1, 2).contiguous()
- return x
-
-
-@BACKBONES.register_module()
-class UniFormer(nn.Module):
- """ Vision Transformer
- A PyTorch impl of : `An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale` -
- https://arxiv.org/abs/2010.11929
- """
- def __init__(self, layers=[3, 4, 8, 3], img_size=224, in_chans=3, num_classes=80, embed_dim=[64, 128, 320, 512],
- head_dim=64, mlp_ratio=4., qkv_bias=True, qk_scale=None, representation_size=None,
- drop_rate=0., attn_drop_rate=0., drop_path_rate=0., norm_layer=partial(nn.LayerNorm, eps=1e-6),
- pretrained_path=None, use_checkpoint=False, checkpoint_num=[0, 0, 0, 0],
- windows=False, hybrid=False, window_size=14):
- """
- Args:
- layer (list): number of block in each layer
- img_size (int, tuple): input image size
- in_chans (int): number of input channels
- num_classes (int): number of classes for classification head
- embed_dim (int): embedding dimension
- head_dim (int): dimension of attention heads
- mlp_ratio (int): ratio of mlp hidden dim to embedding dim
- qkv_bias (bool): enable bias for qkv if True
- qk_scale (float): override default qk scale of head_dim ** -0.5 if set
- representation_size (Optional[int]): enable and set representation layer (pre-logits) to this value if set
- drop_rate (float): dropout rate
- attn_drop_rate (float): attention dropout rate
- drop_path_rate (float): stochastic depth rate
- norm_layer (nn.Module): normalization layer
- pretrained_path (str): path of pretrained model
- use_checkpoint (bool): whether use checkpoint
- checkpoint_num (list): index for using checkpoint in every stage
- windows (bool): whether use window MHRA
- hybrid (bool): whether use hybrid MHRA
- window_size (int): size of window (>14)
- """
- super().__init__()
- self.num_classes = num_classes
- self.use_checkpoint = use_checkpoint
- self.checkpoint_num = checkpoint_num
- self.windows = windows
- print(f'Use Checkpoint: {self.use_checkpoint}')
- print(f'Checkpoint Number: {self.checkpoint_num}')
- self.num_features = self.embed_dim = embed_dim # num_features for consistency with other models
- norm_layer = norm_layer or partial(nn.LayerNorm, eps=1e-6)
-
- self.patch_embed1 = PatchEmbed(
- img_size=img_size, patch_size=4, in_chans=in_chans, embed_dim=embed_dim[0])
- self.patch_embed2 = PatchEmbed(
- img_size=img_size // 4, patch_size=2, in_chans=embed_dim[0], embed_dim=embed_dim[1])
- self.patch_embed3 = PatchEmbed(
- img_size=img_size // 8, patch_size=2, in_chans=embed_dim[1], embed_dim=embed_dim[2])
- self.patch_embed4 = PatchEmbed(
- img_size=img_size // 16, patch_size=2, in_chans=embed_dim[2], embed_dim=embed_dim[3])
-
- self.pos_drop = nn.Dropout(p=drop_rate)
- dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(layers))] # stochastic depth decay rule
- num_heads = [dim // head_dim for dim in embed_dim]
- self.blocks1 = nn.ModuleList([
- CBlock(
- dim=embed_dim[0], num_heads=num_heads[0], mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale,
- drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i], norm_layer=norm_layer)
- for i in range(layers[0])])
- self.norm1=norm_layer(embed_dim[0])
- self.blocks2 = nn.ModuleList([
- CBlock(
- dim=embed_dim[1], num_heads=num_heads[1], mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale,
- drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i+layers[0]], norm_layer=norm_layer)
- for i in range(layers[1])])
- self.norm2 = norm_layer(embed_dim[1])
- if self.windows:
- print('Use local window for all blocks in stage3')
- self.blocks3 = nn.ModuleList([
- SABlock_Windows(
- dim=embed_dim[2], num_heads=num_heads[2], window_size=window_size, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale,
- drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i+layers[0]+layers[1]], norm_layer=norm_layer)
- for i in range(layers[2])])
- elif hybrid:
- print('Use hybrid window for blocks in stage3')
- block3 = []
- for i in range(layers[2]):
- if (i + 1) % 4 == 0:
- block3.append(SABlock(
- dim=embed_dim[2], num_heads=num_heads[2], mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale,
- drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i+layers[0]+layers[1]], norm_layer=norm_layer))
- else:
- block3.append(SABlock_Windows(
- dim=embed_dim[2], num_heads=num_heads[2], window_size=window_size, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale,
- drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i+layers[0]+layers[1]], norm_layer=norm_layer))
- self.blocks3 = nn.ModuleList(block3)
- else:
- print('Use global window for all blocks in stage3')
- self.blocks3 = nn.ModuleList([
- SABlock(
- dim=embed_dim[2], num_heads=num_heads[2], mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale,
- drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i+layers[0]+layers[1]], norm_layer=norm_layer)
- for i in range(layers[2])])
- self.norm3 = norm_layer(embed_dim[2])
- self.blocks4 = nn.ModuleList([
- SABlock(
- dim=embed_dim[3], num_heads=num_heads[3], mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale,
- drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i+layers[0]+layers[1]+layers[2]], norm_layer=norm_layer)
- for i in range(layers[3])])
- self.norm4 = norm_layer(embed_dim[3])
-
- # Representation layer
- if representation_size:
- self.num_features = representation_size
- self.pre_logits = nn.Sequential(OrderedDict([
- ('fc', nn.Linear(embed_dim, representation_size)),
- ('act', nn.Tanh())
- ]))
- else:
- self.pre_logits = nn.Identity()
-
- self.apply(self._init_weights)
- self.init_weights(pretrained=pretrained_path)
-
- def init_weights(self, pretrained):
- if isinstance(pretrained, str):
- logger = get_root_logger()
- load_checkpoint(self, pretrained, map_location='cpu', strict=False, logger=logger)
- print(f'Load pretrained model from {pretrained}')
- def _init_weights(self, m):
- if isinstance(m, nn.Linear):
- trunc_normal_(m.weight, std=.02)
- if isinstance(m, nn.Linear) and m.bias is not None:
- nn.init.constant_(m.bias, 0)
- elif isinstance(m, nn.LayerNorm):
- nn.init.constant_(m.bias, 0)
- nn.init.constant_(m.weight, 1.0)
-
- @torch.jit.ignore
- def no_weight_decay(self):
- return {'pos_embed', 'cls_token'}
-
- def get_classifier(self):
- return self.head
-
- def reset_classifier(self, num_classes, global_pool=''):
- self.num_classes = num_classes
- self.head = nn.Linear(self.embed_dim, num_classes) if num_classes > 0 else nn.Identity()
-
- def forward_features(self, x):
- out = []
- x = self.patch_embed1(x)
- x = self.pos_drop(x)
- for i, blk in enumerate(self.blocks1):
- if self.use_checkpoint and i < self.checkpoint_num[0]:
- x = checkpoint.checkpoint(blk, x)
- else:
- x = blk(x)
- x_out = self.norm1(x.permute(0, 2, 3, 1))
- out.append(x_out.permute(0, 3, 1, 2).contiguous())
- x = self.patch_embed2(x)
- for i, blk in enumerate(self.blocks2):
- if self.use_checkpoint and i < self.checkpoint_num[1]:
- x = checkpoint.checkpoint(blk, x)
- else:
- x = blk(x)
- x_out = self.norm2(x.permute(0, 2, 3, 1))
- out.append(x_out.permute(0, 3, 1, 2).contiguous())
- x = self.patch_embed3(x)
- for i, blk in enumerate(self.blocks3):
- if self.use_checkpoint and i < self.checkpoint_num[2]:
- x = checkpoint.checkpoint(blk, x)
- else:
- x = blk(x)
- x_out = self.norm3(x.permute(0, 2, 3, 1))
- out.append(x_out.permute(0, 3, 1, 2).contiguous())
- x = self.patch_embed4(x)
- for i, blk in enumerate(self.blocks4):
- if self.use_checkpoint and i < self.checkpoint_num[3]:
- x = checkpoint.checkpoint(blk, x)
- else:
- x = blk(x)
- x_out = self.norm4(x.permute(0, 2, 3, 1))
- out.append(x_out.permute(0, 3, 1, 2).contiguous())
- return tuple(out)
-
- def forward(self, x):
- x = self.forward_features(x)
- return x
diff --git a/spaces/GrandaddyShmax/MusicGen_Plus_hfv2/tests/modules/test_seanet.py b/spaces/GrandaddyShmax/MusicGen_Plus_hfv2/tests/modules/test_seanet.py
deleted file mode 100644
index e5c51b340a2f94fb2828b14daf83d5fad645073d..0000000000000000000000000000000000000000
--- a/spaces/GrandaddyShmax/MusicGen_Plus_hfv2/tests/modules/test_seanet.py
+++ /dev/null
@@ -1,115 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-from itertools import product
-
-import pytest
-import torch
-
-from audiocraft.modules.seanet import SEANetEncoder, SEANetDecoder, SEANetResnetBlock
-from audiocraft.modules import StreamableConv1d, StreamableConvTranspose1d
-
-
-class TestSEANetModel:
-
- def test_base(self):
- encoder = SEANetEncoder()
- decoder = SEANetDecoder()
-
- x = torch.randn(1, 1, 24000)
- z = encoder(x)
- assert list(z.shape) == [1, 128, 75], z.shape
- y = decoder(z)
- assert y.shape == x.shape, (x.shape, y.shape)
-
- def test_causal(self):
- encoder = SEANetEncoder(causal=True)
- decoder = SEANetDecoder(causal=True)
- x = torch.randn(1, 1, 24000)
-
- z = encoder(x)
- assert list(z.shape) == [1, 128, 75], z.shape
- y = decoder(z)
- assert y.shape == x.shape, (x.shape, y.shape)
-
- def test_conv_skip_connection(self):
- encoder = SEANetEncoder(true_skip=False)
- decoder = SEANetDecoder(true_skip=False)
-
- x = torch.randn(1, 1, 24000)
- z = encoder(x)
- assert list(z.shape) == [1, 128, 75], z.shape
- y = decoder(z)
- assert y.shape == x.shape, (x.shape, y.shape)
-
- def test_seanet_encoder_decoder_final_act(self):
- encoder = SEANetEncoder(true_skip=False)
- decoder = SEANetDecoder(true_skip=False, final_activation='Tanh')
-
- x = torch.randn(1, 1, 24000)
- z = encoder(x)
- assert list(z.shape) == [1, 128, 75], z.shape
- y = decoder(z)
- assert y.shape == x.shape, (x.shape, y.shape)
-
- def _check_encoder_blocks_norm(self, encoder: SEANetEncoder, n_disable_blocks: int, norm: str):
- n_blocks = 0
- for layer in encoder.model:
- if isinstance(layer, StreamableConv1d):
- n_blocks += 1
- assert layer.conv.norm_type == 'none' if n_blocks <= n_disable_blocks else norm
- elif isinstance(layer, SEANetResnetBlock):
- for resnet_layer in layer.block:
- if isinstance(resnet_layer, StreamableConv1d):
- # here we add + 1 to n_blocks as we increment n_blocks just after the block
- assert resnet_layer.conv.norm_type == 'none' if (n_blocks + 1) <= n_disable_blocks else norm
-
- def test_encoder_disable_norm(self):
- n_residuals = [0, 1, 3]
- disable_blocks = [0, 1, 2, 3, 4, 5, 6]
- norms = ['weight_norm', 'none']
- for n_res, disable_blocks, norm in product(n_residuals, disable_blocks, norms):
- encoder = SEANetEncoder(n_residual_layers=n_res, norm=norm,
- disable_norm_outer_blocks=disable_blocks)
- self._check_encoder_blocks_norm(encoder, disable_blocks, norm)
-
- def _check_decoder_blocks_norm(self, decoder: SEANetDecoder, n_disable_blocks: int, norm: str):
- n_blocks = 0
- for layer in decoder.model:
- if isinstance(layer, StreamableConv1d):
- n_blocks += 1
- assert layer.conv.norm_type == 'none' if (decoder.n_blocks - n_blocks) < n_disable_blocks else norm
- elif isinstance(layer, StreamableConvTranspose1d):
- n_blocks += 1
- assert layer.convtr.norm_type == 'none' if (decoder.n_blocks - n_blocks) < n_disable_blocks else norm
- elif isinstance(layer, SEANetResnetBlock):
- for resnet_layer in layer.block:
- if isinstance(resnet_layer, StreamableConv1d):
- assert resnet_layer.conv.norm_type == 'none' \
- if (decoder.n_blocks - n_blocks) < n_disable_blocks else norm
-
- def test_decoder_disable_norm(self):
- n_residuals = [0, 1, 3]
- disable_blocks = [0, 1, 2, 3, 4, 5, 6]
- norms = ['weight_norm', 'none']
- for n_res, disable_blocks, norm in product(n_residuals, disable_blocks, norms):
- decoder = SEANetDecoder(n_residual_layers=n_res, norm=norm,
- disable_norm_outer_blocks=disable_blocks)
- self._check_decoder_blocks_norm(decoder, disable_blocks, norm)
-
- def test_disable_norm_raises_exception(self):
- # Invalid disable_norm_outer_blocks values raise exceptions
- with pytest.raises(AssertionError):
- SEANetEncoder(disable_norm_outer_blocks=-1)
-
- with pytest.raises(AssertionError):
- SEANetEncoder(ratios=[1, 1, 2, 2], disable_norm_outer_blocks=7)
-
- with pytest.raises(AssertionError):
- SEANetDecoder(disable_norm_outer_blocks=-1)
-
- with pytest.raises(AssertionError):
- SEANetDecoder(ratios=[1, 1, 2, 2], disable_norm_outer_blocks=7)
diff --git a/spaces/Grezz/generate_human_motion/pyrender/tests/conftest.py b/spaces/Grezz/generate_human_motion/pyrender/tests/conftest.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/GroveStreet/GTA_SOVITS/vdecoder/__init__.py b/spaces/GroveStreet/GTA_SOVITS/vdecoder/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/HachiRe/Fusani/index.html b/spaces/HachiRe/Fusani/index.html
deleted file mode 100644
index ca90f96309a5c6457bfeeb74ea271b11ad0bd83a..0000000000000000000000000000000000000000
--- a/spaces/HachiRe/Fusani/index.html
+++ /dev/null
@@ -1,121 +0,0 @@
-<!DOCTYPE html>
-<html>
-
-<head>
- <meta charset="utf-8">
- <meta name="viewport" content="width=device-width">
- <link rel="icon" href="bu.png">
- <title>Fusani
-
-
-
-
-
-
Fusani
-
go conlang!
-
-
-
-
-
-
-
-
-
-
How does this work?
-
- The code provided is a set of instructions that a computer can follow to make changes to a word that someone types into a box on a website.
- There are four buttons on the website that you can click. Each button does a different thing to the word that you type in.
- The first button is called "Add Vowels." When you click this button, the computer looks at the word you typed and adds some vowels to it to make it longer. It does this by picking a random vowel and putting it in between two consonants. For example, if you typed in the word "dog," the computer might add an "e" to make it "doeg."
- The second button is called "Remove Vowels." When you click this button, the computer looks at the word you typed and takes out all the vowels. So if you typed in the word "hello," the computer would change it to "hll."
- The third button is called "Add Consonants." When you click this button, the computer looks at the word you typed and adds some consonants to it to make it longer. It does this by picking a random consonant and putting it in between two vowels. For example, if you typed in the word "cat," the computer might add an "h" to make it "chat."
- The fourth button is called "Remove Consonants." When you click this button, the computer looks at the word you typed and takes out all the consonants. So if you typed in the word "world," the computer would change it to "o."
-
-
-
-
- 
-
-
diff --git a/spaces/AriaMei/TTSdemo/losses.py b/spaces/AriaMei/TTSdemo/losses.py
deleted file mode 100644
index fb22a0e834dd87edaa37bb8190eee2c3c7abe0d5..0000000000000000000000000000000000000000
--- a/spaces/AriaMei/TTSdemo/losses.py
+++ /dev/null
@@ -1,61 +0,0 @@
-import torch
-from torch.nn import functional as F
-
-import commons
-
-
-def feature_loss(fmap_r, fmap_g):
- loss = 0
- for dr, dg in zip(fmap_r, fmap_g):
- for rl, gl in zip(dr, dg):
- rl = rl.float().detach()
- gl = gl.float()
- loss += torch.mean(torch.abs(rl - gl))
-
- return loss * 2
-
-
-def discriminator_loss(disc_real_outputs, disc_generated_outputs):
- loss = 0
- r_losses = []
- g_losses = []
- for dr, dg in zip(disc_real_outputs, disc_generated_outputs):
- dr = dr.float()
- dg = dg.float()
- r_loss = torch.mean((1-dr)**2)
- g_loss = torch.mean(dg**2)
- loss += (r_loss + g_loss)
- r_losses.append(r_loss.item())
- g_losses.append(g_loss.item())
-
- return loss, r_losses, g_losses
-
-
-def generator_loss(disc_outputs):
- loss = 0
- gen_losses = []
- for dg in disc_outputs:
- dg = dg.float()
- l = torch.mean((1-dg)**2)
- gen_losses.append(l)
- loss += l
-
- return loss, gen_losses
-
-
-def kl_loss(z_p, logs_q, m_p, logs_p, z_mask):
- """
- z_p, logs_q: [b, h, t_t]
- m_p, logs_p: [b, h, t_t]
- """
- z_p = z_p.float()
- logs_q = logs_q.float()
- m_p = m_p.float()
- logs_p = logs_p.float()
- z_mask = z_mask.float()
-
- kl = logs_p - logs_q - 0.5
- kl += 0.5 * ((z_p - m_p)**2) * torch.exp(-2. * logs_p)
- kl = torch.sum(kl * z_mask)
- l = kl / torch.sum(z_mask)
- return l
diff --git a/spaces/Awiny/Image2Paragraph/models/grit_src/grit/modeling/backbone/utils.py b/spaces/Awiny/Image2Paragraph/models/grit_src/grit/modeling/backbone/utils.py
deleted file mode 100644
index e71db21f1223c87cceeb422a70888f7bac42bb18..0000000000000000000000000000000000000000
--- a/spaces/Awiny/Image2Paragraph/models/grit_src/grit/modeling/backbone/utils.py
+++ /dev/null
@@ -1,186 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-# This code is from https://github.com/facebookresearch/detectron2/blob/main/detectron2/modeling/backbone/utils.py
-import math
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-__all__ = [
- "window_partition",
- "window_unpartition",
- "add_decomposed_rel_pos",
- "get_abs_pos",
- "PatchEmbed",
-]
-
-def window_partition(x, window_size):
- """
- Partition into non-overlapping windows with padding if needed.
- Args:
- x (tensor): input tokens with [B, H, W, C].
- window_size (int): window size.
-
- Returns:
- windows: windows after partition with [B * num_windows, window_size, window_size, C].
- (Hp, Wp): padded height and width before partition
- """
- B, H, W, C = x.shape
-
- pad_h = (window_size - H % window_size) % window_size
- pad_w = (window_size - W % window_size) % window_size
- if pad_h > 0 or pad_w > 0:
- x = F.pad(x, (0, 0, 0, pad_w, 0, pad_h))
- Hp, Wp = H + pad_h, W + pad_w
-
- x = x.view(B, Hp // window_size, window_size, Wp // window_size, window_size, C)
- windows = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, C)
- return windows, (Hp, Wp)
-
-
-def window_unpartition(windows, window_size, pad_hw, hw):
- """
- Window unpartition into original sequences and removing padding.
- Args:
- x (tensor): input tokens with [B * num_windows, window_size, window_size, C].
- window_size (int): window size.
- pad_hw (Tuple): padded height and width (Hp, Wp).
- hw (Tuple): original height and width (H, W) before padding.
-
- Returns:
- x: unpartitioned sequences with [B, H, W, C].
- """
- Hp, Wp = pad_hw
- H, W = hw
- B = windows.shape[0] // (Hp * Wp // window_size // window_size)
- x = windows.view(B, Hp // window_size, Wp // window_size, window_size, window_size, -1)
- x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, Hp, Wp, -1)
-
- if Hp > H or Wp > W:
- x = x[:, :H, :W, :].contiguous()
- return x
-
-
-def get_rel_pos(q_size, k_size, rel_pos):
- """
- Get relative positional embeddings according to the relative positions of
- query and key sizes.
- Args:
- q_size (int): size of query q.
- k_size (int): size of key k.
- rel_pos (Tensor): relative position embeddings (L, C).
-
- Returns:
- Extracted positional embeddings according to relative positions.
- """
- max_rel_dist = int(2 * max(q_size, k_size) - 1)
- # Interpolate rel pos if needed.
- if rel_pos.shape[0] != max_rel_dist:
- # Interpolate rel pos.
- rel_pos_resized = F.interpolate(
- rel_pos.reshape(1, rel_pos.shape[0], -1).permute(0, 2, 1),
- size=max_rel_dist,
- mode="linear",
- )
- rel_pos_resized = rel_pos_resized.reshape(-1, max_rel_dist).permute(1, 0)
- else:
- rel_pos_resized = rel_pos
-
- # Scale the coords with short length if shapes for q and k are different.
- q_coords = torch.arange(q_size)[:, None] * max(k_size / q_size, 1.0)
- k_coords = torch.arange(k_size)[None, :] * max(q_size / k_size, 1.0)
- relative_coords = (q_coords - k_coords) + (k_size - 1) * max(q_size / k_size, 1.0)
-
- return rel_pos_resized[relative_coords.long()]
-
-
-def add_decomposed_rel_pos(attn, q, rel_pos_h, rel_pos_w, q_size, k_size):
- """
- Calculate decomposed Relative Positional Embeddings from :paper:`mvitv2`.
- https://github.com/facebookresearch/mvit/blob/19786631e330df9f3622e5402b4a419a263a2c80/mvit/models/attention.py # noqa B950
- Args:
- attn (Tensor): attention map.
- q (Tensor): query q in the attention layer with shape (B, q_h * q_w, C).
- rel_pos_h (Tensor): relative position embeddings (Lh, C) for height axis.
- rel_pos_w (Tensor): relative position embeddings (Lw, C) for width axis.
- q_size (Tuple): spatial sequence size of query q with (q_h, q_w).
- k_size (Tuple): spatial sequence size of key k with (k_h, k_w).
-
- Returns:
- attn (Tensor): attention map with added relative positional embeddings.
- """
- q_h, q_w = q_size
- k_h, k_w = k_size
- Rh = get_rel_pos(q_h, k_h, rel_pos_h)
- Rw = get_rel_pos(q_w, k_w, rel_pos_w)
-
- B, _, dim = q.shape
- r_q = q.reshape(B, q_h, q_w, dim)
- rel_h = torch.einsum("bhwc,hkc->bhwk", r_q, Rh)
- rel_w = torch.einsum("bhwc,wkc->bhwk", r_q, Rw)
-
- attn = (
- attn.view(B, q_h, q_w, k_h, k_w) + rel_h[:, :, :, :, None] + rel_w[:, :, :, None, :]
- ).view(B, q_h * q_w, k_h * k_w)
-
- return attn
-
-
-def get_abs_pos(abs_pos, has_cls_token, hw):
- """
- Calculate absolute positional embeddings. If needed, resize embeddings and remove cls_token
- dimension for the original embeddings.
- Args:
- abs_pos (Tensor): absolute positional embeddings with (1, num_position, C).
- has_cls_token (bool): If true, has 1 embedding in abs_pos for cls token.
- hw (Tuple): size of input image tokens.
-
- Returns:
- Absolute positional embeddings after processing with shape (1, H, W, C)
- """
- h, w = hw
- if has_cls_token:
- abs_pos = abs_pos[:, 1:]
- xy_num = abs_pos.shape[1]
- size = int(math.sqrt(xy_num))
- assert size * size == xy_num
-
- if size != h or size != w:
- new_abs_pos = F.interpolate(
- abs_pos.reshape(1, size, size, -1).permute(0, 3, 1, 2),
- size=(h, w),
- mode="bicubic",
- align_corners=False,
- )
-
- return new_abs_pos.permute(0, 2, 3, 1)
- else:
- return abs_pos.reshape(1, h, w, -1)
-
-
-class PatchEmbed(nn.Module):
- """
- Image to Patch Embedding.
- """
-
- def __init__(
- self, kernel_size=(16, 16), stride=(16, 16), padding=(0, 0), in_chans=3, embed_dim=768
- ):
- """
- Args:
- kernel_size (Tuple): kernel size of the projection layer.
- stride (Tuple): stride of the projection layer.
- padding (Tuple): padding size of the projection layer.
- in_chans (int): Number of input image channels.
- embed_dim (int): embed_dim (int): Patch embedding dimension.
- """
- super().__init__()
-
- self.proj = nn.Conv2d(
- in_chans, embed_dim, kernel_size=kernel_size, stride=stride, padding=padding
- )
-
- def forward(self, x):
- x = self.proj(x)
- # B C H W -> B H W C
- x = x.permute(0, 2, 3, 1)
- return x
diff --git a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/configs/COCO-Detection/fcos_R_50_FPN_1x.py b/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/configs/COCO-Detection/fcos_R_50_FPN_1x.py
deleted file mode 100644
index 86f83c68786f5995c462ade5f3067072d69f047e..0000000000000000000000000000000000000000
--- a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/configs/COCO-Detection/fcos_R_50_FPN_1x.py
+++ /dev/null
@@ -1,11 +0,0 @@
-from ..common.optim import SGD as optimizer
-from ..common.coco_schedule import lr_multiplier_1x as lr_multiplier
-from ..common.data.coco import dataloader
-from ..common.models.fcos import model
-from ..common.train import train
-
-dataloader.train.mapper.use_instance_mask = False
-optimizer.lr = 0.01
-
-model.backbone.bottom_up.freeze_at = 2
-train.init_checkpoint = "detectron2://ImageNetPretrained/MSRA/R-50.pkl"
diff --git a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/data/build.py b/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/data/build.py
deleted file mode 100644
index a31369d1693f86154a7a9249fc043d49f3e9f390..0000000000000000000000000000000000000000
--- a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/data/build.py
+++ /dev/null
@@ -1,542 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import itertools
-import logging
-import numpy as np
-import operator
-import pickle
-from typing import Any, Callable, Dict, List, Optional, Union
-import torch
-import torch.utils.data as torchdata
-from tabulate import tabulate
-from termcolor import colored
-
-from detectron2.config import configurable
-from detectron2.structures import BoxMode
-from detectron2.utils.comm import get_world_size
-from detectron2.utils.env import seed_all_rng
-from detectron2.utils.file_io import PathManager
-from detectron2.utils.logger import _log_api_usage, log_first_n
-
-from .catalog import DatasetCatalog, MetadataCatalog
-from .common import AspectRatioGroupedDataset, DatasetFromList, MapDataset, ToIterableDataset
-from .dataset_mapper import DatasetMapper
-from .detection_utils import check_metadata_consistency
-from .samplers import (
- InferenceSampler,
- RandomSubsetTrainingSampler,
- RepeatFactorTrainingSampler,
- TrainingSampler,
-)
-
-"""
-This file contains the default logic to build a dataloader for training or testing.
-"""
-
-__all__ = [
- "build_batch_data_loader",
- "build_detection_train_loader",
- "build_detection_test_loader",
- "get_detection_dataset_dicts",
- "load_proposals_into_dataset",
- "print_instances_class_histogram",
-]
-
-
-def filter_images_with_only_crowd_annotations(dataset_dicts):
- """
- Filter out images with none annotations or only crowd annotations
- (i.e., images without non-crowd annotations).
- A common training-time preprocessing on COCO dataset.
-
- Args:
- dataset_dicts (list[dict]): annotations in Detectron2 Dataset format.
-
- Returns:
- list[dict]: the same format, but filtered.
- """
- num_before = len(dataset_dicts)
-
- def valid(anns):
- for ann in anns:
- if ann.get("iscrowd", 0) == 0:
- return True
- return False
-
- dataset_dicts = [x for x in dataset_dicts if valid(x["annotations"])]
- num_after = len(dataset_dicts)
- logger = logging.getLogger(__name__)
- logger.info(
- "Removed {} images with no usable annotations. {} images left.".format(
- num_before - num_after, num_after
- )
- )
- return dataset_dicts
-
-
-def filter_images_with_few_keypoints(dataset_dicts, min_keypoints_per_image):
- """
- Filter out images with too few number of keypoints.
-
- Args:
- dataset_dicts (list[dict]): annotations in Detectron2 Dataset format.
-
- Returns:
- list[dict]: the same format as dataset_dicts, but filtered.
- """
- num_before = len(dataset_dicts)
-
- def visible_keypoints_in_image(dic):
- # Each keypoints field has the format [x1, y1, v1, ...], where v is visibility
- annotations = dic["annotations"]
- return sum(
- (np.array(ann["keypoints"][2::3]) > 0).sum()
- for ann in annotations
- if "keypoints" in ann
- )
-
- dataset_dicts = [
- x for x in dataset_dicts if visible_keypoints_in_image(x) >= min_keypoints_per_image
- ]
- num_after = len(dataset_dicts)
- logger = logging.getLogger(__name__)
- logger.info(
- "Removed {} images with fewer than {} keypoints.".format(
- num_before - num_after, min_keypoints_per_image
- )
- )
- return dataset_dicts
-
-
-def load_proposals_into_dataset(dataset_dicts, proposal_file):
- """
- Load precomputed object proposals into the dataset.
-
- The proposal file should be a pickled dict with the following keys:
-
- - "ids": list[int] or list[str], the image ids
- - "boxes": list[np.ndarray], each is an Nx4 array of boxes corresponding to the image id
- - "objectness_logits": list[np.ndarray], each is an N sized array of objectness scores
- corresponding to the boxes.
- - "bbox_mode": the BoxMode of the boxes array. Defaults to ``BoxMode.XYXY_ABS``.
-
- Args:
- dataset_dicts (list[dict]): annotations in Detectron2 Dataset format.
- proposal_file (str): file path of pre-computed proposals, in pkl format.
-
- Returns:
- list[dict]: the same format as dataset_dicts, but added proposal field.
- """
- logger = logging.getLogger(__name__)
- logger.info("Loading proposals from: {}".format(proposal_file))
-
- with PathManager.open(proposal_file, "rb") as f:
- proposals = pickle.load(f, encoding="latin1")
-
- # Rename the key names in D1 proposal files
- rename_keys = {"indexes": "ids", "scores": "objectness_logits"}
- for key in rename_keys:
- if key in proposals:
- proposals[rename_keys[key]] = proposals.pop(key)
-
- # Fetch the indexes of all proposals that are in the dataset
- # Convert image_id to str since they could be int.
- img_ids = set({str(record["image_id"]) for record in dataset_dicts})
- id_to_index = {str(id): i for i, id in enumerate(proposals["ids"]) if str(id) in img_ids}
-
- # Assuming default bbox_mode of precomputed proposals are 'XYXY_ABS'
- bbox_mode = BoxMode(proposals["bbox_mode"]) if "bbox_mode" in proposals else BoxMode.XYXY_ABS
-
- for record in dataset_dicts:
- # Get the index of the proposal
- i = id_to_index[str(record["image_id"])]
-
- boxes = proposals["boxes"][i]
- objectness_logits = proposals["objectness_logits"][i]
- # Sort the proposals in descending order of the scores
- inds = objectness_logits.argsort()[::-1]
- record["proposal_boxes"] = boxes[inds]
- record["proposal_objectness_logits"] = objectness_logits[inds]
- record["proposal_bbox_mode"] = bbox_mode
-
- return dataset_dicts
-
-
-def print_instances_class_histogram(dataset_dicts, class_names):
- """
- Args:
- dataset_dicts (list[dict]): list of dataset dicts.
- class_names (list[str]): list of class names (zero-indexed).
- """
- num_classes = len(class_names)
- hist_bins = np.arange(num_classes + 1)
- histogram = np.zeros((num_classes,), dtype=np.int)
- for entry in dataset_dicts:
- annos = entry["annotations"]
- classes = np.asarray(
- [x["category_id"] for x in annos if not x.get("iscrowd", 0)], dtype=np.int
- )
- if len(classes):
- assert classes.min() >= 0, f"Got an invalid category_id={classes.min()}"
- assert (
- classes.max() < num_classes
- ), f"Got an invalid category_id={classes.max()} for a dataset of {num_classes} classes"
- histogram += np.histogram(classes, bins=hist_bins)[0]
-
- N_COLS = min(6, len(class_names) * 2)
-
- def short_name(x):
- # make long class names shorter. useful for lvis
- if len(x) > 13:
- return x[:11] + ".."
- return x
-
- data = list(
- itertools.chain(*[[short_name(class_names[i]), int(v)] for i, v in enumerate(histogram)])
- )
- total_num_instances = sum(data[1::2])
- data.extend([None] * (N_COLS - (len(data) % N_COLS)))
- if num_classes > 1:
- data.extend(["total", total_num_instances])
- data = itertools.zip_longest(*[data[i::N_COLS] for i in range(N_COLS)])
- table = tabulate(
- data,
- headers=["category", "#instances"] * (N_COLS // 2),
- tablefmt="pipe",
- numalign="left",
- stralign="center",
- )
- log_first_n(
- logging.INFO,
- "Distribution of instances among all {} categories:\n".format(num_classes)
- + colored(table, "cyan"),
- key="message",
- )
-
-
-def get_detection_dataset_dicts(
- names,
- filter_empty=True,
- min_keypoints=0,
- proposal_files=None,
- check_consistency=True,
-):
- """
- Load and prepare dataset dicts for instance detection/segmentation and semantic segmentation.
-
- Args:
- names (str or list[str]): a dataset name or a list of dataset names
- filter_empty (bool): whether to filter out images without instance annotations
- min_keypoints (int): filter out images with fewer keypoints than
- `min_keypoints`. Set to 0 to do nothing.
- proposal_files (list[str]): if given, a list of object proposal files
- that match each dataset in `names`.
- check_consistency (bool): whether to check if datasets have consistent metadata.
-
- Returns:
- list[dict]: a list of dicts following the standard dataset dict format.
- """
- if isinstance(names, str):
- names = [names]
- assert len(names), names
- dataset_dicts = [DatasetCatalog.get(dataset_name) for dataset_name in names]
- for dataset_name, dicts in zip(names, dataset_dicts):
- assert len(dicts), "Dataset '{}' is empty!".format(dataset_name)
-
- if proposal_files is not None:
- assert len(names) == len(proposal_files)
- # load precomputed proposals from proposal files
- dataset_dicts = [
- load_proposals_into_dataset(dataset_i_dicts, proposal_file)
- for dataset_i_dicts, proposal_file in zip(dataset_dicts, proposal_files)
- ]
-
- if isinstance(dataset_dicts[0], torchdata.Dataset):
- return torchdata.ConcatDataset(dataset_dicts)
-
- dataset_dicts = list(itertools.chain.from_iterable(dataset_dicts))
-
- has_instances = "annotations" in dataset_dicts[0]
- if filter_empty and has_instances:
- dataset_dicts = filter_images_with_only_crowd_annotations(dataset_dicts)
- if min_keypoints > 0 and has_instances:
- dataset_dicts = filter_images_with_few_keypoints(dataset_dicts, min_keypoints)
-
- if check_consistency and has_instances:
- try:
- class_names = MetadataCatalog.get(names[0]).thing_classes
- check_metadata_consistency("thing_classes", names)
- print_instances_class_histogram(dataset_dicts, class_names)
- except AttributeError: # class names are not available for this dataset
- pass
-
- assert len(dataset_dicts), "No valid data found in {}.".format(",".join(names))
- return dataset_dicts
-
-
-def build_batch_data_loader(
- dataset,
- sampler,
- total_batch_size,
- *,
- aspect_ratio_grouping=False,
- num_workers=0,
- collate_fn=None,
-):
- """
- Build a batched dataloader. The main differences from `torch.utils.data.DataLoader` are:
- 1. support aspect ratio grouping options
- 2. use no "batch collation", because this is common for detection training
-
- Args:
- dataset (torch.utils.data.Dataset): a pytorch map-style or iterable dataset.
- sampler (torch.utils.data.sampler.Sampler or None): a sampler that produces indices.
- Must be provided iff. ``dataset`` is a map-style dataset.
- total_batch_size, aspect_ratio_grouping, num_workers, collate_fn: see
- :func:`build_detection_train_loader`.
-
- Returns:
- iterable[list]. Length of each list is the batch size of the current
- GPU. Each element in the list comes from the dataset.
- """
- world_size = get_world_size()
- assert (
- total_batch_size > 0 and total_batch_size % world_size == 0
- ), "Total batch size ({}) must be divisible by the number of gpus ({}).".format(
- total_batch_size, world_size
- )
- batch_size = total_batch_size // world_size
-
- if isinstance(dataset, torchdata.IterableDataset):
- assert sampler is None, "sampler must be None if dataset is IterableDataset"
- else:
- dataset = ToIterableDataset(dataset, sampler)
-
- if aspect_ratio_grouping:
- data_loader = torchdata.DataLoader(
- dataset,
- num_workers=num_workers,
- collate_fn=operator.itemgetter(0), # don't batch, but yield individual elements
- worker_init_fn=worker_init_reset_seed,
- ) # yield individual mapped dict
- data_loader = AspectRatioGroupedDataset(data_loader, batch_size)
- if collate_fn is None:
- return data_loader
- return MapDataset(data_loader, collate_fn)
- else:
- return torchdata.DataLoader(
- dataset,
- batch_size=batch_size,
- drop_last=True,
- num_workers=num_workers,
- collate_fn=trivial_batch_collator if collate_fn is None else collate_fn,
- worker_init_fn=worker_init_reset_seed,
- )
-
-
-def _train_loader_from_config(cfg, mapper=None, *, dataset=None, sampler=None):
- if dataset is None:
- dataset = get_detection_dataset_dicts(
- cfg.DATASETS.TRAIN,
- filter_empty=cfg.DATALOADER.FILTER_EMPTY_ANNOTATIONS,
- min_keypoints=cfg.MODEL.ROI_KEYPOINT_HEAD.MIN_KEYPOINTS_PER_IMAGE
- if cfg.MODEL.KEYPOINT_ON
- else 0,
- proposal_files=cfg.DATASETS.PROPOSAL_FILES_TRAIN if cfg.MODEL.LOAD_PROPOSALS else None,
- )
- _log_api_usage("dataset." + cfg.DATASETS.TRAIN[0])
-
- if mapper is None:
- mapper = DatasetMapper(cfg, True)
-
- if sampler is None:
- sampler_name = cfg.DATALOADER.SAMPLER_TRAIN
- logger = logging.getLogger(__name__)
- logger.info("Using training sampler {}".format(sampler_name))
- if sampler_name == "TrainingSampler":
- sampler = TrainingSampler(len(dataset))
- elif sampler_name == "RepeatFactorTrainingSampler":
- repeat_factors = RepeatFactorTrainingSampler.repeat_factors_from_category_frequency(
- dataset, cfg.DATALOADER.REPEAT_THRESHOLD
- )
- sampler = RepeatFactorTrainingSampler(repeat_factors)
- elif sampler_name == "RandomSubsetTrainingSampler":
- sampler = RandomSubsetTrainingSampler(len(dataset), cfg.DATALOADER.RANDOM_SUBSET_RATIO)
- else:
- raise ValueError("Unknown training sampler: {}".format(sampler_name))
-
- return {
- "dataset": dataset,
- "sampler": sampler,
- "mapper": mapper,
- "total_batch_size": cfg.SOLVER.IMS_PER_BATCH,
- "aspect_ratio_grouping": cfg.DATALOADER.ASPECT_RATIO_GROUPING,
- "num_workers": cfg.DATALOADER.NUM_WORKERS,
- }
-
-
-@configurable(from_config=_train_loader_from_config)
-def build_detection_train_loader(
- dataset,
- *,
- mapper,
- sampler=None,
- total_batch_size,
- aspect_ratio_grouping=True,
- num_workers=0,
- collate_fn=None,
-):
- """
- Build a dataloader for object detection with some default features.
-
- Args:
- dataset (list or torch.utils.data.Dataset): a list of dataset dicts,
- or a pytorch dataset (either map-style or iterable). It can be obtained
- by using :func:`DatasetCatalog.get` or :func:`get_detection_dataset_dicts`.
- mapper (callable): a callable which takes a sample (dict) from dataset and
- returns the format to be consumed by the model.
- When using cfg, the default choice is ``DatasetMapper(cfg, is_train=True)``.
- sampler (torch.utils.data.sampler.Sampler or None): a sampler that produces
- indices to be applied on ``dataset``.
- If ``dataset`` is map-style, the default sampler is a :class:`TrainingSampler`,
- which coordinates an infinite random shuffle sequence across all workers.
- Sampler must be None if ``dataset`` is iterable.
- total_batch_size (int): total batch size across all workers.
- aspect_ratio_grouping (bool): whether to group images with similar
- aspect ratio for efficiency. When enabled, it requires each
- element in dataset be a dict with keys "width" and "height".
- num_workers (int): number of parallel data loading workers
- collate_fn: a function that determines how to do batching, same as the argument of
- `torch.utils.data.DataLoader`. Defaults to do no collation and return a list of
- data. No collation is OK for small batch size and simple data structures.
- If your batch size is large and each sample contains too many small tensors,
- it's more efficient to collate them in data loader.
-
- Returns:
- torch.utils.data.DataLoader:
- a dataloader. Each output from it is a ``list[mapped_element]`` of length
- ``total_batch_size / num_workers``, where ``mapped_element`` is produced
- by the ``mapper``.
- """
- if isinstance(dataset, list):
- dataset = DatasetFromList(dataset, copy=False)
- if mapper is not None:
- dataset = MapDataset(dataset, mapper)
-
- if isinstance(dataset, torchdata.IterableDataset):
- assert sampler is None, "sampler must be None if dataset is IterableDataset"
- else:
- if sampler is None:
- sampler = TrainingSampler(len(dataset))
- assert isinstance(sampler, torchdata.Sampler), f"Expect a Sampler but got {type(sampler)}"
- return build_batch_data_loader(
- dataset,
- sampler,
- total_batch_size,
- aspect_ratio_grouping=aspect_ratio_grouping,
- num_workers=num_workers,
- collate_fn=collate_fn,
- )
-
-
-def _test_loader_from_config(cfg, dataset_name, mapper=None):
- """
- Uses the given `dataset_name` argument (instead of the names in cfg), because the
- standard practice is to evaluate each test set individually (not combining them).
- """
- if isinstance(dataset_name, str):
- dataset_name = [dataset_name]
-
- dataset = get_detection_dataset_dicts(
- dataset_name,
- filter_empty=False,
- proposal_files=[
- cfg.DATASETS.PROPOSAL_FILES_TEST[list(cfg.DATASETS.TEST).index(x)] for x in dataset_name
- ]
- if cfg.MODEL.LOAD_PROPOSALS
- else None,
- )
- if mapper is None:
- mapper = DatasetMapper(cfg, False)
- return {
- "dataset": dataset,
- "mapper": mapper,
- "num_workers": cfg.DATALOADER.NUM_WORKERS,
- "sampler": InferenceSampler(len(dataset)),
- }
-
-
-@configurable(from_config=_test_loader_from_config)
-def build_detection_test_loader(
- dataset: Union[List[Any], torchdata.Dataset],
- *,
- mapper: Callable[[Dict[str, Any]], Any],
- sampler: Optional[torchdata.Sampler] = None,
- batch_size: int = 1,
- num_workers: int = 0,
- collate_fn: Optional[Callable[[List[Any]], Any]] = None,
-) -> torchdata.DataLoader:
- """
- Similar to `build_detection_train_loader`, with default batch size = 1,
- and sampler = :class:`InferenceSampler`. This sampler coordinates all workers
- to produce the exact set of all samples.
-
- Args:
- dataset: a list of dataset dicts,
- or a pytorch dataset (either map-style or iterable). They can be obtained
- by using :func:`DatasetCatalog.get` or :func:`get_detection_dataset_dicts`.
- mapper: a callable which takes a sample (dict) from dataset
- and returns the format to be consumed by the model.
- When using cfg, the default choice is ``DatasetMapper(cfg, is_train=False)``.
- sampler: a sampler that produces
- indices to be applied on ``dataset``. Default to :class:`InferenceSampler`,
- which splits the dataset across all workers. Sampler must be None
- if `dataset` is iterable.
- batch_size: the batch size of the data loader to be created.
- Default to 1 image per worker since this is the standard when reporting
- inference time in papers.
- num_workers: number of parallel data loading workers
- collate_fn: same as the argument of `torch.utils.data.DataLoader`.
- Defaults to do no collation and return a list of data.
-
- Returns:
- DataLoader: a torch DataLoader, that loads the given detection
- dataset, with test-time transformation and batching.
-
- Examples:
- ::
- data_loader = build_detection_test_loader(
- DatasetRegistry.get("my_test"),
- mapper=DatasetMapper(...))
-
- # or, instantiate with a CfgNode:
- data_loader = build_detection_test_loader(cfg, "my_test")
- """
- if isinstance(dataset, list):
- dataset = DatasetFromList(dataset, copy=False)
- if mapper is not None:
- dataset = MapDataset(dataset, mapper)
- if isinstance(dataset, torchdata.IterableDataset):
- assert sampler is None, "sampler must be None if dataset is IterableDataset"
- else:
- if sampler is None:
- sampler = InferenceSampler(len(dataset))
- return torchdata.DataLoader(
- dataset,
- batch_size=batch_size,
- sampler=sampler,
- drop_last=False,
- num_workers=num_workers,
- collate_fn=trivial_batch_collator if collate_fn is None else collate_fn,
- )
-
-
-def trivial_batch_collator(batch):
- """
- A batch collator that does nothing.
- """
- return batch
-
-
-def worker_init_reset_seed(worker_id):
- initial_seed = torch.initial_seed() % 2 ** 31
- seed_all_rng(initial_seed + worker_id)
diff --git a/spaces/Benson/text-generation/Dockerfile b/spaces/Benson/text-generation/Dockerfile
deleted file mode 100644
index 14271315789e0c87a912ea3cc090345eb9d90595..0000000000000000000000000000000000000000
--- a/spaces/Benson/text-generation/Dockerfile
+++ /dev/null
@@ -1,28 +0,0 @@
-# Use the official Python 3.9 image
-FROM python:3.9
-
-# Set the working directory to /code
-WORKDIR /code
-
-# Copy the current directory contents into the container at /code
-COPY ./requirements.txt /code/requirements.txt
-
-# Install requirements.txt
-RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
-
-# Set up a new user named "user" with user ID 1000
-RUN useradd -m -u 1000 user
-# Switch to the "user" user
-USER user
-# Set home to the user's home directory
-ENV HOME=/home/user \
- PATH=/home/user/.local/bin:$PATH
-
-# Set the working directory to the user's home directory
-WORKDIR $HOME/app
-
-# Copy the current directory contents into the container at $HOME/app setting the owner to the user
-COPY --chown=user . $HOME/app
-
-# Start the FastAPI app on port 7860, the default port expected by Spaces
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
diff --git a/spaces/Benson/text-generation/Examples/Baloncesto Estrellas Multijugador Mod Apk Dinero Ilimitado Y Oro.md b/spaces/Benson/text-generation/Examples/Baloncesto Estrellas Multijugador Mod Apk Dinero Ilimitado Y Oro.md
deleted file mode 100644
index 52d8eadfe0e604bdbb7455303dcc5b2989be8d82..0000000000000000000000000000000000000000
--- a/spaces/Benson/text-generation/Examples/Baloncesto Estrellas Multijugador Mod Apk Dinero Ilimitado Y Oro.md
+++ /dev/null
@@ -1,50 +0,0 @@
-
- }})
- 
- 
- 
-