diff --git a/spaces/1acneusushi/gradio-2dmoleculeeditor/data/Analisis Literario Del Cuento El Hijo Horacio Quiroga Un Estudio Filolgico Y Crtico.md b/spaces/1acneusushi/gradio-2dmoleculeeditor/data/Analisis Literario Del Cuento El Hijo Horacio Quiroga Un Estudio Filolgico Y Crtico.md
deleted file mode 100644
index 3781bf3d53c5f21e4017db18d6a5450409322c75..0000000000000000000000000000000000000000
--- a/spaces/1acneusushi/gradio-2dmoleculeeditor/data/Analisis Literario Del Cuento El Hijo Horacio Quiroga Un Estudio Filolgico Y Crtico.md
+++ /dev/null
@@ -1,136 +0,0 @@
-
-
Dragon Ball Z Sparking Mugen 2010 PC Download Torrent 15
-
If you are a fan of Dragon Ball Z, you might be interested in downloading and playing Dragon Ball Z Sparking Mugen 2010 PC Torrent 15. This is a fan-made game that combines the elements of Dragon Ball Z and Mugen, a popular engine for creating fighting games. In this article, we will show you how to download and play this game on your PC.
-
Introduction
-
What is Dragon Ball Z Sparking Mugen 2010?
-
Dragon Ball Z Sparking Mugen 2010 is a game that was created by fans using the Mugen engine. It is based on the anime series Dragon Ball Z, which follows the adventures of Goku and his friends as they fight against various enemies and villains. The game features over 100 characters from the series, each with their own moves and abilities. You can choose from different game modes, such as arcade, team battle, survival, training, and more. You can also customize your own characters and stages using the built-in editor.
-
Dragon ball z sparking mugen 2010 pc download torrent 15
There are many reasons why you should download Dragon Ball Z Sparking Mugen 2010 PC Torrent 15. Here are some of them:
-
-
It is free and easy to download and install.
-
It has high-quality graphics and sound effects that capture the essence of the anime.
-
It has a large roster of characters that you can play as or fight against.
-
It has a variety of game modes that offer different challenges and fun.
-
It has a loyal fan community that supports and updates the game regularly.
-
-
How to download Dragon Ball Z Sparking Mugen 2010 PC Torrent 15
-
Step 1: Find a reliable torrent site
-
The first step to download Dragon Ball Z Sparking Mugen 2010 PC Torrent 15 is to find a reliable torrent site that hosts the game file. There are many torrent sites on the internet, but not all of them are safe and trustworthy. Some of them may contain malware, viruses, or fake files that can harm your computer or waste your time. Therefore, you should do some research before choosing a torrent site. You can read reviews, ratings, comments, or feedback from other users to see if the site is reputable and reliable. You can also use a VPN service to protect your privacy and security while browsing torrent sites.
-
Step 2: Search for the game torrent
-
The next step is to search for the game torrent on the torrent site that you have chosen. You can use keywords such as "Dragon Ball Z Sparking Mugen 2010 PC", "DBZ Sparking Mugen", or "DBZSM". You should look for the torrent that has the most seeders and leechers, as this indicates that the file is popular and fast to download. You should also check the file size, description, comments, and screenshots to make sure that it is the correct and complete version of the game.
-
Step 3: Download and install a torrent client
-
The third step is to download and install a torrent client on your PC. A torrent client is a software that allows you to download files from torrent sites using peer-to-peer technology. There are many torrent clients available online, such as uTorrent, BitTorrent, qBittorrent, etc. You can choose one that suits your preferences and needs. You should also make sure that your torrent client is updated and configured properly to optimize your download speed and performance.
-
Dragon ball z sparking mugen 2010 pc game free download
-How to download dragon ball z sparking mugen 2010 for pc
-Dragon ball z sparking mugen 2010 pc full version torrent
-Dragon ball z sparking mugen 2010 pc gameplay and review
-Dragon ball z sparking mugen 2010 pc system requirements and installation guide
-Dragon ball z sparking mugen 2010 pc cheats and mods
-Dragon ball z sparking mugen 2010 pc best characters and stages
-Dragon ball z sparking mugen 2010 pc online multiplayer mode
-Dragon ball z sparking mugen 2010 pc iso file download
-Dragon ball z sparking mugen 2010 pc rar password and crack
-Dragon ball z sparking mugen 2010 pc update and patch download
-Dragon ball z sparking mugen 2010 pc error fix and troubleshooting
-Dragon ball z sparking mugen 2010 pc comparison with other dragon ball games
-Dragon ball z sparking mugen 2010 pc fan made and custom content
-Dragon ball z sparking mugen 2010 pc tips and tricks for beginners
-Dragon ball z sparking mugen 2010 pc controller support and configuration
-Dragon ball z sparking mugen 2010 pc high quality graphics and sound settings
-Dragon ball z sparking mugen 2010 pc download link and torrent magnet
-Dragon ball z sparking mugen 2010 pc safe and virus free download
-Dragon ball z sparking mugen 2010 pc latest version and new features
-Dragon ball z sparking mugen 2010 pc all transformations and fusions
-Dragon ball z sparking mugen 2010 pc story mode and cutscenes
-Dragon ball z sparking mugen 2010 pc unlockable characters and secrets
-Dragon ball z sparking mugen 2010 pc minimum and recommended specs
-Dragon ball z sparking mugen 2010 pc compatible windows versions and platforms
-Dragon ball z sparking mugen 2010 pc original and official source
-Dragon ball z sparking mugen 2010 pc alternative and similar games
-Dragon ball z sparking mugen 2010 pc feedback and ratings from users
-Dragon ball z sparking mugen 2010 pc trailer and screenshots
-Dragon ball z sparking mugen 2010 pc how to burn to dvd or usb drive
-Dragon ball z sparking mugen 2010 pc how to extract and run the game
-Dragon ball z sparking mugen 2010 pc how to change the language and subtitles
-Dragon ball z sparking mugen 2010 pc how to customize the controls and options
-Dragon ball z sparking mugen 2010 pc how to add more characters and stages
-Dragon ball z sparking mugen 2010 pc how to play with friends online or offline
-Dragon ball z sparking mugen 2010 pc how to record and edit gameplay videos
-Dragon ball z sparking mugen 2010 pc how to stream and share the game online
-Dragon ball z sparking mugen 2010 pc how to speed up and optimize the game performance
-Dragon ball z sparking mugen 2010 pc how to backup and restore the game data
-Dragon ball z sparking mugen 2010 pc how to uninstall and remove the game completely
-Dragon ball z sparking mugen 2010 pc pros and cons of downloading the game from torrent
-Dragon ball z sparking mugen 2010 pc legal and ethical issues of downloading the game from torrent
-Dragon ball z sparking mugen 2010 pc frequently asked questions and answers
-Dragon ball z sparkling (sic) vs dragon ball z sparkin (sic) vs dragonballzsparkin (sic) vs dragonballzsparkling (sic)
-What is dragonballzsparkin (sic) or dragonballzsparkling (sic) or dragonballzsparkin (sic) or dragonballzsparkling (sic)
-What is dragonballzsparkin (sic) or dragonballzsparkling (sic) or dragonballzsparkin (sic) or dragonballzsparkling (sic) in Japanese?
-What is dragonballzsparkin (sic) or dragonballzsparkling (sic) or dragonballzsparkin (sic) or dragonballzsparkling (sic) in English?
-What is the difference between dragonballzsparkin (sic) or dragonballzsparkling (sic) or dragonballzsparkin (sic) or dragonballzsparkling (sic) in terms of gameplay, graphics, sound, etc.?
-
Step 4: Open the torrent file and start downloading
-
The fourth step is to open the torrent file that you have downloaded from the torrent site using your torrent client. The torrent file contains information about the game file, such as its name, size, hash, trackers, etc. You should double-click on the torrent file or drag it into your torrent client window to start downloading. You can monitor the progress of your download by looking at the status bar or details panel of your torrent client. You can also pause, resume, or cancel your download at any time.
-
Step 5: Extract the game files and run the setup
-the instructions on the screen to install the game on your PC. You may need to agree to some terms and conditions, choose a destination folder, and create a shortcut icon. Once the installation is complete, you can launch the game from your desktop or start menu.
-
How to play Dragon Ball Z Sparking Mugen 2010 PC
-
The game modes
-
Dragon Ball Z Sparking Mugen 2010 PC has several game modes that you can choose from. Here are some of them:
-
-
Arcade: This is the classic mode where you fight against a series of opponents until you reach the final boss. You can choose your difficulty level and the number of rounds per match.
-
Team Battle: This is the mode where you can form a team of up to four characters and fight against another team. You can choose between single, simul, or turns mode. In single mode, you control one character at a time and switch between them when one is defeated. In simul mode, you control one character and the others are controlled by the computer or another player. In turns mode, you control one character per round and switch between them after each round.
-
Survival: This is the mode where you try to survive as long as possible against an endless stream of opponents. You can choose your difficulty level and the number of lives you have. Your health does not regenerate between matches, so you have to be careful.
-
Training: This is the mode where you can practice your moves and combos against a dummy opponent. You can adjust the settings such as the dummy's behavior, health, defense, etc. You can also view your inputs and damage output on the screen.
-
Watch: This is the mode where you can watch two computer-controlled characters fight against each other. You can choose the characters, stage, and music. You can also pause, fast-forward, or rewind the match.
-
Edit: This is the mode where you can create your own characters and stages using the built-in editor. You can modify various aspects such as the sprites, sounds, animations, moves, etc. You can also test your creations in a preview mode.
-
-
The game controls
-
Dragon Ball Z Sparking Mugen 2010 PC uses a keyboard or a gamepad as its input device. The default keyboard controls are as follows:
-
-
Key
Function
-
A
Light punch
-
S
Medium punch
-
D
Heavy punch
-
Z
Light kick
-
X
Medium kick
-
C
Heavy kick
-
V
Start button
-
B
Coin button
-
F1
Pause button
-
F2
Restart button
-
F4
Toggle fullscreen/windowed mode
-
F12
Take screenshot
-
Arrow keys
Move character
-
Enter
Select option/menu item
-
Esc
Cancel/back/exit option/menu item
-
-
You can change the keyboard controls in the options menu or in the config file. You can also use a gamepad if you prefer. You will need to configure your gamepad buttons in the options menu or in the config file.
-
The game features
-
Dragon Ball Z Sparking Mugen 2010 PC has many features that make it an enjoyable and exciting game. Here are some of them:
-
-
The game has over 100 characters from Dragon Ball Z and other related series, such as Dragon Ball GT, Dragon Ball Super, Dragon Ball Heroes, etc. You can play as your favorite heroes or villains, such as Goku, Vegeta, Gohan, Piccolo, Frieza, Cell, Buu, Broly, Beerus, Jiren, etc.
-
The game has over 50 stages from different locations in the Dragon Ball universe, such as Earth, Namek, Planet Vegeta, Hell, Tournament of Power, etc. You can fight in different environments and scenarios, such as day or night, rain or snow, lava or water, etc.
-
The game has over 200 music tracks from various sources related to Dragon Ball Z and other anime series. You can listen to iconic themes and songs that match the mood and atmosphere of each stage and character.
-kicks, blocks, throws, dodges, counters, etc. You can also use special moves and super moves that are unique to each character, such as Kamehameha, Final Flash, Masenko, Death Beam, Spirit Bomb, etc. You can also transform into different forms and power-ups, such as Super Saiyan, Kaioken, Golden Frieza, Ultra Instinct, etc.
-
The game has a realistic and immersive physics and collision system that makes the fights more dynamic and realistic. You can interact with the environment and objects in various ways, such as breaking walls, smashing rocks, creating craters, etc. You can also cause damage and injuries to your opponents and yourself, such as bruises, cuts, blood, etc.
-
The game has a customizable and user-friendly interface that allows you to adjust various settings and preferences according to your liking. You can change the resolution, frame rate, sound volume, language, etc. You can also enable or disable various features and effects, such as shadows, reflections, particles, etc.
-
-
Conclusion
-
Summary of the main points
-
In conclusion, Dragon Ball Z Sparking Mugen 2010 PC Torrent 15 is a fan-made game that lets you experience the thrill and excitement of Dragon Ball Z on your PC. It is free and easy to download and install. It has high-quality graphics and sound effects that resemble the anime. It has a large roster of characters that you can play as or fight against. It has a variety of game modes that offer different challenges and fun. It has a dynamic and responsive combat system that allows you to perform various moves and combos. It has a realistic and immersive physics and collision system that makes the fights more dynamic and realistic. It has a customizable and user-friendly interface that allows you to adjust various settings and preferences.
-
Call to action
-
If you are interested in downloading and playing Dragon Ball Z Sparking Mugen 2010 PC Torrent 15, you can follow the steps that we have outlined in this article. You will need a reliable torrent site, a torrent client, and a software to extract the game files. You will also need a PC that meets the minimum system requirements for the game. You can check the game's official website or forum for more information and updates. You can also join the game's fan community and share your feedback and suggestions with other players. We hope that you enjoy playing Dragon Ball Z Sparking Mugen 2010 PC Torrent 15 as much as we do.
-
FAQs
-
Q: Is Dragon Ball Z Sparking Mugen 2010 PC Torrent 15 legal?
-
A: Dragon Ball Z Sparking Mugen 2010 PC Torrent 15 is a fan-made game that is not affiliated with or endorsed by the official creators or owners of Dragon Ball Z or Mugen. It is made for entertainment purposes only and does not intend to infringe any copyrights or trademarks. However, downloading and sharing torrents may be illegal in some countries or regions depending on their laws and regulations. Therefore, you should be careful and responsible when downloading and playing this game.
-
Q: Is Dragon Ball Z Sparking Mugen 2010 PC Torrent 15 safe?
-
A: Dragon Ball Z Sparking Mugen 2010 PC Torrent 15 is safe to download and play as long as you use a reliable torrent site and a torrent client that are free from malware, viruses, or fake files. You should also scan your downloaded file with an antivirus software before extracting it. You should also backup your data before installing the game on your PC in case of any errors or problems.
-
Q: Is Dragon Ball Z Sparking Mugen 2010 PC Torrent 15 compatible with Windows 10?
-Windows Vista, Windows 7, and Windows 8. However, you may need to run the game in compatibility mode or as an administrator if you encounter any issues or errors. You can also check the game's official website or forum for more troubleshooting tips and solutions.
-
Q: How can I update Dragon Ball Z Sparking Mugen 2010 PC Torrent 15?
-
A: Dragon Ball Z Sparking Mugen 2010 PC Torrent 15 is updated regularly by its fan community with new characters, stages, music, features, etc. You can check the game's official website or forum for the latest updates and patches. You can also download and install them manually or automatically using your torrent client. You should always backup your data before updating the game to avoid any errors or problems.
-
Q: How can I contact the developers of Dragon Ball Z Sparking Mugen 2010 PC Torrent 15?
-
A: Dragon Ball Z Sparking Mugen 2010 PC Torrent 15 is developed by a team of fans who are passionate about Dragon Ball Z and Mugen. You can contact them through their official website or forum where they post their news, announcements, updates, etc. You can also join their Discord server or Facebook group where they interact with other players and fans. You can also send them an email or a message if you have any questions, feedback, suggestions, etc.
- 0a6ba089eb
-
-
\ No newline at end of file
diff --git a/spaces/1acneusushi/gradio-2dmoleculeeditor/data/Cara Upgrade Windows 7 SP1 ke SP2 dengan Mudah dan Cepat.md b/spaces/1acneusushi/gradio-2dmoleculeeditor/data/Cara Upgrade Windows 7 SP1 ke SP2 dengan Mudah dan Cepat.md
deleted file mode 100644
index 4d2473f13fa55b215b34f119b22621fb9febb5c0..0000000000000000000000000000000000000000
--- a/spaces/1acneusushi/gradio-2dmoleculeeditor/data/Cara Upgrade Windows 7 SP1 ke SP2 dengan Mudah dan Cepat.md
+++ /dev/null
@@ -1,115 +0,0 @@
-
-
Cara Upgrade Windows 7 SP1 ke SP2
-
Windows 7 is one of the most popular operating systems in the world, but it is not supported by Microsoft anymore. This means that you will not receive any security updates or bug fixes for your system. However, you can still upgrade your Windows 7 to the latest service pack, which is a collection of updates that improve the performance and stability of your system. In this article, we will show you how to upgrade your Windows 7 SP1 to SP2 offline, without using Windows Update. We will also show you how to install other important updates for your system.
-
What is Windows 7 SP1 and SP2?
-
Service packs are cumulative updates that contain all the previous updates for a specific version of Windows. They also include new features and enhancements that improve the functionality and security of your system. Service packs are usually released every few years by Microsoft.
Windows 7 only has one official service pack, which is SP1. It was released in February 2011 and it contains all the updates that were released from the launch of Windows 7 in October 2009 until January 2011. It also includes some new features such as improved support for USB 3.0 devices, enhanced backup and restore options, and better compatibility with third-party software.
-
However, Microsoft also released a convenience rollup update for Windows 7 in May 2016. This update is often called SP2 unofficially, because it contains all the updates that were released from SP1 until April 2016. It also includes some improvements such as reduced network bandwidth consumption, increased reliability of Windows Update, and faster installation time.
-
cara install windows 7 sp1 dan sp2 offline[^1^]
-how to obtain and install windows 7 sp2[^2^]
-cara update windows 7 sp1 ke sp2 tanpa internet
-how to integrate windows 7 convenience rollup into sp1 iso[^2^]
-cara download windows 7 sp1 dan sp2 offline installer[^1^]
-how to fix windows 7 update stuck on checking for updates[^2^]
-cara mengatasi windows 7 sp1 yang tidak bisa upgrade ke sp2
-how to install internet explorer 11 and .net framework on windows 7 sp2[^2^]
-cara cek versi windows 7 sp1 atau sp2
-how to uninstall windows 7 convenience rollup update
-cara backup data sebelum upgrade windows 7 sp1 ke sp2
-how to activate windows 7 after installing convenience rollup update
-cara menghapus file sisa update windows 7 sp1 dan sp2
-how to speed up windows 7 after applying convenience rollup update
-cara menonaktifkan windows update setelah upgrade windows 7 sp1 ke sp2
-how to troubleshoot windows 7 convenience rollup installation issues
-cara mengembalikan windows 7 ke versi sebelumnya jika upgrade sp1 ke sp2 gagal
-how to optimize windows 7 performance and security with convenience rollup update
-cara membuat bootable usb windows 7 dengan service pack terbaru
-how to slipstream windows 7 convenience rollup into a custom installation disc
-cara memperbaiki error code saat upgrade windows 7 sp1 ke sp2
-how to install additional language packs on windows 7 with convenience rollup update
-cara menambahkan fitur baru di windows 7 setelah upgrade ke sp2
-how to enable or disable automatic updates on windows 7 with convenience rollup update
-cara mematikan notifikasi upgrade ke windows 10 di windows 7 sp2
-how to check the compatibility of your hardware and software with windows 7 convenience rollup update
-cara mengubah tampilan windows 7 menjadi lebih modern setelah upgrade ke sp2
-how to create a system restore point before installing windows 7 convenience rollup update
-cara membersihkan registry dan disk space di windows 7 setelah upgrade ke sp2
-how to use dism tool to integrate convenience rollup update into your installation media[^2^]
-cara mengatasi masalah driver dan perangkat keras di windows 7 setelah upgrade ke sp2
-how to use system file checker tool to repair corrupted files on windows 7 with convenience rollup update
-cara menginstal aplikasi dan game yang tidak kompatibel dengan windows 7 sp2
-how to use compatibility mode and troubleshooter to run older programs on windows 7 with convenience rollup update
-cara mengubah pengaturan power plan dan sleep mode di windows 7 setelah upgrade ke sp2
-how to adjust display settings and themes on windows 7 with convenience rollup update
-cara mengubah pengaturan jaringan dan firewall di windows 7 setelah upgrade ke sp2
-how to configure network and internet settings on windows 7 with convenience rollup update
-cara mengubah pengaturan suara dan audio di windows 7 setelah upgrade ke sp2
-how to change sound and audio settings on windows 7 with convenience rollup update
-cara mengubah pengaturan mouse dan keyboard di windows 7 setelah upgrade ke sp2
-how to change mouse and keyboard settings on windows 7 with convenience rollup update
-cara mengubah pengaturan user account dan parental control di windows 7 setelah upgrade ke sp2
-how to change user account and parental control settings on windows 7 with convenience rollup update
-cara mengubah pengaturan security dan privacy di windows 7 setelah upgrade ke sp2
-how to change security and privacy settings on windows 7 with convenience rollup update
-cara mengubah pengaturan system dan recovery di windows 7 setelah upgrade ke sp2
-how to change system and recovery settings on windows 7 with convenience rollup update
-cara mengubah pengaturan date and time di windows 7 setelah upgrade ke sp2
-how to change date and time settings on windows 7 with convenience rollup update
-
By installing both SP1 and SP2, you can bring your Windows 7 up to date with the latest patches and fixes that Microsoft has provided. This will make your system more secure, stable, and efficient.
-
How to check your Windows 7 version and edition?
-
Before you download and install any service pack, you need to check what version and edition of Windows 7 you have on your system. This will help you choose the right file for your system.
-
To check your Windows 7 version and edition, follow these steps:
-
-
Click on the Start button and type system in the search box.
-
Click on System in the list of results.
-
In the System window, look for Windows edition section. Here you will see the name and edition of your Windows 7 (such as Home Premium, Professional, or Ultimate).
-
Look for System type section. Here you will see whether your system is 32-bit or 64-bit.
-
Look for Service Pack section. Here you will see whether you have SP1 installed or not.
-
-
If you have SP1 installed, you will see Service Pack 1 next to Windows edition. If you don't have SP1 installed, you will not see anything there.
-
How to download and install Windows 7 SP1 offline?
-
If you don't have SP1 installed on your system, you need to download and install it before you can install SP2. You can do this offline, without using Windows Update. This is useful if you have a slow or unreliable internet connection, or if you want to save bandwidth and time.
-
To download and install Windows 7 SP1 offline, follow these steps:
Save the file to a convenient location on your system or on a removable media such as a USB flash drive.
-
Double-click on the file to run it. Follow the on-screen instructions to install SP1.
-
The installation process may take a while. Please be patient and do not turn off your system.
-
When the installation is complete, your system will restart automatically.
-
-
How to download and install Windows 7 SP2 offline?
-
If you have SP1 installed on your system, you can proceed to download and install SP2 (or convenience rollup update). You can also do this offline, without using Windows Update.
-
To download and install Windows 7 SP2 offline, follow these steps:
The file type is .MSU, not .EXE like before. Save the file to a convenient location on your system or on a removable media such as a USB flash drive.
-
Double-click on the file to run it. Follow the on-screen instructions to install SP2.
-
The installation process may take a while. Please be patient and do not turn off your system.
-
When the installation is complete, your system will restart automatically.
-
-
How to install other Windows updates?
-
The convenience rollup update only contains the updates released after Service Pack 1 and before April 2016. Any updates that Microsoft has released since then will not be installed automatically. You should run Windows Update manually to install any other available updates for your system.
-
To run Windows Update manually, follow these steps:
-
-
Click on the Start button and type windows update in the search box.
-
Click on Windows Update in the list of results.
-
In the Windows Update window, click on Check for updates. Wait for a few minutes while Windows searches for new updates.
-
If there are any important or optional updates available, select them and click on Install updates. Follow the on-screen instructions to complete the installation.
-
You may need to restart your system after installing some updates.
-
-
Note:
-
The convenience update does not include Internet Explorer 11 or the latest .NET Framework Updates. You should install those packages manually or from Windows Update if you need them.
-
Tips:
-
-
You can change the settings of Windows Update to automatically download and install updates in the background. This way, you don't have to worry about missing any important updates in the future.
-
You can also use third-party tools such as WSUS Offline Update or AutoPatcher to download and install multiple updates at once offline.
-
-
Conclusion
-
In this article, we have shown you how to upgrade your Windows 7 SP1 to SP2 offline, without using Windows Update. We have also shown you how to check your Windows version and edition, how
0a6ba089eb
-
-
\ No newline at end of file
diff --git a/spaces/1acneusushi/gradio-2dmoleculeeditor/data/GX Developer 8.7 Full Version Learn How to Create Edit Debug and Monitor PLC Programs.md b/spaces/1acneusushi/gradio-2dmoleculeeditor/data/GX Developer 8.7 Full Version Learn How to Create Edit Debug and Monitor PLC Programs.md
deleted file mode 100644
index 544fb46db3bdd13622e7ec1479f7d14b2cdc1d2c..0000000000000000000000000000000000000000
--- a/spaces/1acneusushi/gradio-2dmoleculeeditor/data/GX Developer 8.7 Full Version Learn How to Create Edit Debug and Monitor PLC Programs.md
+++ /dev/null
@@ -1,205 +0,0 @@
-
-
GX Developer 8.7 Full Version: A Comprehensive Guide
-
If you are looking for a reliable and easy-to-use programming software for Mitsubishi PLCs, you might want to check out GX Developer 8.7. This software is the latest version of the GX Developer series, which supports various PLC models and operating systems. In this article, we will give you a comprehensive guide on what GX Developer is, how to download and install it, how to use it, and some tips and tricks for using it effectively.
-
What is GX Developer?
-
GX Developer is a programming software for Mitsubishi PLCs that allows you to create, edit, monitor, debug, and transfer programs using ladder logic or structured text. It also supports other programming languages such as SFC, MELSAP-L, IL, ST, LD, FBD, and SFC/GRAFCET.
GX Developer is part of the MELSOFT series of engineering software that includes other products such as GX Works2, GX Works3, GT Designer, MX Component, etc. You can use these software products together to create a complete automation system with Mitsubishi devices.
-
Features and benefits of GX Developer
-
Some of the features and benefits of using GX Developer are:
-
-
It has a user-friendly interface that allows you to easily create and edit programs using drag-and-drop, copy-and-paste, undo-and-redo, etc.
-
It has a powerful simulation function that allows you to test and debug your program without connecting to a PLC.
-
It has a built-in online monitoring function that allows you to view and modify the status of devices, registers, timers, counters, etc. in real time.
-
It has a comprehensive help function that provides detailed information on functions, instructions, devices, error codes, etc.
-
It has a batch processing function that allows you to perform multiple operations such as printing, searching, replacing, etc. at once.
-
It has a data backup function that allows you to save and restore your program data in case of power failure or other accidents.
-
It has a password protection function that allows you to prevent unauthorized access or modification of your program data.
-
It has a library function that allows you to store and reuse frequently used programs or devices.
-
It has a template function that allows you to create standard programs or devices based on predefined formats.
-
-
Supported PLC series and operating systems
-
GX Developer 8.7 supports various PLC series such as:
-
-
FX Series: FX0(S), FX0N, FX1(S), FX1N, FX2N, FX3G, FX3U
The password for extracting the file is: plc4me.com
-
gx developer software mitsubishi electric americas
-gx developer v8.98c new version 2022 download
-gx developer programming software for melsec fx series
-gx developer trouble viewing this page download the pdf
-gx developer product key 352-100201687
-gx developer v8.91 software plc mitsubishi install
-gx developer simulator converter configurator-en
-gx developer 8.7 full version t-luscious tea
-gx developer basic controller programming environment
-gx developer support q process q l fx series
-gx developer comprehensive line of factory automation solutions
-gx developer plc4me.com home downloads mitsubishi software
-gx developer compatible with operating systems windows xp/7/8/10
-gx developer support programming for mitsubishi plc series
-gx developer instructions for installing gx-developer
-gx developer v8.98c updated 06/2022
-gx developer v8.98c software download backup link
-gx developer password extract plc4me.com
-gx developer comment below the article if the link is broken
-gx developer gt designer 3 v1.260w full new version
-gx developer sysmac studio v1.45 full googledrive
-gx developer mx component ver.5 mitsubishi googledrive link
-gx developer gx works2 v1.610l new version 2022
-gx developer gx works3 v1.080j software full version
-gx developer cx-one v4.51 cx-programmer v9.73 full version
-gx developer sim ekb install 2022 11 27 for siemens software
-gx developer tia portal v18 full googledrive link
-gx developer blog-teknisi.com install-gx-developer-v891-software-plc.html
-gx developer bytlly.com/2sH3fz download-gx-developer-8.7-full
-gx developer legacy controllers a and ans series
-gx developer q00u q02u q04udh older versions will not support fx3g fx3u plcs
-gx developer feel free to contact us for input product id serial number
-gx developer fx0 s fx0n fx1 s fx1n fx2n fx3g fx3u plcs
-gx developer environment of melsoft setup install software install simulator install converter install configurator-en
-gx developer us.mitsubishielectric.com fa en products controllers programmable controllers melsec engineering software other engineering softwares
-gx developer plc4me.com article 2336385-korean-nuclear-fusion-reactor achieves 100 millionc for 30 seconds
-gx developer nssdc.gsfc.nasa.gov planetary factsheet sunfact.html
-gx developer solar.physics.montana.edu YPOP Spotlight SunInfo Core.html
-gx developer curious.astro.cornell.edu about-us 54 our-solar-system the-sun interior 206 how-hot-is-each-one-of-the-layers-of-the-sun-beginner
-gx developer en.wikipedia.org wiki Sun core temperature kelvin
-gx developer en.wikipedia.org wiki Solar_core
-gx developer news.yahoo.com nuclear-fusion-breakthrough-reactor-runs 130157687.html
-gx developer the-sun.com news 4381435-holy-grail-fusion-experiments-breakthrough-race-unlimited-energy
-gx developer thesun.co.uk news 17143468-holy-grail-fusion-experiments-breakthrough-race-unlimited-energy
-gx developer newscientist.com article 2336385-korean-nuclear-fusion-reactor achieves 100 millionc for 30 seconds
-
Installation steps and product key
-
To install GX Developer 8.7 on your computer, follow these steps:
-
-
Click on the file "autorun" in the extracted folder.
-
Select "Setup Environment of MELSOFT" and click "Next". Follow the instructions on the screen to install the environment components.
-
Select "Install GX Developer Software" and click "Next". Follow the instructions on the screen to install the software components.
-
Select "Install GX Simulator Software" and click "Next". Follow the instructions on the screen to install the simulator components.
-
When prompted for the product key, enter: 352-100201687
-
Finish the installation process and restart your computer if necessary.
-
-
How to use GX Developer 8.7
-
Creating a new project
-
To create a new project in GX Developer 8.7, follow these steps:
-
-
Open GX Developer from the Start menu or desktop shortcut.
-
Select "File" -> "New Project" from the menu bar or click on the "New Project" icon on the toolbar.
-
Select the PLC type that matches your target device from the list of supported models.
-
Select the communication method that you will use to connect your PC to the PLC from the list of available options.
-
Select the programming language that you will use to create your program from the list of supported languages.
-
Select "OK" to create a new project with default settings or select "Advanced Settings" to customize your project settings such as device comment file name, device range setting file name, etc.
-
A new project window will open with an empty program area where you can start writing your program.
-
-
Programming with ladder logic
-
Ladder logic is one of the most common programming languages used for PLCs. It consists of graphical symbols that represent contacts, coils, timers, counters, etc., arranged in horizontal rows called rungs. Each rung represents a logical condition that controls an output device or operation.
-
To program with ladder logic in GX Developer 8.7, follow these steps:
-
-
Select "Edit" -> "Ladder" from the menu bar or click on the "Ladder" icon on the toolbar to switch to ladder mode.
-
Select "Insert" -> "Rung" from the menu bar or click on the "Insert Rung" icon on the toolbar to insert a new rung at the end of your program.
- the rung. You can select a device symbol from the device list on the left side of the screen or type the device name in the input box.
-
Repeat step 3 to insert more device symbols on the same rung or on different rungs until you complete your program logic.
-
Select "Edit" -> "Check" from the menu bar or click on the "Check" icon on the toolbar to check your program for errors and warnings. If there are any errors or warnings, they will be displayed in the error list at the bottom of the screen. You can double-click on an error or warning to jump to the corresponding location in your program and fix it.
-
Select "File" -> "Save" from the menu bar or click on the "Save" icon on the toolbar to save your program.
-
-
Simulating and debugging the program
-
Simulating and debugging your program is an important step to verify its functionality and performance before transferring it to the PLC. You can use GX Simulator to simulate your program without connecting to a PLC and monitor and modify the status of devices, registers, timers, counters, etc.
-
To simulate and debug your program in GX Developer 8.7, follow these steps:
-
-
Select "Tools" -> "GX Simulator" from the menu bar or click on the "GX Simulator" icon on the toolbar to launch GX Simulator.
-
Select "File" -> "Open Project" from the menu bar or click on the "Open Project" icon on the toolbar to open your project file in GX Simulator.
-
Select "Simulation" -> "Start Simulation" from the menu bar or click on the "Start Simulation" icon on the toolbar to start simulating your program. The simulation status will be displayed in the status bar at the bottom of the screen.
-
Select "View" -> "Device Monitor" from the menu bar or click on the "Device Monitor" icon on the toolbar to open the device monitor window. You can view and modify the status of devices, registers, timers, counters, etc. in this window.
-
Select "View" -> "Debug Monitor" from the menu bar or click on the "Debug Monitor" icon on the toolbar to open the debug monitor window. You can view and modify the status of internal relays, data registers, special relays, special registers, etc. in this window.
-
Select "Simulation" -> "Stop Simulation" from the menu bar or click on the "Stop Simulation" icon on the toolbar to stop simulating your program.
- the toolbar to close your project file in GX Simulator.
-
Select "File" -> "Exit" from the menu bar or click on the "Exit" icon on the toolbar to exit GX Simulator.
-
-
Transferring the program to the PLC
-
After you have created and tested your program, you can transfer it to the PLC using a communication cable or a memory card. You can also transfer the program from the PLC to your PC for backup or modification.
-
To transfer your program to the PLC in GX Developer 8.7, follow these steps:
-
-
Connect your PC to the PLC using a communication cable or insert a memory card into the PLC.
-
Select "Online" -> "Transfer Setup" from the menu bar or click on the "Transfer Setup" icon on the toolbar to open the transfer setup window. You can select the transfer mode, direction, device range, etc. in this window.
-
Select "OK" to confirm your transfer settings or select "Cancel" to cancel the transfer.
-
Select "Online" -> "Write to PLC" from the menu bar or click on the "Write to PLC" icon on the toolbar to transfer your program from your PC to the PLC. A progress bar will show the transfer status.
-
Select "Online" -> "Read from PLC" from the menu bar or click on the "Read from PLC" icon on the toolbar to transfer your program from the PLC to your PC. A progress bar will show the transfer status.
-
-
Tips and tricks for using GX Developer 8.7
-
Using shortcuts and hotkeys
-
You can use shortcuts and hotkeys to perform various operations quickly and conveniently in GX Developer 8.7. Here are some of the most useful shortcuts and hotkeys:
-
-
Ctrl+N: Create a new project
-
Ctrl+O: Open an existing project
-
Ctrl+S: Save the current project
-
Ctrl+P: Print the current project
-
Ctrl+Z: Undo the last operation
-
Ctrl+Y: Redo the last operation
-
Ctrl+C: Copy the selected device or rung
-
Ctrl+X: Cut the selected device or rung
-
Ctrl+V: Paste the copied or cut device or rung
-
Ctrl+F: Find a device or text in the current project
-
Ctrl+H: Replace a device or text in the current project
-
F1: Open the help function
-
F5: Start simulation
-
F6: Stop simulation
-
F7: Write to PLC
-
F8: Read from PLC
-
F9: Insert a new rung
-
F10: Delete a rung
-
F11: Insert a device
-
F12: Delete a device
-
-
Using comments and labels
-
You can use comments and labels to add descriptive information to your program and make it easier to understand and maintain. Comments are text that explain the purpose or function of a device, rung, or program. Labels are names that identify a device, rung, or program.
-
To use comments and labels in GX Developer 8.7, follow these steps:
-
- the menu bar or click on the "Comment/Label Display Setting" icon on the toolbar to open the comment/label display setting window. You can select the display mode, font size, color, etc. for comments and labels in this window.
-
Select "OK" to confirm your settings or select "Cancel" to cancel the settings.
-
Select "Edit" -> "Comment/Label" from the menu bar or click on the "Comment/Label" icon on the toolbar to open the comment/label edit window. You can add, edit, or delete comments and labels for devices, rungs, or programs in this window.
-
Select "OK" to save your changes or select "Cancel" to discard your changes.
-
-
Using libraries and templates
-
You can use libraries and templates to store and reuse frequently used programs or devices. Libraries are files that contain programs or devices that you can import into your project. Templates are files that contain standard programs or devices that you can create based on predefined formats.
-
To use libraries and templates in GX Developer 8.7, follow these steps:
-
-
Select "File" -> "Library" from the menu bar or click on the "Library" icon on the toolbar to open the library window. You can create, open, save, import, or export library files in this window.
-
Select "File" -> "Template" from the menu bar or click on the "Template" icon on the toolbar to open the template window. You can create, open, save, import, or export template files in this window.
-
-
Conclusion
-
GX Developer 8.7 is a powerful and versatile programming software for Mitsubishi PLCs that supports various PLC models and operating systems. It allows you to create, edit, monitor, debug, and transfer programs using ladder logic or other programming languages. It also has many features and benefits that make it easy and convenient to use. In this article, we have given you a comprehensive guide on how to download and install GX Developer 8.7, how to use it, and some tips and tricks for using it effectively. We hope you have found this article helpful and informative.
-
FAQs
-
Here are some frequently asked questions about GX Developer 8.7:
-
Q: How can I update GX Developer 8.7 to the latest version?
A: You can share your program with other users by saving it as a project file (.prg) or a library file (.lib) and sending it via email or other methods. You can also print your program as a document file (.doc) or a PDF file (.pdf) and share it as a hard copy.
-
Q: How can I convert my program from GX Developer 8.7 to GX Works2 or GX Works3?
-
A: You can convert your program from GX Developer 8.7 to GX Works2 or GX Works3 by using the conversion tool that is included in GX Works2 or GX Works3. You can access the conversion tool by selecting "Tools" -> "Conversion Tool" from the menu bar in GX Works2 or GX Works3.
- 0a6ba089eb
-
-
\ No newline at end of file
diff --git a/spaces/1gistliPinn/ChatGPT4/Examples/3planesoft Earth 3d Screensaver Keygen __FULL__.md b/spaces/1gistliPinn/ChatGPT4/Examples/3planesoft Earth 3d Screensaver Keygen __FULL__.md
deleted file mode 100644
index e2c3037280895d1c56f402b51bd8e6fee03a0985..0000000000000000000000000000000000000000
--- a/spaces/1gistliPinn/ChatGPT4/Examples/3planesoft Earth 3d Screensaver Keygen __FULL__.md
+++ /dev/null
@@ -1,9 +0,0 @@
-
-
Now we present you our latest 3d screensavers collections. It is looking like already for our next releases. 3Planesoft Open Ocean 3D Screensaver. 3Planesoft. 2.0.2. 2.0.2 Crack, Serial Number 3D Earth Screensaver. 3Planesoft. 3.8.3.
-
3Planesoft is an independent screensaver developing company specializing 3D screensavers. The company has released 48 titles and is currently the most. 3Planesoft. 3.3.3. Keygen Serial Number 3D Earth Screensaver. 3Planesoft. 3.3.3. Serial Number, Crack 3D Earth Screensaver, Keygen. 3Planesoft. 4.0.
Registration Key for the following 3Planesoft Screensavers: - Ancient Castle 3D. Clock 3D Screensaver - Discovery 3D Screensaver - Earth 3D Screensaver. 3Planesoft Autumn Forest 3D Screensaver 1.0.0.1 crack, Hull City Tigers, 22KB, Vote!. Planet Earth 3D Screensaver 1.0 keygen, 8KB, Vote!
-
3Planesoft Mechanical Clock 3D Screensaver v1.0 build 3 crack by FFF. 3Planesoft Earth 3D Screensaver v1.0 DIR FIX keygen by Lz0. 613 records. 3d screensaver serial numbers are presented here.. 3Planesoft Voyage of Columbus.3D Screensaver v1.0. Planet Earth 3D Screensaver 1.0.
-
FazionEgg3D - a user-friendly Windows desktop display screensaver with ambient music that will add to the ambiance. Hundreds of items will be displayed with realistic 3D graphics and animations. You can place your. Fancy Planet Earth. Soft 3D Screensaver and Desktop Wallpaper - Dream Aquarium screensaver is a home aquarium simulation screensaver with a vast range of beautiful fish and. Unlock Dream Aquarium 5.0 keygen. Aquarium Lava Scene Screensaver - Look, it's a complex structure, but don't take my word for it, look for yourself! The incredible beauty of this complicated. Aquarium Lava Scene Screensaver without Registration. Dream Aquarium is a unique and extremely luxurious freshwater aquarium screen saver, which claims to be the real aquarium screensaver. Click to install Dream Aquarium 5.0. Dream Aquarium 5.0.5 Crack. Luna Wind (Aquarium Wallpaper 3d Aquarium Lava Scene Screensaver) Dream Aquarium.
899543212b
-
-
\ No newline at end of file
diff --git a/spaces/1gistliPinn/ChatGPT4/Examples/Castlevania Lords Of Shadow Mirror Of Fate HD-RELOADED Fitgirl Repack.md b/spaces/1gistliPinn/ChatGPT4/Examples/Castlevania Lords Of Shadow Mirror Of Fate HD-RELOADED Fitgirl Repack.md
deleted file mode 100644
index 8255d72c4bf680bbae63d276dfcc5b473d1f066f..0000000000000000000000000000000000000000
--- a/spaces/1gistliPinn/ChatGPT4/Examples/Castlevania Lords Of Shadow Mirror Of Fate HD-RELOADED Fitgirl Repack.md
+++ /dev/null
@@ -1,15 +0,0 @@
-
-
Review: Castlevania Lords of Shadow Mirror of Fate HD-RELOADED fitgirl repack
-
If you are a fan of the Castlevania series, you might be interested in the fitgirl repack of Castlevania Lords of Shadow Mirror of Fate HD-RELOADED, a side-scrolling action-adventure game that follows the story of the Belmont family across generations. The game was originally released for Nintendo 3DS in 2013, and later ported to PC, PS3 and Xbox 360 with improved graphics and sound. The fitgirl repack is based on the PC version and reduces the original size of 2 GB to 576 MB, without compromising the quality or content of the game.
-
Castlevania Lords of Shadow Mirror of Fate HD-RELOADED fitgirl repack
The game features four playable characters: Gabriel Belmont, the protagonist of Castlevania Lords of Shadow who became the vampire lord Dracula; Trevor Belmont, his son and a knight of the Brotherhood of Light; Simon Belmont, Trevor's son and a barbarian warrior; and Alucard, Dracula's son and a half-vampire. Each character has their own abilities, weapons and skills, and the game switches between them as the story progresses. The game combines platforming, combat, puzzles and exploration, with some elements borrowed from the Metroidvania subgenre. The game also has a boss rush mode and a leaderboards system.
-
The fitgirl repack includes the latest update v1.0.684579 that fixes some bugs and improves performance. It also has an optional Russian text/audio translation (compiled by Siberian Gremlin) that can be installed during setup. The repack is 100% lossless and MD5 perfect, meaning that all files are identical to originals after installation. The installation takes only 1-2 minutes, and the game can be run from the Language Selector.exe in the game root folder. The repack is compatible with some filehosters and torrent trackers, but not with others.
-
Castlevania Lords of Shadow Mirror of Fate HD-RELOADED fitgirl repack is a great way to enjoy this game on PC with minimal storage space and maximum quality. The game offers a rich and engaging story that expands the lore of the Castlevania universe, as well as a challenging and varied gameplay that will test your skills and reflexes. If you are looking for a thrilling and satisfying adventure in the dark and Gothic world of Castlevania, you should definitely check out this repack.
-
-
-
The game has received mostly positive reviews from critics and players alike, who praised its story, graphics, music and gameplay. Some of the drawbacks mentioned were the lack of replay value, the linear level design and the occasional technical issues. The game has a Metacritic score of 72/100 for PC, based on 16 reviews. The user score is 7.8/10, based on 95 ratings.
-
If you want to download this repack, you can use one of the following links: , , , or . Make sure you have at least 2 GB of free RAM and 2 GB of HDD space before installing. You will also need a compatible gamepad to play the game, as it does not support mouse and keyboard controls. The game runs on Windows XP with Service Pack 3 or higher, and requires DirectX 9.0c or better.
-
Some other games that you might enjoy if you liked this one are Castlevania Lords of Shadow â Ultimate Edition, which is the first game in the Lords of Shadow trilogy and a reboot of the Castlevania series; Castlevania Lords of Shadow 2, which is the final game in the trilogy and follows Dracula's quest to end his immortality; and Castlevania: Symphony of the Night, which is a classic Metroidvania game that features Alucard as the main character.
-
In conclusion, Castlevania Lords of Shadow Mirror of Fate HD-RELOADED fitgirl repack is a worthy addition to your PC game collection, especially if you are a fan of the Castlevania franchise or the action-adventure genre. The game delivers a captivating story, a stunning visual presentation, a memorable soundtrack and a fun and challenging gameplay that will keep you hooked for hours. Don't miss this opportunity to experience this epic saga in a compact and convenient format.
d5da3c52bf
-
-
\ No newline at end of file
diff --git a/spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Download CarSim The Industry-Leading Tool for Vehicle Dynamics Analysis and Development.md b/spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Download CarSim The Industry-Leading Tool for Vehicle Dynamics Analysis and Development.md
deleted file mode 100644
index 2aad384f53d7f286533d009910af8e6f7cf6bbdc..0000000000000000000000000000000000000000
--- a/spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Download CarSim The Industry-Leading Tool for Vehicle Dynamics Analysis and Development.md
+++ /dev/null
@@ -1,189 +0,0 @@
-
-
How to Download CarSim: A Comprehensive Guide
-
If you are interested in simulating the dynamic performance of cars, trucks, motorcycles, or specialty vehicles, you might have heard of CarSim, a software tool that can help you achieve accurate and efficient results. But how do you download CarSim and use it for your projects? In this article, we will provide you with a comprehensive guide on how to download CarSim for Windows or Linux, as well as how to use it for vehicle dynamics simulation. We will also cover some of the features, benefits, and alternatives of CarSim, so you can decide if it is the right tool for you.
-
What is CarSim and why do you need it?
-
CarSim is a commercial software package that predicts the performance of vehicles in response to driver controls (steering, throttle, brakes, clutch, and shifting) in a given environment (road geometry, coefficients of friction, wind). It uses 3D multibody dynamics models to accurately reproduce the physics of the vehicle in response to controls from the driver and/or automation. It also supports vehicle sensors and interactive traffic for V2V and ADAS development. CarSim can be used as a standalone application or in co-simulation with other software tools such as MATLAB/Simulink, NI LabVIEW, FMI/FMU, Unreal Engine, etc.
CarSim was first introduced in 1990 and has been developed continuously since then by Mechanical Simulation Corporation. It is used worldwide by over 110 OEMs and Tier 1 suppliers and over 200 universities and government research labs. There are more than 2600 active CarSim seats, not including driving simulators or students. Some of the features of CarSim include:
-
-
An intuitive user interface and powerful analysis tools
-
A library of example vehicles, roads, procedures, controllers, sensors, etc.
-
A modular VS math model that can be extended with user-defined programs or connections to third-party software
-
A VS visualizer tool for viewing simulations with plots and photo-realistic animation
-
A VS scene builder tool for creating custom road networks and environments
-
A VS SDK tool for developing custom applications using VehicleSim technology
-
A support for real-time systems such as hardware-in-the-loop (HIL) and driver-in-the-loop (DIL)
-
An extensive documentation covering all aspects of the software
-
-
CarSim benefits and applications
-
CarSim delivers the most accurate, detailed, and efficient methods for simulating the performance of passenger vehicles and light-duty trucks. It has been validated by automotive engineers for over twenty years and has shown close agreement between simulation predictions and test results. Some of the benefits and applications of CarSim are:
-
-
It can help you analyze vehicle dynamics, develop active controllers, calculate vehicle performance characteristics, and engineer next-generation active safety systems
-
It can help you reduce development time and cost by enabling virtual testing and optimization before physical prototyping
-
It can help you improve vehicle quality and safety by identifying potential issues and solutions early in the design process
-
It can help you enhance vehicle performance and efficiency by exploring different design scenarios and trade-offs
-
It can help you demonstrate vehicle capabilities and features to customers and stakeholders by creating realistic simulations and animations
-
-
CarSim alternatives and competitors
-
CarSim is not the only software tool available for vehicle dynamics simulation. There are several alternatives that offer similar or different
features and capabilities. Some of the most popular ones are:
-
-
ADAMS Car: A software tool from MSC Software that provides a comprehensive set of built-in components, templates, and test rigs for vehicle modeling and simulation. It can be used for vehicle dynamics, durability, ride and handling, and NVH analysis. It can also be integrated with other MSC products such as MSC Nastran, MSC Fatigue, etc.
-
Dymola: A software tool from Dassault Systèmes that uses the Modelica language for modeling and simulating complex and multidisciplinary systems. It can be used for vehicle dynamics, powertrain, thermal management, electric and hybrid vehicles, etc. It can also be coupled with other tools such as Simulink, FMI/FMU, etc.
-
IPG CarMaker: A software tool from IPG Automotive that provides a complete solution for virtual test driving. It can be used for vehicle dynamics, ADAS, autonomous driving, powertrain, chassis, etc. It can also be connected to real-time systems such as HIL and DIL.
-
-
Each of these tools has its own advantages and disadvantages, depending on your specific needs and preferences. You can compare them based on various criteria such as features, accuracy, speed, ease of use, cost, support, etc. You can also try them out by requesting a free trial or a demo from their respective websites.
-
How to download CarSim for Windows or Linux
-
If you have decided that CarSim is the right tool for you, you might be wondering how to download it and install it on your computer. In this section, we will guide you through the process of downloading CarSim for Windows or Linux. We will also provide you with some tips and tricks to optimize CarSim performance on your system.
-
Requirements and prerequisites
-
Before you download CarSim, you need to make sure that your computer meets the minimum requirements for running the software. According to the official website, these are:
-
How to download carsim software for vehicle dynamics simulation
-Download carsim demo version for free
-Carsim download link and installation guide
-Download carsim 2023.0 with new features and enhancements
-Carsim download for Windows 10, 8, 7, and XP
-Download carsim MATLAB/Simulink interface and examples
-Carsim download for real-time systems and hardware-in-the-loop testing
-Download carsim Unreal Engine plugin and VS Scene Builder
-Carsim download for driving simulators and virtual reality applications
-Download carsim ADAS sensors and interactive traffic models
-Carsim download for electric powertrain analysis and optimization
-Download carsim lap time optimization tool and examples
-Carsim download for motorcycle dynamics simulation and bikeSim integration
-Download carsim truck dynamics simulation and truckSim integration
-Carsim download for suspension design and analysis with suspensionSim
-Download carsim vehicle parameters and tables from measurement services
-Carsim download for co-simulation with FMI/FMU, LabVIEW, and ASCET
-Download carsim VS Visualizer tool for animation and plotting
-Carsim download for vehicle stability control and ESC testing
-Download carsim tilt table test procedure and results
-Carsim download for path following and speed control driver models
-Download carsim vehicle models and license options PDF
-Carsim download for industry, education, and motorsports applications
-Download carsim technical papers and publications
-Carsim download for sine with dwell test procedure and results
-Download carsim newsletters, press releases, and webcasts
-Carsim download for V2V communication and autonomous vehicle development
-Download carsim user section, support, and training resources
-Carsim download for trailer dynamics simulation and dual tire models
-Download carsim customer testimonials and case studies
-Carsim download for vehicle aerodynamics simulation and wind effects
-Download carsim built-in features overview PDF
-Carsim download for tire modeling and tire data import/export
-Download carsim VehicleSim SDK for custom programming and scripting
-Carsim download for brake system modeling and ABS testing
-Download carsim steering system modeling and EPS testing
-Carsim download for transmission modeling and gear shifting control
-Download carsim clutch modeling and mechanical clutch control
-Carsim download for engine modeling and torque generation control
-Download carsim fuel consumption modeling and fuel economy analysis
-Carsim download for thermal effects modeling and heat transfer analysis
-Download carsim road load modeling and road profile data import/export
-Carsim download for road geometry modeling and road network generation
-Download carsim terrain modeling and off-road simulation capabilities
-Carsim download for vehicle damage modeling and crash simulation capabilities
-Download carsim noise modeling and sound generation capabilities
-Carsim download for vehicle component modeling and sub-system integration capabilities
-Download carsim vehicle design optimization tool and examples
-Carsim download for vehicle handling evaluation tool and examples
-Download carsim vehicle performance evaluation tool and examples
-
-
-
Operating System
-
Processor
-
Memory
-
Disk Space
-
Graphics Card
-
-
-
Windows 10 (64-bit) or Linux (64-bit)
-
Intel Core i5 or equivalent
-
8 GB RAM or more
-
10 GB free disk space or more
-
NVIDIA GeForce GTX 1050 or equivalent
-
-
-
In addition to these requirements, you also need to have a valid license for using CarSim. You can obtain a license by contacting Mechanical Simulation Corporation or one of their authorized distributors. You can choose from different types of licenses such as node-locked, floating, networked, academic, etc. depending on your needs and budget.
-
Steps to download and install CarSim
-
Once you have a license for CarSim, you can proceed to download and install the software on your computer. The steps are as follows:
-
-
Go to the official website of Mechanical Simulation Corporation and log in with your username and password.
-
Go to the Downloads section and select the latest version of CarSim for your operating system (Windows or Linux).
-
Download the installation file (CarSim_Setup.exe for Windows or CarSim_Setup.run for Linux) and save it to your preferred location.
-
Run the installation file and follow the instructions on the screen. You will need to accept the license agreement, choose the installation directory, select the components to install, etc.
-
When the installation is complete, you will need to activate your license by entering your license code or connecting to your license server.
-
You can now launch CarSim from the Start menu (Windows) or the Applications menu (Linux) and start using it for your projects.
-
-
Tips and tricks to optimize CarSim performance
-
To get the most out of CarSim, you might want to optimize its performance on your system. Here are some tips and tricks that can help you do that:
-
-
Keep your system updated with the latest drivers, patches, and security updates.
-
Close any unnecessary programs or processes that might be consuming CPU, memory, disk space, or network bandwidth.
-
Adjust the graphics settings in CarSim according to your system capabilities and preferences. You can change the resolution, quality, anti-aliasing, shadows, etc. in the VS Visualizer options menu.
-
Use a wired connection instead of a wireless one if you are using CarSim in co-simulation with other software tools such as MATLAB/Simulink, NI LabVIEW, etc. This can improve the communication speed and reliability between the tools.
-
Use the VS Scene Builder tool to create custom road networks and environments for your simulation scenarios. You can import existing road data from OpenDRIVE, Google Maps, etc. or create your own roads using the graphical interface.
-
Use the VS SDK tool to develop custom applications using VehicleSim technology. You can create your own user interface, data processing, visualization, etc. using C++, C#, Python, or Java.
-
-
How to use CarSim for vehicle dynamics simulation
-
Now that you have downloaded and installed CarSim on your system, you might be wondering how to use it for vehicle dynamics simulation. In this section, we will guide you through the process of creating and running a simulation scenario, using built-in controllers and sensors, and analyzing and visualizing simulation results.
-
How to create and run a simulation scenario
-
A simulation scenario in CarSim consists of four main components: a vehicle model, a road model, a driver model, and a procedure. You can create and run a simulation scenario by following these steps:
-
-
Launch CarSim from the Start menu (Windows) or the Applications menu (Linux) and select New from the File menu to create a new project.
-
Select a vehicle model from the library or create your own using the Vehicle Browser. You can modify the vehicle parameters such as mass, inertia, suspension, tires, brakes, steering, etc. using the Vehicle Editor.
-
Select a road model from the library or create your own using the Road Browser. You can modify the road parameters such as geometry, elevation, curvature, friction, etc. using the Road Editor.
-
Select a driver model from the library or create your own using the Driver Browser. You can modify the driver parameters such as reaction time, steering gain, speed profile, etc. using the Driver Editor.
-
Select a procedure from the library or create your own using the Procedure Browser. You can modify the procedure parameters such as initial conditions, events, outputs, etc. using the Procedure Editor.
-
Save your project and click on Run Simulation to start the simulation. You can monitor the simulation progress and status in the Simulation Control window.
-
-
How to use built-in controllers and sensors
-
CarSim provides a number of built-in controllers and sensors that you can use for your simulation scenarios. These include:
-
-
Controllers: ABS, TCS, ESC, ACC, LKA, AEB, etc.
-
Sensors: Radar, Lidar, Camera, GPS, IMU, etc.
-
-
You can use these controllers and sensors by following these steps:
-
-
Select a controller or sensor from the library or create your own using the Controller Browser or Sensor Browser. You can modify the controller or sensor parameters such as gains, thresholds, delays, fields of view, etc. using the Controller Editor or Sensor Editor.
-
Assign the controller or sensor to a vehicle component such as brakes, throttle, steering, etc. using the Vehicle Editor. You can also specify the connections and interactions between different controllers and sensors using the Controller Network Editor.
-
Save your project and run the simulation. You can observe the effects of the controllers and sensors on the vehicle behavior and performance in the VS Visualizer.
-
-
How to analyze and visualize simulation results
-
After running a simulation, you can analyze and visualize the simulation results using the VS Visualizer tool. You can do this by following these steps:
-
-
Open the VS Visualizer from the Tools menu or by clicking on the VS Visualizer icon in the Simulation Control window.
-
Select a simulation run from the list of available runs or browse for a run file (.sim) in your project folder.
-
Select a plot or animation type from the list of available types or create your own using the Plot Editor or Animation Editor. You can choose from various plot types such as time history, XY, polar, histogram, etc. and animation types such as 3D, 2D, video, etc.
-
Select the variables that you want to plot or animate from the list of available variables or create your own using the Variable Editor. You can choose from various variables such as vehicle states, driver inputs, controller outputs, sensor measurements, etc.
-
Adjust the plot or animation settings such as scale, range, color, font, legend, etc. using the Plot Options or Animation Options menu.
-
View the plot or animation in the VS Visualizer window. You can zoom, pan, rotate, pause, play, etc. using the mouse or keyboard commands.
-
Save or export the plot or animation as an image file (.png, .jpg, etc.) or a video file (.avi, .mp4, etc.) using the File menu.
-
-
Conclusion and FAQs
-
In this article, we have provided you with a comprehensive guide on how to download CarSim for Windows or Linux, as well as how to use it for vehicle dynamics simulation. We have also covered some of the features, benefits, and alternatives of CarSim, so you can decide if it is the right tool for you. We hope that you have found this article useful and informative. If you have any questions or feedback, please feel free to contact us or leave a comment below. Here are some FAQs that might help you further:
-
Summary of the main points
-
-
CarSim is a commercial software package that predicts the performance of vehicles in response to driver controls and environment conditions.
-
CarSim uses 3D multibody dynamics models to accurately reproduce the physics of the vehicle and supports vehicle sensors and interactive traffic.
-
CarSim can be used as a standalone application or in co-simulation with other software tools such as MATLAB/Simulink, NI LabVIEW, FMI/FMU, Unreal Engine, etc.
-
CarSim can help you analyze vehicle dynamics, develop active controllers, calculate vehicle performance characteristics, and engineer next-generation active safety systems.
-
CarSim can help you reduce development time and cost, improve vehicle quality and safety, enhance vehicle performance and efficiency, and demonstrate vehicle capabilities and features.
-
CarSim has several alternatives that offer similar or different features and capabilities, such as ADAMS Car, Dymola, IPG CarMaker, etc.
-
To download CarSim, you need to have a valid license and a computer that meets the minimum requirements. You can download the installation file from the official website and follow the instructions on the screen.
-
To use CarSim, you need to create and run a simulation scenario that consists of a vehicle model, a road model, a driver model, and a procedure. You can use built-in controllers and sensors or create your own. You can analyze and visualize the simulation results using the VS Visualizer tool.
-
-
FAQs
-
-
Q: How much does CarSim cost?
-A: The cost of CarSim depends on the type of license, the number of seats, the duration of use, and the level of support. You can contact Mechanical Simulation Corporation or one of their authorized distributors for a quote.
-
Q: How can I learn more about CarSim?
-A: You can learn more about CarSim by visiting the official website, reading the documentation, watching the tutorials, attending the webinars, or joining the user forum. You can also request a free trial or a demo to try out CarSim for yourself.
-
Q: How can I get technical support for CarSim?
-A: You can get technical support for CarSim by contacting Mechanical Simulation Corporation or one of their authorized distributors. You can also use the online help system, the FAQ page, or the user forum to find answers to common questions or issues.
-
Q: How can I upgrade to the latest version of CarSim?
-A: You can upgrade to the latest version of CarSim by downloading the installation file from the official website and running it on your system. You will need to have a valid license for the latest version or renew your license if it has expired.
-
Q: How can I share my CarSim projects with others?
-A: You can share your CarSim projects with others by exporting them as ZIP files or VS Browser files using the File menu. You can also share your simulation results as image files or video files using the VS Visualizer tool.
- 197e85843d
-
-
\ No newline at end of file
diff --git a/spaces/1phancelerku/anime-remove-background/Cmo jugar al tablero deuda eterna juego apk y aprender sobre la realidad latinoamericana.md b/spaces/1phancelerku/anime-remove-background/Cmo jugar al tablero deuda eterna juego apk y aprender sobre la realidad latinoamericana.md
deleted file mode 100644
index e7e45fe18f5f1933d616ed6d60614f76a9b6a3ed..0000000000000000000000000000000000000000
--- a/spaces/1phancelerku/anime-remove-background/Cmo jugar al tablero deuda eterna juego apk y aprender sobre la realidad latinoamericana.md
+++ /dev/null
@@ -1,92 +0,0 @@
-
-
What is Tablero Deuda Eterna Juego APK?
-
If you are looking for a board game that combines strategy, education, and fun, you might want to check out Tablero Deuda Eterna Juego APK. This is a digital version of a classic board game that was created in Cuba in the 1960s as a response to Monopoly. The game simulates the economic and political situation of Latin America and challenges the players to defeat the International Monetary Fund (IMF) and achieve development and independence.
The game can be played by 2 to 6 players, who take on the role of governments of Third World countries. The goal is to use the natural resources of Latin America, industrialize them, and sell them in the Northern markets. To do so, each player has to become an entrepreneur and overcome all the obstacles that the game presents. The capital is provided by the IMF, which imposes conditions, devaluations, and other difficulties. The objective is to overcome these challenges and get rid of the IMF.
-
The components of the game
-
The game consists of a board that represents Latin America and North America, divided into 24 territories. Each territory has a different value and produces a different resource. The board also has spaces for cards, dice, money, and other elements. The cards are divided into three types: IMF cards, which contain instructions that affect all players; Event cards, which contain random events that affect one or more players; and Development cards, which contain benefits that players can buy with their money. The dice are used to determine the movement of players on the board and to resolve conflicts. The money is used to buy properties, industries, and development cards.
-
The rules of the game
-
The game follows these basic steps:
-
-
Each player chooses a color and receives a starting amount of money.
-
Each player rolls a die and moves their pawn on the board according to the number.
-
If a player lands on an empty territory in Latin America, they can buy it with their money.
-
If a player lands on an occupied territory in Latin America, they have to pay rent to the owner.
-
If a player lands on an empty territory in North America, they can build a multinational industry with their money.
-
If a player lands on an occupied territory in North America, they have to pay royalties to the owner.
-
If a player lands on an IMF space, they have to draw an IMF card and follow its instructions.
-
If a player lands on an Event space, they have to draw an Event card and follow its instructions.
-
If a player lands on a Development space, they can buy a Development card with their money.
-
If two or more players land on the same space, they have to roll dice to determine who stays and who moves back one space.
-
-
The game ends when one of these conditions is met:
-
-
Tie: If one player, or a pair or trio of players, owns more than - 50% of the territories in Latin America and North America, they win the game together. - Victory: If one player, or a pair or trio of players, manages to pay off their debt to the IMF and get rid of all the IMF cards, they win the game together. - Defeat: If all the players run out of money and cannot pay their debts, they lose the game together.
-
Why should you play Tablero Deuda Eterna Juego APK?
-
The educational value of the game
-
One of the main reasons to play Tablero Deuda Eterna Juego APK is that it is a great way to learn about the economic and political realities of Latin America and the world. The game exposes the players to the concepts of debt, interest, inflation, devaluation, trade, development, and imperialism. It also shows the historical and cultural aspects of Latin America, such as its diversity, richness, and struggles. The game encourages critical thinking and reflection on the causes and consequences of underdevelopment and dependency.
Another reason to play Tablero Deuda Eterna Juego APK is that it is a lot of fun. The game is full of surprises, challenges, and opportunities. The players have to make strategic decisions, negotiate with each other, and deal with unexpected events. The game is also very social, as it fosters cooperation, competition, and communication among the players. The game can be played with friends, family, or online with other players from around the world.
-
The availability of the game
-
A final reason to play Tablero Deuda Eterna Juego APK is that it is very easy to access and enjoy. The game is available for free on Google Play Store for Android devices. You can download and install it in minutes and start playing right away. The game has a simple and intuitive interface, with clear instructions and graphics. The game also has a multiplayer mode, where you can join or create rooms with other players online.
-
Conclusion
-
Tablero Deuda Eterna Juego APK is a board game that offers a unique and engaging experience for anyone who wants to learn more about Latin America and the world. The game combines strategy, education, and fun in a way that challenges and entertains the players. The game is also very accessible and easy to play on Android devices. If you are looking for a board game that will make you think, laugh, and have a good time, you should definitely give Tablero Deuda Eterna Juego APK a try.
-
FAQs
-
Here are some frequently asked questions about Tablero Deuda Eterna Juego APK:
-
-
Q: How long does a game last?
-
A: The duration of a game depends on the number of players, the level of difficulty, and the luck factor. A typical game can last from 30 minutes to 2 hours.
-
Q: Can I play the game offline?
-
A: Yes, you can play the game offline with up to 6 players on one device. You can also play online with other players from different devices.
-
Q: What languages does the game support?
-
A: The game supports Spanish, English, Portuguese, French, German, Italian, Russian, Chinese, Japanese, Korean, Arabic, Hindi, and Turkish.
-
Q: Is the game based on real facts?
-
A: The game is based on historical and current facts about Latin America and the world. However, some aspects of the game are fictional or exaggerated for entertainment purposes.
-
Q: Where can I find more information about the game?
-
A: You can find more information about the game on its official website, its Facebook page, or its YouTube channel.
-
- : https://www.deudaeterna.com/ : https://www.facebook.com/deudaeterna/ : https://www.youtube.com/channel/UCwYkXtZ8v0a9yZyRlJg7oLw 401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/1phancelerku/anime-remove-background/Download Hacked My Talking Tom APK with Unlimited Money and Coins.md b/spaces/1phancelerku/anime-remove-background/Download Hacked My Talking Tom APK with Unlimited Money and Coins.md
deleted file mode 100644
index c3f8e54a565ba9bfe1c73778716262aacc2720b6..0000000000000000000000000000000000000000
--- a/spaces/1phancelerku/anime-remove-background/Download Hacked My Talking Tom APK with Unlimited Money and Coins.md
+++ /dev/null
@@ -1,77 +0,0 @@
-
-
Download Hacked My Talking Tom: Is It Worth It?
-
My Talking Tom is one of the most popular virtual pet games in the world, with over a billion downloads on Google Play and App Store. But some people are not satisfied with the official version of the game and look for ways to download hacked versions that offer unlimited coins, unlocked features, and no ads. But is it worth it to download hacked My Talking Tom? What are the risks and consequences of doing so? In this article, we will explore these questions and give you some tips on how to play My Talking Tom safely and legally.
-
What is My Talking Tom?
-
A popular virtual pet game
-
My Talking Tom is a game developed by Outfit7, a company that specializes in creating games featuring animated characters that can talk and interact with the players. The game was released in 2013 and has since become a global phenomenon, spawning several sequels and spin-offs, such as My Talking Tom 2, My Talking Angela, My Talking Tom Friends, and more.
The game allows you to adopt a cute kitten named Tom and take care of him as he grows up. You can feed him, play with him, dress him up, decorate his house, and travel to different destinations with him. You can also talk to him and he will repeat what you say in a funny voice. The game also features mini-games that add action, adventure, and fun to the gameplay. The game is free to download and play, but it contains in-app purchases and ads that can enhance or interrupt your experience.
-
What are hacked games?
-
Games that have been cracked or modified
-
Hacked games are games that have been cracked or modified by hackers or pirates to bypass the digital rights management (DRM) technology that protects the copyrighted content. By doing so, they allow users to access and play the games without paying the developers or distributors. Often, in-demand titles are singled out for this treatment as soon as they become available to buy, although there are even examples of pirates getting hold of and distributing free copies in advance of official release dates.
-
Reasons why people download hacked games
-
Some of the reasons why people download hacked games are:
-
-
They want to save money by not paying for the games.
-
They want to access features or content that are locked or unavailable in the official version.
-
They want to avoid ads or in-app purchases that may annoy or tempt them.
-
They want to try out the games before buying them.
-
They want to challenge themselves or show off their skills by playing harder or modified versions of the games.
-
-
What are the risks of downloading hacked games?
-
Malware infection
-
One of the biggest risks of downloading hacked games is malware infection. Malware is malicious software that can harm your device or data in various ways, such as stealing your personal information, locking your files, displaying unwanted ads, slowing down your performance, or even taking over your device. Hackers and pirates often use popular games as bait to lure users into downloading malware-infested software. They may do so by sharing messages on social media, phishing emails, or even through search engine optimization of their websites or P2P torrents. Often, the malware has been crafted to bypass traditional security filters or it may require the user to deactivate their anti-malware software altogether. It also typically asks for excessive permissions to run.
-
Legal consequences
-
Another risk of downloading hacked games is legal consequences. Downloading hacked games is a form of piracy, which is illegal in most countries. Piracy is the unauthorized use or distribution of copyrighted material, such as games, movies, music, books, etc. Piracy violates the intellectual property rights of the creators and owners of the content, who invest time, money, and effort to produce and distribute it. Piracy also harms the legitimate businesses and industries that depend on the revenue from the sales of the content. Piracy can result in civil or criminal penalties, such as fines, lawsuits, or even jail time, depending on the severity and frequency of the offense.
-
stick war legacy mod apk unlimited head items download
-stick war legacy hack 99999 head avatar items free download
-stick war legacy mod new 99999 head skins and weapons download
-stick war legacy hack unlimited head items and gold download
-stick war legacy mod apk 99999 head avatar items unlocked download
-stick war legacy hack 99999 head items vs final boss download
-stick war legacy mod new 99999 head skins and griffon download
-stick war legacy hack unlimited head items and gems download
-stick war legacy mod apk 99999 head avatar items and leaf griffon download
-stick war legacy hack 99999 head items and zombies download
-stick war legacy mod new 99999 head skins and spearton download
-stick war legacy hack unlimited head items and magikill download
-stick war legacy mod apk 99999 head avatar items and swordwrath download
-stick war legacy hack 99999 head items and movie download
-stick war legacy mod new 99999 head skins and miner download
-stick war legacy hack unlimited head items and giant download
-stick war legacy mod apk 99999 head avatar items and archer download
-stick war legacy hack 99999 head items and hacked download
-stick war legacy mod new 99999 head skins and the elites download
-stick war legacy hack unlimited head items and cheats download
-stick war legacy mod apk 99999 head avatar items and no ads download
-stick war legacy hack 99999 head items and online download
-stick war legacy mod new 99999 head skins and offline download
-stick war legacy hack unlimited head items and latest version download
-stick war legacy mod apk 99999 head avatar items and update download
-
Poor gaming experience
-
A third risk of downloading hacked games is poor gaming experience. Hacked games may not work properly or at all on your device, as they may not be compatible with your operating system, hardware, or software. They may also contain bugs, glitches, errors, or crashes that can ruin your gameplay or cause you to lose your progress. Hacked games may also lack the updates, patches, or support that the official version receives from the developers or distributors. This means that you may miss out on new features, content, improvements, or fixes that can enhance your gaming experience. Hacked games may also be unfair or unbalanced, as they may give you an advantage or disadvantage over other players or the game itself.
-
How to play My Talking Tom safely and legally?
-
Download from official sources
-
The best way to play My Talking Tom safely and legally is to download it from official sources, such as Google Play or App Store. These platforms have strict policies and procedures to ensure that the games they offer are authentic, secure, and compliant with the law. They also have ratings, reviews, and feedback systems that can help you choose the best games for your preferences and needs. By downloading from official sources, you can also enjoy the benefits of cloud saving, achievements, leaderboards, and social features that can enrich your gaming experience.
-
Use antivirus software and VPN
-
Another way to play My Talking Tom safely and legally is to use antivirus software and VPN (virtual private network) on your device. Antivirus software can protect your device from malware infection by scanning and removing any suspicious files or programs that you download or run. VPN can protect your online privacy and security by encrypting your data and hiding your IP address from hackers, trackers, or spies. VPN can also help you access geo-restricted content or bypass censorship that may prevent you from playing My Talking Tom in some regions.
-
Support the developers
-
A final way to play My Talking Tom safely and legally is to support the developers by paying for the game or making in-app purchases. By doing so, you can show your appreciation and gratitude for their hard work and creativity. You can also help them cover their costs and earn a profit that can motivate them to continue making more games for you to enjoy. You can also access premium features or content that can enhance your gameplay or customization options. You can also disable ads that may interrupt or distract you from your gameplay.
-
Conclusion
-
My Talking Tom is a fun and engaging virtual pet game that millions of people love and play around the world. However, some people may be tempted to download hacked versions of the game that offer unlimited coins, unlocked features, and no ads. But this is not worth it, as it poses many risks and consequences for your device, data, legal status, and gaming experience. Instead, you should play My Talking Tom safely and legally by downloading it from official sources, using antivirus software and VPN on your device, and supporting the developers by paying for the game or making in-app purchases.
-
FAQs
-
-
Q: How do I download My Talking Tom?
-
A: You can download My Talking Tom from Google Play or App Store on your Android or iOS device.
-
Q: How do I update My Talking Tom?
-
A: You can update My Talking Tom by checking for updates on Google Play or App Store and following the instructions.
-
Q: How do I get more coins in My Talking Tom?
-
A: You can get more coins in My Talking Tom by playing mini-games, watching ads, completing tasks, or making in-app purchases.
-
Q: How do I unlock more features or content in My Talking Tom?
-
A: You can unlock more features or content in My Talking Tom by leveling up your Tom, traveling to different destinations, dressing him up with different outfits and accessories, decorating his house with various items and furniture, or making in-app purchases.
-
Q: How do I talk to my Tom in My Talking Tom?
-
A: You can talk to your Tom in My Talking Tom by tapping on the microphone icon and speaking into your device. Your Tom will repeat what you say in a funny voice.
-
197e85843d
-
-
\ No newline at end of file
diff --git a/spaces/1phancelerku/anime-remove-background/Download Pink Wallpaper Android - Amazing and Free HD Pink Wallpapers for Your Mobile and Desktop.md b/spaces/1phancelerku/anime-remove-background/Download Pink Wallpaper Android - Amazing and Free HD Pink Wallpapers for Your Mobile and Desktop.md
deleted file mode 100644
index 1db173026e570bb03b1cafa8cc1f2d4f4b4116a1..0000000000000000000000000000000000000000
--- a/spaces/1phancelerku/anime-remove-background/Download Pink Wallpaper Android - Amazing and Free HD Pink Wallpapers for Your Mobile and Desktop.md
+++ /dev/null
@@ -1,168 +0,0 @@
-
-
How to Download Pink Wallpaper for Android
-
If you are looking for a way to spice up your Android device with some color and style, you might want to consider downloading some pink wallpaper. Pink is a versatile and attractive color that can suit any mood, occasion, or personality. Whether you want a soft and romantic pink, a bright and cheerful pink, or a bold and edgy pink, there is a pink wallpaper for you.
-
In this article, we will show you what is pink wallpaper, why you should choose it for your Android device, where to find it, and how to download and set it as your home screen or lock screen. By the end of this article, you will be able to enjoy the beauty and charm of pink wallpaper on your Android device.
Pink wallpaper is a type of digital image that features the color pink as the main or dominant color. Pink wallpaper can have different shades, tones, patterns, textures, designs, or images that are related to the color pink. Some examples of pink wallpaper are:
-
-
Pink flowers, such as roses, tulips, cherry blossoms, or peonies
-
Pink animals, such as flamingos, pigs, cats, or unicorns
-
Pink food, such as cupcakes, ice cream, candy, or strawberries
-
Pink abstract shapes, such as circles, triangles, stars, or hearts
-
Pink gradients, such as pastel pink, hot pink, neon pink, or magenta
-
Pink quotes, such as "Think Pink", "Pink Power", "Pink is My Favorite Color", or "Pink Makes Me Happy"
-
-
Pink wallpaper can be downloaded from various sources online, such as websites, apps, or social media platforms. You can also create your own pink wallpaper using photo editing software or online tools.
-
Why Choose Pink Wallpaper for Android?
-
Pink wallpaper is a great choice for your Android device because it has many benefits and advantages. Some of them are:
-
-
Pink wallpaper can make your device look more attractive and stylish. Pink is a fashionable and trendy color that can match any theme or case.
-
Pink wallpaper can boost your mood and energy. Pink is a positive and uplifting color that can inspire joy, happiness, love, or creativity.
-
Pink wallpaper can express your personality and preferences. Pink is a versatile and diverse color that can reflect your interests, hobbies, passions, or values.
-
Pink wallpaper can suit any occasion or season. Pink is a timeless and universal color that can fit any event or celebration.
-
-
Pink Wallpaper for Different Moods and Occasions
-
Depending on your mood or the occasion, you can choose different types of pink wallpaper for your Android device. Here are some examples of pink wallpaper for various themes and events:
-
-
-
Theme/Event
-
Pink Wallpaper
-
-
-
Valentine's Day
-
Pink hearts, roses, chocolates, or love letters
-
-
-
Birthday
-
Pink balloons, cakes, candles, or confetti
-
-
-
Spring
-
Pink cherry blossoms, tulips, butterflies, or birds
-
-
-
Summer
-
Pink flamingos, watermelons, ice creams, or sunglasses
-
-
-
Halloween
-
Pink pumpkins, skulls, witches, or ghosts
-
-
-
Christmas
-
Pink snowflakes, trees, ornaments, or stockings
-
-
-
Pink Wallpaper for Different Screen Sizes and Resolutions
-
Another factor to consider when choosing pink wallpaper for your Android device is the screen size and resolution. You want to make sure that the pink wallpaper you download is compatible with your device and does not look blurry, pixelated, or stretched. Here are some tips on how to choose the right pink wallpaper for your device:
-
-
Check the screen size and resolution of your device. You can find this information in the settings menu or online. For example, if you have a Samsung Galaxy S10, your screen size is 6.1 inches and your resolution is 1440 x 3040 pixels.
-
Look for pink wallpaper that matches or exceeds your screen resolution. You can use online tools or apps to resize or crop the pink wallpaper if needed. For example, if you find a pink wallpaper that is 1920 x 1080 pixels, you can resize it to fit your screen without losing quality.
-
Avoid pink wallpaper that is too small or too large for your screen. If the pink wallpaper is too small, it will look blurry or pixelated when you zoom in. If the pink wallpaper is too large, it will take up more space and memory on your device and may slow down its performance.
-
Preview the pink wallpaper before you download it. You can use the web browser or the app to see how the pink wallpaper looks on your device. You can also adjust the brightness, contrast, or saturation of the pink wallpaper to suit your preference.
-
-
Where to Find Pink Wallpaper for Android?
-
There are many sources and websites where you can find and download pink wallpaper for your Android device. Some of them are free and some of them are paid. Some of them offer high-quality and original pink wallpaper and some of them offer low-quality and generic pink wallpaper. You should be careful and selective when choosing where to download pink wallpaper from. Here are some of the best and most popular sources and websites for downloading pink wallpaper:
-
Free HD Pink Wallpaper from Unsplash
-
Unsplash is a website that offers free high-resolution photos that you can use for anything. You can find thousands of stunning and unique pink wallpaper images on Unsplash that are uploaded by talented photographers from around the world. You can browse by category, keyword, color, orientation, or popularity. You can also download as many pink wallpaper images as you want without any limit or watermark.
-
download pink wallpaper android free
-download pink wallpaper android hd
-download pink wallpaper android 4k
-download pink wallpaper android cute
-download pink wallpaper android aesthetic
-download pink wallpaper android glitter
-download pink wallpaper android girly
-download pink wallpaper android love
-download pink wallpaper android floral
-download pink wallpaper android abstract
-download pink wallpaper android gradient
-download pink wallpaper android marshmallow
-download pink wallpaper android bokeh
-download pink wallpaper android crystals
-download pink wallpaper android silk
-download pink wallpaper android nature
-download pink wallpaper android sky
-download pink wallpaper android city
-download pink wallpaper android cars
-download pink wallpaper android travel
-download pink wallpaper android iphone
-download pink wallpaper android unsplash
-download pink wallpaper android pixabay
-download pink wallpaper android blackpink
-download pink wallpaper android quotes
-download hd free pink wallpapers for android
-download hd cute pink wallpapers for android
-download hd aesthetic pink wallpapers for android
-download hd glitter pink wallpapers for android
-download hd girly pink wallpapers for android
-download hd love pink wallpapers for android
-download hd floral pink wallpapers for android
-download hd abstract pink wallpapers for android
-download hd gradient pink wallpapers for android
-download hd marshmallow pink wallpapers for android
-download hd bokeh pink wallpapers for android
-download hd crystals pink wallpapers for android
-download hd silk pink wallpapers for android
-download hd nature pink wallpapers for android
-download hd sky pink wallpapers for android
-download hd city pink wallpapers for android
-download hd cars pink wallpapers for android
-download hd travel pink wallpapers for android
-download hd iphone compatible pink wallpapers for android
-download hd unsplash premium quality images of 500+ hq of free HD Pink Wallpapers for Android
-Download HD Pixabay royalty-free images of 40,000+ Beautiful Pink Backgrounds for Android
-Download HD Blackpink K-pop band themed Pink Wallpapers for Android
-Download HD inspirational and motivational quotes Pink Wallpapers for Android
-
Awesome Pink Android Wallpaper from WallpaperAccess
-
WallpaperAccess is a website that offers awesome wallpapers for various devices and platforms. You can find hundreds of amazing and cool pink wallpaper images on WallpaperAccess that are curated by a team of editors and designers. You can browse by category, resolution, device, or popularity. You can also download any pink wallpaper image with one click without any registration or login.
-
Beautiful Pink Backgrounds from Pixabay
-
Pixabay is a website that offers free stock photos, vectors, illustrations, and videos that you can use for anything. You can find thousands of beautiful and creative pink wallpaper images on Pixabay that are uploaded by a community of artists and photographers from around the world. You can browse by category, keyword, color, size, or popularity. You can also download any pink wallpaper image without any attribution or license.
-
How to Download and Set Pink Wallpaper for Android?
-
Now that you know what is pink wallpaper, why you should choose it for your Android device, and where to find it, you might be wondering how to download and set it as your home screen or lock screen. Don't worry, it's very easy and simple to do. Just follow these steps:
-
How to Download Pink Wallpaper from a Website ?
-
If you want to download pink wallpaper from a website, such as Unsplash, WallpaperAccess, or Pixabay, you can follow these steps:
-
-
Open your web browser on your Android device and go to the website of your choice.
-
Search for pink wallpaper images using the search bar or the filters on the website.
-
Select the pink wallpaper image that you like and tap on it to open it in full size.
-
Tap and hold on the pink wallpaper image and select "Download image" or "Save image" from the menu that appears.
-
Choose a location on your device where you want to save the pink wallpaper image and tap on "Save" or "OK".
-
-
You have successfully downloaded the pink wallpaper image from the website. You can find it in your gallery or file manager app.
-
How to Download Pink Wallpaper from an App?
-
If you want to download pink wallpaper from an app, such as Zedge, Walli, or Backgrounds HD, you can follow these steps:
-
-
Open the Google Play Store on your Android device and search for the app of your choice.
-
Install and open the app on your device and grant it the necessary permissions.
-
Search for pink wallpaper images using the search bar or the categories on the app.
-
Select the pink wallpaper image that you like and tap on it to open it in full size.
-
Tap on the download icon or button on the bottom of the screen and wait for the download to complete.
-
-
You have successfully downloaded the pink wallpaper image from the app. You can find it in your gallery or file manager app.
-
How to Set Pink Wallpaper as Home Screen or Lock Screen?
-
If you want to set pink wallpaper as your home screen or lock screen, you can follow these steps:
-
-
Open your gallery or file manager app and find the pink wallpaper image that you downloaded.
-
Tap on the pink wallpaper image to open it in full size.
-
Tap on the menu icon or button on the top right corner of the screen and select "Set as" or "Use as" from the menu that appears.
-
Choose whether you want to set the pink wallpaper as your home screen, lock screen, or both.
-
Crop or adjust the pink wallpaper image if needed and tap on "Done" or "Apply".
-
-
You have successfully set the pink wallpaper as your home screen or lock screen. You can enjoy the beauty and charm of pink wallpaper on your Android device.
-
Conclusion
-
Pink wallpaper is a wonderful way to customize and beautify your Android device. Pink is a color that can suit any mood, occasion, or personality. You can find and download various types of pink wallpaper images from different sources online, such as websites or apps. You can also easily set them as your home screen or lock screen with a few simple steps. We hope this article has helped you learn how to download pink wallpaper for Android and inspired you to try some of them out. If you have any questions or comments, feel free to leave them below.
-
FAQs
-
Here are some frequently asked questions and answers on pink wallpaper for Android:
-
Q: How can I create my own pink wallpaper for Android?
-
A: You can create your own pink wallpaper for Android using photo editing software or online tools. You can use your own photos or images, add text, stickers, filters, effects, or other elements to make them more pink and personalized. You can also use online generators or templates to create pink wallpaper for Android easily and quickly.
-
Q: How can I change my pink wallpaper for Android automatically?
-
A: You can change your pink wallpaper for Android automatically using apps that offer this feature. Some examples of these apps are Wallpaper Changer, Auto Wallpaper Changer, or DailyPic. You can set a time interval, a source folder, a category, or a keyword for changing your pink wallpaper for Android automatically. You can also choose whether you want to change your home screen, lock screen, or both.
-
Q: How can I share my pink wallpaper for Android with others?
-
A: You can share your pink wallpaper for Android with others using social media platforms, messaging apps, email, or Bluetooth. You can also upload your pink wallpaper for Android to online platforms, such as Pinterest, Tumblr, Instagram, or Reddit. You can also join online communities or groups that are dedicated to pink wallpaper for Android and share your creations with other fans and enthusiasts.
- Q: How can I delete or remove my pink wallpaper for Android?
-
A: You can delete or remove your pink wallpaper for Android using your gallery or file manager app. You can find the pink wallpaper image that you downloaded or created and tap on it to open it. Then, you can tap on the menu icon or button and select "Delete" or "Remove" from the menu that appears. You can also select multiple pink wallpaper images and delete or remove them at once.
-
Q: How can I find more pink wallpaper for Android?
-
A: You can find more pink wallpaper for Android by exploring other sources and websites that offer them. You can also use search engines, such as Google or Bing, to look for more pink wallpaper images. You can also follow blogs, channels, pages, or accounts that post or share pink wallpaper images regularly. You can also ask for recommendations or suggestions from other users or friends who like pink wallpaper for Android.
197e85843d
-
-
\ No newline at end of file
diff --git a/spaces/2ndelement/voicevox/speaker_info/388f246b-8c41-4ac1-8e2d-5d79f3ff56d9/policy.md b/spaces/2ndelement/voicevox/speaker_info/388f246b-8c41-4ac1-8e2d-5d79f3ff56d9/policy.md
deleted file mode 100644
index 0328c63112a40f44145440562c8fe2d56ac86e38..0000000000000000000000000000000000000000
--- a/spaces/2ndelement/voicevox/speaker_info/388f246b-8c41-4ac1-8e2d-5d79f3ff56d9/policy.md
+++ /dev/null
@@ -1,3 +0,0 @@
-dummy2 policy
-
-https://voicevox.hiroshiba.jp/
diff --git a/spaces/2ndelement/voicevox/voicevox_engine/preset/Preset.py b/spaces/2ndelement/voicevox/voicevox_engine/preset/Preset.py
deleted file mode 100644
index 40b03d10c7f3f663c42b8c32fa0db1bf2da0365b..0000000000000000000000000000000000000000
--- a/spaces/2ndelement/voicevox/voicevox_engine/preset/Preset.py
+++ /dev/null
@@ -1,18 +0,0 @@
-from pydantic import BaseModel, Field
-
-
-class Preset(BaseModel):
- """
- プリセット情報
- """
-
- id: int = Field(title="プリセットID")
- name: str = Field(title="プリセット名")
- speaker_uuid: str = Field(title="スピーカーのUUID")
- style_id: int = Field(title="スタイルID")
- speedScale: float = Field(title="全体の話速")
- pitchScale: float = Field(title="全体の音高")
- intonationScale: float = Field(title="全体の抑揚")
- volumeScale: float = Field(title="全体の音量")
- prePhonemeLength: float = Field(title="音声の前の無音時間")
- postPhonemeLength: float = Field(title="音声の後の無音時間")
diff --git a/spaces/4Taps/SadTalker/src/face3d/models/arcface_torch/dataset.py b/spaces/4Taps/SadTalker/src/face3d/models/arcface_torch/dataset.py
deleted file mode 100644
index 96bbb8bb6da99122f350bc8e1a6390245840e32b..0000000000000000000000000000000000000000
--- a/spaces/4Taps/SadTalker/src/face3d/models/arcface_torch/dataset.py
+++ /dev/null
@@ -1,124 +0,0 @@
-import numbers
-import os
-import queue as Queue
-import threading
-
-import mxnet as mx
-import numpy as np
-import torch
-from torch.utils.data import DataLoader, Dataset
-from torchvision import transforms
-
-
-class BackgroundGenerator(threading.Thread):
- def __init__(self, generator, local_rank, max_prefetch=6):
- super(BackgroundGenerator, self).__init__()
- self.queue = Queue.Queue(max_prefetch)
- self.generator = generator
- self.local_rank = local_rank
- self.daemon = True
- self.start()
-
- def run(self):
- torch.cuda.set_device(self.local_rank)
- for item in self.generator:
- self.queue.put(item)
- self.queue.put(None)
-
- def next(self):
- next_item = self.queue.get()
- if next_item is None:
- raise StopIteration
- return next_item
-
- def __next__(self):
- return self.next()
-
- def __iter__(self):
- return self
-
-
-class DataLoaderX(DataLoader):
-
- def __init__(self, local_rank, **kwargs):
- super(DataLoaderX, self).__init__(**kwargs)
- self.stream = torch.cuda.Stream(local_rank)
- self.local_rank = local_rank
-
- def __iter__(self):
- self.iter = super(DataLoaderX, self).__iter__()
- self.iter = BackgroundGenerator(self.iter, self.local_rank)
- self.preload()
- return self
-
- def preload(self):
- self.batch = next(self.iter, None)
- if self.batch is None:
- return None
- with torch.cuda.stream(self.stream):
- for k in range(len(self.batch)):
- self.batch[k] = self.batch[k].to(device=self.local_rank, non_blocking=True)
-
- def __next__(self):
- torch.cuda.current_stream().wait_stream(self.stream)
- batch = self.batch
- if batch is None:
- raise StopIteration
- self.preload()
- return batch
-
-
-class MXFaceDataset(Dataset):
- def __init__(self, root_dir, local_rank):
- super(MXFaceDataset, self).__init__()
- self.transform = transforms.Compose(
- [transforms.ToPILImage(),
- transforms.RandomHorizontalFlip(),
- transforms.ToTensor(),
- transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
- ])
- self.root_dir = root_dir
- self.local_rank = local_rank
- path_imgrec = os.path.join(root_dir, 'train.rec')
- path_imgidx = os.path.join(root_dir, 'train.idx')
- self.imgrec = mx.recordio.MXIndexedRecordIO(path_imgidx, path_imgrec, 'r')
- s = self.imgrec.read_idx(0)
- header, _ = mx.recordio.unpack(s)
- if header.flag > 0:
- self.header0 = (int(header.label[0]), int(header.label[1]))
- self.imgidx = np.array(range(1, int(header.label[0])))
- else:
- self.imgidx = np.array(list(self.imgrec.keys))
-
- def __getitem__(self, index):
- idx = self.imgidx[index]
- s = self.imgrec.read_idx(idx)
- header, img = mx.recordio.unpack(s)
- label = header.label
- if not isinstance(label, numbers.Number):
- label = label[0]
- label = torch.tensor(label, dtype=torch.long)
- sample = mx.image.imdecode(img).asnumpy()
- if self.transform is not None:
- sample = self.transform(sample)
- return sample, label
-
- def __len__(self):
- return len(self.imgidx)
-
-
-class SyntheticDataset(Dataset):
- def __init__(self, local_rank):
- super(SyntheticDataset, self).__init__()
- img = np.random.randint(0, 255, size=(112, 112, 3), dtype=np.int32)
- img = np.transpose(img, (2, 0, 1))
- img = torch.from_numpy(img).squeeze(0).float()
- img = ((img / 255) - 0.5) / 0.5
- self.img = img
- self.label = 1
-
- def __getitem__(self, index):
- return self.img, self.label
-
- def __len__(self):
- return 1000000
diff --git a/spaces/801artistry/RVC801/infer/modules/onnx/export.py b/spaces/801artistry/RVC801/infer/modules/onnx/export.py
deleted file mode 100644
index ed4a4162ff04b7e12642fcbe96847f8ea9db06aa..0000000000000000000000000000000000000000
--- a/spaces/801artistry/RVC801/infer/modules/onnx/export.py
+++ /dev/null
@@ -1,52 +0,0 @@
-import torch
-
-from infer.lib.infer_pack.models_onnx import SynthesizerTrnMsNSFsidM
-
-
-def export_onnx(ModelPath, ExportedPath):
- cpt = torch.load(ModelPath, map_location="cpu")
- cpt["config"][-3] = cpt["weight"]["emb_g.weight"].shape[0]
- vec_channels = 256 if cpt.get("version", "v1") == "v1" else 768
-
- test_phone = torch.rand(1, 200, vec_channels) # hidden unit
- test_phone_lengths = torch.tensor([200]).long() # hidden unit 长度（貌似没啥用）
- test_pitch = torch.randint(size=(1, 200), low=5, high=255) # 基频（单位赫兹）
- test_pitchf = torch.rand(1, 200) # nsf基频
- test_ds = torch.LongTensor([0]) # 说话人ID
- test_rnd = torch.rand(1, 192, 200) # 噪声（加入随机因子）
-
- device = "cpu" # 导出时设备（不影响使用模型）
-
- net_g = SynthesizerTrnMsNSFsidM(
- *cpt["config"], is_half=False, version=cpt.get("version", "v1")
- ) # fp32导出（C++要支持fp16必须手动将内存重新排列所以暂时不用fp16）
- net_g.load_state_dict(cpt["weight"], strict=False)
- input_names = ["phone", "phone_lengths", "pitch", "pitchf", "ds", "rnd"]
- output_names = [
- "audio",
- ]
- # net_g.construct_spkmixmap(n_speaker) 多角色混合轨道导出
- torch.onnx.export(
- net_g,
- (
- test_phone.to(device),
- test_phone_lengths.to(device),
- test_pitch.to(device),
- test_pitchf.to(device),
- test_ds.to(device),
- test_rnd.to(device),
- ),
- ExportedPath,
- dynamic_axes={
- "phone": [1],
- "pitch": [1],
- "pitchf": [1],
- "rnd": [2],
- },
- do_constant_folding=False,
- opset_version=13,
- verbose=False,
- input_names=input_names,
- output_names=output_names,
- )
- return "Finished"
diff --git a/spaces/801artistry/RVC801/julius/filters.py b/spaces/801artistry/RVC801/julius/filters.py
deleted file mode 100644
index afabcc0158e4cf45d215174b4f946ca1b0e3acaa..0000000000000000000000000000000000000000
--- a/spaces/801artistry/RVC801/julius/filters.py
+++ /dev/null
@@ -1,258 +0,0 @@
-# File under the MIT license, see https://github.com/adefossez/julius/LICENSE for details.
-# Author: adefossez, 2021
-"""
-FIR windowed sinc highpass and bandpass filters.
-Those are convenience wrappers around the filters defined in `julius.lowpass`.
-"""
-
-from typing import Sequence, Optional
-
-import torch
-
-# Import all lowpass filters for consistency.
-from .lowpass import lowpass_filter, lowpass_filters, LowPassFilter, LowPassFilters # noqa
-from .utils import simple_repr
-
-
-class HighPassFilters(torch.nn.Module):
- """
- Bank of high pass filters. See `julius.lowpass.LowPassFilters` for more
- details on the implementation.
-
- Args:
- cutoffs (list[float]): list of cutoff frequencies, in [0, 0.5] expressed as `f/f_s` where
- f_s is the samplerate and `f` is the cutoff frequency.
- The upper limit is 0.5, because a signal sampled at `f_s` contains only
- frequencies under `f_s / 2`.
- stride (int): how much to decimate the output. Probably not a good idea
- to do so with a high pass filters though...
- pad (bool): if True, appropriately pad the input with zero over the edge. If `stride=1`,
- the output will have the same length as the input.
- zeros (float): Number of zero crossings to keep.
- Controls the receptive field of the Finite Impulse Response filter.
- For filters with low cutoff frequency, e.g. 40Hz at 44.1kHz,
- it is a bad idea to set this to a high value.
- This is likely appropriate for most use. Lower values
- will result in a faster filter, but with a slower attenuation around the
- cutoff frequency.
- fft (bool or None): if True, uses `julius.fftconv` rather than PyTorch convolutions.
- If False, uses PyTorch convolutions. If None, either one will be chosen automatically
- depending on the effective filter size.
-
-
- ..warning::
- All the filters will use the same filter size, aligned on the lowest
- frequency provided. If you combine a lot of filters with very diverse frequencies, it might
- be more efficient to split them over multiple modules with similar frequencies.
-
- Shape:
-
- - Input: `[*, T]`
- - Output: `[F, *, T']`, with `T'=T` if `pad` is True and `stride` is 1, and
- `F` is the numer of cutoff frequencies.
-
- >>> highpass = HighPassFilters([1/4])
- >>> x = torch.randn(4, 12, 21, 1024)
- >>> list(highpass(x).shape)
- [1, 4, 12, 21, 1024]
- """
-
- def __init__(self, cutoffs: Sequence[float], stride: int = 1, pad: bool = True,
- zeros: float = 8, fft: Optional[bool] = None):
- super().__init__()
- self._lowpasses = LowPassFilters(cutoffs, stride, pad, zeros, fft)
-
- @property
- def cutoffs(self):
- return self._lowpasses.cutoffs
-
- @property
- def stride(self):
- return self._lowpasses.stride
-
- @property
- def pad(self):
- return self._lowpasses.pad
-
- @property
- def zeros(self):
- return self._lowpasses.zeros
-
- @property
- def fft(self):
- return self._lowpasses.fft
-
- def forward(self, input):
- lows = self._lowpasses(input)
-
- # We need to extract the right portion of the input in case
- # pad is False or stride > 1
- if self.pad:
- start, end = 0, input.shape[-1]
- else:
- start = self._lowpasses.half_size
- end = -start
- input = input[..., start:end:self.stride]
- highs = input - lows
- return highs
-
- def __repr__(self):
- return simple_repr(self)
-
-
-class HighPassFilter(torch.nn.Module):
- """
- Same as `HighPassFilters` but applies a single high pass filter.
-
- Shape:
-
- - Input: `[*, T]`
- - Output: `[*, T']`, with `T'=T` if `pad` is True and `stride` is 1.
-
- >>> highpass = HighPassFilter(1/4, stride=1)
- >>> x = torch.randn(4, 124)
- >>> list(highpass(x).shape)
- [4, 124]
- """
-
- def __init__(self, cutoff: float, stride: int = 1, pad: bool = True,
- zeros: float = 8, fft: Optional[bool] = None):
- super().__init__()
- self._highpasses = HighPassFilters([cutoff], stride, pad, zeros, fft)
-
- @property
- def cutoff(self):
- return self._highpasses.cutoffs[0]
-
- @property
- def stride(self):
- return self._highpasses.stride
-
- @property
- def pad(self):
- return self._highpasses.pad
-
- @property
- def zeros(self):
- return self._highpasses.zeros
-
- @property
- def fft(self):
- return self._highpasses.fft
-
- def forward(self, input):
- return self._highpasses(input)[0]
-
- def __repr__(self):
- return simple_repr(self)
-
-
-def highpass_filters(input: torch.Tensor, cutoffs: Sequence[float],
- stride: int = 1, pad: bool = True,
- zeros: float = 8, fft: Optional[bool] = None):
- """
- Functional version of `HighPassFilters`, refer to this class for more information.
- """
- return HighPassFilters(cutoffs, stride, pad, zeros, fft).to(input)(input)
-
-
-def highpass_filter(input: torch.Tensor, cutoff: float,
- stride: int = 1, pad: bool = True,
- zeros: float = 8, fft: Optional[bool] = None):
- """
- Functional version of `HighPassFilter`, refer to this class for more information.
- Output will not have a dimension inserted in the front.
- """
- return highpass_filters(input, [cutoff], stride, pad, zeros, fft)[0]
-
-
-class BandPassFilter(torch.nn.Module):
- """
- Single band pass filter, implemented as a the difference of two lowpass filters.
-
- Args:
- cutoff_low (float): lower cutoff frequency, in [0, 0.5] expressed as `f/f_s` where
- f_s is the samplerate and `f` is the cutoff frequency.
- The upper limit is 0.5, because a signal sampled at `f_s` contains only
- frequencies under `f_s / 2`.
- cutoff_high (float): higher cutoff frequency, in [0, 0.5] expressed as `f/f_s`.
- This must be higher than cutoff_high. Note that due to the fact
- that filter are not perfect, the output will be non zero even if
- cutoff_high == cutoff_low.
- stride (int): how much to decimate the output.
- pad (bool): if True, appropriately pad the input with zero over the edge. If `stride=1`,
- the output will have the same length as the input.
- zeros (float): Number of zero crossings to keep.
- Controls the receptive field of the Finite Impulse Response filter.
- For filters with low cutoff frequency, e.g. 40Hz at 44.1kHz,
- it is a bad idea to set this to a high value.
- This is likely appropriate for most use. Lower values
- will result in a faster filter, but with a slower attenuation around the
- cutoff frequency.
- fft (bool or None): if True, uses `julius.fftconv` rather than PyTorch convolutions.
- If False, uses PyTorch convolutions. If None, either one will be chosen automatically
- depending on the effective filter size.
-
-
- Shape:
-
- - Input: `[*, T]`
- - Output: `[*, T']`, with `T'=T` if `pad` is True and `stride` is 1.
-
- ..Note:: There is no BandPassFilters (bank of bandpasses) because its
- signification would be the same as `julius.bands.SplitBands`.
-
- >>> bandpass = BandPassFilter(1/4, 1/3)
- >>> x = torch.randn(4, 12, 21, 1024)
- >>> list(bandpass(x).shape)
- [4, 12, 21, 1024]
- """
-
- def __init__(self, cutoff_low: float, cutoff_high: float, stride: int = 1, pad: bool = True,
- zeros: float = 8, fft: Optional[bool] = None):
- super().__init__()
- if cutoff_low > cutoff_high:
- raise ValueError(f"Lower cutoff {cutoff_low} should be less than "
- f"higher cutoff {cutoff_high}.")
- self._lowpasses = LowPassFilters([cutoff_low, cutoff_high], stride, pad, zeros, fft)
-
- @property
- def cutoff_low(self):
- return self._lowpasses.cutoffs[0]
-
- @property
- def cutoff_high(self):
- return self._lowpasses.cutoffs[1]
-
- @property
- def stride(self):
- return self._lowpasses.stride
-
- @property
- def pad(self):
- return self._lowpasses.pad
-
- @property
- def zeros(self):
- return self._lowpasses.zeros
-
- @property
- def fft(self):
- return self._lowpasses.fft
-
- def forward(self, input):
- lows = self._lowpasses(input)
- return lows[1] - lows[0]
-
- def __repr__(self):
- return simple_repr(self)
-
-
-def bandpass_filter(input: torch.Tensor, cutoff_low: float, cutoff_high: float,
- stride: int = 1, pad: bool = True,
- zeros: float = 8, fft: Optional[bool] = None):
- """
- Functional version of `BandPassfilter`, refer to this class for more information.
- Output will not have a dimension inserted in the front.
- """
- return BandPassFilter(cutoff_low, cutoff_high, stride, pad, zeros, fft).to(input)(input)
diff --git a/spaces/A00001/bingothoo/src/app/layout.tsx b/spaces/A00001/bingothoo/src/app/layout.tsx
deleted file mode 100644
index 8b5122759987177b8dc4e4356d1d06cea25c15ea..0000000000000000000000000000000000000000
--- a/spaces/A00001/bingothoo/src/app/layout.tsx
+++ /dev/null
@@ -1,47 +0,0 @@
-import { Metadata } from 'next'
-import { Toaster } from 'react-hot-toast'
-import { TailwindIndicator } from '@/components/tailwind-indicator'
-import { Providers } from '@/components/providers'
-import { Header } from '@/components/header'
-
-import '@/app/globals.scss'
-
-
-export const metadata: Metadata = {
- title: {
- default: 'Bing AI Chatbot',
- template: `%s - Bing AI Chatbot`
- },
- description: 'Bing AI Chatbot Web App.',
- themeColor: [
- { media: '(prefers-color-scheme: light)', color: 'white' },
- { media: '(prefers-color-scheme: dark)', color: 'dark' }
- ],
- icons: {
- icon: '/favicon.ico',
- shortcut: '../assets/images/logo.svg',
- apple: '../assets/images/logo.svg'
- }
-}
-
-interface RootLayoutProps {
- children: React.ReactNode
-}
-
-export default function RootLayout({ children }: RootLayoutProps) {
- return (
-
-
-
-
-
- {/* @ts-ignore */}
-
- {children}
-
-
-
-
-
- )
-}
diff --git a/spaces/AB-TW/team-ai/documents/bussiness_context/NOTION_DB/Engineering Wiki 2402f5396a3244fdb3f1d135bdb0f3d6/Backend 137c41fa386f43249b249e956eb06bb0.md b/spaces/AB-TW/team-ai/documents/bussiness_context/NOTION_DB/Engineering Wiki 2402f5396a3244fdb3f1d135bdb0f3d6/Backend 137c41fa386f43249b249e956eb06bb0.md
deleted file mode 100644
index ece6cd70b34985511cb8a88169cbb6addadf986f..0000000000000000000000000000000000000000
--- a/spaces/AB-TW/team-ai/documents/bussiness_context/NOTION_DB/Engineering Wiki 2402f5396a3244fdb3f1d135bdb0f3d6/Backend 137c41fa386f43249b249e956eb06bb0.md
+++ /dev/null
@@ -1,27 +0,0 @@
-# Backend
-
-Last edited time: April 23, 2023 3:58 PM
-Owner: Anonymous
-Tags: Codebase
-
-## 技术栈
-
-我们的技术栈是Sprig WebFlux + Spring Boot + Spring Reactive Data Couchbase
-
-**Sprig WebFlux**是Spring Framework 5.0引入的一种新的反应式Web框架，可以用于构建高性能的Web应用程序。它支持异步编程模型，可以处理大量的并发请求，适用于高负载的Web应用程序。与传统的Servlet API相比，Sprig WebFlux提供了更好的性能、更高的吞吐量和更少的资源消耗。
-
-**Spring Boot**是一个用于构建独立的、生产级别的Spring应用程序的框架。它提供了许多开箱即用的功能，如自动配置、嵌入式Web服务器和健康检查等，可以帮助开发人员快速构建Spring应用程序。
-
-**Spring Reactive Data Couchbase**是一个基于反应式编程模型的Couchbase客户端库，可以与Sprig WebFlux和Spring Boot一起使用。它提供了异步的、非阻塞的API，可以处理大量的并发请求。同时，它还提供了一些有用的功能，如自动映射、复杂查询和事务管理等。
-
-## 架构风格
-
-Smart Domain是一种软件架构风格，旨在通过将业务逻辑与数据访问逻辑分离来提高可维护性和可扩展性。在Smart Domain架构中，业务逻辑被定义为一个领域模型，它包含了应用程序的核心概念和行为。与此同时，数据访问逻辑被封装在一个或多个数据访问对象中，它们负责与数据库交互。通过这种方式，Smart Domain架构可以使开发人员更加专注于业务逻辑，从而提高应用程序的质量和可维护性。
-
-## Couchbase
-
-Couchbase是一款面向企业应用的NoSQL数据库。它提供了高性能、高可用性和可扩展性，使得它成为了许多企业的首选。Couchbase支持类JSON文档、键值对和图形数据模型，非常适合用于Web应用、移动应用和物联网应用等场景。
-
-对于需要高可用性和可扩展性的企业来说，Couchbase提供了一些非常有用的功能，如动态数据分片、自动故障转移和跨数据中心复制。Couchbase还提供了一个灵活的查询引擎，使得查询数据变得非常容易。同时，Couchbase还支持各种各样的客户端库，包括Java、Python、C#和Node.js等。
-
-有关Couchbase的更多信息，请查看[Couchbase官方网站](https://www.couchbase.com/)。
\ No newline at end of file
diff --git "a/spaces/AI4PD/hexviz/hexviz/pages/2_\360\237\246\205Birds_Eye_View.py" "b/spaces/AI4PD/hexviz/hexviz/pages/2_\360\237\246\205Birds_Eye_View.py"
deleted file mode 100644
index b65fd97e3b9d8df231f99e357a122860c6b3f693..0000000000000000000000000000000000000000
--- "a/spaces/AI4PD/hexviz/hexviz/pages/2_\360\237\246\205Birds_Eye_View.py"
+++ /dev/null
@@ -1,176 +0,0 @@
-import re
-
-import py3Dmol
-import stmol
-import streamlit as st
-
-from hexviz.attention import (
- clean_and_validate_sequence,
- get_attention,
- get_attention_pairs,
- res_to_1letter,
-)
-from hexviz.models import Model, ModelType
-from hexviz.view import (
- menu_items,
- select_heads_and_layers,
- select_model,
- select_pdb,
- select_protein,
-)
-
-st.set_page_config(layout="wide", menu_items=menu_items)
-st.title("Bird's Eye View of attention heads")
-
-
-for k, v in st.session_state.items():
- st.session_state[k] = v
-
-models = [
- Model(name=ModelType.TAPE_BERT, layers=12, heads=12),
- Model(name=ModelType.ZymCTRL, layers=36, heads=16),
- Model(name=ModelType.PROT_BERT, layers=30, heads=16),
- Model(name=ModelType.PROT_T5, layers=24, heads=32),
-]
-
-with st.expander("Input a PDB id, upload a PDB file or input a sequence", expanded=True):
- pdb_id = select_pdb() or "2FZ5"
- uploaded_file = st.file_uploader("2.Upload PDB", type=["pdb"])
- input_sequence = st.text_area("3.Input sequence", "", key="input_sequence", max_chars=400)
- sequence, error = clean_and_validate_sequence(input_sequence)
- if error:
- st.error(error)
- pdb_str, structure, source = select_protein(pdb_id, uploaded_file, sequence)
- st.write(f"Visualizing: {source}")
-
-selected_model = select_model(models)
-
-
-if "viewer_width" not in st.session_state:
- st.session_state.viewer_width = 1200
-viewer_width = st.sidebar.number_input(
- label="Protein viewer width (px)",
- min_value=0,
- key="viewer_width",
-)
-
-chains = list(structure.get_chains())
-chain_ids = [chain.id for chain in chains]
-if "selected_chain" not in st.session_state:
- st.session_state.selected_chain = chain_ids[0] if chain_ids else None
-chain_selection = st.sidebar.selectbox(
- label="Select Chain",
- options=chain_ids,
- key="selected_chain",
-)
-
-selected_chain = next(chain for chain in chains if chain.id == chain_selection)
-
-ec_number = ""
-if selected_model.name == ModelType.ZymCTRL:
- st.sidebar.markdown(
- """
- ZymCTRL EC number
- ---
- """
- )
- try:
- ec_number = structure.header["compound"]["1"]["ec"]
- except KeyError:
- pass
- ec_number = st.sidebar.text_input("Enzyme Comission number (EC)", ec_number)
-
- # Validate EC number
- if not re.match(r"^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$", ec_number):
- st.sidebar.error(
- """Please enter a valid Enzyme Commission number in the format of 4
- integers separated by periods (e.g., 1.2.3.21)"""
- )
-
-
-min_attn = st.sidebar.slider("Minimum attention", min_value=0.0, max_value=0.4, value=0.1)
-if "show_ligands" not in st.session_state:
- st.session_state.show_ligands = True
-show_ligands = st.sidebar.checkbox("Show ligands", key="show_ligands")
-
-with st.sidebar.expander("Highlight residues"):
- st.write("Residue will be highlighted in yellow")
- hl_resi_list = st.multiselect(label="Selected Residues", options=list(range(1, 5000)))
- highlight_resi = st.checkbox(label="Highlight residues", value=True)
- label_resi = st.checkbox(label="Label residue names", value=False)
-layer_sequence, head_sequence = select_heads_and_layers(st.sidebar, selected_model)
-# TODO add slider for widht of grid
-
-
-residues = [res for res in selected_chain.get_residues()]
-sequence = res_to_1letter(residues)
-
-attention, tokens = get_attention(
- sequence=sequence,
- model_type=selected_model.name,
- ec_number=ec_number,
-)
-
-grid_rows = len(layer_sequence)
-grid_cols = len(head_sequence)
-cell_width = viewer_width / grid_cols
-viewer_height = int(cell_width * grid_rows)
-
-xyzview = py3Dmol.view(
- width=viewer_width,
- height=viewer_height,
- viewergrid=(grid_rows, grid_cols),
-)
-
-xyzview.addModel(pdb_str, "pdb")
-xyzview.zoomTo()
-
-for row, layer in enumerate(layer_sequence):
- for col, head in enumerate(head_sequence):
- attention_pairs, top_residues = get_attention_pairs(
- pdb_str=pdb_str,
- chain_ids=None,
- layer=layer,
- head=head,
- threshold=min_attn,
- model_type=selected_model.name,
- top_n=1,
- ec_numbers=None,
- )
-
- for att_weight, first, second in attention_pairs:
- cylradius = att_weight
- cylColor = "red"
- dashed = False
- xyzview.addCylinder(
- {
- "start": {"x": first[0], "y": first[1], "z": first[2]},
- "end": {"x": second[0], "y": second[1], "z": second[2]},
- "radius": cylradius,
- "fromCap": True,
- "toCap": True,
- "color": cylColor,
- "dashed": dashed,
- },
- viewer=(row, col),
- )
-
-
-xyzview.setStyle({"cartoon": {"color": "white"}})
-if highlight_resi:
- for res in hl_resi_list:
- xyzview.setStyle({"resi": res}, {"cartoon": {"color": "yellow"}})
-if label_resi:
- for hl_resi in hl_resi_list:
- xyzview.addResLabels(
- {"resi": hl_resi},
- {
- "backgroundColor": "lightgray",
- "fontColor": "black",
- "backgroundOpacity": 0.5,
- },
- )
-if show_ligands:
- xyzview.addStyle({"hetflag": True}, {"stick": {"radius": 0.2}})
-
-stmol.showmol(xyzview, height=viewer_height, width=viewer_width)
diff --git a/spaces/AIGC-Audio/AudioGPT/text_to_audio/Make_An_Audio/ldm/modules/midas/midas/dpt_depth.py b/spaces/AIGC-Audio/AudioGPT/text_to_audio/Make_An_Audio/ldm/modules/midas/midas/dpt_depth.py
deleted file mode 100644
index 4e9aab5d2767dffea39da5b3f30e2798688216f1..0000000000000000000000000000000000000000
--- a/spaces/AIGC-Audio/AudioGPT/text_to_audio/Make_An_Audio/ldm/modules/midas/midas/dpt_depth.py
+++ /dev/null
@@ -1,109 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-from .base_model import BaseModel
-from .blocks import (
- FeatureFusionBlock,
- FeatureFusionBlock_custom,
- Interpolate,
- _make_encoder,
- forward_vit,
-)
-
-
-def _make_fusion_block(features, use_bn):
- return FeatureFusionBlock_custom(
- features,
- nn.ReLU(False),
- deconv=False,
- bn=use_bn,
- expand=False,
- align_corners=True,
- )
-
-
-class DPT(BaseModel):
- def __init__(
- self,
- head,
- features=256,
- backbone="vitb_rn50_384",
- readout="project",
- channels_last=False,
- use_bn=False,
- ):
-
- super(DPT, self).__init__()
-
- self.channels_last = channels_last
-
- hooks = {
- "vitb_rn50_384": [0, 1, 8, 11],
- "vitb16_384": [2, 5, 8, 11],
- "vitl16_384": [5, 11, 17, 23],
- }
-
- # Instantiate backbone and reassemble blocks
- self.pretrained, self.scratch = _make_encoder(
- backbone,
- features,
- False, # Set to true of you want to train from scratch, uses ImageNet weights
- groups=1,
- expand=False,
- exportable=False,
- hooks=hooks[backbone],
- use_readout=readout,
- )
-
- self.scratch.refinenet1 = _make_fusion_block(features, use_bn)
- self.scratch.refinenet2 = _make_fusion_block(features, use_bn)
- self.scratch.refinenet3 = _make_fusion_block(features, use_bn)
- self.scratch.refinenet4 = _make_fusion_block(features, use_bn)
-
- self.scratch.output_conv = head
-
-
- def forward(self, x):
- if self.channels_last == True:
- x.contiguous(memory_format=torch.channels_last)
-
- layer_1, layer_2, layer_3, layer_4 = forward_vit(self.pretrained, x)
-
- layer_1_rn = self.scratch.layer1_rn(layer_1)
- layer_2_rn = self.scratch.layer2_rn(layer_2)
- layer_3_rn = self.scratch.layer3_rn(layer_3)
- layer_4_rn = self.scratch.layer4_rn(layer_4)
-
- path_4 = self.scratch.refinenet4(layer_4_rn)
- path_3 = self.scratch.refinenet3(path_4, layer_3_rn)
- path_2 = self.scratch.refinenet2(path_3, layer_2_rn)
- path_1 = self.scratch.refinenet1(path_2, layer_1_rn)
-
- out = self.scratch.output_conv(path_1)
-
- return out
-
-
-class DPTDepthModel(DPT):
- def __init__(self, path=None, non_negative=True, **kwargs):
- features = kwargs["features"] if "features" in kwargs else 256
-
- head = nn.Sequential(
- nn.Conv2d(features, features // 2, kernel_size=3, stride=1, padding=1),
- Interpolate(scale_factor=2, mode="bilinear", align_corners=True),
- nn.Conv2d(features // 2, 32, kernel_size=3, stride=1, padding=1),
- nn.ReLU(True),
- nn.Conv2d(32, 1, kernel_size=1, stride=1, padding=0),
- nn.ReLU(True) if non_negative else nn.Identity(),
- nn.Identity(),
- )
-
- super().__init__(head, **kwargs)
-
- if path is not None:
- self.load(path)
-
- def forward(self, x):
- return super().forward(x).squeeze(dim=1)
-
diff --git a/spaces/AIGC-Audio/AudioGPT/text_to_speech/modules/vocoder/parallel_wavegan/layers/__init__.py b/spaces/AIGC-Audio/AudioGPT/text_to_speech/modules/vocoder/parallel_wavegan/layers/__init__.py
deleted file mode 100644
index 2fc2a9e79504bdc90dafd6f07f28d39c5004753e..0000000000000000000000000000000000000000
--- a/spaces/AIGC-Audio/AudioGPT/text_to_speech/modules/vocoder/parallel_wavegan/layers/__init__.py
+++ /dev/null
@@ -1,5 +0,0 @@
-from .causal_conv import * # NOQA
-from .pqmf import * # NOQA
-from .residual_block import * # NOQA
-from text_to_speech.modules.vocoder.parallel_wavegan.layers.residual_stack import * # NOQA
-from .upsample import * # NOQA
diff --git a/spaces/AIWaves/Software_Company/src/agents/Environment/base_environment.py b/spaces/AIWaves/Software_Company/src/agents/Environment/base_environment.py
deleted file mode 100644
index 2cf4f08bcd83f4f8c0437e0789db1456e13998e1..0000000000000000000000000000000000000000
--- a/spaces/AIWaves/Software_Company/src/agents/Environment/base_environment.py
+++ /dev/null
@@ -1,167 +0,0 @@
-from utils import get_relevant_history, get_embedding
-import torch
-from LLM.base_LLM import *
-from Memory import Memory
-from Prompt import *
-import json
-class Environment:
- """
- The place where the agent activities, responsible for storing some shared memories
- """
- def __init__(self, config) -> None:
- self.shared_memory = {"long_term_memory": [], "short_term_memory": None}
- self.agents = None
-
- self.summary_system_prompt = {}
- self.summary_last_prompt = {}
- self.environment_prompt = {}
- self.environment_type = config["environment_type"] if "environment_type" in config else "cooperative"
- self.current_chat_history_idx = 0
- self.LLMs = {}
-
- # 初始化每个state 的summary 方法
- # Initialize the summary method for each state
- for state_name, state_dict in config["states"].items():
- if state_name != "end_state":
- self.summary_system_prompt[state_name] = (
- state_dict["summary_system_prompt"]
- if "summary_system_prompt" in state_dict
- else eval(Default_environment_summary_system_prompt)
- )
-
- self.summary_last_prompt[state_name] = (
- state_dict["summary_last_prompt"]
- if "summary_last_prompt" in state_dict
- else eval(Default_environment_summary_last_prompt)
- )
-
- self.environment_prompt[state_name] = (
- state_dict["environment_prompt"]
- if "environment_prompt" in state_dict
- else " "
- )
- self.LLMs[state_name] = init_LLM(f"logs/{state_name}",**state_dict)
- self.roles_to_names = None
- self.names_to_roles = None
-
- @classmethod
- def from_config(cls, config_path):
- with open(config_path) as f:
- config = json.load(f)
- return cls(config)
-
- def summary(self, current_state):
- """
- Summarize the situation in the current environment every once in a while
- """
- MAX_CHAT_HISTORY = eval(os.environ["MAX_CHAT_HISTORY"])
- current_state_name = current_state.name
-
- query = self.shared_memory["long_term_memory"][-1].content
- relevant_history = get_relevant_history(
- query,
- self.shared_memory["long_term_memory"][:-1],
- self.shared_memory["chat_embeddings"][:-1],
- )
-
- relevant_history = Memory.get_chat_history(relevant_history)
- chat_history = Memory.get_chat_history(
- self.shared_memory["long_term_memory"][-MAX_CHAT_HISTORY + 1 :]
- )
- summary = self.shared_memory["short_term_memory"]
-
-
- # system prompt = environment prompt + current memory + system prompt
- # current_memory = summary + chat history + relevant history
- current_memory = eval(Environment_summary_memory)
- environment_prompt = self.environment_prompt[current_state_name]
- summary_system_prompt = self.summary_system_prompt[current_state_name]
-
- environment_summary_system_prompt = eval(Environment_summary_system_prompt)
- response = self.LLMs[current_state_name].get_response(None, environment_summary_system_prompt, stream=False)
- return response
-
- def update_memory(self, memory, current_state):
- """
- update chat embbedings and long term memory,short term memory,agents long term memory
- """
- MAX_CHAT_HISTORY = eval(os.environ["MAX_CHAT_HISTORY"])
- self.shared_memory["long_term_memory"].append(memory)
- current_embedding = get_embedding(memory.content)
- if "chat_embeddings" not in self.shared_memory:
- self.shared_memory["chat_embeddings"] = current_embedding
- else:
- self.shared_memory["chat_embeddings"] = torch.cat(
- [self.shared_memory["chat_embeddings"], current_embedding], dim=0
- )
- if len(self.shared_memory["long_term_memory"]) % MAX_CHAT_HISTORY == 0:
- summary = self.summary(current_state)
- self.shared_memory["short_term_memory"] = summary
-
- self.agents[memory.send_name].update_memory(memory)
-
-
- def _get_agent_last_conversation_idx(self,agent,current_long_term_memory):
- last_conversation_idx = -1
- for i, history in enumerate(current_long_term_memory):
- if history.send_name == agent.name:
- last_conversation_idx = i
- return last_conversation_idx
-
-
- def _get_agent_new_memory(self,agent,current_long_term_memory):
- # get new conversation
- last_conversation_idx = self._get_agent_last_conversation_idx(agent,current_long_term_memory)
-
- if last_conversation_idx == -1:
- new_conversation =current_long_term_memory
- elif (
- last_conversation_idx
- == len(current_long_term_memory) - 1
- ):
- new_conversation = []
- else:
- new_conversation = current_long_term_memory[
- last_conversation_idx + 1 :
- ]
-
- # get chat history from new conversation
- return Memory.get_chat_history(new_conversation)
-
-
- def _observe(self,agent):
- MAX_CHAT_HISTORY = eval(os.environ["MAX_CHAT_HISTORY"])
- current_state = agent.current_state
- current_role = agent.state_roles[current_state.name]
- current_component_dict = current_state.components[current_role]
-
- # cooperative:Sharing information between different states ; competive: No information is shared between different states
- current_chat_history_idx = self.current_chat_history_idx if self.environment_type == "competive" else 0
- current_long_term_memory = self.shared_memory["long_term_memory"][current_chat_history_idx:]
- current_chat_embbedings = self.shared_memory["chat_embeddings"][current_chat_history_idx:]
-
-
- # relevant_memory
- query = current_long_term_memory[-1].content
-
- relevant_memory = get_relevant_history(
- query,
- current_long_term_memory[:-1],
- current_chat_embbedings[:-1],
- )
- relevant_memory = Memory.get_chat_history(relevant_memory,agent.name)
-
- relevant_memory = eval(Agent_observe_relevant_memory)
- agent.relevant_memory = relevant_memory
-
-
- # get chat history from new conversation
- conversations = self._get_agent_new_memory(agent,current_long_term_memory)
-
- # memory = relevant_memory + summary + history + query
- query = current_long_term_memory[-1]
- current_memory = eval(Agent_observe_memory)
-
- return {"role": "user", "content": current_memory}
-
-
diff --git a/spaces/ATang0729/Forecast4Muses/Model/Model6/Model6_0_ClothesDetection/mmyolo/configs/yolov5/voc/__init__.py b/spaces/ATang0729/Forecast4Muses/Model/Model6/Model6_0_ClothesDetection/mmyolo/configs/yolov5/voc/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/ATang0729/Forecast4Muses/Model/Model6/Model6_2_ProfileRecogition/mmpretrain/configs/resnext101_4xb16_1024e_4channel.py b/spaces/ATang0729/Forecast4Muses/Model/Model6/Model6_2_ProfileRecogition/mmpretrain/configs/resnext101_4xb16_1024e_4channel.py
deleted file mode 100644
index 0de71f68d6705b3fc1000419ca705be2b839d425..0000000000000000000000000000000000000000
--- a/spaces/ATang0729/Forecast4Muses/Model/Model6/Model6_2_ProfileRecogition/mmpretrain/configs/resnext101_4xb16_1024e_4channel.py
+++ /dev/null
@@ -1,88 +0,0 @@
-_base_ = [ # 此配置文件将继承所有 `_base_` 中的配置
- '../configs/_base_/schedules/custom_schedule.py', # 训练策略配置
- '../configs/_base_/default_runtime.py' # 默认运行设置
-]
-
-default_hooks = dict(
- # print log every 50 iterations.
- logger=dict(type='LoggerHook', interval=25),
- # save checkpoint per 8 epochs.
- checkpoint=dict(save_best='auto', interval=16)
-)
-
-visualizer = dict(
- vis_backends=[dict(type='LocalVisBackend'),
- dict(type='WandbVisBackend')])
-
-dataset_type = 'CustomDataset'
-
-# config of pipline
-train_pipeline = [
- dict(type='LoadImageFromFile', imdecode_backend='pillow', color_type='unchanged'), # 读取图像
- dict(type='RandomResizedCrop', scale=224), # 随机放缩裁剪
- dict(type='RandomFlip', prob=0.5, direction='horizontal'), # 随机水平翻转
- dict(type='PackInputs'), # 准备图像以及标签
-]
-
-test_pipeline = [
- dict(type='LoadImageFromFile', imdecode_backend='pillow', color_type='unchanged'), # 读取图像
- dict(type='ResizeEdge', scale=256, edge='short'), # 缩放短边尺寸至 256px
- dict(type='CenterCrop', crop_size=224), # 中心裁剪
- dict(type='PackInputs'), # 准备图像以及标签
-]
-
-# config of dataloader
-train_dataloader = dict(
- batch_size=16, # 每张 GPU 的 batchsize
- num_workers=5, # 每个 GPU 的线程数
- dataset=dict( # 训练数据集
- type=dataset_type,
- data_root='../2_preprocess_data_3000',
- with_label=True,
- ann_file='',
- data_prefix='train',
- pipeline=train_pipeline),
- sampler=dict(type='DefaultSampler', shuffle=True), # 默认采样器
- persistent_workers=True, # 是否保持进程，可以缩短每个 epoch 的准备时间
-)
-
-# 构造验证集 dataloader
-val_dataloader = dict(
- batch_size=16,
- num_workers=5,
- dataset=dict(
- type=dataset_type,
- data_root='../2_preprocess_data_3000',
- with_label=True,
- ann_file='',
- data_prefix='val',
- pipeline=test_pipeline),
- sampler=dict(type='DefaultSampler', shuffle=False),
- persistent_workers=True,
-)
-
-# set evaluator of validation dataset. Here uses top1 and top3 accuracy
-val_evaluator = dict(type='Accuracy', topk=(1, 3))
-
-test_dataloader = val_dataloader
-test_evaluator = val_evaluator
-
-model = dict(
- type='ImageClassifier', # 主模型类型（对于图像分类任务，使用 `ImageClassifier`）
- backbone=dict(
- type='ResNeXt', # 主干网络类型
- depth=101,
- in_channels=4, # 输入通道数
- ),
- neck=dict(type='GlobalAveragePooling'), # 颈网络类型
- head=dict(
- type='LinearClsHead', # 分类颈网络类型
- # 除了 `type` 之外的所有字段都来自 `LinearClsHead` 类的 __init__ 方法
- # 可查阅 https://mmpretrain.readthedocs.io/zh_CN/latest/api/generated/mmpretrain.models.heads.LinearClsHead.html
- num_classes=7, # 分类类别数
- in_channels=2048,
- loss=dict(type='CrossEntropyLoss', loss_weight=1.0), # 损失函数配置信息
- topk=(1, 3), # 评估指标，Top-k 准确率
- ))
-
-
diff --git a/spaces/Abhaykoul/Youtube_video_downloader/README.md b/spaces/Abhaykoul/Youtube_video_downloader/README.md
deleted file mode 100644
index 0209bb7b4e174fad069bee9f7c2953d2d184e97a..0000000000000000000000000000000000000000
--- a/spaces/Abhaykoul/Youtube_video_downloader/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Youtube Video Downloader
-emoji: 💻
-colorFrom: purple
-colorTo: red
-sdk: streamlit
-sdk_version: 1.28.1
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/AchyuthGamer/OpenGPT/g4f/Provider/deprecated/EasyChat.py b/spaces/AchyuthGamer/OpenGPT/g4f/Provider/deprecated/EasyChat.py
deleted file mode 100644
index ffe9a785a61f17d3b816089165f38dd53e1d7c3f..0000000000000000000000000000000000000000
--- a/spaces/AchyuthGamer/OpenGPT/g4f/Provider/deprecated/EasyChat.py
+++ /dev/null
@@ -1,111 +0,0 @@
-from __future__ import annotations
-
-import json
-import random
-
-import requests
-
-from ...typing import Any, CreateResult
-from ..base_provider import BaseProvider
-
-
-class EasyChat(BaseProvider):
- url: str = "https://free.easychat.work"
- supports_stream = True
- supports_gpt_35_turbo = True
- working = False
-
- @staticmethod
- def create_completion(
- model: str,
- messages: list[dict[str, str]],
- stream: bool, **kwargs: Any) -> CreateResult:
-
- active_servers = [
- "https://chat10.fastgpt.me",
- "https://chat9.fastgpt.me",
- "https://chat1.fastgpt.me",
- "https://chat2.fastgpt.me",
- "https://chat3.fastgpt.me",
- "https://chat4.fastgpt.me",
- "https://gxos1h1ddt.fastgpt.me"
- ]
-
- server = active_servers[kwargs.get("active_server", random.randint(0, 5))]
- headers = {
- "authority" : f"{server}".replace("https://", ""),
- "accept" : "text/event-stream",
- "accept-language" : "en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3,fa=0.2",
- "content-type" : "application/json",
- "origin" : f"{server}",
- "referer" : f"{server}/",
- "x-requested-with" : "XMLHttpRequest",
- 'plugins' : '0',
- 'sec-ch-ua' : '"Chromium";v="116", "Not)A;Brand";v="24", "Google Chrome";v="116"',
- 'sec-ch-ua-mobile' : '?0',
- 'sec-ch-ua-platform': '"Windows"',
- 'sec-fetch-dest' : 'empty',
- 'sec-fetch-mode' : 'cors',
- 'sec-fetch-site' : 'same-origin',
- 'user-agent' : 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36',
- 'usesearch' : 'false',
- 'x-requested-with' : 'XMLHttpRequest'
- }
-
- json_data = {
- "messages" : messages,
- "stream" : stream,
- "model" : model,
- "temperature" : kwargs.get("temperature", 0.5),
- "presence_penalty" : kwargs.get("presence_penalty", 0),
- "frequency_penalty" : kwargs.get("frequency_penalty", 0),
- "top_p" : kwargs.get("top_p", 1)
- }
-
- session = requests.Session()
- # init cookies from server
- session.get(f"{server}/")
-
- response = session.post(f"{server}/api/openai/v1/chat/completions",
- headers=headers, json=json_data, stream=stream)
-
- if response.status_code == 200:
-
- if stream == False:
- json_data = response.json()
-
- if "choices" in json_data:
- yield json_data["choices"][0]["message"]["content"]
- else:
- raise Exception("No response from server")
-
- else:
-
- for chunk in response.iter_lines():
-
- if b"content" in chunk:
- splitData = chunk.decode().split("data:")
-
- if len(splitData) > 1:
- yield json.loads(splitData[1])["choices"][0]["delta"]["content"]
- else:
- continue
- else:
- raise Exception(f"Error {response.status_code} from server : {response.reason}")
-
-
- @classmethod
- @property
- def params(cls):
- params = [
- ("model", "str"),
- ("messages", "list[dict[str, str]]"),
- ("stream", "bool"),
- ("temperature", "float"),
- ("presence_penalty", "int"),
- ("frequency_penalty", "int"),
- ("top_p", "int"),
- ("active_server", "int"),
- ]
- param = ", ".join([": ".join(p) for p in params])
- return f"g4f.provider.{cls.__name__} supports: ({param})"
diff --git a/spaces/AgentVerse/agentVerse/agentverse/demo.py b/spaces/AgentVerse/agentVerse/agentverse/demo.py
deleted file mode 100644
index 810839ecdfb17118b1854c03819bf0ec38ddcc48..0000000000000000000000000000000000000000
--- a/spaces/AgentVerse/agentVerse/agentverse/demo.py
+++ /dev/null
@@ -1,487 +0,0 @@
-import base64
-import itertools
-import json
-from typing import Dict, List, Tuple
-
-import cv2
-import gradio as gr
-
-from agentverse.agentverse import AgentVerse
-from agentverse.message import Message
-
-
-def cover_img(background, img, place: Tuple[int, int]):
- """
- Overlays the specified image to the specified position of the background image.
- :param background: background image
- :param img: the specified image
- :param place: the top-left coordinate of the target location
- """
- back_h, back_w, _ = background.shape
- height, width, _ = img.shape
- for i, j in itertools.product(range(height), range(width)):
- if img[i, j, 3]:
- background[place[0] + i, place[1] + j] = img[i, j, :3]
-
-
-class UI:
- """
- the UI of frontend
- """
-
- def __init__(self, task: str):
- """
- init a UI.
- default number of students is 0
- """
- self.messages = []
- self.task = task
- self.backend = AgentVerse.from_task(task)
- self.turns_remain = 0
- self.agent_id = {
- self.backend.agents[idx].name: idx
- for idx in range(len(self.backend.agents))
- }
- self.stu_num = len(self.agent_id) - 1
- self.autoplay = False
- self.image_now = None
- self.text_now = None
- self.tot_solutions = 5
- self.solution_status = [False] * self.tot_solutions
-
- def get_avatar(self, idx):
- if idx == -1:
- img = cv2.imread("./imgs/db_diag/-1.png")
- elif self.task == "prisoner_dilemma":
- img = cv2.imread(f"./imgs/prison/{idx}.png")
- elif self.task == "db_diag":
- img = cv2.imread(f"./imgs/db_diag/{idx}.png")
- elif "sde" in self.task:
- img = cv2.imread(f"./imgs/sde/{idx}.png")
- else:
- img = cv2.imread(f"./imgs/{idx}.png")
- base64_str = cv2.imencode(".png", img)[1].tostring()
- return "data:image/png;base64," + base64.b64encode(base64_str).decode("utf-8")
-
- def stop_autoplay(self):
- self.autoplay = False
- return (
- gr.Button.update(interactive=False),
- gr.Button.update(interactive=False),
- gr.Button.update(interactive=False),
- )
-
- def start_autoplay(self):
- self.autoplay = True
- yield (
- self.image_now,
- self.text_now,
- gr.Button.update(interactive=False),
- gr.Button.update(interactive=True),
- gr.Button.update(interactive=False),
- *[gr.Button.update(visible=statu) for statu in self.solution_status],
- gr.Box.update(visible=any(self.solution_status)),
- )
-
- while self.autoplay and self.turns_remain > 0:
- outputs = self.gen_output()
- self.image_now, self.text_now = outputs
-
- yield (
- *outputs,
- gr.Button.update(interactive=not self.autoplay and self.turns_remain > 0),
- gr.Button.update(interactive=self.autoplay and self.turns_remain > 0),
- gr.Button.update(interactive=not self.autoplay and self.turns_remain > 0),
- *[gr.Button.update(visible=statu) for statu in self.solution_status],
- gr.Box.update(visible=any(self.solution_status))
- )
-
- def delay_gen_output(self):
- yield (
- self.image_now,
- self.text_now,
- gr.Button.update(interactive=False),
- gr.Button.update(interactive=False),
- *[gr.Button.update(visible=statu) for statu in self.solution_status],
- gr.Box.update(visible=any(self.solution_status))
- )
-
- outputs = self.gen_output()
- self.image_now, self.text_now = outputs
-
- yield (
- self.image_now,
- self.text_now,
- gr.Button.update(interactive=self.turns_remain > 0),
- gr.Button.update(interactive=self.turns_remain > 0),
- *[gr.Button.update(visible=statu) for statu in self.solution_status],
- gr.Box.update(visible=any(self.solution_status))
- )
-
- def delay_reset(self):
- self.autoplay = False
- self.image_now, self.text_now = self.reset()
- return (
- self.image_now,
- self.text_now,
- gr.Button.update(interactive=True),
- gr.Button.update(interactive=False),
- gr.Button.update(interactive=True),
- *[gr.Button.update(visible=statu) for statu in self.solution_status],
- gr.Box.update(visible=any(self.solution_status))
- )
-
- def reset(self, stu_num=0):
- """
- tell backend the new number of students and generate new empty image
- :param stu_num:
- :return: [empty image, empty message]
- """
- if not 0 <= stu_num <= 30:
- raise gr.Error("the number of students must be between 0 and 30.")
-
- """
- # [To-Do] Need to add a function to assign agent numbers into the backend.
- """
- # self.backend.reset(stu_num)
- # self.stu_num = stu_num
-
- """
- # [To-Do] Pass the parameters to reset
- """
- self.backend.reset()
- self.turns_remain = self.backend.environment.max_turns
-
- if self.task == "prisoner_dilemma":
- background = cv2.imread("./imgs/prison/case_1.png")
- elif self.task == "db_diag":
- background = cv2.imread("./imgs/db_diag/background.png")
- elif "sde" in self.task:
- background = cv2.imread("./imgs/sde/background.png")
- else:
- background = cv2.imread("./imgs/background.png")
- back_h, back_w, _ = background.shape
- stu_cnt = 0
- for h_begin, w_begin in itertools.product(
- range(800, back_h, 300), range(135, back_w - 200, 200)
- ):
- stu_cnt += 1
- img = cv2.imread(
- f"./imgs/{(stu_cnt - 1) % 11 + 1 if stu_cnt <= self.stu_num else 'empty'}.png",
- cv2.IMREAD_UNCHANGED,
- )
- cover_img(
- background,
- img,
- (h_begin - 30 if img.shape[0] > 190 else h_begin, w_begin),
- )
- self.messages = []
- self.solution_status = [False] * self.tot_solutions
- return [cv2.cvtColor(background, cv2.COLOR_BGR2RGB), ""]
-
- def gen_img(self, data: List[Dict]):
- """
- generate new image with sender rank
- :param data:
- :return: the new image
- """
- # The following code need to be more general. This one is too task-specific.
- # if len(data) != self.stu_num:
- if len(data) != self.stu_num + 1:
- raise gr.Error("data length is not equal to the total number of students.")
- if self.task == "prisoner_dilemma":
- img = cv2.imread("./imgs/speaking.png", cv2.IMREAD_UNCHANGED)
- if (
- len(self.messages) < 2
- or self.messages[-1][0] == 1
- or self.messages[-2][0] == 2
- ):
- background = cv2.imread("./imgs/prison/case_1.png")
- if data[0]["message"] != "":
- cover_img(background, img, (400, 480))
- else:
- background = cv2.imread("./imgs/prison/case_2.png")
- if data[0]["message"] != "":
- cover_img(background, img, (400, 880))
- if data[1]["message"] != "":
- cover_img(background, img, (550, 480))
- if data[2]["message"] != "":
- cover_img(background, img, (550, 880))
- elif self.task == "db_diag":
- background = cv2.imread("./imgs/db_diag/background.png")
- img = cv2.imread("./imgs/db_diag/speaking.png", cv2.IMREAD_UNCHANGED)
- if data[0]["message"] != "":
- cover_img(background, img, (750, 80))
- if data[1]["message"] != "":
- cover_img(background, img, (310, 220))
- if data[2]["message"] != "":
- cover_img(background, img, (522, 11))
- elif "sde" in self.task:
- background = cv2.imread("./imgs/sde/background.png")
- img = cv2.imread("./imgs/sde/speaking.png", cv2.IMREAD_UNCHANGED)
- if data[0]["message"] != "":
- cover_img(background, img, (692, 330))
- if data[1]["message"] != "":
- cover_img(background, img, (692, 660))
- if data[2]["message"] != "":
- cover_img(background, img, (692, 990))
- else:
- background = cv2.imread("./imgs/background.png")
- back_h, back_w, _ = background.shape
- stu_cnt = 0
- if data[stu_cnt]["message"] not in ["", "[RaiseHand]"]:
- img = cv2.imread("./imgs/speaking.png", cv2.IMREAD_UNCHANGED)
- cover_img(background, img, (370, 1250))
- for h_begin, w_begin in itertools.product(
- range(800, back_h, 300), range(135, back_w - 200, 200)
- ):
- stu_cnt += 1
- if stu_cnt <= self.stu_num:
- img = cv2.imread(
- f"./imgs/{(stu_cnt - 1) % 11 + 1}.png", cv2.IMREAD_UNCHANGED
- )
- cover_img(
- background,
- img,
- (h_begin - 30 if img.shape[0] > 190 else h_begin, w_begin),
- )
- if "[RaiseHand]" in data[stu_cnt]["message"]:
- # elif data[stu_cnt]["message"] == "[RaiseHand]":
- img = cv2.imread("./imgs/hand.png", cv2.IMREAD_UNCHANGED)
- cover_img(background, img, (h_begin - 90, w_begin + 10))
- elif data[stu_cnt]["message"] not in ["", "[RaiseHand]"]:
- img = cv2.imread("./imgs/speaking.png", cv2.IMREAD_UNCHANGED)
- cover_img(background, img, (h_begin - 90, w_begin + 10))
-
- else:
- img = cv2.imread("./imgs/empty.png", cv2.IMREAD_UNCHANGED)
- cover_img(background, img, (h_begin, w_begin))
- return cv2.cvtColor(background, cv2.COLOR_BGR2RGB)
-
- def return_format(self, messages: List[Message]):
- _format = [{"message": "", "sender": idx} for idx in range(len(self.agent_id))]
-
- for message in messages:
- if self.task == "db_diag":
- content_json: dict = message.content
- content_json["diagnose"] = f"[{message.sender}]: {content_json['diagnose']}"
- _format[self.agent_id[message.sender]]["message"] = json.dumps(content_json)
- elif "sde" in self.task:
- if message.sender == "code_tester":
- pre_message, message_ = message.content.split("\n")
- message_ = "{}\n{}".format(pre_message, json.loads(message_)["feedback"])
- _format[self.agent_id[message.sender]]["message"] = "[{}]: {}".format(
- message.sender, message_
- )
- else:
- _format[self.agent_id[message.sender]]["message"] = "[{}]: {}".format(
- message.sender, message.content
- )
-
- else:
- _format[self.agent_id[message.sender]]["message"] = "[{}]: {}".format(
- message.sender, message.content
- )
-
- return _format
-
- def gen_output(self):
- """
- generate new image and message of next step
- :return: [new image, new message]
- """
-
- # data = self.backend.next_data()
- return_message = self.backend.next()
- data = self.return_format(return_message)
-
- # data.sort(key=lambda item: item["sender"])
- """
- # [To-Do]; Check the message from the backend: only 1 person can speak
- """
-
- for item in data:
- if item["message"] not in ["", "[RaiseHand]"]:
- self.messages.append((item["sender"], item["message"]))
-
- message = self.gen_message()
- self.turns_remain -= 1
- return [self.gen_img(data), message]
-
- def gen_message(self):
- # If the backend cannot handle this error, use the following code.
- message = ""
- """
- for item in data:
- if item["message"] not in ["", "[RaiseHand]"]:
- message = item["message"]
- break
- """
- for sender, msg in self.messages:
- if sender == 0:
- avatar = self.get_avatar(0)
- elif sender == -1:
- avatar = self.get_avatar(-1)
- else:
- avatar = self.get_avatar((sender - 1) % 11 + 1)
- if self.task == "db_diag":
- msg_json = json.loads(msg)
- self.solution_status = [False] * self.tot_solutions
- msg = msg_json["diagnose"]
- if msg_json["solution"] != "":
- solution: List[str] = msg_json["solution"]
- for solu in solution:
- if "query" in solu or "queries" in solu:
- self.solution_status[0] = True
- solu = solu.replace("query", 'query')
- solu = solu.replace("queries", 'queries')
- if "join" in solu:
- self.solution_status[1] = True
- solu = solu.replace("join", 'join')
- if "index" in solu:
- self.solution_status[2] = True
- solu = solu.replace("index", 'index')
- if "system configuration" in solu:
- self.solution_status[3] = True
- solu = solu.replace("system configuration",
- 'system configuration')
- if "monitor" in solu or "Monitor" in solu or "Investigate" in solu:
- self.solution_status[4] = True
- solu = solu.replace("monitor", 'monitor')
- solu = solu.replace("Monitor", 'Monitor')
- solu = solu.replace("Investigate", 'Investigate')
- msg = f"{msg} {solu}"
- if msg_json["knowledge"] != "":
- msg = f'{msg}{msg_json["knowledge"]}'
- else:
- msg = msg.replace("<", "<")
- msg = msg.replace(">", ">")
- message = (
- f'
'
- f''
- f'
'
- f"{msg}"
- f"
" + message
- )
- message = '
' + message + "
"
- return message
-
- def submit(self, message: str):
- """
- submit message to backend
- :param message: message
- :return: [new image, new message]
- """
- self.backend.submit(message)
- self.messages.append((-1, f"[User]: {message}"))
- return self.gen_img([{"message": ""}] * len(self.agent_id)), self.gen_message()
-
- def launch(self):
- """
- start a frontend
- """
- with gr.Blocks() as demo:
- with gr.Row():
- with gr.Column():
- image_output = gr.Image()
- with gr.Row():
- reset_btn = gr.Button("Reset")
- # next_btn = gr.Button("Next", variant="primary")
- next_btn = gr.Button("Next", interactive=False)
- stop_autoplay_btn = gr.Button(
- "Stop Autoplay", interactive=False
- )
- start_autoplay_btn = gr.Button("Start Autoplay", interactive=False)
- with gr.Box(visible=False) as solutions:
- with gr.Column():
- gr.HTML("Optimization Solutions:")
- with gr.Row():
- rewrite_slow_query_btn = gr.Button("Rewrite Slow Query", visible=False)
- add_query_hints_btn = gr.Button("Add Query Hints", visible=False)
- update_indexes_btn = gr.Button("Update Indexes", visible=False)
- tune_parameters_btn = gr.Button("Tune Parameters", visible=False)
- gather_more_info_btn = gr.Button("Gather More Info", visible=False)
- # text_output = gr.Textbox()
- text_output = gr.HTML(self.reset()[1])
-
- # Given a botton to provide student numbers and their inf.
- # stu_num = gr.Number(label="Student Number", precision=0)
- # stu_num = self.stu_num
-
- if self.task == "db_diag":
- user_msg = gr.Textbox()
- submit_btn = gr.Button("Submit", variant="primary")
-
- submit_btn.click(fn=self.submit, inputs=user_msg, outputs=[image_output, text_output], show_progress=False)
- else:
- pass
-
- # next_btn.click(fn=self.gen_output, inputs=None, outputs=[image_output, text_output], show_progress=False)
- next_btn.click(
- fn=self.delay_gen_output,
- inputs=None,
- outputs=[
- image_output,
- text_output,
- next_btn,
- start_autoplay_btn,
- rewrite_slow_query_btn,
- add_query_hints_btn,
- update_indexes_btn,
- tune_parameters_btn,
- gather_more_info_btn,
- solutions
- ],
- show_progress=False,
- )
-
- # [To-Do] Add botton: re-start (load different people and env)
- # reset_btn.click(fn=self.reset, inputs=stu_num, outputs=[image_output, text_output], show_progress=False)
- # reset_btn.click(fn=self.reset, inputs=None, outputs=[image_output, text_output], show_progress=False)
- reset_btn.click(
- fn=self.delay_reset,
- inputs=None,
- outputs=[
- image_output,
- text_output,
- next_btn,
- stop_autoplay_btn,
- start_autoplay_btn,
- rewrite_slow_query_btn,
- add_query_hints_btn,
- update_indexes_btn,
- tune_parameters_btn,
- gather_more_info_btn,
- solutions
- ],
- show_progress=False,
- )
-
- stop_autoplay_btn.click(
- fn=self.stop_autoplay,
- inputs=None,
- outputs=[next_btn, stop_autoplay_btn, start_autoplay_btn],
- show_progress=False,
- )
- start_autoplay_btn.click(
- fn=self.start_autoplay,
- inputs=None,
- outputs=[
- image_output,
- text_output,
- next_btn,
- stop_autoplay_btn,
- start_autoplay_btn,
- rewrite_slow_query_btn,
- add_query_hints_btn,
- update_indexes_btn,
- tune_parameters_btn,
- gather_more_info_btn,
- solutions
- ],
- show_progress=False,
- )
-
- demo.queue(concurrency_count=5, max_size=20).launch()
- # demo.launch()
diff --git a/spaces/AgentVerse/agentVerse/agentverse/environments/tasksolving_env/rules/decision_maker/concurrent.py b/spaces/AgentVerse/agentVerse/agentverse/environments/tasksolving_env/rules/decision_maker/concurrent.py
deleted file mode 100644
index cc34e00b75e6c0fa20d17d3387c13e66dfc9e060..0000000000000000000000000000000000000000
--- a/spaces/AgentVerse/agentVerse/agentverse/environments/tasksolving_env/rules/decision_maker/concurrent.py
+++ /dev/null
@@ -1,80 +0,0 @@
-from __future__ import annotations
-import asyncio
-from colorama import Fore
-
-from typing import TYPE_CHECKING, List
-
-from . import decision_maker_registry
-from .base import BaseDecisionMaker
-from agentverse.logging import typewriter_log, logger
-
-if TYPE_CHECKING:
- from agentverse.agents import BaseAgent, SolverAgent, CriticAgent
- from agentverse.message import Message, CriticMessage, SolverMessage
-
-
-@decision_maker_registry.register("concurrent")
-class ConcurrentDecisionMaker(BaseDecisionMaker):
- """
- Discuss in a concurrent manner.
- """
-
- name: str = "concurrent"
- max_inner_turns: int = 3
-
- async def astep(
- self,
- agents: List[BaseAgent],
- task_description: str,
- previous_plan: str = "No solution yet.",
- advice: str = "No advice yet.",
- *args,
- **kwargs,
- ) -> List[SolverMessage]:
- # Here we assume that the first agent is the solver.
- # The rest of the agents are the reviewers.
- last_reviews = []
- for i in range(self.max_inner_turns):
- reviews: List[CriticMessage] = await asyncio.gather(
- *[
- agent.astep(previous_plan, advice, task_description)
- for agent in agents[1:]
- ]
- )
- logger.info("", "Reviews:", Fore.YELLOW)
- logger.info(
- "",
- "\n".join(
- [f"[{review.sender}]: {review.content}" for review in reviews]
- ),
- Fore.YELLOW,
- )
- nonempty_reviews = []
- for review in reviews:
- if not review.is_agree and review.content != "":
- nonempty_reviews.append(review)
- self.broadcast_messages(agents[1:], nonempty_reviews)
- if len(nonempty_reviews) == 0:
- break
- last_reviews = nonempty_reviews
-
- agents[0].add_message_to_memory(last_reviews)
- result = agents[0].step(previous_plan, advice, task_description)
- # agents[0].add_message_to_memory([result])
- self.broadcast_messages(agents, [result])
- return [result]
-
- def broadcast_messages(self, agents, messages) -> None:
- for agent in agents:
- agent.add_message_to_memory(messages)
-
- def p2p_messages(self, agents, messages) -> None:
- agents[0].add_message_to_memory(messages)
- for message in messages:
- for agent in agents[1:]:
- if agent.name == message.sender:
- agent.add_message_to_memory(messages)
- break
-
- def reset(self):
- pass
diff --git a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/plugins/lzstring.d.ts b/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/plugins/lzstring.d.ts
deleted file mode 100644
index dc2c6fe11b20a1b790aeb063bf49989157918a74..0000000000000000000000000000000000000000
--- a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/plugins/lzstring.d.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-import LZString from './string/lzstring/LZString';
-export default LZString;
\ No newline at end of file
diff --git a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/bejeweled/states/MainState.js b/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/bejeweled/states/MainState.js
deleted file mode 100644
index 9d094e9ff068aa951f2cc7325f8721772dff35bd..0000000000000000000000000000000000000000
--- a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/bejeweled/states/MainState.js
+++ /dev/null
@@ -1,222 +0,0 @@
-import BaseState from './BaseState.js';
-import MatchState from './MatchState.js';
-// Actions
-import SelectChess from '../actions/SelectChess.js';
-import SwapChess from '../actions/SwapChess.js'
-
-const GetValue = Phaser.Utils.Objects.GetValue;
-
-class State extends BaseState {
- constructor(bejeweled, config) {
- super(bejeweled, config);
- // this.bejeweled = bejeweled; // Bejeweled
- // this.board = bejeweled.board; // Bejeweled.board
-
- this.selectedChess1;
- this.selectedChess2;
- this.matchState = new MatchState(bejeweled, config); // sub-state
-
- // Actions
- // select1 action
- this.select1Action = GetValue(config, 'select1Action', SelectChess);
- // select2 action
- this.select2Action = GetValue(config, 'select2Action', this.select1Action);
- // Swap action
- this.swapAction = GetValue(config, 'swapAction', SwapChess);
- // UndoSwap action
- this.undoSwapAction = GetValue(config, 'undoSwapAction', this.swapAction);
-
- var debug = GetValue(config, 'debug', false);
- if (debug) {
- this.on('statechange', this.printState, this);
- }
- }
-
- shutdown() {
- super.shutdown();
-
- this.matchState.shutdown();
-
- this.matchState = undefined;
- this.selectedChess1 = undefined;
- this.selectedChess2 = undefined;
- return this;
- }
-
- // START
- enter_START() {
- this.board.init(); // Fill background tiles
- this.next();
- }
- next_START() {
- return 'RESET';
- }
- // START
-
- // RESET
- enter_RESET() {
- this.board.reset(); // Refill chess
- this.next();
- }
- next_RESET() {
- return 'PRETEST';
- }
- // RESET
-
-
- // PRETEST
- enter_PRETEST() {
- this.next();
- }
- next_PRETEST() {
- var nextState;
- if (this.board.preTest()) {
- nextState = 'SELECT1START';
- } else {
- nextState = 'RESET';
- }
- return nextState;
- }
- // PRETEST
-
- // SELECT1START
- enter_SELECT1() {
- this.selectedChess1 = undefined;
- this.selectedChess2 = undefined;
-
- this.bejeweled.emit('select1-start', this.board.board, this.bejeweled);
- }
- selectChess1(chess) {
- if (this.state === 'SELECT1START') {
- this.selectedChess1 = chess;
- this.next();
- }
- return this;
- }
- next_SELECT1START() {
- var nextState;
- if (this.selectedChess1) {
- nextState = 'SELECT1';
- }
- return nextState;
- }
- // SELECT1START
-
- // SELECT1
- enter_SELECT1() {
- var board = this.board.board,
- chess = this.selectedChess1;
-
- this.bejeweled.emit('select1', chess, board, this.bejeweled);
-
- this.select1Action(chess, board, this.bejeweled);
-
- // To next state when all completed
- this.next();
- }
- next_SELECT1() {
- return 'SELECT2START';
- }
- // SELECT1
-
- // SELECT2START
- enter_SELECT2START() {
- this.bejeweled.emit('select2-start', this.board.board, this.bejeweled);
- }
- selectChess2(chess) {
- if (this.state === 'SELECT2START') {
- this.selectedChess2 = chess;
- this.next();
- }
- return this;
- }
- next_SELECT2START() {
- var nextState;
- if (this.selectedChess2 &&
- this.board.board.areNeighbors(this.selectedChess1, this.selectedChess2)) {
- nextState = 'SELECT2';
- } else {
- nextState = 'SELECT1START';
- }
- return nextState;
- }
- // SELECT2START
-
- // SELECT2
- enter_SELECT2() {
- var board = this.board.board,
- chess = this.selectedChess2;
-
- this.bejeweled.emit('select2', chess, board, this.bejeweled);
-
- this.select2Action(chess, board, this.bejeweled);
-
- // To next state when all completed
- this.next();
- }
- next_SELECT2() {
- return 'SWAP';
- }
- // SELECT2
-
- // SWAP
- enter_SWAP() {
- var board = this.board.board,
- chess1 = this.selectedChess1,
- chess2 = this.selectedChess2;
-
- this.bejeweled.emit('swap', chess1, chess2, board, this.bejeweled);
-
- this.swapAction(chess1, chess2, board, this.bejeweled);
-
- // To next state when all completed
- this.next();
- }
- next_SWAP() {
- return 'MATCH3';
- }
- // SWAP
-
- // MATCH3
- enter_MATCH3() {
- this.matchState
- .once('complete', this.next, this)
- .goto('START');
- }
- next_MATCH3() {
- var nextState;
- if (this.matchState.totalMatchedLinesCount === 0) {
- nextState = 'UNDOSWAP';
- } else {
- nextState = 'PRETEST';
- }
- return nextState;
- }
- // MATCH3
-
- // UNDO_SWAP
- enter_UNDOSWAP() {
- var board = this.board.board,
- chess1 = this.selectedChess1,
- chess2 = this.selectedChess2;
-
- this.bejeweled.emit('undo-swap', chess1, chess2, board, this.bejeweled);
-
- this.undoSwapAction(chess1, chess2, board, this.bejeweled);
-
- // To next state when all completed
- this.next();
- }
- next_UNDOSWAP() {
- return 'SELECT1START';
- }
- // UNDO_SWAP
-
- // debug
- printState() {
- console.log('Main state: ' + this.prevState + ' -> ' + this.state);
- }
-
-}
-
-export default State;
\ No newline at end of file
diff --git a/spaces/Aki004/herta-so-vits/models.py b/spaces/Aki004/herta-so-vits/models.py
deleted file mode 100644
index 13278d680493970f5a670cf3fc955a6e9b7ab1d5..0000000000000000000000000000000000000000
--- a/spaces/Aki004/herta-so-vits/models.py
+++ /dev/null
@@ -1,420 +0,0 @@
-import copy
-import math
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-import modules.attentions as attentions
-import modules.commons as commons
-import modules.modules as modules
-
-from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
-from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
-
-import utils
-from modules.commons import init_weights, get_padding
-from vdecoder.hifigan.models import Generator
-from utils import f0_to_coarse
-
-class ResidualCouplingBlock(nn.Module):
- def __init__(self,
- channels,
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- n_flows=4,
- gin_channels=0):
- super().__init__()
- self.channels = channels
- self.hidden_channels = hidden_channels
- self.kernel_size = kernel_size
- self.dilation_rate = dilation_rate
- self.n_layers = n_layers
- self.n_flows = n_flows
- self.gin_channels = gin_channels
-
- self.flows = nn.ModuleList()
- for i in range(n_flows):
- self.flows.append(modules.ResidualCouplingLayer(channels, hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=gin_channels, mean_only=True))
- self.flows.append(modules.Flip())
-
- def forward(self, x, x_mask, g=None, reverse=False):
- if not reverse:
- for flow in self.flows:
- x, _ = flow(x, x_mask, g=g, reverse=reverse)
- else:
- for flow in reversed(self.flows):
- x = flow(x, x_mask, g=g, reverse=reverse)
- return x
-
-
-class Encoder(nn.Module):
- def __init__(self,
- in_channels,
- out_channels,
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- gin_channels=0):
- super().__init__()
- self.in_channels = in_channels
- self.out_channels = out_channels
- self.hidden_channels = hidden_channels
- self.kernel_size = kernel_size
- self.dilation_rate = dilation_rate
- self.n_layers = n_layers
- self.gin_channels = gin_channels
-
- self.pre = nn.Conv1d(in_channels, hidden_channels, 1)
- self.enc = modules.WN(hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=gin_channels)
- self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
- def forward(self, x, x_lengths, g=None):
- # print(x.shape,x_lengths.shape)
- x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
- x = self.pre(x) * x_mask
- x = self.enc(x, x_mask, g=g)
- stats = self.proj(x) * x_mask
- m, logs = torch.split(stats, self.out_channels, dim=1)
- z = (m + torch.randn_like(m) * torch.exp(logs)) * x_mask
- return z, m, logs, x_mask
-
-
-class TextEncoder(nn.Module):
- def __init__(self,
- out_channels,
- hidden_channels,
- kernel_size,
- n_layers,
- gin_channels=0,
- filter_channels=None,
- n_heads=None,
- p_dropout=None):
- super().__init__()
- self.out_channels = out_channels
- self.hidden_channels = hidden_channels
- self.kernel_size = kernel_size
- self.n_layers = n_layers
- self.gin_channels = gin_channels
- self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
- self.f0_emb = nn.Embedding(256, hidden_channels)
-
- self.enc_ = attentions.Encoder(
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout)
-
- def forward(self, x, x_mask, f0=None, noice_scale=1):
- x = x + self.f0_emb(f0).transpose(1,2)
- x = self.enc_(x * x_mask, x_mask)
- stats = self.proj(x) * x_mask
- m, logs = torch.split(stats, self.out_channels, dim=1)
- z = (m + torch.randn_like(m) * torch.exp(logs) * noice_scale) * x_mask
-
- return z, m, logs, x_mask
-
-
-
-class DiscriminatorP(torch.nn.Module):
- def __init__(self, period, kernel_size=5, stride=3, use_spectral_norm=False):
- super(DiscriminatorP, self).__init__()
- self.period = period
- self.use_spectral_norm = use_spectral_norm
- norm_f = weight_norm if use_spectral_norm == False else spectral_norm
- self.convs = nn.ModuleList([
- norm_f(Conv2d(1, 32, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
- norm_f(Conv2d(32, 128, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
- norm_f(Conv2d(128, 512, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
- norm_f(Conv2d(512, 1024, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
- norm_f(Conv2d(1024, 1024, (kernel_size, 1), 1, padding=(get_padding(kernel_size, 1), 0))),
- ])
- self.conv_post = norm_f(Conv2d(1024, 1, (3, 1), 1, padding=(1, 0)))
-
- def forward(self, x):
- fmap = []
-
- # 1d to 2d
- b, c, t = x.shape
- if t % self.period != 0: # pad first
- n_pad = self.period - (t % self.period)
- x = F.pad(x, (0, n_pad), "reflect")
- t = t + n_pad
- x = x.view(b, c, t // self.period, self.period)
-
- for l in self.convs:
- x = l(x)
- x = F.leaky_relu(x, modules.LRELU_SLOPE)
- fmap.append(x)
- x = self.conv_post(x)
- fmap.append(x)
- x = torch.flatten(x, 1, -1)
-
- return x, fmap
-
-
-class DiscriminatorS(torch.nn.Module):
- def __init__(self, use_spectral_norm=False):
- super(DiscriminatorS, self).__init__()
- norm_f = weight_norm if use_spectral_norm == False else spectral_norm
- self.convs = nn.ModuleList([
- norm_f(Conv1d(1, 16, 15, 1, padding=7)),
- norm_f(Conv1d(16, 64, 41, 4, groups=4, padding=20)),
- norm_f(Conv1d(64, 256, 41, 4, groups=16, padding=20)),
- norm_f(Conv1d(256, 1024, 41, 4, groups=64, padding=20)),
- norm_f(Conv1d(1024, 1024, 41, 4, groups=256, padding=20)),
- norm_f(Conv1d(1024, 1024, 5, 1, padding=2)),
- ])
- self.conv_post = norm_f(Conv1d(1024, 1, 3, 1, padding=1))
-
- def forward(self, x):
- fmap = []
-
- for l in self.convs:
- x = l(x)
- x = F.leaky_relu(x, modules.LRELU_SLOPE)
- fmap.append(x)
- x = self.conv_post(x)
- fmap.append(x)
- x = torch.flatten(x, 1, -1)
-
- return x, fmap
-
-
-class MultiPeriodDiscriminator(torch.nn.Module):
- def __init__(self, use_spectral_norm=False):
- super(MultiPeriodDiscriminator, self).__init__()
- periods = [2,3,5,7,11]
-
- discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
- discs = discs + [DiscriminatorP(i, use_spectral_norm=use_spectral_norm) for i in periods]
- self.discriminators = nn.ModuleList(discs)
-
- def forward(self, y, y_hat):
- y_d_rs = []
- y_d_gs = []
- fmap_rs = []
- fmap_gs = []
- for i, d in enumerate(self.discriminators):
- y_d_r, fmap_r = d(y)
- y_d_g, fmap_g = d(y_hat)
- y_d_rs.append(y_d_r)
- y_d_gs.append(y_d_g)
- fmap_rs.append(fmap_r)
- fmap_gs.append(fmap_g)
-
- return y_d_rs, y_d_gs, fmap_rs, fmap_gs
-
-
-class SpeakerEncoder(torch.nn.Module):
- def __init__(self, mel_n_channels=80, model_num_layers=3, model_hidden_size=256, model_embedding_size=256):
- super(SpeakerEncoder, self).__init__()
- self.lstm = nn.LSTM(mel_n_channels, model_hidden_size, model_num_layers, batch_first=True)
- self.linear = nn.Linear(model_hidden_size, model_embedding_size)
- self.relu = nn.ReLU()
-
- def forward(self, mels):
- self.lstm.flatten_parameters()
- _, (hidden, _) = self.lstm(mels)
- embeds_raw = self.relu(self.linear(hidden[-1]))
- return embeds_raw / torch.norm(embeds_raw, dim=1, keepdim=True)
-
- def compute_partial_slices(self, total_frames, partial_frames, partial_hop):
- mel_slices = []
- for i in range(0, total_frames-partial_frames, partial_hop):
- mel_range = torch.arange(i, i+partial_frames)
- mel_slices.append(mel_range)
-
- return mel_slices
-
- def embed_utterance(self, mel, partial_frames=128, partial_hop=64):
- mel_len = mel.size(1)
- last_mel = mel[:,-partial_frames:]
-
- if mel_len > partial_frames:
- mel_slices = self.compute_partial_slices(mel_len, partial_frames, partial_hop)
- mels = list(mel[:,s] for s in mel_slices)
- mels.append(last_mel)
- mels = torch.stack(tuple(mels), 0).squeeze(1)
-
- with torch.no_grad():
- partial_embeds = self(mels)
- embed = torch.mean(partial_embeds, axis=0).unsqueeze(0)
- #embed = embed / torch.linalg.norm(embed, 2)
- else:
- with torch.no_grad():
- embed = self(last_mel)
-
- return embed
-
-class F0Decoder(nn.Module):
- def __init__(self,
- out_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- spk_channels=0):
- super().__init__()
- self.out_channels = out_channels
- self.hidden_channels = hidden_channels
- self.filter_channels = filter_channels
- self.n_heads = n_heads
- self.n_layers = n_layers
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.spk_channels = spk_channels
-
- self.prenet = nn.Conv1d(hidden_channels, hidden_channels, 3, padding=1)
- self.decoder = attentions.FFT(
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout)
- self.proj = nn.Conv1d(hidden_channels, out_channels, 1)
- self.f0_prenet = nn.Conv1d(1, hidden_channels , 3, padding=1)
- self.cond = nn.Conv1d(spk_channels, hidden_channels, 1)
-
- def forward(self, x, norm_f0, x_mask, spk_emb=None):
- x = torch.detach(x)
- if (spk_emb is not None):
- x = x + self.cond(spk_emb)
- x += self.f0_prenet(norm_f0)
- x = self.prenet(x) * x_mask
- x = self.decoder(x * x_mask, x_mask)
- x = self.proj(x) * x_mask
- return x
-
-
-class SynthesizerTrn(nn.Module):
- """
- Synthesizer for Training
- """
-
- def __init__(self,
- spec_channels,
- segment_size,
- inter_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- resblock,
- resblock_kernel_sizes,
- resblock_dilation_sizes,
- upsample_rates,
- upsample_initial_channel,
- upsample_kernel_sizes,
- gin_channels,
- ssl_dim,
- n_speakers,
- sampling_rate=44100,
- **kwargs):
-
- super().__init__()
- self.spec_channels = spec_channels
- self.inter_channels = inter_channels
- self.hidden_channels = hidden_channels
- self.filter_channels = filter_channels
- self.n_heads = n_heads
- self.n_layers = n_layers
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.resblock = resblock
- self.resblock_kernel_sizes = resblock_kernel_sizes
- self.resblock_dilation_sizes = resblock_dilation_sizes
- self.upsample_rates = upsample_rates
- self.upsample_initial_channel = upsample_initial_channel
- self.upsample_kernel_sizes = upsample_kernel_sizes
- self.segment_size = segment_size
- self.gin_channels = gin_channels
- self.ssl_dim = ssl_dim
- self.emb_g = nn.Embedding(n_speakers, gin_channels)
-
- self.pre = nn.Conv1d(ssl_dim, hidden_channels, kernel_size=5, padding=2)
-
- self.enc_p = TextEncoder(
- inter_channels,
- hidden_channels,
- filter_channels=filter_channels,
- n_heads=n_heads,
- n_layers=n_layers,
- kernel_size=kernel_size,
- p_dropout=p_dropout
- )
- hps = {
- "sampling_rate": sampling_rate,
- "inter_channels": inter_channels,
- "resblock": resblock,
- "resblock_kernel_sizes": resblock_kernel_sizes,
- "resblock_dilation_sizes": resblock_dilation_sizes,
- "upsample_rates": upsample_rates,
- "upsample_initial_channel": upsample_initial_channel,
- "upsample_kernel_sizes": upsample_kernel_sizes,
- "gin_channels": gin_channels,
- }
- self.dec = Generator(h=hps)
- self.enc_q = Encoder(spec_channels, inter_channels, hidden_channels, 5, 1, 16, gin_channels=gin_channels)
- self.flow = ResidualCouplingBlock(inter_channels, hidden_channels, 5, 1, 4, gin_channels=gin_channels)
- self.f0_decoder = F0Decoder(
- 1,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- spk_channels=gin_channels
- )
- self.emb_uv = nn.Embedding(2, hidden_channels)
-
- def forward(self, c, f0, uv, spec, g=None, c_lengths=None, spec_lengths=None):
- g = self.emb_g(g).transpose(1,2)
- # ssl prenet
- x_mask = torch.unsqueeze(commons.sequence_mask(c_lengths, c.size(2)), 1).to(c.dtype)
- x = self.pre(c) * x_mask + self.emb_uv(uv.long()).transpose(1,2)
-
- # f0 predict
- lf0 = 2595. * torch.log10(1. + f0.unsqueeze(1) / 700.) / 500
- norm_lf0 = utils.normalize_f0(lf0, x_mask, uv)
- pred_lf0 = self.f0_decoder(x, norm_lf0, x_mask, spk_emb=g)
-
- # encoder
- z_ptemp, m_p, logs_p, _ = self.enc_p(x, x_mask, f0=f0_to_coarse(f0))
- z, m_q, logs_q, spec_mask = self.enc_q(spec, spec_lengths, g=g)
-
- # flow
- z_p = self.flow(z, spec_mask, g=g)
- z_slice, pitch_slice, ids_slice = commons.rand_slice_segments_with_pitch(z, f0, spec_lengths, self.segment_size)
-
- # nsf decoder
- o = self.dec(z_slice, g=g, f0=pitch_slice)
-
- return o, ids_slice, spec_mask, (z, z_p, m_p, logs_p, m_q, logs_q), pred_lf0, norm_lf0, lf0
-
- def infer(self, c, f0, uv, g=None, noice_scale=0.35, predict_f0=False):
- c_lengths = (torch.ones(c.size(0)) * c.size(-1)).to(c.device)
- g = self.emb_g(g).transpose(1,2)
- x_mask = torch.unsqueeze(commons.sequence_mask(c_lengths, c.size(2)), 1).to(c.dtype)
- x = self.pre(c) * x_mask + self.emb_uv(uv.long()).transpose(1,2)
-
- if predict_f0:
- lf0 = 2595. * torch.log10(1. + f0.unsqueeze(1) / 700.) / 500
- norm_lf0 = utils.normalize_f0(lf0, x_mask, uv, random_scale=False)
- pred_lf0 = self.f0_decoder(x, norm_lf0, x_mask, spk_emb=g)
- f0 = (700 * (torch.pow(10, pred_lf0 * 500 / 2595) - 1)).squeeze(1)
-
- z_p, m_p, logs_p, c_mask = self.enc_p(x, x_mask, f0=f0_to_coarse(f0), noice_scale=noice_scale)
- z = self.flow(z_p, c_mask, g=g, reverse=True)
- o = self.dec(z * c_mask, g=g, f0=f0)
- return o
diff --git a/spaces/Alpaca233/SadTalker/src/face3d/util/visualizer.py b/spaces/Alpaca233/SadTalker/src/face3d/util/visualizer.py
deleted file mode 100644
index 4023a6d4086acba9bc88e079f625194d324d7c9e..0000000000000000000000000000000000000000
--- a/spaces/Alpaca233/SadTalker/src/face3d/util/visualizer.py
+++ /dev/null
@@ -1,227 +0,0 @@
-"""This script defines the visualizer for Deep3DFaceRecon_pytorch
-"""
-
-import numpy as np
-import os
-import sys
-import ntpath
-import time
-from . import util, html
-from subprocess import Popen, PIPE
-from torch.utils.tensorboard import SummaryWriter
-
-def save_images(webpage, visuals, image_path, aspect_ratio=1.0, width=256):
- """Save images to the disk.
-
- Parameters:
- webpage (the HTML class) -- the HTML webpage class that stores these imaegs (see html.py for more details)
- visuals (OrderedDict) -- an ordered dictionary that stores (name, images (either tensor or numpy) ) pairs
- image_path (str) -- the string is used to create image paths
- aspect_ratio (float) -- the aspect ratio of saved images
- width (int) -- the images will be resized to width x width
-
- This function will save images stored in 'visuals' to the HTML file specified by 'webpage'.
- """
- image_dir = webpage.get_image_dir()
- short_path = ntpath.basename(image_path[0])
- name = os.path.splitext(short_path)[0]
-
- webpage.add_header(name)
- ims, txts, links = [], [], []
-
- for label, im_data in visuals.items():
- im = util.tensor2im(im_data)
- image_name = '%s/%s.png' % (label, name)
- os.makedirs(os.path.join(image_dir, label), exist_ok=True)
- save_path = os.path.join(image_dir, image_name)
- util.save_image(im, save_path, aspect_ratio=aspect_ratio)
- ims.append(image_name)
- txts.append(label)
- links.append(image_name)
- webpage.add_images(ims, txts, links, width=width)
-
-
-class Visualizer():
- """This class includes several functions that can display/save images and print/save logging information.
-
- It uses a Python library tensprboardX for display, and a Python library 'dominate' (wrapped in 'HTML') for creating HTML files with images.
- """
-
- def __init__(self, opt):
- """Initialize the Visualizer class
-
- Parameters:
- opt -- stores all the experiment flags; needs to be a subclass of BaseOptions
- Step 1: Cache the training/test options
- Step 2: create a tensorboard writer
- Step 3: create an HTML object for saveing HTML filters
- Step 4: create a logging file to store training losses
- """
- self.opt = opt # cache the option
- self.use_html = opt.isTrain and not opt.no_html
- self.writer = SummaryWriter(os.path.join(opt.checkpoints_dir, 'logs', opt.name))
- self.win_size = opt.display_winsize
- self.name = opt.name
- self.saved = False
- if self.use_html: # create an HTML object at /web/; images will be saved under /web/images/
- self.web_dir = os.path.join(opt.checkpoints_dir, opt.name, 'web')
- self.img_dir = os.path.join(self.web_dir, 'images')
- print('create web directory %s...' % self.web_dir)
- util.mkdirs([self.web_dir, self.img_dir])
- # create a logging file to store training losses
- self.log_name = os.path.join(opt.checkpoints_dir, opt.name, 'loss_log.txt')
- with open(self.log_name, "a") as log_file:
- now = time.strftime("%c")
- log_file.write('================ Training Loss (%s) ================\n' % now)
-
- def reset(self):
- """Reset the self.saved status"""
- self.saved = False
-
-
- def display_current_results(self, visuals, total_iters, epoch, save_result):
- """Display current results on tensorboad; save current results to an HTML file.
-
- Parameters:
- visuals (OrderedDict) - - dictionary of images to display or save
- total_iters (int) -- total iterations
- epoch (int) - - the current epoch
- save_result (bool) - - if save the current results to an HTML file
- """
- for label, image in visuals.items():
- self.writer.add_image(label, util.tensor2im(image), total_iters, dataformats='HWC')
-
- if self.use_html and (save_result or not self.saved): # save images to an HTML file if they haven't been saved.
- self.saved = True
- # save images to the disk
- for label, image in visuals.items():
- image_numpy = util.tensor2im(image)
- img_path = os.path.join(self.img_dir, 'epoch%.3d_%s.png' % (epoch, label))
- util.save_image(image_numpy, img_path)
-
- # update website
- webpage = html.HTML(self.web_dir, 'Experiment name = %s' % self.name, refresh=0)
- for n in range(epoch, 0, -1):
- webpage.add_header('epoch [%d]' % n)
- ims, txts, links = [], [], []
-
- for label, image_numpy in visuals.items():
- image_numpy = util.tensor2im(image)
- img_path = 'epoch%.3d_%s.png' % (n, label)
- ims.append(img_path)
- txts.append(label)
- links.append(img_path)
- webpage.add_images(ims, txts, links, width=self.win_size)
- webpage.save()
-
- def plot_current_losses(self, total_iters, losses):
- # G_loss_collection = {}
- # D_loss_collection = {}
- # for name, value in losses.items():
- # if 'G' in name or 'NCE' in name or 'idt' in name:
- # G_loss_collection[name] = value
- # else:
- # D_loss_collection[name] = value
- # self.writer.add_scalars('G_collec', G_loss_collection, total_iters)
- # self.writer.add_scalars('D_collec', D_loss_collection, total_iters)
- for name, value in losses.items():
- self.writer.add_scalar(name, value, total_iters)
-
- # losses: same format as |losses| of plot_current_losses
- def print_current_losses(self, epoch, iters, losses, t_comp, t_data):
- """print current losses on console; also save the losses to the disk
-
- Parameters:
- epoch (int) -- current epoch
- iters (int) -- current training iteration during this epoch (reset to 0 at the end of every epoch)
- losses (OrderedDict) -- training losses stored in the format of (name, float) pairs
- t_comp (float) -- computational time per data point (normalized by batch_size)
- t_data (float) -- data loading time per data point (normalized by batch_size)
- """
- message = '(epoch: %d, iters: %d, time: %.3f, data: %.3f) ' % (epoch, iters, t_comp, t_data)
- for k, v in losses.items():
- message += '%s: %.3f ' % (k, v)
-
- print(message) # print the message
- with open(self.log_name, "a") as log_file:
- log_file.write('%s\n' % message) # save the message
-
-
-class MyVisualizer:
- def __init__(self, opt):
- """Initialize the Visualizer class
-
- Parameters:
- opt -- stores all the experiment flags; needs to be a subclass of BaseOptions
- Step 1: Cache the training/test options
- Step 2: create a tensorboard writer
- Step 3: create an HTML object for saveing HTML filters
- Step 4: create a logging file to store training losses
- """
- self.opt = opt # cache the optio
- self.name = opt.name
- self.img_dir = os.path.join(opt.checkpoints_dir, opt.name, 'results')
-
- if opt.phase != 'test':
- self.writer = SummaryWriter(os.path.join(opt.checkpoints_dir, opt.name, 'logs'))
- # create a logging file to store training losses
- self.log_name = os.path.join(opt.checkpoints_dir, opt.name, 'loss_log.txt')
- with open(self.log_name, "a") as log_file:
- now = time.strftime("%c")
- log_file.write('================ Training Loss (%s) ================\n' % now)
-
-
- def display_current_results(self, visuals, total_iters, epoch, dataset='train', save_results=False, count=0, name=None,
- add_image=True):
- """Display current results on tensorboad; save current results to an HTML file.
-
- Parameters:
- visuals (OrderedDict) - - dictionary of images to display or save
- total_iters (int) -- total iterations
- epoch (int) - - the current epoch
- dataset (str) - - 'train' or 'val' or 'test'
- """
- # if (not add_image) and (not save_results): return
-
- for label, image in visuals.items():
- for i in range(image.shape[0]):
- image_numpy = util.tensor2im(image[i])
- if add_image:
- self.writer.add_image(label + '%s_%02d'%(dataset, i + count),
- image_numpy, total_iters, dataformats='HWC')
-
- if save_results:
- save_path = os.path.join(self.img_dir, dataset, 'epoch_%s_%06d'%(epoch, total_iters))
- if not os.path.isdir(save_path):
- os.makedirs(save_path)
-
- if name is not None:
- img_path = os.path.join(save_path, '%s.png' % name)
- else:
- img_path = os.path.join(save_path, '%s_%03d.png' % (label, i + count))
- util.save_image(image_numpy, img_path)
-
-
- def plot_current_losses(self, total_iters, losses, dataset='train'):
- for name, value in losses.items():
- self.writer.add_scalar(name + '/%s'%dataset, value, total_iters)
-
- # losses: same format as |losses| of plot_current_losses
- def print_current_losses(self, epoch, iters, losses, t_comp, t_data, dataset='train'):
- """print current losses on console; also save the losses to the disk
-
- Parameters:
- epoch (int) -- current epoch
- iters (int) -- current training iteration during this epoch (reset to 0 at the end of every epoch)
- losses (OrderedDict) -- training losses stored in the format of (name, float) pairs
- t_comp (float) -- computational time per data point (normalized by batch_size)
- t_data (float) -- data loading time per data point (normalized by batch_size)
- """
- message = '(dataset: %s, epoch: %d, iters: %d, time: %.3f, data: %.3f) ' % (
- dataset, epoch, iters, t_comp, t_data)
- for k, v in losses.items():
- message += '%s: %.3f ' % (k, v)
-
- print(message) # print the message
- with open(self.log_name, "a") as log_file:
- log_file.write('%s\n' % message) # save the message
diff --git a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/models/__init__.py b/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/models/__init__.py
deleted file mode 100644
index ce093adea9504dd24cca4ea90002c3fc1521d30e..0000000000000000000000000000000000000000
--- a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/models/__init__.py
+++ /dev/null
@@ -1,37 +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 ..utils import is_flax_available, is_torch_available
-
-
-if is_torch_available():
- from .adapter import MultiAdapter, T2IAdapter
- from .autoencoder_asym_kl import AsymmetricAutoencoderKL
- from .autoencoder_kl import AutoencoderKL
- from .controlnet import ControlNetModel
- from .dual_transformer_2d import DualTransformer2DModel
- from .modeling_utils import ModelMixin
- from .prior_transformer import PriorTransformer
- from .t5_film_transformer import T5FilmDecoder
- from .transformer_2d import Transformer2DModel
- from .unet_1d import UNet1DModel
- from .unet_2d import UNet2DModel
- from .unet_2d_condition import UNet2DConditionModel
- from .unet_3d_condition import UNet3DConditionModel
- from .vq_model import VQModel
-
-if is_flax_available():
- from .controlnet_flax import FlaxControlNetModel
- from .unet_2d_condition_flax import FlaxUNet2DConditionModel
- from .vae_flax import FlaxAutoencoderKL
diff --git a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/pipelines/audioldm/pipeline_audioldm.py b/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/pipelines/audioldm/pipeline_audioldm.py
deleted file mode 100644
index 1816972e3bb1e2d310854fd12319c2c8dba7b29d..0000000000000000000000000000000000000000
--- a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/pipelines/audioldm/pipeline_audioldm.py
+++ /dev/null
@@ -1,559 +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.
-
-import inspect
-from typing import Any, Callable, Dict, List, Optional, Union
-
-import numpy as np
-import torch
-import torch.nn.functional as F
-from transformers import ClapTextModelWithProjection, RobertaTokenizer, RobertaTokenizerFast, SpeechT5HifiGan
-
-from ...models import AutoencoderKL, UNet2DConditionModel
-from ...schedulers import KarrasDiffusionSchedulers
-from ...utils import logging, randn_tensor, replace_example_docstring
-from ..pipeline_utils import AudioPipelineOutput, DiffusionPipeline
-
-
-logger = logging.get_logger(__name__) # pylint: disable=invalid-name
-
-EXAMPLE_DOC_STRING = """
- Examples:
- ```py
- >>> from diffusers import AudioLDMPipeline
- >>> import torch
- >>> import scipy
-
- >>> repo_id = "cvssp/audioldm-s-full-v2"
- >>> pipe = AudioLDMPipeline.from_pretrained(repo_id, torch_dtype=torch.float16)
- >>> pipe = pipe.to("cuda")
-
- >>> prompt = "Techno music with a strong, upbeat tempo and high melodic riffs"
- >>> audio = pipe(prompt, num_inference_steps=10, audio_length_in_s=5.0).audios[0]
-
- >>> # save the audio sample as a .wav file
- >>> scipy.io.wavfile.write("techno.wav", rate=16000, data=audio)
- ```
-"""
-
-
-class AudioLDMPipeline(DiffusionPipeline):
- r"""
- Pipeline for text-to-audio generation using AudioLDM.
-
- This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods
- implemented for all pipelines (downloading, saving, running on a particular device, etc.).
-
- Args:
- vae ([`AutoencoderKL`]):
- Variational Auto-Encoder (VAE) model to encode and decode images to and from latent representations.
- text_encoder ([`~transformers.ClapTextModelWithProjection`]):
- Frozen text-encoder (`ClapTextModelWithProjection`, specifically the
- [laion/clap-htsat-unfused](https://huggingface.co/laion/clap-htsat-unfused) variant.
- tokenizer ([`PreTrainedTokenizer`]):
- A [`~transformers.RobertaTokenizer`] to tokenize text.
- unet ([`UNet2DConditionModel`]):
- A `UNet2DConditionModel` to denoise the encoded audio latents.
- scheduler ([`SchedulerMixin`]):
- A scheduler to be used in combination with `unet` to denoise the encoded audio latents. Can be one of
- [`DDIMScheduler`], [`LMSDiscreteScheduler`], or [`PNDMScheduler`].
- vocoder ([`~transformers.SpeechT5HifiGan`]):
- Vocoder of class `SpeechT5HifiGan`.
- """
-
- def __init__(
- self,
- vae: AutoencoderKL,
- text_encoder: ClapTextModelWithProjection,
- tokenizer: Union[RobertaTokenizer, RobertaTokenizerFast],
- unet: UNet2DConditionModel,
- scheduler: KarrasDiffusionSchedulers,
- vocoder: SpeechT5HifiGan,
- ):
- super().__init__()
-
- self.register_modules(
- vae=vae,
- text_encoder=text_encoder,
- tokenizer=tokenizer,
- unet=unet,
- scheduler=scheduler,
- vocoder=vocoder,
- )
- self.vae_scale_factor = 2 ** (len(self.vae.config.block_out_channels) - 1)
-
- # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.enable_vae_slicing
- def enable_vae_slicing(self):
- r"""
- Enable sliced VAE decoding. When this option is enabled, the VAE will split the input tensor in slices to
- compute decoding in several steps. This is useful to save some memory and allow larger batch sizes.
- """
- self.vae.enable_slicing()
-
- # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.disable_vae_slicing
- def disable_vae_slicing(self):
- r"""
- Disable sliced VAE decoding. If `enable_vae_slicing` was previously enabled, this method will go back to
- computing decoding in one step.
- """
- self.vae.disable_slicing()
-
- def _encode_prompt(
- self,
- prompt,
- device,
- num_waveforms_per_prompt,
- do_classifier_free_guidance,
- negative_prompt=None,
- prompt_embeds: Optional[torch.FloatTensor] = None,
- negative_prompt_embeds: Optional[torch.FloatTensor] = None,
- ):
- r"""
- Encodes the prompt into text encoder hidden states.
-
- Args:
- prompt (`str` or `List[str]`, *optional*):
- prompt to be encoded
- device (`torch.device`):
- torch device
- num_waveforms_per_prompt (`int`):
- number of waveforms that should be generated per prompt
- do_classifier_free_guidance (`bool`):
- whether to use classifier free guidance or not
- negative_prompt (`str` or `List[str]`, *optional*):
- The prompt or prompts not to guide the audio generation. If not defined, one has to pass
- `negative_prompt_embeds` instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is
- less than `1`).
- prompt_embeds (`torch.FloatTensor`, *optional*):
- Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not
- provided, text embeddings will be generated from `prompt` input argument.
- negative_prompt_embeds (`torch.FloatTensor`, *optional*):
- Pre-generated negative text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt
- weighting. If not provided, negative_prompt_embeds will be generated from `negative_prompt` input
- argument.
- """
- if prompt is not None and isinstance(prompt, str):
- batch_size = 1
- elif prompt is not None and isinstance(prompt, list):
- batch_size = len(prompt)
- else:
- batch_size = prompt_embeds.shape[0]
-
- if prompt_embeds is None:
- text_inputs = self.tokenizer(
- prompt,
- padding="max_length",
- max_length=self.tokenizer.model_max_length,
- truncation=True,
- return_tensors="pt",
- )
- text_input_ids = text_inputs.input_ids
- attention_mask = text_inputs.attention_mask
- untruncated_ids = self.tokenizer(prompt, padding="longest", return_tensors="pt").input_ids
-
- if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(
- text_input_ids, untruncated_ids
- ):
- removed_text = self.tokenizer.batch_decode(
- untruncated_ids[:, self.tokenizer.model_max_length - 1 : -1]
- )
- logger.warning(
- "The following part of your input was truncated because CLAP can only handle sequences up to"
- f" {self.tokenizer.model_max_length} tokens: {removed_text}"
- )
-
- prompt_embeds = self.text_encoder(
- text_input_ids.to(device),
- attention_mask=attention_mask.to(device),
- )
- prompt_embeds = prompt_embeds.text_embeds
- # additional L_2 normalization over each hidden-state
- prompt_embeds = F.normalize(prompt_embeds, dim=-1)
-
- prompt_embeds = prompt_embeds.to(dtype=self.text_encoder.dtype, device=device)
-
- (
- bs_embed,
- seq_len,
- ) = prompt_embeds.shape
- # duplicate text embeddings for each generation per prompt, using mps friendly method
- prompt_embeds = prompt_embeds.repeat(1, num_waveforms_per_prompt)
- prompt_embeds = prompt_embeds.view(bs_embed * num_waveforms_per_prompt, seq_len)
-
- # get unconditional embeddings for classifier free guidance
- if do_classifier_free_guidance and negative_prompt_embeds is None:
- uncond_tokens: List[str]
- if negative_prompt is None:
- uncond_tokens = [""] * batch_size
- elif type(prompt) is not type(negative_prompt):
- raise TypeError(
- f"`negative_prompt` should be the same type to `prompt`, but got {type(negative_prompt)} !="
- f" {type(prompt)}."
- )
- elif isinstance(negative_prompt, str):
- uncond_tokens = [negative_prompt]
- elif batch_size != len(negative_prompt):
- raise ValueError(
- f"`negative_prompt`: {negative_prompt} has batch size {len(negative_prompt)}, but `prompt`:"
- f" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches"
- " the batch size of `prompt`."
- )
- else:
- uncond_tokens = negative_prompt
-
- max_length = prompt_embeds.shape[1]
- uncond_input = self.tokenizer(
- uncond_tokens,
- padding="max_length",
- max_length=max_length,
- truncation=True,
- return_tensors="pt",
- )
-
- uncond_input_ids = uncond_input.input_ids.to(device)
- attention_mask = uncond_input.attention_mask.to(device)
-
- negative_prompt_embeds = self.text_encoder(
- uncond_input_ids,
- attention_mask=attention_mask,
- )
- negative_prompt_embeds = negative_prompt_embeds.text_embeds
- # additional L_2 normalization over each hidden-state
- negative_prompt_embeds = F.normalize(negative_prompt_embeds, dim=-1)
-
- if do_classifier_free_guidance:
- # duplicate unconditional embeddings for each generation per prompt, using mps friendly method
- seq_len = negative_prompt_embeds.shape[1]
-
- negative_prompt_embeds = negative_prompt_embeds.to(dtype=self.text_encoder.dtype, device=device)
-
- negative_prompt_embeds = negative_prompt_embeds.repeat(1, num_waveforms_per_prompt)
- negative_prompt_embeds = negative_prompt_embeds.view(batch_size * num_waveforms_per_prompt, seq_len)
-
- # For classifier free guidance, we need to do two forward passes.
- # Here we concatenate the unconditional and text embeddings into a single batch
- # to avoid doing two forward passes
- prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds])
-
- return prompt_embeds
-
- def decode_latents(self, latents):
- latents = 1 / self.vae.config.scaling_factor * latents
- mel_spectrogram = self.vae.decode(latents).sample
- return mel_spectrogram
-
- def mel_spectrogram_to_waveform(self, mel_spectrogram):
- if mel_spectrogram.dim() == 4:
- mel_spectrogram = mel_spectrogram.squeeze(1)
-
- waveform = self.vocoder(mel_spectrogram)
- # we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16
- waveform = waveform.cpu().float()
- return waveform
-
- # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.prepare_extra_step_kwargs
- def prepare_extra_step_kwargs(self, generator, eta):
- # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
- # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
- # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
- # and should be between [0, 1]
-
- accepts_eta = "eta" in set(inspect.signature(self.scheduler.step).parameters.keys())
- extra_step_kwargs = {}
- if accepts_eta:
- extra_step_kwargs["eta"] = eta
-
- # check if the scheduler accepts generator
- accepts_generator = "generator" in set(inspect.signature(self.scheduler.step).parameters.keys())
- if accepts_generator:
- extra_step_kwargs["generator"] = generator
- return extra_step_kwargs
-
- def check_inputs(
- self,
- prompt,
- audio_length_in_s,
- vocoder_upsample_factor,
- callback_steps,
- negative_prompt=None,
- prompt_embeds=None,
- negative_prompt_embeds=None,
- ):
- min_audio_length_in_s = vocoder_upsample_factor * self.vae_scale_factor
- if audio_length_in_s < min_audio_length_in_s:
- raise ValueError(
- f"`audio_length_in_s` has to be a positive value greater than or equal to {min_audio_length_in_s}, but "
- f"is {audio_length_in_s}."
- )
-
- if self.vocoder.config.model_in_dim % self.vae_scale_factor != 0:
- raise ValueError(
- f"The number of frequency bins in the vocoder's log-mel spectrogram has to be divisible by the "
- f"VAE scale factor, but got {self.vocoder.config.model_in_dim} bins and a scale factor of "
- f"{self.vae_scale_factor}."
- )
-
- if (callback_steps is None) or (
- callback_steps is not None and (not isinstance(callback_steps, int) or callback_steps <= 0)
- ):
- raise ValueError(
- f"`callback_steps` has to be a positive integer but is {callback_steps} of type"
- f" {type(callback_steps)}."
- )
-
- if prompt is not None and prompt_embeds is not None:
- raise ValueError(
- f"Cannot forward both `prompt`: {prompt} and `prompt_embeds`: {prompt_embeds}. Please make sure to"
- " only forward one of the two."
- )
- elif prompt is None and prompt_embeds is None:
- raise ValueError(
- "Provide either `prompt` or `prompt_embeds`. Cannot leave both `prompt` and `prompt_embeds` undefined."
- )
- elif prompt is not None and (not isinstance(prompt, str) and not isinstance(prompt, list)):
- raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}")
-
- if negative_prompt is not None and negative_prompt_embeds is not None:
- raise ValueError(
- f"Cannot forward both `negative_prompt`: {negative_prompt} and `negative_prompt_embeds`:"
- f" {negative_prompt_embeds}. Please make sure to only forward one of the two."
- )
-
- if prompt_embeds is not None and negative_prompt_embeds is not None:
- if prompt_embeds.shape != negative_prompt_embeds.shape:
- raise ValueError(
- "`prompt_embeds` and `negative_prompt_embeds` must have the same shape when passed directly, but"
- f" got: `prompt_embeds` {prompt_embeds.shape} != `negative_prompt_embeds`"
- f" {negative_prompt_embeds.shape}."
- )
-
- # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.prepare_latents with width->self.vocoder.config.model_in_dim
- def prepare_latents(self, batch_size, num_channels_latents, height, dtype, device, generator, latents=None):
- shape = (
- batch_size,
- num_channels_latents,
- height // self.vae_scale_factor,
- self.vocoder.config.model_in_dim // self.vae_scale_factor,
- )
- if isinstance(generator, list) and len(generator) != batch_size:
- raise ValueError(
- f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
- f" size of {batch_size}. Make sure the batch size matches the length of the generators."
- )
-
- if latents is None:
- latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
- else:
- latents = latents.to(device)
-
- # scale the initial noise by the standard deviation required by the scheduler
- latents = latents * self.scheduler.init_noise_sigma
- return latents
-
- @torch.no_grad()
- @replace_example_docstring(EXAMPLE_DOC_STRING)
- def __call__(
- self,
- prompt: Union[str, List[str]] = None,
- audio_length_in_s: Optional[float] = None,
- num_inference_steps: int = 10,
- guidance_scale: float = 2.5,
- negative_prompt: Optional[Union[str, List[str]]] = None,
- num_waveforms_per_prompt: Optional[int] = 1,
- eta: float = 0.0,
- generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
- latents: Optional[torch.FloatTensor] = None,
- prompt_embeds: Optional[torch.FloatTensor] = None,
- negative_prompt_embeds: Optional[torch.FloatTensor] = None,
- return_dict: bool = True,
- callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None,
- callback_steps: Optional[int] = 1,
- cross_attention_kwargs: Optional[Dict[str, Any]] = None,
- output_type: Optional[str] = "np",
- ):
- r"""
- The call function to the pipeline for generation.
-
- Args:
- prompt (`str` or `List[str]`, *optional*):
- The prompt or prompts to guide audio generation. If not defined, you need to pass `prompt_embeds`.
- audio_length_in_s (`int`, *optional*, defaults to 5.12):
- The length of the generated audio sample in seconds.
- num_inference_steps (`int`, *optional*, defaults to 10):
- The number of denoising steps. More denoising steps usually lead to a higher quality audio at the
- expense of slower inference.
- guidance_scale (`float`, *optional*, defaults to 2.5):
- A higher guidance scale value encourages the model to generate audio that is closely linked to the text
- `prompt` at the expense of lower sound quality. Guidance scale is enabled when `guidance_scale > 1`.
- negative_prompt (`str` or `List[str]`, *optional*):
- The prompt or prompts to guide what to not include in audio generation. If not defined, you need to
- pass `negative_prompt_embeds` instead. Ignored when not using guidance (`guidance_scale < 1`).
- num_waveforms_per_prompt (`int`, *optional*, defaults to 1):
- The number of waveforms to generate per prompt.
- eta (`float`, *optional*, defaults to 0.0):
- Corresponds to parameter eta (η) from the [DDIM](https://arxiv.org/abs/2010.02502) paper. Only applies
- to the [`~schedulers.DDIMScheduler`], and is ignored in other schedulers.
- generator (`torch.Generator` or `List[torch.Generator]`, *optional*):
- A [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) to make
- generation deterministic.
- latents (`torch.FloatTensor`, *optional*):
- Pre-generated noisy latents sampled from a Gaussian distribution, to be used as inputs for image
- generation. Can be used to tweak the same generation with different prompts. If not provided, a latents
- tensor is generated by sampling using the supplied random `generator`.
- prompt_embeds (`torch.FloatTensor`, *optional*):
- Pre-generated text embeddings. Can be used to easily tweak text inputs (prompt weighting). If not
- provided, text embeddings are generated from the `prompt` input argument.
- negative_prompt_embeds (`torch.FloatTensor`, *optional*):
- Pre-generated negative text embeddings. Can be used to easily tweak text inputs (prompt weighting). If
- not provided, `negative_prompt_embeds` are generated from the `negative_prompt` input argument.
- return_dict (`bool`, *optional*, defaults to `True`):
- Whether or not to return a [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] instead of a
- plain tuple.
- callback (`Callable`, *optional*):
- A function that calls every `callback_steps` steps during inference. The function is called with the
- following arguments: `callback(step: int, timestep: int, latents: torch.FloatTensor)`.
- callback_steps (`int`, *optional*, defaults to 1):
- The frequency at which the `callback` function is called. If not specified, the callback is called at
- every step.
- cross_attention_kwargs (`dict`, *optional*):
- A kwargs dictionary that if specified is passed along to the [`AttentionProcessor`] as defined in
- [`self.processor`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/cross_attention.py).
- output_type (`str`, *optional*, defaults to `"np"`):
- The output format of the generated image. Choose between `"np"` to return a NumPy `np.ndarray` or
- `"pt"` to return a PyTorch `torch.Tensor` object.
-
- Examples:
-
- Returns:
- [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] or `tuple`:
- If `return_dict` is `True`, [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] is returned,
- otherwise a `tuple` is returned where the first element is a list with the generated audio.
- """
- # 0. Convert audio input length from seconds to spectrogram height
- vocoder_upsample_factor = np.prod(self.vocoder.config.upsample_rates) / self.vocoder.config.sampling_rate
-
- if audio_length_in_s is None:
- audio_length_in_s = self.unet.config.sample_size * self.vae_scale_factor * vocoder_upsample_factor
-
- height = int(audio_length_in_s / vocoder_upsample_factor)
-
- original_waveform_length = int(audio_length_in_s * self.vocoder.config.sampling_rate)
- if height % self.vae_scale_factor != 0:
- height = int(np.ceil(height / self.vae_scale_factor)) * self.vae_scale_factor
- logger.info(
- f"Audio length in seconds {audio_length_in_s} is increased to {height * vocoder_upsample_factor} "
- f"so that it can be handled by the model. It will be cut to {audio_length_in_s} after the "
- f"denoising process."
- )
-
- # 1. Check inputs. Raise error if not correct
- self.check_inputs(
- prompt,
- audio_length_in_s,
- vocoder_upsample_factor,
- callback_steps,
- negative_prompt,
- prompt_embeds,
- negative_prompt_embeds,
- )
-
- # 2. Define call parameters
- if prompt is not None and isinstance(prompt, str):
- batch_size = 1
- elif prompt is not None and isinstance(prompt, list):
- batch_size = len(prompt)
- else:
- batch_size = prompt_embeds.shape[0]
-
- device = self._execution_device
- # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
- # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
- # corresponds to doing no classifier free guidance.
- do_classifier_free_guidance = guidance_scale > 1.0
-
- # 3. Encode input prompt
- prompt_embeds = self._encode_prompt(
- prompt,
- device,
- num_waveforms_per_prompt,
- do_classifier_free_guidance,
- negative_prompt,
- prompt_embeds=prompt_embeds,
- negative_prompt_embeds=negative_prompt_embeds,
- )
-
- # 4. Prepare timesteps
- self.scheduler.set_timesteps(num_inference_steps, device=device)
- timesteps = self.scheduler.timesteps
-
- # 5. Prepare latent variables
- num_channels_latents = self.unet.config.in_channels
- latents = self.prepare_latents(
- batch_size * num_waveforms_per_prompt,
- num_channels_latents,
- height,
- prompt_embeds.dtype,
- device,
- generator,
- latents,
- )
-
- # 6. Prepare extra step kwargs
- extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta)
-
- # 7. Denoising loop
- num_warmup_steps = len(timesteps) - num_inference_steps * self.scheduler.order
- with self.progress_bar(total=num_inference_steps) as progress_bar:
- for i, t in enumerate(timesteps):
- # expand the latents if we are doing classifier free guidance
- latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents
- latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)
-
- # predict the noise residual
- noise_pred = self.unet(
- latent_model_input,
- t,
- encoder_hidden_states=None,
- class_labels=prompt_embeds,
- cross_attention_kwargs=cross_attention_kwargs,
- ).sample
-
- # perform guidance
- if do_classifier_free_guidance:
- noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
- noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
-
- # compute the previous noisy sample x_t -> x_t-1
- latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs).prev_sample
-
- # call the callback, if provided
- if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):
- progress_bar.update()
- if callback is not None and i % callback_steps == 0:
- callback(i, t, latents)
-
- # 8. Post-processing
- mel_spectrogram = self.decode_latents(latents)
-
- audio = self.mel_spectrogram_to_waveform(mel_spectrogram)
-
- audio = audio[:, :original_waveform_length]
-
- if output_type == "np":
- audio = audio.numpy()
-
- if not return_dict:
- return (audio,)
-
- return AudioPipelineOutput(audios=audio)
diff --git a/spaces/Andy1621/uniformer_image_detection/mmdet/core/__init__.py b/spaces/Andy1621/uniformer_image_detection/mmdet/core/__init__.py
deleted file mode 100644
index e812391e23894ef296755381386d4849f774418a..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_detection/mmdet/core/__init__.py
+++ /dev/null
@@ -1,7 +0,0 @@
-from .anchor import * # noqa: F401, F403
-from .bbox import * # noqa: F401, F403
-from .evaluation import * # noqa: F401, F403
-from .export import * # noqa: F401, F403
-from .mask import * # noqa: F401, F403
-from .post_processing import * # noqa: F401, F403
-from .utils import * # noqa: F401, F403
diff --git a/spaces/Andy1621/uniformer_image_detection/tools/model_converters/detectron2pytorch.py b/spaces/Andy1621/uniformer_image_detection/tools/model_converters/detectron2pytorch.py
deleted file mode 100644
index 961e6f571b785f01236a660651323cc6372e8189..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_detection/tools/model_converters/detectron2pytorch.py
+++ /dev/null
@@ -1,82 +0,0 @@
-import argparse
-from collections import OrderedDict
-
-import mmcv
-import torch
-
-arch_settings = {50: (3, 4, 6, 3), 101: (3, 4, 23, 3)}
-
-
-def convert_bn(blobs, state_dict, caffe_name, torch_name, converted_names):
- # detectron replace bn with affine channel layer
- state_dict[torch_name + '.bias'] = torch.from_numpy(blobs[caffe_name +
- '_b'])
- state_dict[torch_name + '.weight'] = torch.from_numpy(blobs[caffe_name +
- '_s'])
- bn_size = state_dict[torch_name + '.weight'].size()
- state_dict[torch_name + '.running_mean'] = torch.zeros(bn_size)
- state_dict[torch_name + '.running_var'] = torch.ones(bn_size)
- converted_names.add(caffe_name + '_b')
- converted_names.add(caffe_name + '_s')
-
-
-def convert_conv_fc(blobs, state_dict, caffe_name, torch_name,
- converted_names):
- state_dict[torch_name + '.weight'] = torch.from_numpy(blobs[caffe_name +
- '_w'])
- converted_names.add(caffe_name + '_w')
- if caffe_name + '_b' in blobs:
- state_dict[torch_name + '.bias'] = torch.from_numpy(blobs[caffe_name +
- '_b'])
- converted_names.add(caffe_name + '_b')
-
-
-def convert(src, dst, depth):
- """Convert keys in detectron pretrained ResNet models to pytorch style."""
- # load arch_settings
- if depth not in arch_settings:
- raise ValueError('Only support ResNet-50 and ResNet-101 currently')
- block_nums = arch_settings[depth]
- # load caffe model
- caffe_model = mmcv.load(src, encoding='latin1')
- blobs = caffe_model['blobs'] if 'blobs' in caffe_model else caffe_model
- # convert to pytorch style
- state_dict = OrderedDict()
- converted_names = set()
- convert_conv_fc(blobs, state_dict, 'conv1', 'conv1', converted_names)
- convert_bn(blobs, state_dict, 'res_conv1_bn', 'bn1', converted_names)
- for i in range(1, len(block_nums) + 1):
- for j in range(block_nums[i - 1]):
- if j == 0:
- convert_conv_fc(blobs, state_dict, f'res{i + 1}_{j}_branch1',
- f'layer{i}.{j}.downsample.0', converted_names)
- convert_bn(blobs, state_dict, f'res{i + 1}_{j}_branch1_bn',
- f'layer{i}.{j}.downsample.1', converted_names)
- for k, letter in enumerate(['a', 'b', 'c']):
- convert_conv_fc(blobs, state_dict,
- f'res{i + 1}_{j}_branch2{letter}',
- f'layer{i}.{j}.conv{k+1}', converted_names)
- convert_bn(blobs, state_dict,
- f'res{i + 1}_{j}_branch2{letter}_bn',
- f'layer{i}.{j}.bn{k + 1}', converted_names)
- # check if all layers are converted
- for key in blobs:
- if key not in converted_names:
- print(f'Not Convert: {key}')
- # save checkpoint
- checkpoint = dict()
- checkpoint['state_dict'] = state_dict
- torch.save(checkpoint, dst)
-
-
-def main():
- parser = argparse.ArgumentParser(description='Convert model keys')
- parser.add_argument('src', help='src detectron model path')
- parser.add_argument('dst', help='save path')
- parser.add_argument('depth', type=int, help='ResNet model depth')
- args = parser.parse_args()
- convert(args.src, args.dst, args.depth)
-
-
-if __name__ == '__main__':
- main()
diff --git a/spaces/Andy1621/uniformer_image_segmentation/configs/danet/danet_r50-d8_512x512_80k_ade20k.py b/spaces/Andy1621/uniformer_image_segmentation/configs/danet/danet_r50-d8_512x512_80k_ade20k.py
deleted file mode 100644
index 154e84890ed73fe4813dddc8c321de6cd2854fc1..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_segmentation/configs/danet/danet_r50-d8_512x512_80k_ade20k.py
+++ /dev/null
@@ -1,6 +0,0 @@
-_base_ = [
- '../_base_/models/danet_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/Andy1621/uniformer_image_segmentation/configs/fcn/fcn_r101-d8_480x480_80k_pascal_context_59.py b/spaces/Andy1621/uniformer_image_segmentation/configs/fcn/fcn_r101-d8_480x480_80k_pascal_context_59.py
deleted file mode 100644
index 09cb612e42056133ff4b061e8cd934f0f650d717..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_segmentation/configs/fcn/fcn_r101-d8_480x480_80k_pascal_context_59.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './fcn_r50-d8_480x480_80k_pascal_context_59.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/spaces/Andy1621/uniformer_image_segmentation/configs/nonlocal_net/nonlocal_r50-d8_512x512_80k_ade20k.py b/spaces/Andy1621/uniformer_image_segmentation/configs/nonlocal_net/nonlocal_r50-d8_512x512_80k_ade20k.py
deleted file mode 100644
index 8a7a2f509ba6627ad5ab972ac090362bbcd2ecb7..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_segmentation/configs/nonlocal_net/nonlocal_r50-d8_512x512_80k_ade20k.py
+++ /dev/null
@@ -1,6 +0,0 @@
-_base_ = [
- '../_base_/models/nonlocal_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/Anonymous-sub/Rerender/ControlNet/annotator/midas/midas/base_model.py b/spaces/Anonymous-sub/Rerender/ControlNet/annotator/midas/midas/base_model.py
deleted file mode 100644
index 5cf430239b47ec5ec07531263f26f5c24a2311cd..0000000000000000000000000000000000000000
--- a/spaces/Anonymous-sub/Rerender/ControlNet/annotator/midas/midas/base_model.py
+++ /dev/null
@@ -1,16 +0,0 @@
-import torch
-
-
-class BaseModel(torch.nn.Module):
- def load(self, path):
- """Load model from file.
-
- Args:
- path (str): file path
- """
- parameters = torch.load(path, map_location=torch.device('cpu'))
-
- if "optimizer" in parameters:
- parameters = parameters["model"]
-
- self.load_state_dict(parameters)
diff --git a/spaces/Anonymous-sub/Rerender/ControlNet/ldm/models/autoencoder.py b/spaces/Anonymous-sub/Rerender/ControlNet/ldm/models/autoencoder.py
deleted file mode 100644
index d122549995ce2cd64092c81a58419ed4a15a02fd..0000000000000000000000000000000000000000
--- a/spaces/Anonymous-sub/Rerender/ControlNet/ldm/models/autoencoder.py
+++ /dev/null
@@ -1,219 +0,0 @@
-import torch
-import pytorch_lightning as pl
-import torch.nn.functional as F
-from contextlib import contextmanager
-
-from ldm.modules.diffusionmodules.model import Encoder, Decoder
-from ldm.modules.distributions.distributions import DiagonalGaussianDistribution
-
-from ldm.util import instantiate_from_config
-from ldm.modules.ema import LitEma
-
-
-class AutoencoderKL(pl.LightningModule):
- def __init__(self,
- ddconfig,
- lossconfig,
- embed_dim,
- ckpt_path=None,
- ignore_keys=[],
- image_key="image",
- colorize_nlabels=None,
- monitor=None,
- ema_decay=None,
- learn_logvar=False
- ):
- super().__init__()
- self.learn_logvar = learn_logvar
- self.image_key = image_key
- self.encoder = Encoder(**ddconfig)
- self.decoder = Decoder(**ddconfig)
- self.loss = instantiate_from_config(lossconfig)
- assert ddconfig["double_z"]
- self.quant_conv = torch.nn.Conv2d(2*ddconfig["z_channels"], 2*embed_dim, 1)
- self.post_quant_conv = torch.nn.Conv2d(embed_dim, ddconfig["z_channels"], 1)
- self.embed_dim = embed_dim
- if colorize_nlabels is not None:
- assert type(colorize_nlabels)==int
- self.register_buffer("colorize", torch.randn(3, colorize_nlabels, 1, 1))
- if monitor is not None:
- self.monitor = monitor
-
- self.use_ema = ema_decay is not None
- if self.use_ema:
- self.ema_decay = ema_decay
- assert 0. < ema_decay < 1.
- self.model_ema = LitEma(self, decay=ema_decay)
- print(f"Keeping EMAs of {len(list(self.model_ema.buffers()))}.")
-
- if ckpt_path is not None:
- self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys)
-
- def init_from_ckpt(self, path, ignore_keys=list()):
- sd = torch.load(path, map_location="cpu")["state_dict"]
- keys = list(sd.keys())
- for k in keys:
- for ik in ignore_keys:
- if k.startswith(ik):
- print("Deleting key {} from state_dict.".format(k))
- del sd[k]
- self.load_state_dict(sd, strict=False)
- print(f"Restored from {path}")
-
- @contextmanager
- def ema_scope(self, context=None):
- if self.use_ema:
- self.model_ema.store(self.parameters())
- self.model_ema.copy_to(self)
- if context is not None:
- print(f"{context}: Switched to EMA weights")
- try:
- yield None
- finally:
- if self.use_ema:
- self.model_ema.restore(self.parameters())
- if context is not None:
- print(f"{context}: Restored training weights")
-
- def on_train_batch_end(self, *args, **kwargs):
- if self.use_ema:
- self.model_ema(self)
-
- def encode(self, x):
- h = self.encoder(x)
- moments = self.quant_conv(h)
- posterior = DiagonalGaussianDistribution(moments)
- return posterior
-
- def decode(self, z):
- z = self.post_quant_conv(z)
- dec = self.decoder(z)
- return dec
-
- def forward(self, input, sample_posterior=True):
- posterior = self.encode(input)
- if sample_posterior:
- z = posterior.sample()
- else:
- z = posterior.mode()
- dec = self.decode(z)
- return dec, posterior
-
- def get_input(self, batch, k):
- x = batch[k]
- if len(x.shape) == 3:
- x = x[..., None]
- x = x.permute(0, 3, 1, 2).to(memory_format=torch.contiguous_format).float()
- return x
-
- def training_step(self, batch, batch_idx, optimizer_idx):
- inputs = self.get_input(batch, self.image_key)
- reconstructions, posterior = self(inputs)
-
- if optimizer_idx == 0:
- # train encoder+decoder+logvar
- aeloss, log_dict_ae = self.loss(inputs, reconstructions, posterior, optimizer_idx, self.global_step,
- last_layer=self.get_last_layer(), split="train")
- self.log("aeloss", aeloss, prog_bar=True, logger=True, on_step=True, on_epoch=True)
- self.log_dict(log_dict_ae, prog_bar=False, logger=True, on_step=True, on_epoch=False)
- return aeloss
-
- if optimizer_idx == 1:
- # train the discriminator
- discloss, log_dict_disc = self.loss(inputs, reconstructions, posterior, optimizer_idx, self.global_step,
- last_layer=self.get_last_layer(), split="train")
-
- self.log("discloss", discloss, prog_bar=True, logger=True, on_step=True, on_epoch=True)
- self.log_dict(log_dict_disc, prog_bar=False, logger=True, on_step=True, on_epoch=False)
- return discloss
-
- def validation_step(self, batch, batch_idx):
- log_dict = self._validation_step(batch, batch_idx)
- with self.ema_scope():
- log_dict_ema = self._validation_step(batch, batch_idx, postfix="_ema")
- return log_dict
-
- def _validation_step(self, batch, batch_idx, postfix=""):
- inputs = self.get_input(batch, self.image_key)
- reconstructions, posterior = self(inputs)
- aeloss, log_dict_ae = self.loss(inputs, reconstructions, posterior, 0, self.global_step,
- last_layer=self.get_last_layer(), split="val"+postfix)
-
- discloss, log_dict_disc = self.loss(inputs, reconstructions, posterior, 1, self.global_step,
- last_layer=self.get_last_layer(), split="val"+postfix)
-
- self.log(f"val{postfix}/rec_loss", log_dict_ae[f"val{postfix}/rec_loss"])
- self.log_dict(log_dict_ae)
- self.log_dict(log_dict_disc)
- return self.log_dict
-
- def configure_optimizers(self):
- lr = self.learning_rate
- ae_params_list = list(self.encoder.parameters()) + list(self.decoder.parameters()) + list(
- self.quant_conv.parameters()) + list(self.post_quant_conv.parameters())
- if self.learn_logvar:
- print(f"{self.__class__.__name__}: Learning logvar")
- ae_params_list.append(self.loss.logvar)
- opt_ae = torch.optim.Adam(ae_params_list,
- lr=lr, betas=(0.5, 0.9))
- opt_disc = torch.optim.Adam(self.loss.discriminator.parameters(),
- lr=lr, betas=(0.5, 0.9))
- return [opt_ae, opt_disc], []
-
- def get_last_layer(self):
- return self.decoder.conv_out.weight
-
- @torch.no_grad()
- def log_images(self, batch, only_inputs=False, log_ema=False, **kwargs):
- log = dict()
- x = self.get_input(batch, self.image_key)
- x = x.to(self.device)
- if not only_inputs:
- xrec, posterior = self(x)
- if x.shape[1] > 3:
- # colorize with random projection
- assert xrec.shape[1] > 3
- x = self.to_rgb(x)
- xrec = self.to_rgb(xrec)
- log["samples"] = self.decode(torch.randn_like(posterior.sample()))
- log["reconstructions"] = xrec
- if log_ema or self.use_ema:
- with self.ema_scope():
- xrec_ema, posterior_ema = self(x)
- if x.shape[1] > 3:
- # colorize with random projection
- assert xrec_ema.shape[1] > 3
- xrec_ema = self.to_rgb(xrec_ema)
- log["samples_ema"] = self.decode(torch.randn_like(posterior_ema.sample()))
- log["reconstructions_ema"] = xrec_ema
- log["inputs"] = x
- return log
-
- def to_rgb(self, x):
- assert self.image_key == "segmentation"
- if not hasattr(self, "colorize"):
- self.register_buffer("colorize", torch.randn(3, x.shape[1], 1, 1).to(x))
- x = F.conv2d(x, weight=self.colorize)
- x = 2.*(x-x.min())/(x.max()-x.min()) - 1.
- return x
-
-
-class IdentityFirstStage(torch.nn.Module):
- def __init__(self, *args, vq_interface=False, **kwargs):
- self.vq_interface = vq_interface
- super().__init__()
-
- def encode(self, x, *args, **kwargs):
- return x
-
- def decode(self, x, *args, **kwargs):
- return x
-
- def quantize(self, x, *args, **kwargs):
- if self.vq_interface:
- return x, None, [None, None, None]
- return x
-
- def forward(self, x, *args, **kwargs):
- return x
-
diff --git a/spaces/ArchitSharma/Digital-Photo-Color-Restoration/app.py b/spaces/ArchitSharma/Digital-Photo-Color-Restoration/app.py
deleted file mode 100644
index 49d56df4a9027bab49e40408722c03a5a0674e23..0000000000000000000000000000000000000000
--- a/spaces/ArchitSharma/Digital-Photo-Color-Restoration/app.py
+++ /dev/null
@@ -1,149 +0,0 @@
-# Based on: https://github.com/jantic/DeOldify
-import os, re, time
-
-os.environ["TORCH_HOME"] = os.path.join(os.getcwd(), ".cache")
-os.environ["XDG_CACHE_HOME"] = os.path.join(os.getcwd(), ".cache")
-
-import streamlit as st
-import PIL
-import cv2
-import numpy as np
-import uuid
-from zipfile import ZipFile, ZIP_DEFLATED
-from io import BytesIO
-from random import randint
-from datetime import datetime
-
-from src.deoldify import device
-from src.deoldify.device_id import DeviceId
-from src.deoldify.visualize import *
-from src.app_utils import get_model_bin
-
-
-device.set(device=DeviceId.CPU)
-
-
-@st.cache_resource
-def load_model(model_dir, option):
- if option.lower() == 'artistic':
- model_url = 'https://data.deepai.org/deoldify/ColorizeArtistic_gen.pth'
- get_model_bin(model_url, os.path.join(model_dir, "ColorizeArtistic_gen.pth"))
- colorizer = get_image_colorizer(artistic=True)
- elif option.lower() == 'stable':
- model_url = "https://www.dropbox.com/s/usf7uifrctqw9rl/ColorizeStable_gen.pth?dl=0"
- get_model_bin(model_url, os.path.join(model_dir, "ColorizeStable_gen.pth"))
- colorizer = get_image_colorizer(artistic=False)
-
- return colorizer
-
-
-def resize_img(input_img, max_size):
- img = input_img.copy()
- img_height, img_width = img.shape[0],img.shape[1]
-
- if max(img_height, img_width) > max_size:
- if img_height > img_width:
- new_width = img_width*(max_size/img_height)
- new_height = max_size
- resized_img = cv2.resize(img,(int(new_width), int(new_height)))
- return resized_img
-
- elif img_height <= img_width:
- new_width = img_height*(max_size/img_width)
- new_height = max_size
- resized_img = cv2.resize(img,(int(new_width), int(new_height)))
- return resized_img
-
- return img
-
-
-def colorize_image(pil_image, img_size=800) -> "PIL.Image":
- # Open the image
- pil_img = pil_image.convert("RGB")
- img_rgb = np.array(pil_img)
- resized_img_rgb = resize_img(img_rgb, img_size)
- resized_pil_img = PIL.Image.fromarray(resized_img_rgb)
-
- # Send the image to the model
- output_pil_img = colorizer.plot_transformed_pil_image(resized_pil_img, render_factor=35, compare=False)
-
- return output_pil_img
-
-
-def image_download_button(pil_image, filename: str, fmt: str, label="Download"):
- if fmt not in ["jpg", "png"]:
- raise Exception(f"Unknown image format (Available: {fmt} - case sensitive)")
-
- pil_format = "JPEG" if fmt == "jpg" else "PNG"
- file_format = "jpg" if fmt == "jpg" else "png"
- mime = "image/jpeg" if fmt == "jpg" else "image/png"
-
- buf = BytesIO()
- pil_image.save(buf, format=pil_format)
-
- return st.download_button(
- label=label,
- data=buf.getvalue(),
- file_name=f'{filename}.{file_format}',
- mime=mime,
- )
-
-
-###########################
-###### STREAMLIT CODE #####
-###########################
-
-
-st_color_option = "Artistic"
-
-# Load models
-try:
- with st.spinner("Loading..."):
- print('before loading the model')
- colorizer = load_model('models/', st_color_option)
- print('after loading the model')
-
-except Exception as e:
- colorizer = None
- print('Error while loading the model. Please refresh the page')
- print(e)
- st.write("**App loading error. Please try again later.**")
-
-
-
-if colorizer is not None:
- st.title("Digital Photo Color Restoration")
-
- uploaded_file = st.file_uploader("Upload photo", accept_multiple_files=False, type=["png", "jpg", "jpeg"])
-
- if uploaded_file is not None:
- bytes_data = uploaded_file.getvalue()
- img_input = PIL.Image.open(BytesIO(bytes_data)).convert("RGB")
-
- with st.expander("Original photo", True):
- st.image(img_input)
-
- if st.button("Restore Color!") and uploaded_file is not None:
-
- with st.spinner("AI is doing the magic!"):
- img_output = colorize_image(img_input)
- img_output = img_output.resize(img_input.size)
-
- # NOTE: Calm! I'm not logging the input and outputs.
- # It is impossible to access the filesystem in spaces environment.
- now = datetime.now().strftime("%Y%m%d-%H%M%S-%f")
- img_input.convert("RGB").save(f"./output/{now}-input.jpg")
- img_output.convert("RGB").save(f"./output/{now}-output.jpg")
-
- st.write("AI has finished the job!")
- st.image(img_output)
- # reuse = st.button('Edit again (Re-use this image)', on_click=set_image, args=(inpainted_img, ))
-
- uploaded_name = os.path.splitext(uploaded_file.name)[0]
- image_download_button(
- pil_image=img_output,
- filename=uploaded_name,
- fmt="jpg",
- label="Download Image"
- )
-
\ No newline at end of file
diff --git a/spaces/AriaMei/TTSdemo/models.py b/spaces/AriaMei/TTSdemo/models.py
deleted file mode 100644
index b1b35b4072179b9f12e12bfb8b4e953999adb71a..0000000000000000000000000000000000000000
--- a/spaces/AriaMei/TTSdemo/models.py
+++ /dev/null
@@ -1,537 +0,0 @@
-import copy
-import math
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-import commons
-import modules
-import attentions
-# import monotonic_align
-
-from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
-from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
-from commons import init_weights, get_padding
-
-
-class StochasticDurationPredictor(nn.Module):
- def __init__(self, in_channels, filter_channels, kernel_size, p_dropout, n_flows=4, gin_channels=0):
- super().__init__()
- filter_channels = in_channels # it needs to be removed from future version.
- self.in_channels = in_channels
- self.filter_channels = filter_channels
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.n_flows = n_flows
- self.gin_channels = gin_channels
-
- self.log_flow = modules.Log()
- self.flows = nn.ModuleList()
- self.flows.append(modules.ElementwiseAffine(2))
- for i in range(n_flows):
- self.flows.append(modules.ConvFlow(2, filter_channels, kernel_size, n_layers=3))
- self.flows.append(modules.Flip())
-
- self.post_pre = nn.Conv1d(1, filter_channels, 1)
- self.post_proj = nn.Conv1d(filter_channels, filter_channels, 1)
- self.post_convs = modules.DDSConv(filter_channels, kernel_size, n_layers=3, p_dropout=p_dropout)
- self.post_flows = nn.ModuleList()
- self.post_flows.append(modules.ElementwiseAffine(2))
- for i in range(4):
- self.post_flows.append(modules.ConvFlow(2, filter_channels, kernel_size, n_layers=3))
- self.post_flows.append(modules.Flip())
-
- self.pre = nn.Conv1d(in_channels, filter_channels, 1)
- self.proj = nn.Conv1d(filter_channels, filter_channels, 1)
- self.convs = modules.DDSConv(filter_channels, kernel_size, n_layers=3, p_dropout=p_dropout)
- if gin_channels != 0:
- self.cond = nn.Conv1d(gin_channels, filter_channels, 1)
-
- def forward(self, x, x_mask, w=None, g=None, reverse=False, noise_scale=1.0):
- x = torch.detach(x)
- x = self.pre(x)
- if g is not None:
- g = torch.detach(g)
- x = x + self.cond(g)
- x = self.convs(x, x_mask)
- x = self.proj(x) * x_mask
-
- if not reverse:
- flows = self.flows
- assert w is not None
-
- logdet_tot_q = 0
- h_w = self.post_pre(w)
- h_w = self.post_convs(h_w, x_mask)
- h_w = self.post_proj(h_w) * x_mask
- e_q = torch.randn(w.size(0), 2, w.size(2)).to(device=x.device, dtype=x.dtype) * x_mask
- z_q = e_q
- for flow in self.post_flows:
- z_q, logdet_q = flow(z_q, x_mask, g=(x + h_w))
- logdet_tot_q += logdet_q
- z_u, z1 = torch.split(z_q, [1, 1], 1)
- u = torch.sigmoid(z_u) * x_mask
- z0 = (w - u) * x_mask
- logdet_tot_q += torch.sum((F.logsigmoid(z_u) + F.logsigmoid(-z_u)) * x_mask, [1,2])
- logq = torch.sum(-0.5 * (math.log(2*math.pi) + (e_q**2)) * x_mask, [1,2]) - logdet_tot_q
-
- logdet_tot = 0
- z0, logdet = self.log_flow(z0, x_mask)
- logdet_tot += logdet
- z = torch.cat([z0, z1], 1)
- for flow in flows:
- z, logdet = flow(z, x_mask, g=x, reverse=reverse)
- logdet_tot = logdet_tot + logdet
- nll = torch.sum(0.5 * (math.log(2*math.pi) + (z**2)) * x_mask, [1,2]) - logdet_tot
- return nll + logq # [b]
- else:
- flows = list(reversed(self.flows))
- flows = flows[:-2] + [flows[-1]] # remove a useless vflow
- z = torch.randn(x.size(0), 2, x.size(2)).to(device=x.device, dtype=x.dtype) * noise_scale
- for flow in flows:
- z = flow(z, x_mask, g=x, reverse=reverse)
- z0, z1 = torch.split(z, [1, 1], 1)
- logw = z0
- return logw
-
-
-class DurationPredictor(nn.Module):
- def __init__(self, in_channels, filter_channels, kernel_size, p_dropout, gin_channels=0):
- super().__init__()
-
- self.in_channels = in_channels
- self.filter_channels = filter_channels
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.gin_channels = gin_channels
-
- self.drop = nn.Dropout(p_dropout)
- self.conv_1 = nn.Conv1d(in_channels, filter_channels, kernel_size, padding=kernel_size//2)
- self.norm_1 = modules.LayerNorm(filter_channels)
- self.conv_2 = nn.Conv1d(filter_channels, filter_channels, kernel_size, padding=kernel_size//2)
- self.norm_2 = modules.LayerNorm(filter_channels)
- self.proj = nn.Conv1d(filter_channels, 1, 1)
-
- if gin_channels != 0:
- self.cond = nn.Conv1d(gin_channels, in_channels, 1)
-
- def forward(self, x, x_mask, g=None):
- x = torch.detach(x)
- if g is not None:
- g = torch.detach(g)
- x = x + self.cond(g)
- x = self.conv_1(x * x_mask)
- x = torch.relu(x)
- x = self.norm_1(x)
- x = self.drop(x)
- x = self.conv_2(x * x_mask)
- x = torch.relu(x)
- x = self.norm_2(x)
- x = self.drop(x)
- x = self.proj(x * x_mask)
- return x * x_mask
-
-
-class TextEncoder(nn.Module):
- def __init__(self,
- n_vocab,
- out_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout):
- super().__init__()
- self.n_vocab = n_vocab
- self.out_channels = out_channels
- self.hidden_channels = hidden_channels
- self.filter_channels = filter_channels
- self.n_heads = n_heads
- self.n_layers = n_layers
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
-
- self.emb = nn.Embedding(n_vocab, hidden_channels)
- self.emo_proj = nn.Linear(1024, hidden_channels)
-
- nn.init.normal_(self.emb.weight, 0.0, hidden_channels**-0.5)
-
- self.encoder = attentions.Encoder(
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout)
- self.proj= nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
- def forward(self, x, x_lengths, emo):
- x = self.emb(x) * math.sqrt(self.hidden_channels) # [b, t, h]
- x = x + self.emo_proj(emo.unsqueeze(1))
- x = torch.transpose(x, 1, -1) # [b, h, t]
- x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
-
- x = self.encoder(x * x_mask, x_mask)
- stats = self.proj(x) * x_mask
-
- m, logs = torch.split(stats, self.out_channels, dim=1)
- return x, m, logs, x_mask
-
-
-class ResidualCouplingBlock(nn.Module):
- def __init__(self,
- channels,
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- n_flows=4,
- gin_channels=0):
- super().__init__()
- self.channels = channels
- self.hidden_channels = hidden_channels
- self.kernel_size = kernel_size
- self.dilation_rate = dilation_rate
- self.n_layers = n_layers
- self.n_flows = n_flows
- self.gin_channels = gin_channels
-
- self.flows = nn.ModuleList()
- for i in range(n_flows):
- self.flows.append(modules.ResidualCouplingLayer(channels, hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=gin_channels, mean_only=True))
- self.flows.append(modules.Flip())
-
- def forward(self, x, x_mask, g=None, reverse=False):
- if not reverse:
- for flow in self.flows:
- x, _ = flow(x, x_mask, g=g, reverse=reverse)
- else:
- for flow in reversed(self.flows):
- x = flow(x, x_mask, g=g, reverse=reverse)
- return x
-
-
-class PosteriorEncoder(nn.Module):
- def __init__(self,
- in_channels,
- out_channels,
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- gin_channels=0):
- super().__init__()
- self.in_channels = in_channels
- self.out_channels = out_channels
- self.hidden_channels = hidden_channels
- self.kernel_size = kernel_size
- self.dilation_rate = dilation_rate
- self.n_layers = n_layers
- self.gin_channels = gin_channels
-
- self.pre = nn.Conv1d(in_channels, hidden_channels, 1)
- self.enc = modules.WN(hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=gin_channels)
- self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
- def forward(self, x, x_lengths, g=None):
- x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
- x = self.pre(x) * x_mask
- x = self.enc(x, x_mask, g=g)
- stats = self.proj(x) * x_mask
- m, logs = torch.split(stats, self.out_channels, dim=1)
- z = (m + torch.randn_like(m) * torch.exp(logs)) * x_mask
- return z, m, logs, x_mask
-
-
-class Generator(torch.nn.Module):
- def __init__(self, initial_channel, resblock, resblock_kernel_sizes, resblock_dilation_sizes, upsample_rates, upsample_initial_channel, upsample_kernel_sizes, gin_channels=0):
- super(Generator, self).__init__()
- self.num_kernels = len(resblock_kernel_sizes)
- self.num_upsamples = len(upsample_rates)
- self.conv_pre = Conv1d(initial_channel, upsample_initial_channel, 7, 1, padding=3)
- resblock = modules.ResBlock1 if resblock == '1' else modules.ResBlock2
-
- self.ups = nn.ModuleList()
- for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
- self.ups.append(weight_norm(
- ConvTranspose1d(upsample_initial_channel//(2**i), upsample_initial_channel//(2**(i+1)),
- k, u, padding=(k-u)//2)))
-
- self.resblocks = nn.ModuleList()
- for i in range(len(self.ups)):
- ch = upsample_initial_channel//(2**(i+1))
- for j, (k, d) in enumerate(zip(resblock_kernel_sizes, resblock_dilation_sizes)):
- self.resblocks.append(resblock(ch, k, d))
-
- self.conv_post = Conv1d(ch, 1, 7, 1, padding=3, bias=False)
- self.ups.apply(init_weights)
-
- if gin_channels != 0:
- self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1)
-
- def forward(self, x, g=None):
- x = self.conv_pre(x)
- if g is not None:
- x = x + self.cond(g)
-
- for i in range(self.num_upsamples):
- x = F.leaky_relu(x, modules.LRELU_SLOPE)
- x = self.ups[i](x)
- xs = None
- for j in range(self.num_kernels):
- if xs is None:
- xs = self.resblocks[i*self.num_kernels+j](x)
- else:
- xs += self.resblocks[i*self.num_kernels+j](x)
- x = xs / self.num_kernels
- x = F.leaky_relu(x)
- x = self.conv_post(x)
- x = torch.tanh(x)
-
- return x
-
- def remove_weight_norm(self):
- print('Removing weight norm...')
- for l in self.ups:
- remove_weight_norm(l)
- for l in self.resblocks:
- l.remove_weight_norm()
-
-
-class DiscriminatorP(torch.nn.Module):
- def __init__(self, period, kernel_size=5, stride=3, use_spectral_norm=False):
- super(DiscriminatorP, self).__init__()
- self.period = period
- self.use_spectral_norm = use_spectral_norm
- norm_f = weight_norm if use_spectral_norm == False else spectral_norm
- self.convs = nn.ModuleList([
- norm_f(Conv2d(1, 32, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
- norm_f(Conv2d(32, 128, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
- norm_f(Conv2d(128, 512, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
- norm_f(Conv2d(512, 1024, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
- norm_f(Conv2d(1024, 1024, (kernel_size, 1), 1, padding=(get_padding(kernel_size, 1), 0))),
- ])
- self.conv_post = norm_f(Conv2d(1024, 1, (3, 1), 1, padding=(1, 0)))
-
- def forward(self, x):
- fmap = []
-
- # 1d to 2d
- b, c, t = x.shape
- if t % self.period != 0: # pad first
- n_pad = self.period - (t % self.period)
- x = F.pad(x, (0, n_pad), "reflect")
- t = t + n_pad
- x = x.view(b, c, t // self.period, self.period)
-
- for l in self.convs:
- x = l(x)
- x = F.leaky_relu(x, modules.LRELU_SLOPE)
- fmap.append(x)
- x = self.conv_post(x)
- fmap.append(x)
- x = torch.flatten(x, 1, -1)
-
- return x, fmap
-
-
-class DiscriminatorS(torch.nn.Module):
- def __init__(self, use_spectral_norm=False):
- super(DiscriminatorS, self).__init__()
- norm_f = weight_norm if use_spectral_norm == False else spectral_norm
- self.convs = nn.ModuleList([
- norm_f(Conv1d(1, 16, 15, 1, padding=7)),
- norm_f(Conv1d(16, 64, 41, 4, groups=4, padding=20)),
- norm_f(Conv1d(64, 256, 41, 4, groups=16, padding=20)),
- norm_f(Conv1d(256, 1024, 41, 4, groups=64, padding=20)),
- norm_f(Conv1d(1024, 1024, 41, 4, groups=256, padding=20)),
- norm_f(Conv1d(1024, 1024, 5, 1, padding=2)),
- ])
- self.conv_post = norm_f(Conv1d(1024, 1, 3, 1, padding=1))
-
- def forward(self, x):
- fmap = []
-
- for l in self.convs:
- x = l(x)
- x = F.leaky_relu(x, modules.LRELU_SLOPE)
- fmap.append(x)
- x = self.conv_post(x)
- fmap.append(x)
- x = torch.flatten(x, 1, -1)
-
- return x, fmap
-
-
-class MultiPeriodDiscriminator(torch.nn.Module):
- def __init__(self, use_spectral_norm=False):
- super(MultiPeriodDiscriminator, self).__init__()
- periods = [2,3,5,7,11]
-
- discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
- discs = discs + [DiscriminatorP(i, use_spectral_norm=use_spectral_norm) for i in periods]
- self.discriminators = nn.ModuleList(discs)
-
- def forward(self, y, y_hat):
- y_d_rs = []
- y_d_gs = []
- fmap_rs = []
- fmap_gs = []
- for i, d in enumerate(self.discriminators):
- y_d_r, fmap_r = d(y)
- y_d_g, fmap_g = d(y_hat)
- y_d_rs.append(y_d_r)
- y_d_gs.append(y_d_g)
- fmap_rs.append(fmap_r)
- fmap_gs.append(fmap_g)
-
- return y_d_rs, y_d_gs, fmap_rs, fmap_gs
-
-
-
-class SynthesizerTrn(nn.Module):
- """
- Synthesizer for Training
- """
-
- def __init__(self,
- n_vocab,
- spec_channels,
- segment_size,
- inter_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- resblock,
- resblock_kernel_sizes,
- resblock_dilation_sizes,
- upsample_rates,
- upsample_initial_channel,
- upsample_kernel_sizes,
- n_speakers=0,
- gin_channels=0,
- use_sdp=True,
- **kwargs):
-
- super().__init__()
- self.n_vocab = n_vocab
- self.spec_channels = spec_channels
- self.inter_channels = inter_channels
- self.hidden_channels = hidden_channels
- self.filter_channels = filter_channels
- self.n_heads = n_heads
- self.n_layers = n_layers
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.resblock = resblock
- self.resblock_kernel_sizes = resblock_kernel_sizes
- self.resblock_dilation_sizes = resblock_dilation_sizes
- self.upsample_rates = upsample_rates
- self.upsample_initial_channel = upsample_initial_channel
- self.upsample_kernel_sizes = upsample_kernel_sizes
- self.segment_size = segment_size
- self.n_speakers = n_speakers
- self.gin_channels = gin_channels
-
- self.use_sdp = use_sdp
-
- self.enc_p = TextEncoder(n_vocab,
- inter_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout)
- self.dec = Generator(inter_channels, resblock, resblock_kernel_sizes, resblock_dilation_sizes, upsample_rates, upsample_initial_channel, upsample_kernel_sizes, gin_channels=gin_channels)
- self.enc_q = PosteriorEncoder(spec_channels, inter_channels, hidden_channels, 5, 1, 16, gin_channels=gin_channels)
- self.flow = ResidualCouplingBlock(inter_channels, hidden_channels, 5, 1, 4, gin_channels=gin_channels)
-
- if use_sdp:
- self.dp = StochasticDurationPredictor(hidden_channels, 192, 3, 0.5, 4, gin_channels=gin_channels)
- else:
- self.dp = DurationPredictor(hidden_channels, 256, 3, 0.5, gin_channels=gin_channels)
-
- if n_speakers > 1:
- self.emb_g = nn.Embedding(n_speakers, gin_channels)
-
- def forward(self, x, x_lengths, y, y_lengths, sid=None, emo=None):
-
- x, m_p, logs_p, x_mask = self.enc_p(x, x_lengths, emo)
- if self.n_speakers > 0:
- g = self.emb_g(sid).unsqueeze(-1) # [b, h, 1]
- else:
- g = None
-
- z, m_q, logs_q, y_mask = self.enc_q(y, y_lengths, g=g)
- z_p = self.flow(z, y_mask, g=g)
-
- with torch.no_grad():
- # negative cross-entropy
- s_p_sq_r = torch.exp(-2 * logs_p) # [b, d, t]
- neg_cent1 = torch.sum(-0.5 * math.log(2 * math.pi) - logs_p, [1], keepdim=True) # [b, 1, t_s]
- neg_cent2 = torch.matmul(-0.5 * (z_p ** 2).transpose(1, 2), s_p_sq_r) # [b, t_t, d] x [b, d, t_s] = [b, t_t, t_s]
- neg_cent3 = torch.matmul(z_p.transpose(1, 2), (m_p * s_p_sq_r)) # [b, t_t, d] x [b, d, t_s] = [b, t_t, t_s]
- neg_cent4 = torch.sum(-0.5 * (m_p ** 2) * s_p_sq_r, [1], keepdim=True) # [b, 1, t_s]
- neg_cent = neg_cent1 + neg_cent2 + neg_cent3 + neg_cent4
-
- attn_mask = torch.unsqueeze(x_mask, 2) * torch.unsqueeze(y_mask, -1)
- attn = monotonic_align.maximum_path(neg_cent, attn_mask.squeeze(1)).unsqueeze(1).detach()
-
- w = attn.sum(2)
- if self.use_sdp:
- l_length = self.dp(x, x_mask, w, g=g)
- l_length = l_length / torch.sum(x_mask)
- else:
- logw_ = torch.log(w + 1e-6) * x_mask
- logw = self.dp(x, x_mask, g=g)
- l_length = torch.sum((logw - logw_)**2, [1,2]) / torch.sum(x_mask) # for averaging
-
- # expand prior
- m_p = torch.matmul(attn.squeeze(1), m_p.transpose(1, 2)).transpose(1, 2)
- logs_p = torch.matmul(attn.squeeze(1), logs_p.transpose(1, 2)).transpose(1, 2)
-
- z_slice, ids_slice = commons.rand_slice_segments(z, y_lengths, self.segment_size)
- o = self.dec(z_slice, g=g)
- return o, l_length, attn, ids_slice, x_mask, y_mask, (z, z_p, m_p, logs_p, m_q, logs_q)
-
- def infer(self, x, x_lengths, sid=None, emo=None, noise_scale=1, length_scale=1, noise_scale_w=1., max_len=None):
- x, m_p, logs_p, x_mask = self.enc_p(x, x_lengths,emo)
- if self.n_speakers > 0:
- g = self.emb_g(sid).unsqueeze(-1) # [b, h, 1]
- else:
- g = None
-
- if self.use_sdp:
- logw = self.dp(x, x_mask, g=g, reverse=True, noise_scale=noise_scale_w)
- else:
- logw = self.dp(x, x_mask, g=g)
- w = torch.exp(logw) * x_mask * length_scale
- w_ceil = torch.ceil(w)
- y_lengths = torch.clamp_min(torch.sum(w_ceil, [1, 2]), 1).long()
- y_mask = torch.unsqueeze(commons.sequence_mask(y_lengths, None), 1).to(x_mask.dtype)
- attn_mask = torch.unsqueeze(x_mask, 2) * torch.unsqueeze(y_mask, -1)
- attn = commons.generate_path(w_ceil, attn_mask)
-
- m_p = torch.matmul(attn.squeeze(1), m_p.transpose(1, 2)).transpose(1, 2) # [b, t', t], [b, t, d] -> [b, d, t']
- logs_p = torch.matmul(attn.squeeze(1), logs_p.transpose(1, 2)).transpose(1, 2) # [b, t', t], [b, t, d] -> [b, d, t']
-
- z_p = m_p + torch.randn_like(m_p) * torch.exp(logs_p) * noise_scale
- z = self.flow(z_p, y_mask, g=g, reverse=True)
- o = self.dec((z * y_mask)[:,:,:max_len], g=g)
- return o, attn, y_mask, (z, z_p, m_p, logs_p)
-
- def voice_conversion(self, y, y_lengths, sid_src, sid_tgt):
- assert self.n_speakers > 0, "n_speakers have to be larger than 0."
- g_src = self.emb_g(sid_src).unsqueeze(-1)
- g_tgt = self.emb_g(sid_tgt).unsqueeze(-1)
- z, m_q, logs_q, y_mask = self.enc_q(y, y_lengths, g=g_src)
- z_p = self.flow(z, y_mask, g=g_src)
- z_hat = self.flow(z_p, y_mask, g=g_tgt, reverse=True)
- o_hat = self.dec(z_hat * y_mask, g=g_tgt)
- return o_hat, y_mask, (z, z_p, z_hat)
-
diff --git a/spaces/Atualli/yoloxTeste/configs/yolov3.py b/spaces/Atualli/yoloxTeste/configs/yolov3.py
deleted file mode 100644
index c747f8ae9f42549a1dbd7f03d8ee80e235d6467a..0000000000000000000000000000000000000000
--- a/spaces/Atualli/yoloxTeste/configs/yolov3.py
+++ /dev/null
@@ -1,33 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding:utf-8 -*-
-# Copyright (c) Megvii, Inc. and its affiliates.
-
-import os
-
-import torch.nn as nn
-
-from yolox.exp import Exp as MyExp
-
-
-class Exp(MyExp):
- def __init__(self):
- super(Exp, self).__init__()
- self.depth = 1.0
- self.width = 1.0
- self.exp_name = os.path.split(os.path.realpath(__file__))[1].split(".")[0]
-
- def get_model(self, sublinear=False):
- def init_yolo(M):
- for m in M.modules():
- if isinstance(m, nn.BatchNorm2d):
- m.eps = 1e-3
- m.momentum = 0.03
- if "model" not in self.__dict__:
- from yolox.models import YOLOX, YOLOFPN, YOLOXHead
- backbone = YOLOFPN()
- head = YOLOXHead(self.num_classes, self.width, in_channels=[128, 256, 512], act="lrelu")
- self.model = YOLOX(backbone, head)
- self.model.apply(init_yolo)
- self.model.head.initialize_biases(1e-2)
-
- return self.model
diff --git a/spaces/Audio-AGI/AudioSep/models/CLAP/__init__.py b/spaces/Audio-AGI/AudioSep/models/CLAP/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/modeling/roi_heads/roi_heads.py b/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/modeling/roi_heads/roi_heads.py
deleted file mode 100644
index 13dd57a0478917001841f6c6299f380e1198e63a..0000000000000000000000000000000000000000
--- a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/modeling/roi_heads/roi_heads.py
+++ /dev/null
@@ -1,877 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import inspect
-import logging
-import numpy as np
-from typing import Dict, List, Optional, Tuple
-import torch
-from torch import nn
-
-from detectron2.config import configurable
-from detectron2.layers import ShapeSpec, nonzero_tuple
-from detectron2.structures import Boxes, ImageList, Instances, pairwise_iou
-from detectron2.utils.events import get_event_storage
-from detectron2.utils.registry import Registry
-
-from ..backbone.resnet import BottleneckBlock, ResNet
-from ..matcher import Matcher
-from ..poolers import ROIPooler
-from ..proposal_generator.proposal_utils import add_ground_truth_to_proposals
-from ..sampling import subsample_labels
-from .box_head import build_box_head
-from .fast_rcnn import FastRCNNOutputLayers
-from .keypoint_head import build_keypoint_head
-from .mask_head import build_mask_head
-
-ROI_HEADS_REGISTRY = Registry("ROI_HEADS")
-ROI_HEADS_REGISTRY.__doc__ = """
-Registry for ROI heads in a generalized R-CNN model.
-ROIHeads take feature maps and region proposals, and
-perform per-region computation.
-
-The registered object will be called with `obj(cfg, input_shape)`.
-The call is expected to return an :class:`ROIHeads`.
-"""
-
-logger = logging.getLogger(__name__)
-
-
-def build_roi_heads(cfg, input_shape):
- """
- Build ROIHeads defined by `cfg.MODEL.ROI_HEADS.NAME`.
- """
- name = cfg.MODEL.ROI_HEADS.NAME
- return ROI_HEADS_REGISTRY.get(name)(cfg, input_shape)
-
-
-def select_foreground_proposals(
- proposals: List[Instances], bg_label: int
-) -> Tuple[List[Instances], List[torch.Tensor]]:
- """
- Given a list of N Instances (for N images), each containing a `gt_classes` field,
- return a list of Instances that contain only instances with `gt_classes != -1 &&
- gt_classes != bg_label`.
-
- Args:
- proposals (list[Instances]): A list of N Instances, where N is the number of
- images in the batch.
- bg_label: label index of background class.
-
- Returns:
- list[Instances]: N Instances, each contains only the selected foreground instances.
- list[Tensor]: N boolean vector, correspond to the selection mask of
- each Instances object. True for selected instances.
- """
- assert isinstance(proposals, (list, tuple))
- assert isinstance(proposals[0], Instances)
- assert proposals[0].has("gt_classes")
- fg_proposals = []
- fg_selection_masks = []
- for proposals_per_image in proposals:
- gt_classes = proposals_per_image.gt_classes
- fg_selection_mask = (gt_classes != -1) & (gt_classes != bg_label)
- fg_idxs = fg_selection_mask.nonzero().squeeze(1)
- fg_proposals.append(proposals_per_image[fg_idxs])
- fg_selection_masks.append(fg_selection_mask)
- return fg_proposals, fg_selection_masks
-
-
-def select_proposals_with_visible_keypoints(proposals: List[Instances]) -> List[Instances]:
- """
- Args:
- proposals (list[Instances]): a list of N Instances, where N is the
- number of images.
-
- Returns:
- proposals: only contains proposals with at least one visible keypoint.
-
- Note that this is still slightly different from Detectron.
- In Detectron, proposals for training keypoint head are re-sampled from
- all the proposals with IOU>threshold & >=1 visible keypoint.
-
- Here, the proposals are first sampled from all proposals with
- IOU>threshold, then proposals with no visible keypoint are filtered out.
- This strategy seems to make no difference on Detectron and is easier to implement.
- """
- ret = []
- all_num_fg = []
- for proposals_per_image in proposals:
- # If empty/unannotated image (hard negatives), skip filtering for train
- if len(proposals_per_image) == 0:
- ret.append(proposals_per_image)
- continue
- gt_keypoints = proposals_per_image.gt_keypoints.tensor
- # #fg x K x 3
- vis_mask = gt_keypoints[:, :, 2] >= 1
- xs, ys = gt_keypoints[:, :, 0], gt_keypoints[:, :, 1]
- proposal_boxes = proposals_per_image.proposal_boxes.tensor.unsqueeze(dim=1) # #fg x 1 x 4
- kp_in_box = (
- (xs >= proposal_boxes[:, :, 0])
- & (xs <= proposal_boxes[:, :, 2])
- & (ys >= proposal_boxes[:, :, 1])
- & (ys <= proposal_boxes[:, :, 3])
- )
- selection = (kp_in_box & vis_mask).any(dim=1)
- selection_idxs = nonzero_tuple(selection)[0]
- all_num_fg.append(selection_idxs.numel())
- ret.append(proposals_per_image[selection_idxs])
-
- storage = get_event_storage()
- storage.put_scalar("keypoint_head/num_fg_samples", np.mean(all_num_fg))
- return ret
-
-
-class ROIHeads(torch.nn.Module):
- """
- ROIHeads perform all per-region computation in an R-CNN.
-
- It typically contains logic to
-
- 1. (in training only) match proposals with ground truth and sample them
- 2. crop the regions and extract per-region features using proposals
- 3. make per-region predictions with different heads
-
- It can have many variants, implemented as subclasses of this class.
- This base class contains the logic to match/sample proposals.
- But it is not necessary to inherit this class if the sampling logic is not needed.
- """
-
- @configurable
- def __init__(
- self,
- *,
- num_classes,
- batch_size_per_image,
- positive_fraction,
- proposal_matcher,
- proposal_append_gt=True,
- ):
- """
- NOTE: this interface is experimental.
-
- Args:
- num_classes (int): number of foreground classes (i.e. background is not included)
- batch_size_per_image (int): number of proposals to sample for training
- positive_fraction (float): fraction of positive (foreground) proposals
- to sample for training.
- proposal_matcher (Matcher): matcher that matches proposals and ground truth
- proposal_append_gt (bool): whether to include ground truth as proposals as well
- """
- super().__init__()
- self.batch_size_per_image = batch_size_per_image
- self.positive_fraction = positive_fraction
- self.num_classes = num_classes
- self.proposal_matcher = proposal_matcher
- self.proposal_append_gt = proposal_append_gt
-
- @classmethod
- def from_config(cls, cfg):
- return {
- "batch_size_per_image": cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE,
- "positive_fraction": cfg.MODEL.ROI_HEADS.POSITIVE_FRACTION,
- "num_classes": cfg.MODEL.ROI_HEADS.NUM_CLASSES,
- "proposal_append_gt": cfg.MODEL.ROI_HEADS.PROPOSAL_APPEND_GT,
- # Matcher to assign box proposals to gt boxes
- "proposal_matcher": Matcher(
- cfg.MODEL.ROI_HEADS.IOU_THRESHOLDS,
- cfg.MODEL.ROI_HEADS.IOU_LABELS,
- allow_low_quality_matches=False,
- ),
- }
-
- def _sample_proposals(
- self, matched_idxs: torch.Tensor, matched_labels: torch.Tensor, gt_classes: torch.Tensor
- ) -> Tuple[torch.Tensor, torch.Tensor]:
- """
- Based on the matching between N proposals and M groundtruth,
- sample the proposals and set their classification labels.
-
- Args:
- matched_idxs (Tensor): a vector of length N, each is the best-matched
- gt index in [0, M) for each proposal.
- matched_labels (Tensor): a vector of length N, the matcher's label
- (one of cfg.MODEL.ROI_HEADS.IOU_LABELS) for each proposal.
- gt_classes (Tensor): a vector of length M.
-
- Returns:
- Tensor: a vector of indices of sampled proposals. Each is in [0, N).
- Tensor: a vector of the same length, the classification label for
- each sampled proposal. Each sample is labeled as either a category in
- [0, num_classes) or the background (num_classes).
- """
- has_gt = gt_classes.numel() > 0
- # Get the corresponding GT for each proposal
- if has_gt:
- gt_classes = gt_classes[matched_idxs]
- # Label unmatched proposals (0 label from matcher) as background (label=num_classes)
- gt_classes[matched_labels == 0] = self.num_classes
- # Label ignore proposals (-1 label)
- gt_classes[matched_labels == -1] = -1
- else:
- gt_classes = torch.zeros_like(matched_idxs) + self.num_classes
-
- sampled_fg_idxs, sampled_bg_idxs = subsample_labels(
- gt_classes, self.batch_size_per_image, self.positive_fraction, self.num_classes
- )
-
- sampled_idxs = torch.cat([sampled_fg_idxs, sampled_bg_idxs], dim=0)
- return sampled_idxs, gt_classes[sampled_idxs]
-
- @torch.no_grad()
- def label_and_sample_proposals(
- self, proposals: List[Instances], targets: List[Instances]
- ) -> List[Instances]:
- """
- Prepare some proposals to be used to train the ROI heads.
- It performs box matching between `proposals` and `targets`, and assigns
- training labels to the proposals.
- It returns ``self.batch_size_per_image`` random samples from proposals and groundtruth
- boxes, with a fraction of positives that is no larger than
- ``self.positive_fraction``.
-
- Args:
- See :meth:`ROIHeads.forward`
-
- Returns:
- list[Instances]:
- length `N` list of `Instances`s containing the proposals
- sampled for training. Each `Instances` has the following fields:
-
- - proposal_boxes: the proposal boxes
- - gt_boxes: the ground-truth box that the proposal is assigned to
- (this is only meaningful if the proposal has a label > 0; if label = 0
- then the ground-truth box is random)
-
- Other fields such as "gt_classes", "gt_masks", that's included in `targets`.
- """
- # Augment proposals with ground-truth boxes.
- # In the case of learned proposals (e.g., RPN), when training starts
- # the proposals will be low quality due to random initialization.
- # It's possible that none of these initial
- # proposals have high enough overlap with the gt objects to be used
- # as positive examples for the second stage components (box head,
- # cls head, mask head). Adding the gt boxes to the set of proposals
- # ensures that the second stage components will have some positive
- # examples from the start of training. For RPN, this augmentation improves
- # convergence and empirically improves box AP on COCO by about 0.5
- # points (under one tested configuration).
- if self.proposal_append_gt:
- proposals = add_ground_truth_to_proposals(targets, proposals)
-
- proposals_with_gt = []
-
- num_fg_samples = []
- num_bg_samples = []
- for proposals_per_image, targets_per_image in zip(proposals, targets):
- has_gt = len(targets_per_image) > 0
- match_quality_matrix = pairwise_iou(
- targets_per_image.gt_boxes, proposals_per_image.proposal_boxes
- )
- matched_idxs, matched_labels = self.proposal_matcher(match_quality_matrix)
- sampled_idxs, gt_classes = self._sample_proposals(
- matched_idxs, matched_labels, targets_per_image.gt_classes
- )
-
- # Set target attributes of the sampled proposals:
- proposals_per_image = proposals_per_image[sampled_idxs]
- proposals_per_image.gt_classes = gt_classes
-
- if has_gt:
- sampled_targets = matched_idxs[sampled_idxs]
- # We index all the attributes of targets that start with "gt_"
- # and have not been added to proposals yet (="gt_classes").
- # NOTE: here the indexing waste some compute, because heads
- # like masks, keypoints, etc, will filter the proposals again,
- # (by foreground/background, or number of keypoints in the image, etc)
- # so we essentially index the data twice.
- for (trg_name, trg_value) in targets_per_image.get_fields().items():
- if trg_name.startswith("gt_") and not proposals_per_image.has(trg_name):
- proposals_per_image.set(trg_name, trg_value[sampled_targets])
- # If no GT is given in the image, we don't know what a dummy gt value can be.
- # Therefore the returned proposals won't have any gt_* fields, except for a
- # gt_classes full of background label.
-
- num_bg_samples.append((gt_classes == self.num_classes).sum().item())
- num_fg_samples.append(gt_classes.numel() - num_bg_samples[-1])
- proposals_with_gt.append(proposals_per_image)
-
- # Log the number of fg/bg samples that are selected for training ROI heads
- storage = get_event_storage()
- storage.put_scalar("roi_head/num_fg_samples", np.mean(num_fg_samples))
- storage.put_scalar("roi_head/num_bg_samples", np.mean(num_bg_samples))
-
- return proposals_with_gt
-
- def forward(
- self,
- images: ImageList,
- features: Dict[str, torch.Tensor],
- proposals: List[Instances],
- targets: Optional[List[Instances]] = None,
- ) -> Tuple[List[Instances], Dict[str, torch.Tensor]]:
- """
- Args:
- images (ImageList):
- features (dict[str,Tensor]): input data as a mapping from feature
- map name to tensor. Axis 0 represents the number of images `N` in
- the input data; axes 1-3 are channels, height, and width, which may
- vary between feature maps (e.g., if a feature pyramid is used).
- proposals (list[Instances]): length `N` list of `Instances`. The i-th
- `Instances` contains object proposals for the i-th input image,
- with fields "proposal_boxes" and "objectness_logits".
- targets (list[Instances], optional): length `N` list of `Instances`. The i-th
- `Instances` contains the ground-truth per-instance annotations
- for the i-th input image. Specify `targets` during training only.
- It may have the following fields:
-
- - gt_boxes: the bounding box of each instance.
- - gt_classes: the label for each instance with a category ranging in [0, #class].
- - gt_masks: PolygonMasks or BitMasks, the ground-truth masks of each instance.
- - gt_keypoints: NxKx3, the groud-truth keypoints for each instance.
-
- Returns:
- list[Instances]: length `N` list of `Instances` containing the
- detected instances. Returned during inference only; may be [] during training.
-
- dict[str->Tensor]:
- mapping from a named loss to a tensor storing the loss. Used during training only.
- """
- raise NotImplementedError()
-
-
-@ROI_HEADS_REGISTRY.register()
-class Res5ROIHeads(ROIHeads):
- """
- The ROIHeads in a typical "C4" R-CNN model, where
- the box and mask head share the cropping and
- the per-region feature computation by a Res5 block.
- See :paper:`ResNet` Appendix A.
- """
-
- @configurable
- def __init__(
- self,
- *,
- in_features: List[str],
- pooler: ROIPooler,
- res5: nn.Module,
- box_predictor: nn.Module,
- mask_head: Optional[nn.Module] = None,
- **kwargs,
- ):
- """
- NOTE: this interface is experimental.
-
- Args:
- in_features (list[str]): list of backbone feature map names to use for
- feature extraction
- pooler (ROIPooler): pooler to extra region features from backbone
- res5 (nn.Sequential): a CNN to compute per-region features, to be used by
- ``box_predictor`` and ``mask_head``. Typically this is a "res5"
- block from a ResNet.
- box_predictor (nn.Module): make box predictions from the feature.
- Should have the same interface as :class:`FastRCNNOutputLayers`.
- mask_head (nn.Module): transform features to make mask predictions
- """
- super().__init__(**kwargs)
- self.in_features = in_features
- self.pooler = pooler
- if isinstance(res5, (list, tuple)):
- res5 = nn.Sequential(*res5)
- self.res5 = res5
- self.box_predictor = box_predictor
- self.mask_on = mask_head is not None
- if self.mask_on:
- self.mask_head = mask_head
-
- @classmethod
- def from_config(cls, cfg, input_shape):
- # fmt: off
- ret = super().from_config(cfg)
- in_features = ret["in_features"] = cfg.MODEL.ROI_HEADS.IN_FEATURES
- pooler_resolution = cfg.MODEL.ROI_BOX_HEAD.POOLER_RESOLUTION
- pooler_type = cfg.MODEL.ROI_BOX_HEAD.POOLER_TYPE
- pooler_scales = (1.0 / input_shape[in_features[0]].stride, )
- sampling_ratio = cfg.MODEL.ROI_BOX_HEAD.POOLER_SAMPLING_RATIO
- mask_on = cfg.MODEL.MASK_ON
- # fmt: on
- assert not cfg.MODEL.KEYPOINT_ON
- assert len(in_features) == 1
-
- ret["pooler"] = ROIPooler(
- output_size=pooler_resolution,
- scales=pooler_scales,
- sampling_ratio=sampling_ratio,
- pooler_type=pooler_type,
- )
-
- # Compatbility with old moco code. Might be useful.
- # See notes in StandardROIHeads.from_config
- if not inspect.ismethod(cls._build_res5_block):
- logger.warning(
- "The behavior of _build_res5_block may change. "
- "Please do not depend on private methods."
- )
- cls._build_res5_block = classmethod(cls._build_res5_block)
-
- ret["res5"], out_channels = cls._build_res5_block(cfg)
- ret["box_predictor"] = FastRCNNOutputLayers(
- cfg, ShapeSpec(channels=out_channels, height=1, width=1)
- )
-
- if mask_on:
- ret["mask_head"] = build_mask_head(
- cfg,
- ShapeSpec(channels=out_channels, width=pooler_resolution, height=pooler_resolution),
- )
- return ret
-
- @classmethod
- def _build_res5_block(cls, cfg):
- # fmt: off
- stage_channel_factor = 2 ** 3 # res5 is 8x res2
- num_groups = cfg.MODEL.RESNETS.NUM_GROUPS
- width_per_group = cfg.MODEL.RESNETS.WIDTH_PER_GROUP
- bottleneck_channels = num_groups * width_per_group * stage_channel_factor
- out_channels = cfg.MODEL.RESNETS.RES2_OUT_CHANNELS * stage_channel_factor
- stride_in_1x1 = cfg.MODEL.RESNETS.STRIDE_IN_1X1
- norm = cfg.MODEL.RESNETS.NORM
- assert not cfg.MODEL.RESNETS.DEFORM_ON_PER_STAGE[-1], \
- "Deformable conv is not yet supported in res5 head."
- # fmt: on
-
- blocks = ResNet.make_stage(
- BottleneckBlock,
- 3,
- stride_per_block=[2, 1, 1],
- in_channels=out_channels // 2,
- bottleneck_channels=bottleneck_channels,
- out_channels=out_channels,
- num_groups=num_groups,
- norm=norm,
- stride_in_1x1=stride_in_1x1,
- )
- return nn.Sequential(*blocks), out_channels
-
- def _shared_roi_transform(self, features: List[torch.Tensor], boxes: List[Boxes]):
- x = self.pooler(features, boxes)
- return self.res5(x)
-
- def forward(
- self,
- images: ImageList,
- features: Dict[str, torch.Tensor],
- proposals: List[Instances],
- targets: Optional[List[Instances]] = None,
- ):
- """
- See :meth:`ROIHeads.forward`.
- """
- del images
-
- if self.training:
- assert targets
- proposals = self.label_and_sample_proposals(proposals, targets)
- del targets
-
- proposal_boxes = [x.proposal_boxes for x in proposals]
- box_features = self._shared_roi_transform(
- [features[f] for f in self.in_features], proposal_boxes
- )
- predictions = self.box_predictor(box_features.mean(dim=[2, 3]))
-
- if self.training:
- del features
- losses = self.box_predictor.losses(predictions, proposals)
- if self.mask_on:
- proposals, fg_selection_masks = select_foreground_proposals(
- proposals, self.num_classes
- )
- # Since the ROI feature transform is shared between boxes and masks,
- # we don't need to recompute features. The mask loss is only defined
- # on foreground proposals, so we need to select out the foreground
- # features.
- mask_features = box_features[torch.cat(fg_selection_masks, dim=0)]
- del box_features
- losses.update(self.mask_head(mask_features, proposals))
- return [], losses
- else:
- pred_instances, _ = self.box_predictor.inference(predictions, proposals)
- pred_instances = self.forward_with_given_boxes(features, pred_instances)
- return pred_instances, {}
-
- def forward_with_given_boxes(
- self, features: Dict[str, torch.Tensor], instances: List[Instances]
- ) -> List[Instances]:
- """
- Use the given boxes in `instances` to produce other (non-box) per-ROI outputs.
-
- Args:
- features: same as in `forward()`
- instances (list[Instances]): instances to predict other outputs. Expect the keys
- "pred_boxes" and "pred_classes" to exist.
-
- Returns:
- instances (Instances):
- the same `Instances` object, with extra
- fields such as `pred_masks` or `pred_keypoints`.
- """
- assert not self.training
- assert instances[0].has("pred_boxes") and instances[0].has("pred_classes")
-
- if self.mask_on:
- feature_list = [features[f] for f in self.in_features]
- x = self._shared_roi_transform(feature_list, [x.pred_boxes for x in instances])
- return self.mask_head(x, instances)
- else:
- return instances
-
-
-@ROI_HEADS_REGISTRY.register()
-class StandardROIHeads(ROIHeads):
- """
- It's "standard" in a sense that there is no ROI transform sharing
- or feature sharing between tasks.
- Each head independently processes the input features by each head's
- own pooler and head.
-
- This class is used by most models, such as FPN and C5.
- To implement more models, you can subclass it and implement a different
- :meth:`forward()` or a head.
- """
-
- @configurable
- def __init__(
- self,
- *,
- box_in_features: List[str],
- box_pooler: ROIPooler,
- box_head: nn.Module,
- box_predictor: nn.Module,
- mask_in_features: Optional[List[str]] = None,
- mask_pooler: Optional[ROIPooler] = None,
- mask_head: Optional[nn.Module] = None,
- keypoint_in_features: Optional[List[str]] = None,
- keypoint_pooler: Optional[ROIPooler] = None,
- keypoint_head: Optional[nn.Module] = None,
- train_on_pred_boxes: bool = False,
- **kwargs,
- ):
- """
- NOTE: this interface is experimental.
-
- Args:
- box_in_features (list[str]): list of feature names to use for the box head.
- box_pooler (ROIPooler): pooler to extra region features for box head
- box_head (nn.Module): transform features to make box predictions
- box_predictor (nn.Module): make box predictions from the feature.
- Should have the same interface as :class:`FastRCNNOutputLayers`.
- mask_in_features (list[str]): list of feature names to use for the mask
- pooler or mask head. None if not using mask head.
- mask_pooler (ROIPooler): pooler to extract region features from image features.
- The mask head will then take region features to make predictions.
- If None, the mask head will directly take the dict of image features
- defined by `mask_in_features`
- mask_head (nn.Module): transform features to make mask predictions
- keypoint_in_features, keypoint_pooler, keypoint_head: similar to ``mask_*``.
- train_on_pred_boxes (bool): whether to use proposal boxes or
- predicted boxes from the box head to train other heads.
- """
- super().__init__(**kwargs)
- # keep self.in_features for backward compatibility
- self.in_features = self.box_in_features = box_in_features
- self.box_pooler = box_pooler
- self.box_head = box_head
- self.box_predictor = box_predictor
-
- self.mask_on = mask_in_features is not None
- if self.mask_on:
- self.mask_in_features = mask_in_features
- self.mask_pooler = mask_pooler
- self.mask_head = mask_head
-
- self.keypoint_on = keypoint_in_features is not None
- if self.keypoint_on:
- self.keypoint_in_features = keypoint_in_features
- self.keypoint_pooler = keypoint_pooler
- self.keypoint_head = keypoint_head
-
- self.train_on_pred_boxes = train_on_pred_boxes
-
- @classmethod
- def from_config(cls, cfg, input_shape):
- ret = super().from_config(cfg)
- ret["train_on_pred_boxes"] = cfg.MODEL.ROI_BOX_HEAD.TRAIN_ON_PRED_BOXES
- # Subclasses that have not been updated to use from_config style construction
- # may have overridden _init_*_head methods. In this case, those overridden methods
- # will not be classmethods and we need to avoid trying to call them here.
- # We test for this with ismethod which only returns True for bound methods of cls.
- # Such subclasses will need to handle calling their overridden _init_*_head methods.
- if inspect.ismethod(cls._init_box_head):
- ret.update(cls._init_box_head(cfg, input_shape))
- if inspect.ismethod(cls._init_mask_head):
- ret.update(cls._init_mask_head(cfg, input_shape))
- if inspect.ismethod(cls._init_keypoint_head):
- ret.update(cls._init_keypoint_head(cfg, input_shape))
- return ret
-
- @classmethod
- def _init_box_head(cls, cfg, input_shape):
- # fmt: off
- in_features = cfg.MODEL.ROI_HEADS.IN_FEATURES
- pooler_resolution = cfg.MODEL.ROI_BOX_HEAD.POOLER_RESOLUTION
- pooler_scales = tuple(1.0 / input_shape[k].stride for k in in_features)
- sampling_ratio = cfg.MODEL.ROI_BOX_HEAD.POOLER_SAMPLING_RATIO
- pooler_type = cfg.MODEL.ROI_BOX_HEAD.POOLER_TYPE
- # fmt: on
-
- # If StandardROIHeads is applied on multiple feature maps (as in FPN),
- # then we share the same predictors and therefore the channel counts must be the same
- in_channels = [input_shape[f].channels for f in in_features]
- # Check all channel counts are equal
- assert len(set(in_channels)) == 1, in_channels
- in_channels = in_channels[0]
-
- box_pooler = ROIPooler(
- output_size=pooler_resolution,
- scales=pooler_scales,
- sampling_ratio=sampling_ratio,
- pooler_type=pooler_type,
- )
- # Here we split "box head" and "box predictor", which is mainly due to historical reasons.
- # They are used together so the "box predictor" layers should be part of the "box head".
- # New subclasses of ROIHeads do not need "box predictor"s.
- box_head = build_box_head(
- cfg, ShapeSpec(channels=in_channels, height=pooler_resolution, width=pooler_resolution)
- )
- box_predictor = FastRCNNOutputLayers(cfg, box_head.output_shape)
- return {
- "box_in_features": in_features,
- "box_pooler": box_pooler,
- "box_head": box_head,
- "box_predictor": box_predictor,
- }
-
- @classmethod
- def _init_mask_head(cls, cfg, input_shape):
- if not cfg.MODEL.MASK_ON:
- return {}
- # fmt: off
- in_features = cfg.MODEL.ROI_HEADS.IN_FEATURES
- pooler_resolution = cfg.MODEL.ROI_MASK_HEAD.POOLER_RESOLUTION
- pooler_scales = tuple(1.0 / input_shape[k].stride for k in in_features)
- sampling_ratio = cfg.MODEL.ROI_MASK_HEAD.POOLER_SAMPLING_RATIO
- pooler_type = cfg.MODEL.ROI_MASK_HEAD.POOLER_TYPE
- # fmt: on
-
- in_channels = [input_shape[f].channels for f in in_features][0]
-
- ret = {"mask_in_features": in_features}
- ret["mask_pooler"] = (
- ROIPooler(
- output_size=pooler_resolution,
- scales=pooler_scales,
- sampling_ratio=sampling_ratio,
- pooler_type=pooler_type,
- )
- if pooler_type
- else None
- )
- if pooler_type:
- shape = ShapeSpec(
- channels=in_channels, width=pooler_resolution, height=pooler_resolution
- )
- else:
- shape = {f: input_shape[f] for f in in_features}
- ret["mask_head"] = build_mask_head(cfg, shape)
- return ret
-
- @classmethod
- def _init_keypoint_head(cls, cfg, input_shape):
- if not cfg.MODEL.KEYPOINT_ON:
- return {}
- # fmt: off
- in_features = cfg.MODEL.ROI_HEADS.IN_FEATURES
- pooler_resolution = cfg.MODEL.ROI_KEYPOINT_HEAD.POOLER_RESOLUTION
- pooler_scales = tuple(1.0 / input_shape[k].stride for k in in_features) # noqa
- sampling_ratio = cfg.MODEL.ROI_KEYPOINT_HEAD.POOLER_SAMPLING_RATIO
- pooler_type = cfg.MODEL.ROI_KEYPOINT_HEAD.POOLER_TYPE
- # fmt: on
-
- in_channels = [input_shape[f].channels for f in in_features][0]
-
- ret = {"keypoint_in_features": in_features}
- ret["keypoint_pooler"] = (
- ROIPooler(
- output_size=pooler_resolution,
- scales=pooler_scales,
- sampling_ratio=sampling_ratio,
- pooler_type=pooler_type,
- )
- if pooler_type
- else None
- )
- if pooler_type:
- shape = ShapeSpec(
- channels=in_channels, width=pooler_resolution, height=pooler_resolution
- )
- else:
- shape = {f: input_shape[f] for f in in_features}
- ret["keypoint_head"] = build_keypoint_head(cfg, shape)
- return ret
-
- def forward(
- self,
- images: ImageList,
- features: Dict[str, torch.Tensor],
- proposals: List[Instances],
- targets: Optional[List[Instances]] = None,
- ) -> Tuple[List[Instances], Dict[str, torch.Tensor]]:
- """
- See :class:`ROIHeads.forward`.
- """
- del images
- if self.training:
- assert targets, "'targets' argument is required during training"
- proposals = self.label_and_sample_proposals(proposals, targets)
- del targets
-
- if self.training:
- losses = self._forward_box(features, proposals)
- # Usually the original proposals used by the box head are used by the mask, keypoint
- # heads. But when `self.train_on_pred_boxes is True`, proposals will contain boxes
- # predicted by the box head.
- losses.update(self._forward_mask(features, proposals))
- losses.update(self._forward_keypoint(features, proposals))
- return proposals, losses
- else:
- pred_instances = self._forward_box(features, proposals)
- # During inference cascaded prediction is used: the mask and keypoints heads are only
- # applied to the top scoring box detections.
- pred_instances = self.forward_with_given_boxes(features, pred_instances)
- return pred_instances, {}
-
- def forward_with_given_boxes(
- self, features: Dict[str, torch.Tensor], instances: List[Instances]
- ) -> List[Instances]:
- """
- Use the given boxes in `instances` to produce other (non-box) per-ROI outputs.
-
- This is useful for downstream tasks where a box is known, but need to obtain
- other attributes (outputs of other heads).
- Test-time augmentation also uses this.
-
- Args:
- features: same as in `forward()`
- instances (list[Instances]): instances to predict other outputs. Expect the keys
- "pred_boxes" and "pred_classes" to exist.
-
- Returns:
- list[Instances]:
- the same `Instances` objects, with extra
- fields such as `pred_masks` or `pred_keypoints`.
- """
- assert not self.training
- assert instances[0].has("pred_boxes") and instances[0].has("pred_classes")
-
- instances = self._forward_mask(features, instances)
- instances = self._forward_keypoint(features, instances)
- return instances
-
- def _forward_box(self, features: Dict[str, torch.Tensor], proposals: List[Instances]):
- """
- Forward logic of the box prediction branch. If `self.train_on_pred_boxes is True`,
- the function puts predicted boxes in the `proposal_boxes` field of `proposals` argument.
-
- Args:
- features (dict[str, Tensor]): mapping from feature map names to tensor.
- Same as in :meth:`ROIHeads.forward`.
- proposals (list[Instances]): the per-image object proposals with
- their matching ground truth.
- Each has fields "proposal_boxes", and "objectness_logits",
- "gt_classes", "gt_boxes".
-
- Returns:
- In training, a dict of losses.
- In inference, a list of `Instances`, the predicted instances.
- """
- features = [features[f] for f in self.box_in_features]
- box_features = self.box_pooler(features, [x.proposal_boxes for x in proposals])
- box_features = self.box_head(box_features)
- predictions = self.box_predictor(box_features)
- del box_features
-
- if self.training:
- losses = self.box_predictor.losses(predictions, proposals)
- # proposals is modified in-place below, so losses must be computed first.
- if self.train_on_pred_boxes:
- with torch.no_grad():
- pred_boxes = self.box_predictor.predict_boxes_for_gt_classes(
- predictions, proposals
- )
- for proposals_per_image, pred_boxes_per_image in zip(proposals, pred_boxes):
- proposals_per_image.proposal_boxes = Boxes(pred_boxes_per_image)
- return losses
- else:
- pred_instances, _ = self.box_predictor.inference(predictions, proposals)
- return pred_instances
-
- def _forward_mask(self, features: Dict[str, torch.Tensor], instances: List[Instances]):
- """
- Forward logic of the mask prediction branch.
-
- Args:
- features (dict[str, Tensor]): mapping from feature map names to tensor.
- Same as in :meth:`ROIHeads.forward`.
- instances (list[Instances]): the per-image instances to train/predict masks.
- In training, they can be the proposals.
- In inference, they can be the boxes predicted by R-CNN box head.
-
- Returns:
- In training, a dict of losses.
- In inference, update `instances` with new fields "pred_masks" and return it.
- """
- if not self.mask_on:
- return {} if self.training else instances
-
- if self.training:
- # head is only trained on positive proposals.
- instances, _ = select_foreground_proposals(instances, self.num_classes)
-
- if self.mask_pooler is not None:
- features = [features[f] for f in self.mask_in_features]
- boxes = [x.proposal_boxes if self.training else x.pred_boxes for x in instances]
- features = self.mask_pooler(features, boxes)
- else:
- features = {f: features[f] for f in self.mask_in_features}
- return self.mask_head(features, instances)
-
- def _forward_keypoint(self, features: Dict[str, torch.Tensor], instances: List[Instances]):
- """
- Forward logic of the keypoint prediction branch.
-
- Args:
- features (dict[str, Tensor]): mapping from feature map names to tensor.
- Same as in :meth:`ROIHeads.forward`.
- instances (list[Instances]): the per-image instances to train/predict keypoints.
- In training, they can be the proposals.
- In inference, they can be the boxes predicted by R-CNN box head.
-
- Returns:
- In training, a dict of losses.
- In inference, update `instances` with new fields "pred_keypoints" and return it.
- """
- if not self.keypoint_on:
- return {} if self.training else instances
-
- if self.training:
- # head is only trained on positive proposals with >=1 visible keypoints.
- instances, _ = select_foreground_proposals(instances, self.num_classes)
- instances = select_proposals_with_visible_keypoints(instances)
-
- if self.keypoint_pooler is not None:
- features = [features[f] for f in self.keypoint_in_features]
- boxes = [x.proposal_boxes if self.training else x.pred_boxes for x in instances]
- features = self.keypoint_pooler(features, boxes)
- else:
- features = {f: features[f] for f in self.keypoint_in_features}
- return self.keypoint_head(features, instances)
diff --git a/spaces/BadRobot147/SFQ3/Dockerfile b/spaces/BadRobot147/SFQ3/Dockerfile
deleted file mode 100644
index 6c01c09373883afcb4ea34ae2d316cd596e1737b..0000000000000000000000000000000000000000
--- a/spaces/BadRobot147/SFQ3/Dockerfile
+++ /dev/null
@@ -1,21 +0,0 @@
-FROM node:18-bullseye-slim
-
-RUN apt-get update && \
-
-apt-get install -y git
-
-RUN git clone https://gitgud.io/khanon/oai-reverse-proxy.git /app
-
-WORKDIR /app
-
-RUN npm install
-
-COPY Dockerfile greeting.md* .env* ./
-
-RUN npm run build
-
-EXPOSE 7860
-
-ENV NODE_ENV=production
-
-CMD [ "npm", "start" ]
\ No newline at end of file
diff --git a/spaces/Bart92/RVC_HF/infer/lib/infer_pack/models_onnx.py b/spaces/Bart92/RVC_HF/infer/lib/infer_pack/models_onnx.py
deleted file mode 100644
index 3e99763bf3ed7988eb2ae33d9066f85d37adf119..0000000000000000000000000000000000000000
--- a/spaces/Bart92/RVC_HF/infer/lib/infer_pack/models_onnx.py
+++ /dev/null
@@ -1,824 +0,0 @@
-import math
-import logging
-
-logger = logging.getLogger(__name__)
-
-import numpy as np
-import torch
-from torch import nn
-from torch.nn import AvgPool1d, Conv1d, Conv2d, ConvTranspose1d
-from torch.nn import functional as F
-from torch.nn.utils import remove_weight_norm, spectral_norm, weight_norm
-
-from infer.lib.infer_pack import attentions, commons, modules
-from infer.lib.infer_pack.commons import get_padding, init_weights
-
-
-class TextEncoder256(nn.Module):
- def __init__(
- self,
- out_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- f0=True,
- ):
- super().__init__()
- self.out_channels = out_channels
- self.hidden_channels = hidden_channels
- self.filter_channels = filter_channels
- self.n_heads = n_heads
- self.n_layers = n_layers
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.emb_phone = nn.Linear(256, hidden_channels)
- self.lrelu = nn.LeakyReLU(0.1, inplace=True)
- if f0 == True:
- self.emb_pitch = nn.Embedding(256, hidden_channels) # pitch 256
- self.encoder = attentions.Encoder(
- hidden_channels, filter_channels, n_heads, n_layers, kernel_size, p_dropout
- )
- self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
- def forward(self, phone, pitch, lengths):
- if pitch == None:
- x = self.emb_phone(phone)
- else:
- x = self.emb_phone(phone) + self.emb_pitch(pitch)
- x = x * math.sqrt(self.hidden_channels) # [b, t, h]
- x = self.lrelu(x)
- x = torch.transpose(x, 1, -1) # [b, h, t]
- x_mask = torch.unsqueeze(commons.sequence_mask(lengths, x.size(2)), 1).to(
- x.dtype
- )
- x = self.encoder(x * x_mask, x_mask)
- stats = self.proj(x) * x_mask
-
- m, logs = torch.split(stats, self.out_channels, dim=1)
- return m, logs, x_mask
-
-
-class TextEncoder768(nn.Module):
- def __init__(
- self,
- out_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- f0=True,
- ):
- super().__init__()
- self.out_channels = out_channels
- self.hidden_channels = hidden_channels
- self.filter_channels = filter_channels
- self.n_heads = n_heads
- self.n_layers = n_layers
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.emb_phone = nn.Linear(768, hidden_channels)
- self.lrelu = nn.LeakyReLU(0.1, inplace=True)
- if f0 == True:
- self.emb_pitch = nn.Embedding(256, hidden_channels) # pitch 256
- self.encoder = attentions.Encoder(
- hidden_channels, filter_channels, n_heads, n_layers, kernel_size, p_dropout
- )
- self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
- def forward(self, phone, pitch, lengths):
- if pitch == None:
- x = self.emb_phone(phone)
- else:
- x = self.emb_phone(phone) + self.emb_pitch(pitch)
- x = x * math.sqrt(self.hidden_channels) # [b, t, h]
- x = self.lrelu(x)
- x = torch.transpose(x, 1, -1) # [b, h, t]
- x_mask = torch.unsqueeze(commons.sequence_mask(lengths, x.size(2)), 1).to(
- x.dtype
- )
- x = self.encoder(x * x_mask, x_mask)
- stats = self.proj(x) * x_mask
-
- m, logs = torch.split(stats, self.out_channels, dim=1)
- return m, logs, x_mask
-
-
-class ResidualCouplingBlock(nn.Module):
- def __init__(
- self,
- channels,
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- n_flows=4,
- gin_channels=0,
- ):
- super().__init__()
- self.channels = channels
- self.hidden_channels = hidden_channels
- self.kernel_size = kernel_size
- self.dilation_rate = dilation_rate
- self.n_layers = n_layers
- self.n_flows = n_flows
- self.gin_channels = gin_channels
-
- self.flows = nn.ModuleList()
- for i in range(n_flows):
- self.flows.append(
- modules.ResidualCouplingLayer(
- channels,
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- gin_channels=gin_channels,
- mean_only=True,
- )
- )
- self.flows.append(modules.Flip())
-
- def forward(self, x, x_mask, g=None, reverse=False):
- if not reverse:
- for flow in self.flows:
- x, _ = flow(x, x_mask, g=g, reverse=reverse)
- else:
- for flow in reversed(self.flows):
- x = flow(x, x_mask, g=g, reverse=reverse)
- return x
-
- def remove_weight_norm(self):
- for i in range(self.n_flows):
- self.flows[i * 2].remove_weight_norm()
-
-
-class PosteriorEncoder(nn.Module):
- def __init__(
- self,
- in_channels,
- out_channels,
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- gin_channels=0,
- ):
- super().__init__()
- self.in_channels = in_channels
- self.out_channels = out_channels
- self.hidden_channels = hidden_channels
- self.kernel_size = kernel_size
- self.dilation_rate = dilation_rate
- self.n_layers = n_layers
- self.gin_channels = gin_channels
-
- self.pre = nn.Conv1d(in_channels, hidden_channels, 1)
- self.enc = modules.WN(
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- gin_channels=gin_channels,
- )
- self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
- def forward(self, x, x_lengths, g=None):
- x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(
- x.dtype
- )
- x = self.pre(x) * x_mask
- x = self.enc(x, x_mask, g=g)
- stats = self.proj(x) * x_mask
- m, logs = torch.split(stats, self.out_channels, dim=1)
- z = (m + torch.randn_like(m) * torch.exp(logs)) * x_mask
- return z, m, logs, x_mask
-
- def remove_weight_norm(self):
- self.enc.remove_weight_norm()
-
-
-class Generator(torch.nn.Module):
- def __init__(
- self,
- initial_channel,
- resblock,
- resblock_kernel_sizes,
- resblock_dilation_sizes,
- upsample_rates,
- upsample_initial_channel,
- upsample_kernel_sizes,
- gin_channels=0,
- ):
- super(Generator, self).__init__()
- self.num_kernels = len(resblock_kernel_sizes)
- self.num_upsamples = len(upsample_rates)
- self.conv_pre = Conv1d(
- initial_channel, upsample_initial_channel, 7, 1, padding=3
- )
- resblock = modules.ResBlock1 if resblock == "1" else modules.ResBlock2
-
- self.ups = nn.ModuleList()
- for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
- self.ups.append(
- weight_norm(
- ConvTranspose1d(
- upsample_initial_channel // (2**i),
- upsample_initial_channel // (2 ** (i + 1)),
- k,
- u,
- padding=(k - u) // 2,
- )
- )
- )
-
- self.resblocks = nn.ModuleList()
- for i in range(len(self.ups)):
- ch = upsample_initial_channel // (2 ** (i + 1))
- for j, (k, d) in enumerate(
- zip(resblock_kernel_sizes, resblock_dilation_sizes)
- ):
- self.resblocks.append(resblock(ch, k, d))
-
- self.conv_post = Conv1d(ch, 1, 7, 1, padding=3, bias=False)
- self.ups.apply(init_weights)
-
- if gin_channels != 0:
- self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1)
-
- def forward(self, x, g=None):
- x = self.conv_pre(x)
- if g is not None:
- x = x + self.cond(g)
-
- for i in range(self.num_upsamples):
- x = F.leaky_relu(x, modules.LRELU_SLOPE)
- x = self.ups[i](x)
- xs = None
- for j in range(self.num_kernels):
- if xs is None:
- xs = self.resblocks[i * self.num_kernels + j](x)
- else:
- xs += self.resblocks[i * self.num_kernels + j](x)
- x = xs / self.num_kernels
- x = F.leaky_relu(x)
- x = self.conv_post(x)
- x = torch.tanh(x)
-
- return x
-
- def remove_weight_norm(self):
- for l in self.ups:
- remove_weight_norm(l)
- for l in self.resblocks:
- l.remove_weight_norm()
-
-
-class SineGen(torch.nn.Module):
- """Definition of sine generator
- SineGen(samp_rate, harmonic_num = 0,
- sine_amp = 0.1, noise_std = 0.003,
- voiced_threshold = 0,
- flag_for_pulse=False)
- samp_rate: sampling rate in Hz
- harmonic_num: number of harmonic overtones (default 0)
- sine_amp: amplitude of sine-wavefrom (default 0.1)
- noise_std: std of Gaussian noise (default 0.003)
- voiced_thoreshold: F0 threshold for U/V classification (default 0)
- flag_for_pulse: this SinGen is used inside PulseGen (default False)
- Note: when flag_for_pulse is True, the first time step of a voiced
- segment is always sin(np.pi) or cos(0)
- """
-
- def __init__(
- self,
- samp_rate,
- harmonic_num=0,
- sine_amp=0.1,
- noise_std=0.003,
- voiced_threshold=0,
- flag_for_pulse=False,
- ):
- super(SineGen, self).__init__()
- self.sine_amp = sine_amp
- self.noise_std = noise_std
- self.harmonic_num = harmonic_num
- self.dim = self.harmonic_num + 1
- self.sampling_rate = samp_rate
- self.voiced_threshold = voiced_threshold
-
- def _f02uv(self, f0):
- # generate uv signal
- uv = torch.ones_like(f0)
- uv = uv * (f0 > self.voiced_threshold)
- return uv
-
- def forward(self, f0, upp):
- """sine_tensor, uv = forward(f0)
- input F0: tensor(batchsize=1, length, dim=1)
- f0 for unvoiced steps should be 0
- output sine_tensor: tensor(batchsize=1, length, dim)
- output uv: tensor(batchsize=1, length, 1)
- """
- with torch.no_grad():
- f0 = f0[:, None].transpose(1, 2)
- f0_buf = torch.zeros(f0.shape[0], f0.shape[1], self.dim, device=f0.device)
- # fundamental component
- f0_buf[:, :, 0] = f0[:, :, 0]
- for idx in np.arange(self.harmonic_num):
- f0_buf[:, :, idx + 1] = f0_buf[:, :, 0] * (
- idx + 2
- ) # idx + 2: the (idx+1)-th overtone, (idx+2)-th harmonic
- rad_values = (f0_buf / self.sampling_rate) % 1 ###%1意味着n_har的乘积无法后处理优化
- rand_ini = torch.rand(
- f0_buf.shape[0], f0_buf.shape[2], device=f0_buf.device
- )
- rand_ini[:, 0] = 0
- rad_values[:, 0, :] = rad_values[:, 0, :] + rand_ini
- tmp_over_one = torch.cumsum(rad_values, 1) # % 1 #####%1意味着后面的cumsum无法再优化
- tmp_over_one *= upp
- tmp_over_one = F.interpolate(
- tmp_over_one.transpose(2, 1),
- scale_factor=upp,
- mode="linear",
- align_corners=True,
- ).transpose(2, 1)
- rad_values = F.interpolate(
- rad_values.transpose(2, 1), scale_factor=upp, mode="nearest"
- ).transpose(
- 2, 1
- ) #######
- tmp_over_one %= 1
- tmp_over_one_idx = (tmp_over_one[:, 1:, :] - tmp_over_one[:, :-1, :]) < 0
- cumsum_shift = torch.zeros_like(rad_values)
- cumsum_shift[:, 1:, :] = tmp_over_one_idx * -1.0
- sine_waves = torch.sin(
- torch.cumsum(rad_values + cumsum_shift, dim=1) * 2 * np.pi
- )
- sine_waves = sine_waves * self.sine_amp
- uv = self._f02uv(f0)
- uv = F.interpolate(
- uv.transpose(2, 1), scale_factor=upp, mode="nearest"
- ).transpose(2, 1)
- noise_amp = uv * self.noise_std + (1 - uv) * self.sine_amp / 3
- noise = noise_amp * torch.randn_like(sine_waves)
- sine_waves = sine_waves * uv + noise
- return sine_waves, uv, noise
-
-
-class SourceModuleHnNSF(torch.nn.Module):
- """SourceModule for hn-nsf
- SourceModule(sampling_rate, harmonic_num=0, sine_amp=0.1,
- add_noise_std=0.003, voiced_threshod=0)
- sampling_rate: sampling_rate in Hz
- harmonic_num: number of harmonic above F0 (default: 0)
- sine_amp: amplitude of sine source signal (default: 0.1)
- add_noise_std: std of additive Gaussian noise (default: 0.003)
- note that amplitude of noise in unvoiced is decided
- by sine_amp
- voiced_threshold: threhold to set U/V given F0 (default: 0)
- Sine_source, noise_source = SourceModuleHnNSF(F0_sampled)
- F0_sampled (batchsize, length, 1)
- Sine_source (batchsize, length, 1)
- noise_source (batchsize, length 1)
- uv (batchsize, length, 1)
- """
-
- def __init__(
- self,
- sampling_rate,
- harmonic_num=0,
- sine_amp=0.1,
- add_noise_std=0.003,
- voiced_threshod=0,
- is_half=True,
- ):
- super(SourceModuleHnNSF, self).__init__()
-
- self.sine_amp = sine_amp
- self.noise_std = add_noise_std
- self.is_half = is_half
- # to produce sine waveforms
- self.l_sin_gen = SineGen(
- sampling_rate, harmonic_num, sine_amp, add_noise_std, voiced_threshod
- )
-
- # to merge source harmonics into a single excitation
- self.l_linear = torch.nn.Linear(harmonic_num + 1, 1)
- self.l_tanh = torch.nn.Tanh()
-
- def forward(self, x, upp=None):
- sine_wavs, uv, _ = self.l_sin_gen(x, upp)
- if self.is_half:
- sine_wavs = sine_wavs.half()
- sine_merge = self.l_tanh(self.l_linear(sine_wavs))
- return sine_merge, None, None # noise, uv
-
-
-class GeneratorNSF(torch.nn.Module):
- def __init__(
- self,
- initial_channel,
- resblock,
- resblock_kernel_sizes,
- resblock_dilation_sizes,
- upsample_rates,
- upsample_initial_channel,
- upsample_kernel_sizes,
- gin_channels,
- sr,
- is_half=False,
- ):
- super(GeneratorNSF, self).__init__()
- self.num_kernels = len(resblock_kernel_sizes)
- self.num_upsamples = len(upsample_rates)
-
- self.f0_upsamp = torch.nn.Upsample(scale_factor=np.prod(upsample_rates))
- self.m_source = SourceModuleHnNSF(
- sampling_rate=sr, harmonic_num=0, is_half=is_half
- )
- self.noise_convs = nn.ModuleList()
- self.conv_pre = Conv1d(
- initial_channel, upsample_initial_channel, 7, 1, padding=3
- )
- resblock = modules.ResBlock1 if resblock == "1" else modules.ResBlock2
-
- self.ups = nn.ModuleList()
- for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
- c_cur = upsample_initial_channel // (2 ** (i + 1))
- self.ups.append(
- weight_norm(
- ConvTranspose1d(
- upsample_initial_channel // (2**i),
- upsample_initial_channel // (2 ** (i + 1)),
- k,
- u,
- padding=(k - u) // 2,
- )
- )
- )
- if i + 1 < len(upsample_rates):
- stride_f0 = np.prod(upsample_rates[i + 1 :])
- self.noise_convs.append(
- Conv1d(
- 1,
- c_cur,
- kernel_size=stride_f0 * 2,
- stride=stride_f0,
- padding=stride_f0 // 2,
- )
- )
- else:
- self.noise_convs.append(Conv1d(1, c_cur, kernel_size=1))
-
- self.resblocks = nn.ModuleList()
- for i in range(len(self.ups)):
- ch = upsample_initial_channel // (2 ** (i + 1))
- for j, (k, d) in enumerate(
- zip(resblock_kernel_sizes, resblock_dilation_sizes)
- ):
- self.resblocks.append(resblock(ch, k, d))
-
- self.conv_post = Conv1d(ch, 1, 7, 1, padding=3, bias=False)
- self.ups.apply(init_weights)
-
- if gin_channels != 0:
- self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1)
-
- self.upp = np.prod(upsample_rates)
-
- def forward(self, x, f0, g=None):
- har_source, noi_source, uv = self.m_source(f0, self.upp)
- har_source = har_source.transpose(1, 2)
- x = self.conv_pre(x)
- if g is not None:
- x = x + self.cond(g)
-
- for i in range(self.num_upsamples):
- x = F.leaky_relu(x, modules.LRELU_SLOPE)
- x = self.ups[i](x)
- x_source = self.noise_convs[i](har_source)
- x = x + x_source
- xs = None
- for j in range(self.num_kernels):
- if xs is None:
- xs = self.resblocks[i * self.num_kernels + j](x)
- else:
- xs += self.resblocks[i * self.num_kernels + j](x)
- x = xs / self.num_kernels
- x = F.leaky_relu(x)
- x = self.conv_post(x)
- x = torch.tanh(x)
- return x
-
- def remove_weight_norm(self):
- for l in self.ups:
- remove_weight_norm(l)
- for l in self.resblocks:
- l.remove_weight_norm()
-
-
-sr2sr = {
- "32k": 32000,
- "40k": 40000,
- "48k": 48000,
-}
-
-
-class SynthesizerTrnMsNSFsidM(nn.Module):
- def __init__(
- self,
- spec_channels,
- segment_size,
- inter_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- resblock,
- resblock_kernel_sizes,
- resblock_dilation_sizes,
- upsample_rates,
- upsample_initial_channel,
- upsample_kernel_sizes,
- spk_embed_dim,
- gin_channels,
- sr,
- version,
- **kwargs
- ):
- super().__init__()
- if type(sr) == type("strr"):
- sr = sr2sr[sr]
- self.spec_channels = spec_channels
- self.inter_channels = inter_channels
- self.hidden_channels = hidden_channels
- self.filter_channels = filter_channels
- self.n_heads = n_heads
- self.n_layers = n_layers
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.resblock = resblock
- self.resblock_kernel_sizes = resblock_kernel_sizes
- self.resblock_dilation_sizes = resblock_dilation_sizes
- self.upsample_rates = upsample_rates
- self.upsample_initial_channel = upsample_initial_channel
- self.upsample_kernel_sizes = upsample_kernel_sizes
- self.segment_size = segment_size
- self.gin_channels = gin_channels
- # self.hop_length = hop_length#
- self.spk_embed_dim = spk_embed_dim
- if version == "v1":
- self.enc_p = TextEncoder256(
- inter_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- )
- else:
- self.enc_p = TextEncoder768(
- inter_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- )
- self.dec = GeneratorNSF(
- inter_channels,
- resblock,
- resblock_kernel_sizes,
- resblock_dilation_sizes,
- upsample_rates,
- upsample_initial_channel,
- upsample_kernel_sizes,
- gin_channels=gin_channels,
- sr=sr,
- is_half=kwargs["is_half"],
- )
- self.enc_q = PosteriorEncoder(
- spec_channels,
- inter_channels,
- hidden_channels,
- 5,
- 1,
- 16,
- gin_channels=gin_channels,
- )
- self.flow = ResidualCouplingBlock(
- inter_channels, hidden_channels, 5, 1, 3, gin_channels=gin_channels
- )
- self.emb_g = nn.Embedding(self.spk_embed_dim, gin_channels)
- self.speaker_map = None
- logger.debug(
- "gin_channels: "
- + gin_channels
- + ", self.spk_embed_dim: "
- + self.spk_embed_dim
- )
-
- def remove_weight_norm(self):
- self.dec.remove_weight_norm()
- self.flow.remove_weight_norm()
- self.enc_q.remove_weight_norm()
-
- def construct_spkmixmap(self, n_speaker):
- self.speaker_map = torch.zeros((n_speaker, 1, 1, self.gin_channels))
- for i in range(n_speaker):
- self.speaker_map[i] = self.emb_g(torch.LongTensor([[i]]))
- self.speaker_map = self.speaker_map.unsqueeze(0)
-
- def forward(self, phone, phone_lengths, pitch, nsff0, g, rnd, max_len=None):
- if self.speaker_map is not None: # [N, S] * [S, B, 1, H]
- g = g.reshape((g.shape[0], g.shape[1], 1, 1, 1)) # [N, S, B, 1, 1]
- g = g * self.speaker_map # [N, S, B, 1, H]
- g = torch.sum(g, dim=1) # [N, 1, B, 1, H]
- g = g.transpose(0, -1).transpose(0, -2).squeeze(0) # [B, H, N]
- else:
- g = g.unsqueeze(0)
- g = self.emb_g(g).transpose(1, 2)
-
- m_p, logs_p, x_mask = self.enc_p(phone, pitch, phone_lengths)
- z_p = (m_p + torch.exp(logs_p) * rnd) * x_mask
- z = self.flow(z_p, x_mask, g=g, reverse=True)
- o = self.dec((z * x_mask)[:, :, :max_len], nsff0, g=g)
- return o
-
-
-class MultiPeriodDiscriminator(torch.nn.Module):
- def __init__(self, use_spectral_norm=False):
- super(MultiPeriodDiscriminator, self).__init__()
- periods = [2, 3, 5, 7, 11, 17]
- # periods = [3, 5, 7, 11, 17, 23, 37]
-
- discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
- discs = discs + [
- DiscriminatorP(i, use_spectral_norm=use_spectral_norm) for i in periods
- ]
- self.discriminators = nn.ModuleList(discs)
-
- def forward(self, y, y_hat):
- y_d_rs = [] #
- y_d_gs = []
- fmap_rs = []
- fmap_gs = []
- for i, d in enumerate(self.discriminators):
- y_d_r, fmap_r = d(y)
- y_d_g, fmap_g = d(y_hat)
- # for j in range(len(fmap_r)):
- # print(i,j,y.shape,y_hat.shape,fmap_r[j].shape,fmap_g[j].shape)
- y_d_rs.append(y_d_r)
- y_d_gs.append(y_d_g)
- fmap_rs.append(fmap_r)
- fmap_gs.append(fmap_g)
-
- return y_d_rs, y_d_gs, fmap_rs, fmap_gs
-
-
-class MultiPeriodDiscriminatorV2(torch.nn.Module):
- def __init__(self, use_spectral_norm=False):
- super(MultiPeriodDiscriminatorV2, self).__init__()
- # periods = [2, 3, 5, 7, 11, 17]
- periods = [2, 3, 5, 7, 11, 17, 23, 37]
-
- discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
- discs = discs + [
- DiscriminatorP(i, use_spectral_norm=use_spectral_norm) for i in periods
- ]
- self.discriminators = nn.ModuleList(discs)
-
- def forward(self, y, y_hat):
- y_d_rs = [] #
- y_d_gs = []
- fmap_rs = []
- fmap_gs = []
- for i, d in enumerate(self.discriminators):
- y_d_r, fmap_r = d(y)
- y_d_g, fmap_g = d(y_hat)
- # for j in range(len(fmap_r)):
- # print(i,j,y.shape,y_hat.shape,fmap_r[j].shape,fmap_g[j].shape)
- y_d_rs.append(y_d_r)
- y_d_gs.append(y_d_g)
- fmap_rs.append(fmap_r)
- fmap_gs.append(fmap_g)
-
- return y_d_rs, y_d_gs, fmap_rs, fmap_gs
-
-
-class DiscriminatorS(torch.nn.Module):
- def __init__(self, use_spectral_norm=False):
- super(DiscriminatorS, self).__init__()
- norm_f = weight_norm if use_spectral_norm == False else spectral_norm
- self.convs = nn.ModuleList(
- [
- norm_f(Conv1d(1, 16, 15, 1, padding=7)),
- norm_f(Conv1d(16, 64, 41, 4, groups=4, padding=20)),
- norm_f(Conv1d(64, 256, 41, 4, groups=16, padding=20)),
- norm_f(Conv1d(256, 1024, 41, 4, groups=64, padding=20)),
- norm_f(Conv1d(1024, 1024, 41, 4, groups=256, padding=20)),
- norm_f(Conv1d(1024, 1024, 5, 1, padding=2)),
- ]
- )
- self.conv_post = norm_f(Conv1d(1024, 1, 3, 1, padding=1))
-
- def forward(self, x):
- fmap = []
-
- for l in self.convs:
- x = l(x)
- x = F.leaky_relu(x, modules.LRELU_SLOPE)
- fmap.append(x)
- x = self.conv_post(x)
- fmap.append(x)
- x = torch.flatten(x, 1, -1)
-
- return x, fmap
-
-
-class DiscriminatorP(torch.nn.Module):
- def __init__(self, period, kernel_size=5, stride=3, use_spectral_norm=False):
- super(DiscriminatorP, self).__init__()
- self.period = period
- self.use_spectral_norm = use_spectral_norm
- norm_f = weight_norm if use_spectral_norm == False else spectral_norm
- self.convs = nn.ModuleList(
- [
- norm_f(
- Conv2d(
- 1,
- 32,
- (kernel_size, 1),
- (stride, 1),
- padding=(get_padding(kernel_size, 1), 0),
- )
- ),
- norm_f(
- Conv2d(
- 32,
- 128,
- (kernel_size, 1),
- (stride, 1),
- padding=(get_padding(kernel_size, 1), 0),
- )
- ),
- norm_f(
- Conv2d(
- 128,
- 512,
- (kernel_size, 1),
- (stride, 1),
- padding=(get_padding(kernel_size, 1), 0),
- )
- ),
- norm_f(
- Conv2d(
- 512,
- 1024,
- (kernel_size, 1),
- (stride, 1),
- padding=(get_padding(kernel_size, 1), 0),
- )
- ),
- norm_f(
- Conv2d(
- 1024,
- 1024,
- (kernel_size, 1),
- 1,
- padding=(get_padding(kernel_size, 1), 0),
- )
- ),
- ]
- )
- self.conv_post = norm_f(Conv2d(1024, 1, (3, 1), 1, padding=(1, 0)))
-
- def forward(self, x):
- fmap = []
-
- # 1d to 2d
- b, c, t = x.shape
- if t % self.period != 0: # pad first
- n_pad = self.period - (t % self.period)
- x = F.pad(x, (0, n_pad), "reflect")
- t = t + n_pad
- x = x.view(b, c, t // self.period, self.period)
-
- for l in self.convs:
- x = l(x)
- x = F.leaky_relu(x, modules.LRELU_SLOPE)
- fmap.append(x)
- x = self.conv_post(x)
- fmap.append(x)
- x = torch.flatten(x, 1, -1)
-
- return x, fmap
diff --git a/spaces/Bart92/RVC_HF/infer/lib/uvr5_pack/lib_v5/nets_new.py b/spaces/Bart92/RVC_HF/infer/lib/uvr5_pack/lib_v5/nets_new.py
deleted file mode 100644
index 1c0f4fa96d921e979fe31bd4151701b7783fbcea..0000000000000000000000000000000000000000
--- a/spaces/Bart92/RVC_HF/infer/lib/uvr5_pack/lib_v5/nets_new.py
+++ /dev/null
@@ -1,133 +0,0 @@
-import torch
-import torch.nn.functional as F
-from torch import nn
-
-from . import layers_new
-
-
-class BaseNet(nn.Module):
- def __init__(
- self, nin, nout, nin_lstm, nout_lstm, dilations=((4, 2), (8, 4), (12, 6))
- ):
- super(BaseNet, self).__init__()
- self.enc1 = layers_new.Conv2DBNActiv(nin, nout, 3, 1, 1)
- self.enc2 = layers_new.Encoder(nout, nout * 2, 3, 2, 1)
- self.enc3 = layers_new.Encoder(nout * 2, nout * 4, 3, 2, 1)
- self.enc4 = layers_new.Encoder(nout * 4, nout * 6, 3, 2, 1)
- self.enc5 = layers_new.Encoder(nout * 6, nout * 8, 3, 2, 1)
-
- self.aspp = layers_new.ASPPModule(nout * 8, nout * 8, dilations, dropout=True)
-
- self.dec4 = layers_new.Decoder(nout * (6 + 8), nout * 6, 3, 1, 1)
- self.dec3 = layers_new.Decoder(nout * (4 + 6), nout * 4, 3, 1, 1)
- self.dec2 = layers_new.Decoder(nout * (2 + 4), nout * 2, 3, 1, 1)
- self.lstm_dec2 = layers_new.LSTMModule(nout * 2, nin_lstm, nout_lstm)
- self.dec1 = layers_new.Decoder(nout * (1 + 2) + 1, nout * 1, 3, 1, 1)
-
- def __call__(self, x):
- e1 = self.enc1(x)
- e2 = self.enc2(e1)
- e3 = self.enc3(e2)
- e4 = self.enc4(e3)
- e5 = self.enc5(e4)
-
- h = self.aspp(e5)
-
- h = self.dec4(h, e4)
- h = self.dec3(h, e3)
- h = self.dec2(h, e2)
- h = torch.cat([h, self.lstm_dec2(h)], dim=1)
- h = self.dec1(h, e1)
-
- return h
-
-
-class CascadedNet(nn.Module):
- def __init__(self, n_fft, nout=32, nout_lstm=128):
- super(CascadedNet, self).__init__()
-
- self.max_bin = n_fft // 2
- self.output_bin = n_fft // 2 + 1
- self.nin_lstm = self.max_bin // 2
- self.offset = 64
-
- self.stg1_low_band_net = nn.Sequential(
- BaseNet(2, nout // 2, self.nin_lstm // 2, nout_lstm),
- layers_new.Conv2DBNActiv(nout // 2, nout // 4, 1, 1, 0),
- )
-
- self.stg1_high_band_net = BaseNet(
- 2, nout // 4, self.nin_lstm // 2, nout_lstm // 2
- )
-
- self.stg2_low_band_net = nn.Sequential(
- BaseNet(nout // 4 + 2, nout, self.nin_lstm // 2, nout_lstm),
- layers_new.Conv2DBNActiv(nout, nout // 2, 1, 1, 0),
- )
- self.stg2_high_band_net = BaseNet(
- nout // 4 + 2, nout // 2, self.nin_lstm // 2, nout_lstm // 2
- )
-
- self.stg3_full_band_net = BaseNet(
- 3 * nout // 4 + 2, nout, self.nin_lstm, nout_lstm
- )
-
- self.out = nn.Conv2d(nout, 2, 1, bias=False)
- self.aux_out = nn.Conv2d(3 * nout // 4, 2, 1, bias=False)
-
- def forward(self, x):
- x = x[:, :, : self.max_bin]
-
- bandw = x.size()[2] // 2
- l1_in = x[:, :, :bandw]
- h1_in = x[:, :, bandw:]
- l1 = self.stg1_low_band_net(l1_in)
- h1 = self.stg1_high_band_net(h1_in)
- aux1 = torch.cat([l1, h1], dim=2)
-
- l2_in = torch.cat([l1_in, l1], dim=1)
- h2_in = torch.cat([h1_in, h1], dim=1)
- l2 = self.stg2_low_band_net(l2_in)
- h2 = self.stg2_high_band_net(h2_in)
- aux2 = torch.cat([l2, h2], dim=2)
-
- f3_in = torch.cat([x, aux1, aux2], dim=1)
- f3 = self.stg3_full_band_net(f3_in)
-
- mask = torch.sigmoid(self.out(f3))
- mask = F.pad(
- input=mask,
- pad=(0, 0, 0, self.output_bin - mask.size()[2]),
- mode="replicate",
- )
-
- if self.training:
- aux = torch.cat([aux1, aux2], dim=1)
- aux = torch.sigmoid(self.aux_out(aux))
- aux = F.pad(
- input=aux,
- pad=(0, 0, 0, self.output_bin - aux.size()[2]),
- mode="replicate",
- )
- return mask, aux
- else:
- return mask
-
- def predict_mask(self, x):
- mask = self.forward(x)
-
- if self.offset > 0:
- mask = mask[:, :, :, self.offset : -self.offset]
- assert mask.size()[3] > 0
-
- return mask
-
- def predict(self, x, aggressiveness=None):
- mask = self.forward(x)
- pred_mag = x * mask
-
- if self.offset > 0:
- pred_mag = pred_mag[:, :, :, self.offset : -self.offset]
- assert pred_mag.size()[3] > 0
-
- return pred_mag
diff --git a/spaces/Benson/text-generation/Examples/Casa Escapar Hack Descargar.md b/spaces/Benson/text-generation/Examples/Casa Escapar Hack Descargar.md
deleted file mode 100644
index aa6aa637e0bcbb279af8ed2c2b31080d7ea36bfd..0000000000000000000000000000000000000000
--- a/spaces/Benson/text-generation/Examples/Casa Escapar Hack Descargar.md
+++ /dev/null
@@ -1,56 +0,0 @@
-
-
Inicio Escape Hack Descargar: Cómo hacer trampa en Homescapes?
-
Si eres un fan de los juegos de puzzle casual, es posible que hayas oído hablar de Homescapes, uno de los juegos más populares en este género. Homescapes es un juego en el que tienes que ayudar a Austin, el mayordomo, a renovar su antigua mansión resolviendo puzzles de match-3 y completando varias tareas. El juego es divertido y adictivo, pero también puede ser frustrante y caro si te quedas sin monedas y estrellas, las monedas del juego que necesitas para comprar objetos, desbloquear niveles y progresar en la historia.
Es por eso que muchos jugadores están buscando una manera de engañar en Homescapes y obtener monedas y estrellas ilimitadas de forma gratuita. Si eres uno de ellos, estás de suerte, porque en este artículo, te mostraremos cómo descargar y usar el hack Homescapes, una herramienta que puede generar recursos ilimitados para tu cuenta en minutos. También explicaremos las características y beneficios de usar este hack, y responderemos algunas preguntas frecuentes sobre él. Así que, sin más preámbulos, ¡empecemos!
-
Introducción
-
¿Qué es Homescapes?
-
Homescapes es un juego móvil gratuito desarrollado por Playrix, la misma compañía detrás de otros juegos populares como Gardenscapes y Township. El juego fue lanzado en 2017 y desde entonces ha ganado millones de descargas y críticas positivas de jugadores de todo el mundo. El juego está disponible para dispositivos iOS y Android.
-
En Homescapes, juegas como Austin, un mayordomo amable y leal que regresa a su hogar de la infancia después de muchos años. Descubre que sus padres están planeando vender la vieja mansión porque es demasiado deteriorada y cara de mantener. Austin decide ayudar a sus padres a restaurar la mansión a su antigua gloria renovando cada habitación y haciéndola más acogedora y cómoda. Para ello, necesita tu ayuda para resolver puzzles de match-3 y ganar monedas y estrellas.
-
-
¿Por qué necesitas un hack para Homescapes?
-
Homescapes es un juego divertido y relajante, pero también puede ser muy desafiante y exigente a veces. Algunos niveles son difíciles de superar, especialmente si tienes movimientos o tiempo limitados. También puede encontrar obstáculos como cajas, cadenas, galletas, alfombras, etc., que hacen que los rompecabezas más difícil. Para superar estos desafíos, es posible que tengas que usar potenciadores o potenciadores, como cohetes, bombas, martillos, etc., que pueden ayudarte a limpiar el tablero más rápido.
-
-
Sin embargo, estos boosters no son gratis. Tienes que comprarlos con monedas o ganarlos completando tareas o eventos. Las monedas también son necesarias para comprar artículos para la renovación de su hogar o desbloquear nuevos niveles. Las estrellas son otra moneda que necesitas para completar tareas o avanzar en la historia. Puedes ganar estrellas superando niveles, pero no son fáciles de conseguir.
-
Como resultado, muchos jugadores se encuentran atascados o frustrados en el juego porque no tienen suficientes monedas o estrellas para seguir jugando. También podrían sentirse tentados a gastar dinero real en comprar más recursos de la tienda del juego. Sin embargo, esto puede ser muy costoso y arriesgado, ya que podría terminar gastando su dinero en algo que no vale la pena.
¿Cómo descargar y usar el hack de Homescapes?
-
Si quieres hacer trampa en Homescapes y obtener monedas y estrellas ilimitadas de forma gratuita, es necesario descargar y utilizar el hack Homescapes, una herramienta que puede generar recursos para su cuenta en minutos. El hack de Homescapes es una aplicación simple y fácil de usar que puede instalar en su dispositivo o acceder en línea. Aquí están los pasos a seguir para descargar y utilizar el hack Homescapes:
-
-
Haga clic en el enlace de abajo para ir a la página web oficial del hack Homescapes.
-
Introduzca su nombre de usuario o dirección de correo electrónico que utiliza para jugar Homescapes.
-
Seleccione la plataforma en la que juega (iOS o Android).
-
-
Haga clic en el botón "Generar" y espere unos segundos.
-
Verifica que no eres un robot completando una breve encuesta u oferta.
-
Revisa tu cuenta de Homescapes y disfruta de tus recursos gratuitos.
La característica principal del hack Homescapes es que puede generar monedas y estrellas ilimitadas para su cuenta. Puedes usar estos recursos para comprar potenciadores, objetos y desbloquear niveles en el juego. También puedes usarlos para completar tareas y avanzar en la historia. Usted no tiene que preocuparse de quedarse sin monedas o estrellas nunca más.
-
Libre y seguro de usar
-
El hack de Homescapes es completamente gratuito. No tienes que pagar nada para descargarlo o usarlo. Tampoco tienes que preocuparte por ningún virus, malware o spyware que pueda dañar tu dispositivo o comprometer tu privacidad. El hack de Homescapes es probado y actualizado regularmente para garantizar su seguridad y funcionalidad.
-
Compatible con dispositivos iOS y Android
-
El hackeo de Homescapes funciona tanto en dispositivos iOS como Android. No necesitas rootear o hacer jailbreak a tu dispositivo para usarlo. Solo tiene que instalarlo o acceder a él en línea y siga las instrucciones. El hack de Homescapes detectará automáticamente tu dispositivo y se ajustará en consecuencia.
-
No se requiere raíz o jailbreak
-
Como se mencionó anteriormente, no es necesario erradicar o jailbreak su dispositivo para utilizar el hack Homescapes. Esto significa que no tiene que arriesgarse a dañar su dispositivo o anular su garantía. Tampoco tiene que preocuparse por cualquier problema de compatibilidad o errores que puedan ocurrir. El hack Homescapes está diseñado para funcionar sin problemas y sin problemas en cualquier dispositivo.
Beneficios de usar el hack Homescapes
-
Ahorre tiempo y dinero
-
-
Disfruta del juego sin limitaciones
-
Otro beneficio de usar el hack de Homescapes es que puedes disfrutar del juego sin limitaciones. No tienes que esperar a que las vidas se llenen o ver anuncios para obtener movimientos adicionales. No tienes que lidiar con las molestas ventanas emergentes o notificaciones que te instan a comprar más recursos. Puedes jugar el juego tanto como quieras y tanto como quieras.
-
Personaliza tu hogar como quieras
-
Un tercer beneficio de usar el hack Homescapes es que puede personalizar su hogar como desee. Puedes comprar cualquier mueble, decoración, papel pintado, alfombra o artículo que te guste. También puedes cambiarlos cuando quieras. Puedes crear la casa de tus sueños y expresar tu creatividad y estilo.
-
Impresiona a tus amigos y familiares
-
Un cuarto beneficio de usar el hack de Homescapes es que puedes impresionar a tus amigos y familiares. Puedes mostrarles tu increíble hogar y tu progreso en el juego. También puede invitarlos a jugar con usted y ayudarlos con su propia renovación de la casa. Puede divertirse y vincularse con sus seres queridos en este juego.
-
Conclusión
-
En conclusión, Homescapes es un gran juego que puedes jugar en tu dispositivo móvil. Es divertido, relajante y adictivo, pero también puede ser desafiante y caro si no tienes suficientes monedas y estrellas. Es por eso que necesitas descargar y usar el hack de Homescapes, una herramienta que puede generar recursos ilimitados para tu cuenta en minutos. El hack Homescapes es gratis, seguro, compatible y fácil de usar. Tiene muchas características y beneficios que harán que tu experiencia de juego sea más agradable y satisfactoria. Entonces, ¿qué estás esperando? Descargar el hack Homescapes hoy y empezar a hacer trampa en Homescapes!
-
Preguntas frecuentes
-
Aquí hay algunas preguntas frecuentes sobre el hack Homescapes:
-
-
-
¿Es seguro el hackeo de Homescapes? El hack de Homescapes es seguro de usar, siempre y cuando lo descargues de una fuente confiable y sigas las instrucciones cuidadosamente. El hackeo de Homescapes no contiene ningún virus, malware o spyware que pueda dañar su dispositivo o comprometer su privacidad. También se actualiza periódicamente para garantizar su seguridad y funcionalidad.
-
¿Me prohibirán por usar el hack de Homescapes? Hay una baja probabilidad de que se le prohibió el uso del hack Homescapes, siempre y cuando se utiliza sabiamente y moderadamente. El hack de Homescapes tiene un sistema anti-van incorporado que protege su cuenta de la detección y suspensión por los servidores del juego. Sin embargo, no debe abusar o abusar del hackeo, ya que esto podría levantar sospechas o desencadenar una alerta roja. También debes evitar presumir o jactarte de tus logros en el juego, ya que esto podría atraer atención no deseada o celos de otros jugadores.
-
¿Con qué frecuencia puedo utilizar el hack Homescapes? Puedes usar el hack de Homescapes tantas veces como quieras, pero te recomendamos que lo uses con moderación y solo cuando lo necesites. El hack Homescapes está destinado a mejorar su experiencia de juego, no para arruinarlo. Usted todavía debe jugar el juego normalmente y disfrutar de sus características y desafíos. También debes respetar a otros jugadores y no arruinar su diversión o experiencia haciendo trampa.
-
¿Puedo compartir el hack Homescapes con otros? Puedes compartir el hack de Homescapes con otros, pero solo con personas en las que confías y que conoces bien. No debe compartirlo con extraños o foros públicos, ya que esto podría exponer su cuenta o dispositivo a riesgos o peligros. Tampoco deberías vender o intercambiar los Homescapes por dinero u otros beneficios, ya que esto podría ser ilegal o poco ético. También debe respetar los derechos y deseos del desarrollador de Homescapes, que podría no aprobar el uso del hack.
-
64aa2da5cf
-
-
\ No newline at end of file
diff --git a/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_internal/network/lazy_wheel.py b/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_internal/network/lazy_wheel.py
deleted file mode 100644
index 82ec50d5106ff0ac41dd1c03c2a789dbc468c401..0000000000000000000000000000000000000000
--- a/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_internal/network/lazy_wheel.py
+++ /dev/null
@@ -1,210 +0,0 @@
-"""Lazy ZIP over HTTP"""
-
-__all__ = ["HTTPRangeRequestUnsupported", "dist_from_wheel_url"]
-
-from bisect import bisect_left, bisect_right
-from contextlib import contextmanager
-from tempfile import NamedTemporaryFile
-from typing import Any, Dict, Generator, List, Optional, Tuple
-from zipfile import BadZipFile, ZipFile
-
-from pip._vendor.packaging.utils import canonicalize_name
-from pip._vendor.requests.models import CONTENT_CHUNK_SIZE, Response
-
-from pip._internal.metadata import BaseDistribution, MemoryWheel, get_wheel_distribution
-from pip._internal.network.session import PipSession
-from pip._internal.network.utils import HEADERS, raise_for_status, response_chunks
-
-
-class HTTPRangeRequestUnsupported(Exception):
- pass
-
-
-def dist_from_wheel_url(name: str, url: str, session: PipSession) -> BaseDistribution:
- """Return a distribution object from the given wheel URL.
-
- This uses HTTP range requests to only fetch the portion of the wheel
- containing metadata, just enough for the object to be constructed.
- If such requests are not supported, HTTPRangeRequestUnsupported
- is raised.
- """
- with LazyZipOverHTTP(url, session) as zf:
- # For read-only ZIP files, ZipFile only needs methods read,
- # seek, seekable and tell, not the whole IO protocol.
- wheel = MemoryWheel(zf.name, zf) # type: ignore
- # After context manager exit, wheel.name
- # is an invalid file by intention.
- return get_wheel_distribution(wheel, canonicalize_name(name))
-
-
-class LazyZipOverHTTP:
- """File-like object mapped to a ZIP file over HTTP.
-
- This uses HTTP range requests to lazily fetch the file's content,
- which is supposed to be fed to ZipFile. If such requests are not
- supported by the server, raise HTTPRangeRequestUnsupported
- during initialization.
- """
-
- def __init__(
- self, url: str, session: PipSession, chunk_size: int = CONTENT_CHUNK_SIZE
- ) -> None:
- head = session.head(url, headers=HEADERS)
- raise_for_status(head)
- assert head.status_code == 200
- self._session, self._url, self._chunk_size = session, url, chunk_size
- self._length = int(head.headers["Content-Length"])
- self._file = NamedTemporaryFile()
- self.truncate(self._length)
- self._left: List[int] = []
- self._right: List[int] = []
- if "bytes" not in head.headers.get("Accept-Ranges", "none"):
- raise HTTPRangeRequestUnsupported("range request is not supported")
- self._check_zip()
-
- @property
- def mode(self) -> str:
- """Opening mode, which is always rb."""
- return "rb"
-
- @property
- def name(self) -> str:
- """Path to the underlying file."""
- return self._file.name
-
- def seekable(self) -> bool:
- """Return whether random access is supported, which is True."""
- return True
-
- def close(self) -> None:
- """Close the file."""
- self._file.close()
-
- @property
- def closed(self) -> bool:
- """Whether the file is closed."""
- return self._file.closed
-
- def read(self, size: int = -1) -> bytes:
- """Read up to size bytes from the object and return them.
-
- As a convenience, if size is unspecified or -1,
- all bytes until EOF are returned. Fewer than
- size bytes may be returned if EOF is reached.
- """
- download_size = max(size, self._chunk_size)
- start, length = self.tell(), self._length
- stop = length if size < 0 else min(start + download_size, length)
- start = max(0, stop - download_size)
- self._download(start, stop - 1)
- return self._file.read(size)
-
- def readable(self) -> bool:
- """Return whether the file is readable, which is True."""
- return True
-
- def seek(self, offset: int, whence: int = 0) -> int:
- """Change stream position and return the new absolute position.
-
- Seek to offset relative position indicated by whence:
- * 0: Start of stream (the default). pos should be >= 0;
- * 1: Current position - pos may be negative;
- * 2: End of stream - pos usually negative.
- """
- return self._file.seek(offset, whence)
-
- def tell(self) -> int:
- """Return the current position."""
- return self._file.tell()
-
- def truncate(self, size: Optional[int] = None) -> int:
- """Resize the stream to the given size in bytes.
-
- If size is unspecified resize to the current position.
- The current stream position isn't changed.
-
- Return the new file size.
- """
- return self._file.truncate(size)
-
- def writable(self) -> bool:
- """Return False."""
- return False
-
- def __enter__(self) -> "LazyZipOverHTTP":
- self._file.__enter__()
- return self
-
- def __exit__(self, *exc: Any) -> None:
- self._file.__exit__(*exc)
-
- @contextmanager
- def _stay(self) -> Generator[None, None, None]:
- """Return a context manager keeping the position.
-
- At the end of the block, seek back to original position.
- """
- pos = self.tell()
- try:
- yield
- finally:
- self.seek(pos)
-
- def _check_zip(self) -> None:
- """Check and download until the file is a valid ZIP."""
- end = self._length - 1
- for start in reversed(range(0, end, self._chunk_size)):
- self._download(start, end)
- with self._stay():
- try:
- # For read-only ZIP files, ZipFile only needs
- # methods read, seek, seekable and tell.
- ZipFile(self) # type: ignore
- except BadZipFile:
- pass
- else:
- break
-
- def _stream_response(
- self, start: int, end: int, base_headers: Dict[str, str] = HEADERS
- ) -> Response:
- """Return HTTP response to a range request from start to end."""
- headers = base_headers.copy()
- headers["Range"] = f"bytes={start}-{end}"
- # TODO: Get range requests to be correctly cached
- headers["Cache-Control"] = "no-cache"
- return self._session.get(self._url, headers=headers, stream=True)
-
- def _merge(
- self, start: int, end: int, left: int, right: int
- ) -> Generator[Tuple[int, int], None, None]:
- """Return a generator of intervals to be fetched.
-
- Args:
- start (int): Start of needed interval
- end (int): End of needed interval
- left (int): Index of first overlapping downloaded data
- right (int): Index after last overlapping downloaded data
- """
- lslice, rslice = self._left[left:right], self._right[left:right]
- i = start = min([start] + lslice[:1])
- end = max([end] + rslice[-1:])
- for j, k in zip(lslice, rslice):
- if j > i:
- yield i, j - 1
- i = k + 1
- if i <= end:
- yield i, end
- self._left[left:right], self._right[left:right] = [start], [end]
-
- def _download(self, start: int, end: int) -> None:
- """Download bytes from start to end inclusively."""
- with self._stay():
- left = bisect_left(self._right, start)
- right = bisect_right(self._left, end)
- for start, end in self._merge(start, end, left, right):
- response = self._stream_response(start, end)
- response.raise_for_status()
- self.seek(start)
- for chunk in response_chunks(response, self._chunk_size):
- self._file.write(chunk)
diff --git a/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/pygments/formatters/terminal256.py b/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/pygments/formatters/terminal256.py
deleted file mode 100644
index 201b3c3283218f45d5cfa192a07c9e9d991eaaff..0000000000000000000000000000000000000000
--- a/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/pygments/formatters/terminal256.py
+++ /dev/null
@@ -1,338 +0,0 @@
-"""
- pygments.formatters.terminal256
- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
- Formatter for 256-color terminal output with ANSI sequences.
-
- RGB-to-XTERM color conversion routines adapted from xterm256-conv
- tool (http://frexx.de/xterm-256-notes/data/xterm256-conv2.tar.bz2)
- by Wolfgang Frisch.
-
- Formatter version 1.
-
- :copyright: Copyright 2006-2022 by the Pygments team, see AUTHORS.
- :license: BSD, see LICENSE for details.
-"""
-
-# TODO:
-# - Options to map style's bold/underline/italic/border attributes
-# to some ANSI attrbutes (something like 'italic=underline')
-# - An option to output "style RGB to xterm RGB/index" conversion table
-# - An option to indicate that we are running in "reverse background"
-# xterm. This means that default colors are white-on-black, not
-# black-on-while, so colors like "white background" need to be converted
-# to "white background, black foreground", etc...
-
-from pip._vendor.pygments.formatter import Formatter
-from pip._vendor.pygments.console import codes
-from pip._vendor.pygments.style import ansicolors
-
-
-__all__ = ['Terminal256Formatter', 'TerminalTrueColorFormatter']
-
-
-class EscapeSequence:
- def __init__(self, fg=None, bg=None, bold=False, underline=False, italic=False):
- self.fg = fg
- self.bg = bg
- self.bold = bold
- self.underline = underline
- self.italic = italic
-
- def escape(self, attrs):
- if len(attrs):
- return "\x1b[" + ";".join(attrs) + "m"
- return ""
-
- def color_string(self):
- attrs = []
- if self.fg is not None:
- if self.fg in ansicolors:
- esc = codes[self.fg.replace('ansi','')]
- if ';01m' in esc:
- self.bold = True
- # extract fg color code.
- attrs.append(esc[2:4])
- else:
- attrs.extend(("38", "5", "%i" % self.fg))
- if self.bg is not None:
- if self.bg in ansicolors:
- esc = codes[self.bg.replace('ansi','')]
- # extract fg color code, add 10 for bg.
- attrs.append(str(int(esc[2:4])+10))
- else:
- attrs.extend(("48", "5", "%i" % self.bg))
- if self.bold:
- attrs.append("01")
- if self.underline:
- attrs.append("04")
- if self.italic:
- attrs.append("03")
- return self.escape(attrs)
-
- def true_color_string(self):
- attrs = []
- if self.fg:
- attrs.extend(("38", "2", str(self.fg[0]), str(self.fg[1]), str(self.fg[2])))
- if self.bg:
- attrs.extend(("48", "2", str(self.bg[0]), str(self.bg[1]), str(self.bg[2])))
- if self.bold:
- attrs.append("01")
- if self.underline:
- attrs.append("04")
- if self.italic:
- attrs.append("03")
- return self.escape(attrs)
-
- def reset_string(self):
- attrs = []
- if self.fg is not None:
- attrs.append("39")
- if self.bg is not None:
- attrs.append("49")
- if self.bold or self.underline or self.italic:
- attrs.append("00")
- return self.escape(attrs)
-
-
-class Terminal256Formatter(Formatter):
- """
- Format tokens with ANSI color sequences, for output in a 256-color
- terminal or console. Like in `TerminalFormatter` color sequences
- are terminated at newlines, so that paging the output works correctly.
-
- The formatter takes colors from a style defined by the `style` option
- and converts them to nearest ANSI 256-color escape sequences. Bold and
- underline attributes from the style are preserved (and displayed).
-
- .. versionadded:: 0.9
-
- .. versionchanged:: 2.2
- If the used style defines foreground colors in the form ``#ansi*``, then
- `Terminal256Formatter` will map these to non extended foreground color.
- See :ref:`AnsiTerminalStyle` for more information.
-
- .. versionchanged:: 2.4
- The ANSI color names have been updated with names that are easier to
- understand and align with colornames of other projects and terminals.
- See :ref:`this table ` for more information.
-
-
- Options accepted:
-
- `style`
- The style to use, can be a string or a Style subclass (default:
- ``'default'``).
-
- `linenos`
- Set to ``True`` to have line numbers on the terminal output as well
- (default: ``False`` = no line numbers).
- """
- name = 'Terminal256'
- aliases = ['terminal256', 'console256', '256']
- filenames = []
-
- def __init__(self, **options):
- Formatter.__init__(self, **options)
-
- self.xterm_colors = []
- self.best_match = {}
- self.style_string = {}
-
- self.usebold = 'nobold' not in options
- self.useunderline = 'nounderline' not in options
- self.useitalic = 'noitalic' not in options
-
- self._build_color_table() # build an RGB-to-256 color conversion table
- self._setup_styles() # convert selected style's colors to term. colors
-
- self.linenos = options.get('linenos', False)
- self._lineno = 0
-
- def _build_color_table(self):
- # colors 0..15: 16 basic colors
-
- self.xterm_colors.append((0x00, 0x00, 0x00)) # 0
- self.xterm_colors.append((0xcd, 0x00, 0x00)) # 1
- self.xterm_colors.append((0x00, 0xcd, 0x00)) # 2
- self.xterm_colors.append((0xcd, 0xcd, 0x00)) # 3
- self.xterm_colors.append((0x00, 0x00, 0xee)) # 4
- self.xterm_colors.append((0xcd, 0x00, 0xcd)) # 5
- self.xterm_colors.append((0x00, 0xcd, 0xcd)) # 6
- self.xterm_colors.append((0xe5, 0xe5, 0xe5)) # 7
- self.xterm_colors.append((0x7f, 0x7f, 0x7f)) # 8
- self.xterm_colors.append((0xff, 0x00, 0x00)) # 9
- self.xterm_colors.append((0x00, 0xff, 0x00)) # 10
- self.xterm_colors.append((0xff, 0xff, 0x00)) # 11
- self.xterm_colors.append((0x5c, 0x5c, 0xff)) # 12
- self.xterm_colors.append((0xff, 0x00, 0xff)) # 13
- self.xterm_colors.append((0x00, 0xff, 0xff)) # 14
- self.xterm_colors.append((0xff, 0xff, 0xff)) # 15
-
- # colors 16..232: the 6x6x6 color cube
-
- valuerange = (0x00, 0x5f, 0x87, 0xaf, 0xd7, 0xff)
-
- for i in range(217):
- r = valuerange[(i // 36) % 6]
- g = valuerange[(i // 6) % 6]
- b = valuerange[i % 6]
- self.xterm_colors.append((r, g, b))
-
- # colors 233..253: grayscale
-
- for i in range(1, 22):
- v = 8 + i * 10
- self.xterm_colors.append((v, v, v))
-
- def _closest_color(self, r, g, b):
- distance = 257*257*3 # "infinity" (>distance from #000000 to #ffffff)
- match = 0
-
- for i in range(0, 254):
- values = self.xterm_colors[i]
-
- rd = r - values[0]
- gd = g - values[1]
- bd = b - values[2]
- d = rd*rd + gd*gd + bd*bd
-
- if d < distance:
- match = i
- distance = d
- return match
-
- def _color_index(self, color):
- index = self.best_match.get(color, None)
- if color in ansicolors:
- # strip the `ansi/#ansi` part and look up code
- index = color
- self.best_match[color] = index
- if index is None:
- try:
- rgb = int(str(color), 16)
- except ValueError:
- rgb = 0
-
- r = (rgb >> 16) & 0xff
- g = (rgb >> 8) & 0xff
- b = rgb & 0xff
- index = self._closest_color(r, g, b)
- self.best_match[color] = index
- return index
-
- def _setup_styles(self):
- for ttype, ndef in self.style:
- escape = EscapeSequence()
- # get foreground from ansicolor if set
- if ndef['ansicolor']:
- escape.fg = self._color_index(ndef['ansicolor'])
- elif ndef['color']:
- escape.fg = self._color_index(ndef['color'])
- if ndef['bgansicolor']:
- escape.bg = self._color_index(ndef['bgansicolor'])
- elif ndef['bgcolor']:
- escape.bg = self._color_index(ndef['bgcolor'])
- if self.usebold and ndef['bold']:
- escape.bold = True
- if self.useunderline and ndef['underline']:
- escape.underline = True
- if self.useitalic and ndef['italic']:
- escape.italic = True
- self.style_string[str(ttype)] = (escape.color_string(),
- escape.reset_string())
-
- def _write_lineno(self, outfile):
- self._lineno += 1
- outfile.write("%s%04d: " % (self._lineno != 1 and '\n' or '', self._lineno))
-
- def format(self, tokensource, outfile):
- return Formatter.format(self, tokensource, outfile)
-
- def format_unencoded(self, tokensource, outfile):
- if self.linenos:
- self._write_lineno(outfile)
-
- for ttype, value in tokensource:
- not_found = True
- while ttype and not_found:
- try:
- # outfile.write( "<" + str(ttype) + ">" )
- on, off = self.style_string[str(ttype)]
-
- # Like TerminalFormatter, add "reset colors" escape sequence
- # on newline.
- spl = value.split('\n')
- for line in spl[:-1]:
- if line:
- outfile.write(on + line + off)
- if self.linenos:
- self._write_lineno(outfile)
- else:
- outfile.write('\n')
-
- if spl[-1]:
- outfile.write(on + spl[-1] + off)
-
- not_found = False
- # outfile.write( '#' + str(ttype) + '#' )
-
- except KeyError:
- # ottype = ttype
- ttype = ttype.parent
- # outfile.write( '!' + str(ottype) + '->' + str(ttype) + '!' )
-
- if not_found:
- outfile.write(value)
-
- if self.linenos:
- outfile.write("\n")
-
-
-
-class TerminalTrueColorFormatter(Terminal256Formatter):
- r"""
- Format tokens with ANSI color sequences, for output in a true-color
- terminal or console. Like in `TerminalFormatter` color sequences
- are terminated at newlines, so that paging the output works correctly.
-
- .. versionadded:: 2.1
-
- Options accepted:
-
- `style`
- The style to use, can be a string or a Style subclass (default:
- ``'default'``).
- """
- name = 'TerminalTrueColor'
- aliases = ['terminal16m', 'console16m', '16m']
- filenames = []
-
- def _build_color_table(self):
- pass
-
- def _color_tuple(self, color):
- try:
- rgb = int(str(color), 16)
- except ValueError:
- return None
- r = (rgb >> 16) & 0xff
- g = (rgb >> 8) & 0xff
- b = rgb & 0xff
- return (r, g, b)
-
- def _setup_styles(self):
- for ttype, ndef in self.style:
- escape = EscapeSequence()
- if ndef['color']:
- escape.fg = self._color_tuple(ndef['color'])
- if ndef['bgcolor']:
- escape.bg = self._color_tuple(ndef['bgcolor'])
- if self.usebold and ndef['bold']:
- escape.bold = True
- if self.useunderline and ndef['underline']:
- escape.underline = True
- if self.useitalic and ndef['italic']:
- escape.italic = True
- self.style_string[str(ttype)] = (escape.true_color_string(),
- escape.reset_string())
diff --git a/spaces/Big-Web/MMSD/env/Lib/site-packages/setuptools/_vendor/importlib_metadata/_collections.py b/spaces/Big-Web/MMSD/env/Lib/site-packages/setuptools/_vendor/importlib_metadata/_collections.py
deleted file mode 100644
index cf0954e1a30546d781bf25781ec716ef92a77e32..0000000000000000000000000000000000000000
--- a/spaces/Big-Web/MMSD/env/Lib/site-packages/setuptools/_vendor/importlib_metadata/_collections.py
+++ /dev/null
@@ -1,30 +0,0 @@
-import collections
-
-
-# from jaraco.collections 3.3
-class FreezableDefaultDict(collections.defaultdict):
- """
- Often it is desirable to prevent the mutation of
- a default dict after its initial construction, such
- as to prevent mutation during iteration.
-
- >>> dd = FreezableDefaultDict(list)
- >>> dd[0].append('1')
- >>> dd.freeze()
- >>> dd[1]
- []
- >>> len(dd)
- 1
- """
-
- def __missing__(self, key):
- return getattr(self, '_frozen', super().__missing__)(key)
-
- def freeze(self):
- self._frozen = lambda key: self.default_factory()
-
-
-class Pair(collections.namedtuple('Pair', 'name value')):
- @classmethod
- def parse(cls, text):
- return cls(*map(str.strip, text.split("=", 1)))
diff --git a/spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/detectron2/structures/instances.py b/spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/detectron2/structures/instances.py
deleted file mode 100644
index 1d1ac9c70befe3f0c1ebc2fbd918425ce5608674..0000000000000000000000000000000000000000
--- a/spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/detectron2/structures/instances.py
+++ /dev/null
@@ -1,187 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-import itertools
-from typing import Any, Dict, List, Tuple, Union
-import torch
-
-from detectron2.layers import cat
-
-
-class Instances:
- """
- This class represents a list of instances in an image.
- It stores the attributes of instances (e.g., boxes, masks, labels, scores) as "fields".
- All fields must have the same ``__len__`` which is the number of instances.
-
- All other (non-field) attributes of this class are considered private:
- they must start with '_' and are not modifiable by a user.
-
- Some basic usage:
-
- 1. Set/Get a field:
-
- .. code-block:: python
-
- instances.gt_boxes = Boxes(...)
- print(instances.pred_masks) # a tensor of shape (N, H, W)
- print('gt_masks' in instances)
-
- 2. ``len(instances)`` returns the number of instances
- 3. Indexing: ``instances[indices]`` will apply the indexing on all the fields
- and returns a new :class:`Instances`.
- Typically, ``indices`` is a integer vector of indices,
- or a binary mask of length ``num_instances``,
- """
-
- def __init__(self, image_size: Tuple[int, int], **kwargs: Any):
- """
- Args:
- image_size (height, width): the spatial size of the image.
- kwargs: fields to add to this `Instances`.
- """
- self._image_size = image_size
- self._fields: Dict[str, Any] = {}
- for k, v in kwargs.items():
- self.set(k, v)
-
- @property
- def image_size(self) -> Tuple[int, int]:
- """
- Returns:
- tuple: height, width
- """
- return self._image_size
-
- def __setattr__(self, name: str, val: Any) -> None:
- if name.startswith("_"):
- super().__setattr__(name, val)
- else:
- self.set(name, val)
-
- def __getattr__(self, name: str) -> Any:
- if name == "_fields" or name not in self._fields:
- raise AttributeError("Cannot find field '{}' in the given Instances!".format(name))
- return self._fields[name]
-
- def set(self, name: str, value: Any) -> None:
- """
- Set the field named `name` to `value`.
- The length of `value` must be the number of instances,
- and must agree with other existing fields in this object.
- """
- data_len = len(value)
- if len(self._fields):
- assert (
- len(self) == data_len
- ), "Adding a field of length {} to a Instances of length {}".format(data_len, len(self))
- self._fields[name] = value
-
- def has(self, name: str) -> bool:
- """
- Returns:
- bool: whether the field called `name` exists.
- """
- return name in self._fields
-
- def remove(self, name: str) -> None:
- """
- Remove the field called `name`.
- """
- del self._fields[name]
-
- def get(self, name: str) -> Any:
- """
- Returns the field called `name`.
- """
- return self._fields[name]
-
- def get_fields(self) -> Dict[str, Any]:
- """
- Returns:
- dict: a dict which maps names (str) to data of the fields
-
- Modifying the returned dict will modify this instance.
- """
- return self._fields
-
- # Tensor-like methods
- def to(self, device: str) -> "Instances":
- """
- Returns:
- Instances: all fields are called with a `to(device)`, if the field has this method.
- """
- ret = Instances(self._image_size)
- for k, v in self._fields.items():
- if hasattr(v, "to"):
- v = v.to(device)
- ret.set(k, v)
- return ret
-
- def __getitem__(self, item: Union[int, slice, torch.BoolTensor]) -> "Instances":
- """
- Args:
- item: an index-like object and will be used to index all the fields.
-
- Returns:
- If `item` is a string, return the data in the corresponding field.
- Otherwise, returns an `Instances` where all fields are indexed by `item`.
- """
- if type(item) == int:
- if item >= len(self) or item < -len(self):
- raise IndexError("Instances index out of range!")
- else:
- item = slice(item, None, len(self))
-
- ret = Instances(self._image_size)
- for k, v in self._fields.items():
- ret.set(k, v[item])
- return ret
-
- def __len__(self) -> int:
- for v in self._fields.values():
- return len(v)
- raise NotImplementedError("Empty Instances does not support __len__!")
-
- def __iter__(self):
- raise NotImplementedError("`Instances` object is not iterable!")
-
- @staticmethod
- def cat(instance_lists: List["Instances"]) -> "Instances":
- """
- Args:
- instance_lists (list[Instances])
-
- Returns:
- Instances
- """
- assert all(isinstance(i, Instances) for i in instance_lists)
- assert len(instance_lists) > 0
- if len(instance_lists) == 1:
- return instance_lists[0]
-
- image_size = instance_lists[0].image_size
- for i in instance_lists[1:]:
- assert i.image_size == image_size
- ret = Instances(image_size)
- for k in instance_lists[0]._fields.keys():
- values = [i.get(k) for i in instance_lists]
- v0 = values[0]
- if isinstance(v0, torch.Tensor):
- values = cat(values, dim=0)
- elif isinstance(v0, list):
- values = list(itertools.chain(*values))
- elif hasattr(type(v0), "cat"):
- values = type(v0).cat(values)
- else:
- raise ValueError("Unsupported type {} for concatenation".format(type(v0)))
- ret.set(k, values)
- return ret
-
- def __str__(self) -> str:
- s = self.__class__.__name__ + "("
- s += "num_instances={}, ".format(len(self))
- s += "image_height={}, ".format(self._image_size[0])
- s += "image_width={}, ".format(self._image_size[1])
- s += "fields=[{}])".format(", ".join((f"{k}: {v}" for k, v in self._fields.items())))
- return s
-
- __repr__ = __str__
diff --git a/spaces/CVPR/LIVE/pybind11/include/pybind11/numpy.h b/spaces/CVPR/LIVE/pybind11/include/pybind11/numpy.h
deleted file mode 100644
index 674450a631a49213a7fc83feed3a10e36934da61..0000000000000000000000000000000000000000
--- a/spaces/CVPR/LIVE/pybind11/include/pybind11/numpy.h
+++ /dev/null
@@ -1,1647 +0,0 @@
-/*
- pybind11/numpy.h: Basic NumPy support, vectorize() wrapper
-
- Copyright (c) 2016 Wenzel Jakob
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include "pybind11.h"
-#include "complex.h"
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-
-#if defined(_MSC_VER)
-# pragma warning(push)
-# pragma warning(disable: 4127) // warning C4127: Conditional expression is constant
-#endif
-
-/* This will be true on all flat address space platforms and allows us to reduce the
- whole npy_intp / ssize_t / Py_intptr_t business down to just ssize_t for all size
- and dimension types (e.g. shape, strides, indexing), instead of inflicting this
- upon the library user. */
-static_assert(sizeof(ssize_t) == sizeof(Py_intptr_t), "ssize_t != Py_intptr_t");
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-
-class array; // Forward declaration
-
-PYBIND11_NAMESPACE_BEGIN(detail)
-
-template <> struct handle_type_name { static constexpr auto name = _("numpy.ndarray"); };
-
-template struct npy_format_descriptor;
-
-struct PyArrayDescr_Proxy {
- PyObject_HEAD
- PyObject *typeobj;
- char kind;
- char type;
- char byteorder;
- char flags;
- int type_num;
- int elsize;
- int alignment;
- char *subarray;
- PyObject *fields;
- PyObject *names;
-};
-
-struct PyArray_Proxy {
- PyObject_HEAD
- char *data;
- int nd;
- ssize_t *dimensions;
- ssize_t *strides;
- PyObject *base;
- PyObject *descr;
- int flags;
-};
-
-struct PyVoidScalarObject_Proxy {
- PyObject_VAR_HEAD
- char *obval;
- PyArrayDescr_Proxy *descr;
- int flags;
- PyObject *base;
-};
-
-struct numpy_type_info {
- PyObject* dtype_ptr;
- std::string format_str;
-};
-
-struct numpy_internals {
- std::unordered_map registered_dtypes;
-
- numpy_type_info *get_type_info(const std::type_info& tinfo, bool throw_if_missing = true) {
- auto it = registered_dtypes.find(std::type_index(tinfo));
- if (it != registered_dtypes.end())
- return &(it->second);
- if (throw_if_missing)
- pybind11_fail(std::string("NumPy type info missing for ") + tinfo.name());
- return nullptr;
- }
-
- template numpy_type_info *get_type_info(bool throw_if_missing = true) {
- return get_type_info(typeid(typename std::remove_cv::type), throw_if_missing);
- }
-};
-
-inline PYBIND11_NOINLINE void load_numpy_internals(numpy_internals* &ptr) {
- ptr = &get_or_create_shared_data("_numpy_internals");
-}
-
-inline numpy_internals& get_numpy_internals() {
- static numpy_internals* ptr = nullptr;
- if (!ptr)
- load_numpy_internals(ptr);
- return *ptr;
-}
-
-template struct same_size {
- template using as = bool_constant;
-};
-
-template constexpr int platform_lookup() { return -1; }
-
-// Lookup a type according to its size, and return a value corresponding to the NumPy typenum.
-template
-constexpr int platform_lookup(int I, Ints... Is) {
- return sizeof(Concrete) == sizeof(T) ? I : platform_lookup(Is...);
-}
-
-struct npy_api {
- enum constants {
- NPY_ARRAY_C_CONTIGUOUS_ = 0x0001,
- NPY_ARRAY_F_CONTIGUOUS_ = 0x0002,
- NPY_ARRAY_OWNDATA_ = 0x0004,
- NPY_ARRAY_FORCECAST_ = 0x0010,
- NPY_ARRAY_ENSUREARRAY_ = 0x0040,
- NPY_ARRAY_ALIGNED_ = 0x0100,
- NPY_ARRAY_WRITEABLE_ = 0x0400,
- NPY_BOOL_ = 0,
- NPY_BYTE_, NPY_UBYTE_,
- NPY_SHORT_, NPY_USHORT_,
- NPY_INT_, NPY_UINT_,
- NPY_LONG_, NPY_ULONG_,
- NPY_LONGLONG_, NPY_ULONGLONG_,
- NPY_FLOAT_, NPY_DOUBLE_, NPY_LONGDOUBLE_,
- NPY_CFLOAT_, NPY_CDOUBLE_, NPY_CLONGDOUBLE_,
- NPY_OBJECT_ = 17,
- NPY_STRING_, NPY_UNICODE_, NPY_VOID_,
- // Platform-dependent normalization
- NPY_INT8_ = NPY_BYTE_,
- NPY_UINT8_ = NPY_UBYTE_,
- NPY_INT16_ = NPY_SHORT_,
- NPY_UINT16_ = NPY_USHORT_,
- // `npy_common.h` defines the integer aliases. In order, it checks:
- // NPY_BITSOF_LONG, NPY_BITSOF_LONGLONG, NPY_BITSOF_INT, NPY_BITSOF_SHORT, NPY_BITSOF_CHAR
- // and assigns the alias to the first matching size, so we should check in this order.
- NPY_INT32_ = platform_lookup(
- NPY_LONG_, NPY_INT_, NPY_SHORT_),
- NPY_UINT32_ = platform_lookup(
- NPY_ULONG_, NPY_UINT_, NPY_USHORT_),
- NPY_INT64_ = platform_lookup(
- NPY_LONG_, NPY_LONGLONG_, NPY_INT_),
- NPY_UINT64_ = platform_lookup(
- NPY_ULONG_, NPY_ULONGLONG_, NPY_UINT_),
- };
-
- typedef struct {
- Py_intptr_t *ptr;
- int len;
- } PyArray_Dims;
-
- static npy_api& get() {
- static npy_api api = lookup();
- return api;
- }
-
- bool PyArray_Check_(PyObject *obj) const {
- return (bool) PyObject_TypeCheck(obj, PyArray_Type_);
- }
- bool PyArrayDescr_Check_(PyObject *obj) const {
- return (bool) PyObject_TypeCheck(obj, PyArrayDescr_Type_);
- }
-
- unsigned int (*PyArray_GetNDArrayCFeatureVersion_)();
- PyObject *(*PyArray_DescrFromType_)(int);
- PyObject *(*PyArray_NewFromDescr_)
- (PyTypeObject *, PyObject *, int, Py_intptr_t const *,
- Py_intptr_t const *, void *, int, PyObject *);
- // Unused. Not removed because that affects ABI of the class.
- PyObject *(*PyArray_DescrNewFromType_)(int);
- int (*PyArray_CopyInto_)(PyObject *, PyObject *);
- PyObject *(*PyArray_NewCopy_)(PyObject *, int);
- PyTypeObject *PyArray_Type_;
- PyTypeObject *PyVoidArrType_Type_;
- PyTypeObject *PyArrayDescr_Type_;
- PyObject *(*PyArray_DescrFromScalar_)(PyObject *);
- PyObject *(*PyArray_FromAny_) (PyObject *, PyObject *, int, int, int, PyObject *);
- int (*PyArray_DescrConverter_) (PyObject *, PyObject **);
- bool (*PyArray_EquivTypes_) (PyObject *, PyObject *);
- int (*PyArray_GetArrayParamsFromObject_)(PyObject *, PyObject *, unsigned char, PyObject **, int *,
- Py_intptr_t *, PyObject **, PyObject *);
- PyObject *(*PyArray_Squeeze_)(PyObject *);
- // Unused. Not removed because that affects ABI of the class.
- int (*PyArray_SetBaseObject_)(PyObject *, PyObject *);
- PyObject* (*PyArray_Resize_)(PyObject*, PyArray_Dims*, int, int);
-private:
- enum functions {
- API_PyArray_GetNDArrayCFeatureVersion = 211,
- API_PyArray_Type = 2,
- API_PyArrayDescr_Type = 3,
- API_PyVoidArrType_Type = 39,
- API_PyArray_DescrFromType = 45,
- API_PyArray_DescrFromScalar = 57,
- API_PyArray_FromAny = 69,
- API_PyArray_Resize = 80,
- API_PyArray_CopyInto = 82,
- API_PyArray_NewCopy = 85,
- API_PyArray_NewFromDescr = 94,
- API_PyArray_DescrNewFromType = 96,
- API_PyArray_DescrConverter = 174,
- API_PyArray_EquivTypes = 182,
- API_PyArray_GetArrayParamsFromObject = 278,
- API_PyArray_Squeeze = 136,
- API_PyArray_SetBaseObject = 282
- };
-
- static npy_api lookup() {
- module m = module::import("numpy.core.multiarray");
- auto c = m.attr("_ARRAY_API");
-#if PY_MAJOR_VERSION >= 3
- void **api_ptr = (void **) PyCapsule_GetPointer(c.ptr(), NULL);
-#else
- void **api_ptr = (void **) PyCObject_AsVoidPtr(c.ptr());
-#endif
- npy_api api;
-#define DECL_NPY_API(Func) api.Func##_ = (decltype(api.Func##_)) api_ptr[API_##Func];
- DECL_NPY_API(PyArray_GetNDArrayCFeatureVersion);
- if (api.PyArray_GetNDArrayCFeatureVersion_() < 0x7)
- pybind11_fail("pybind11 numpy support requires numpy >= 1.7.0");
- DECL_NPY_API(PyArray_Type);
- DECL_NPY_API(PyVoidArrType_Type);
- DECL_NPY_API(PyArrayDescr_Type);
- DECL_NPY_API(PyArray_DescrFromType);
- DECL_NPY_API(PyArray_DescrFromScalar);
- DECL_NPY_API(PyArray_FromAny);
- DECL_NPY_API(PyArray_Resize);
- DECL_NPY_API(PyArray_CopyInto);
- DECL_NPY_API(PyArray_NewCopy);
- DECL_NPY_API(PyArray_NewFromDescr);
- DECL_NPY_API(PyArray_DescrNewFromType);
- DECL_NPY_API(PyArray_DescrConverter);
- DECL_NPY_API(PyArray_EquivTypes);
- DECL_NPY_API(PyArray_GetArrayParamsFromObject);
- DECL_NPY_API(PyArray_Squeeze);
- DECL_NPY_API(PyArray_SetBaseObject);
-#undef DECL_NPY_API
- return api;
- }
-};
-
-inline PyArray_Proxy* array_proxy(void* ptr) {
- return reinterpret_cast(ptr);
-}
-
-inline const PyArray_Proxy* array_proxy(const void* ptr) {
- return reinterpret_cast(ptr);
-}
-
-inline PyArrayDescr_Proxy* array_descriptor_proxy(PyObject* ptr) {
- return reinterpret_cast(ptr);
-}
-
-inline const PyArrayDescr_Proxy* array_descriptor_proxy(const PyObject* ptr) {
- return reinterpret_cast(ptr);
-}
-
-inline bool check_flags(const void* ptr, int flag) {
- return (flag == (array_proxy(ptr)->flags & flag));
-}
-
-template struct is_std_array : std::false_type { };
-template struct is_std_array> : std::true_type { };
-template struct is_complex : std::false_type { };
-template struct is_complex> : std::true_type { };
-
-template struct array_info_scalar {
- typedef T type;
- static constexpr bool is_array = false;
- static constexpr bool is_empty = false;
- static constexpr auto extents = _("");
- static void append_extents(list& /* shape */) { }
-};
-// Computes underlying type and a comma-separated list of extents for array
-// types (any mix of std::array and built-in arrays). An array of char is
-// treated as scalar because it gets special handling.
-template struct array_info : array_info_scalar { };
-template struct array_info> {
- using type = typename array_info::type;
- static constexpr bool is_array = true;
- static constexpr bool is_empty = (N == 0) || array_info::is_empty;
- static constexpr size_t extent = N;
-
- // appends the extents to shape
- static void append_extents(list& shape) {
- shape.append(N);
- array_info::append_extents(shape);
- }
-
- static constexpr auto extents = _::is_array>(
- concat(_(), array_info::extents), _()
- );
-};
-// For numpy we have special handling for arrays of characters, so we don't include
-// the size in the array extents.
-template struct array_info : array_info_scalar { };
-template struct array_info> : array_info_scalar> { };
-template struct array_info : array_info> { };
-template using remove_all_extents_t = typename array_info::type;
-
-template using is_pod_struct = all_of<
- std::is_standard_layout, // since we're accessing directly in memory we need a standard layout type
-#if !defined(__GNUG__) || defined(_LIBCPP_VERSION) || defined(_GLIBCXX_USE_CXX11_ABI)
- // _GLIBCXX_USE_CXX11_ABI indicates that we're using libstdc++ from GCC 5 or newer, independent
- // of the actual compiler (Clang can also use libstdc++, but it always defines __GNUC__ == 4).
- std::is_trivially_copyable,
-#else
- // GCC 4 doesn't implement is_trivially_copyable, so approximate it
- std::is_trivially_destructible,
- satisfies_any_of,
-#endif
- satisfies_none_of
->;
-
-template ssize_t byte_offset_unsafe(const Strides &) { return 0; }
-template
-ssize_t byte_offset_unsafe(const Strides &strides, ssize_t i, Ix... index) {
- return i * strides[Dim] + byte_offset_unsafe(strides, index...);
-}
-
-/**
- * Proxy class providing unsafe, unchecked const access to array data. This is constructed through
- * the `unchecked()` method of `array` or the `unchecked()` method of `array_t`. `Dims`
- * will be -1 for dimensions determined at runtime.
- */
-template
-class unchecked_reference {
-protected:
- static constexpr bool Dynamic = Dims < 0;
- const unsigned char *data_;
- // Storing the shape & strides in local variables (i.e. these arrays) allows the compiler to
- // make large performance gains on big, nested loops, but requires compile-time dimensions
- conditional_t>
- shape_, strides_;
- const ssize_t dims_;
-
- friend class pybind11::array;
- // Constructor for compile-time dimensions:
- template
- unchecked_reference(const void *data, const ssize_t *shape, const ssize_t *strides, enable_if_t)
- : data_{reinterpret_cast(data)}, dims_{Dims} {
- for (size_t i = 0; i < (size_t) dims_; i++) {
- shape_[i] = shape[i];
- strides_[i] = strides[i];
- }
- }
- // Constructor for runtime dimensions:
- template
- unchecked_reference(const void *data, const ssize_t *shape, const ssize_t *strides, enable_if_t dims)
- : data_{reinterpret_cast(data)}, shape_{shape}, strides_{strides}, dims_{dims} {}
-
-public:
- /**
- * Unchecked const reference access to data at the given indices. For a compile-time known
- * number of dimensions, this requires the correct number of arguments; for run-time
- * dimensionality, this is not checked (and so is up to the caller to use safely).
- */
- template const T &operator()(Ix... index) const {
- static_assert(ssize_t{sizeof...(Ix)} == Dims || Dynamic,
- "Invalid number of indices for unchecked array reference");
- return *reinterpret_cast(data_ + byte_offset_unsafe(strides_, ssize_t(index)...));
- }
- /**
- * Unchecked const reference access to data; this operator only participates if the reference
- * is to a 1-dimensional array. When present, this is exactly equivalent to `obj(index)`.
- */
- template >
- const T &operator[](ssize_t index) const { return operator()(index); }
-
- /// Pointer access to the data at the given indices.
- template const T *data(Ix... ix) const { return &operator()(ssize_t(ix)...); }
-
- /// Returns the item size, i.e. sizeof(T)
- constexpr static ssize_t itemsize() { return sizeof(T); }
-
- /// Returns the shape (i.e. size) of dimension `dim`
- ssize_t shape(ssize_t dim) const { return shape_[(size_t) dim]; }
-
- /// Returns the number of dimensions of the array
- ssize_t ndim() const { return dims_; }
-
- /// Returns the total number of elements in the referenced array, i.e. the product of the shapes
- template
- enable_if_t size() const {
- return std::accumulate(shape_.begin(), shape_.end(), (ssize_t) 1, std::multiplies());
- }
- template
- enable_if_t size() const {
- return std::accumulate(shape_, shape_ + ndim(), (ssize_t) 1, std::multiplies());
- }
-
- /// Returns the total number of bytes used by the referenced data. Note that the actual span in
- /// memory may be larger if the referenced array has non-contiguous strides (e.g. for a slice).
- ssize_t nbytes() const {
- return size() * itemsize();
- }
-};
-
-template
-class unchecked_mutable_reference : public unchecked_reference {
- friend class pybind11::array;
- using ConstBase = unchecked_reference;
- using ConstBase::ConstBase;
- using ConstBase::Dynamic;
-public:
- /// Mutable, unchecked access to data at the given indices.
- template T& operator()(Ix... index) {
- static_assert(ssize_t{sizeof...(Ix)} == Dims || Dynamic,
- "Invalid number of indices for unchecked array reference");
- return const_cast(ConstBase::operator()(index...));
- }
- /**
- * Mutable, unchecked access data at the given index; this operator only participates if the
- * reference is to a 1-dimensional array (or has runtime dimensions). When present, this is
- * exactly equivalent to `obj(index)`.
- */
- template >
- T &operator[](ssize_t index) { return operator()(index); }
-
- /// Mutable pointer access to the data at the given indices.
- template T *mutable_data(Ix... ix) { return &operator()(ssize_t(ix)...); }
-};
-
-template
-struct type_caster> {
- static_assert(Dim == 0 && Dim > 0 /* always fail */, "unchecked array proxy object is not castable");
-};
-template
-struct type_caster> : type_caster> {};
-
-PYBIND11_NAMESPACE_END(detail)
-
-class dtype : public object {
-public:
- PYBIND11_OBJECT_DEFAULT(dtype, object, detail::npy_api::get().PyArrayDescr_Check_);
-
- explicit dtype(const buffer_info &info) {
- dtype descr(_dtype_from_pep3118()(PYBIND11_STR_TYPE(info.format)));
- // If info.itemsize == 0, use the value calculated from the format string
- m_ptr = descr.strip_padding(info.itemsize ? info.itemsize : descr.itemsize()).release().ptr();
- }
-
- explicit dtype(const std::string &format) {
- m_ptr = from_args(pybind11::str(format)).release().ptr();
- }
-
- dtype(const char *format) : dtype(std::string(format)) { }
-
- dtype(list names, list formats, list offsets, ssize_t itemsize) {
- dict args;
- args["names"] = names;
- args["formats"] = formats;
- args["offsets"] = offsets;
- args["itemsize"] = pybind11::int_(itemsize);
- m_ptr = from_args(args).release().ptr();
- }
-
- /// This is essentially the same as calling numpy.dtype(args) in Python.
- static dtype from_args(object args) {
- PyObject *ptr = nullptr;
- if (!detail::npy_api::get().PyArray_DescrConverter_(args.ptr(), &ptr) || !ptr)
- throw error_already_set();
- return reinterpret_steal(ptr);
- }
-
- /// Return dtype associated with a C++ type.
- template static dtype of() {
- return detail::npy_format_descriptor::type>::dtype();
- }
-
- /// Size of the data type in bytes.
- ssize_t itemsize() const {
- return detail::array_descriptor_proxy(m_ptr)->elsize;
- }
-
- /// Returns true for structured data types.
- bool has_fields() const {
- return detail::array_descriptor_proxy(m_ptr)->names != nullptr;
- }
-
- /// Single-character type code.
- char kind() const {
- return detail::array_descriptor_proxy(m_ptr)->kind;
- }
-
-private:
- static object _dtype_from_pep3118() {
- static PyObject *obj = module::import("numpy.core._internal")
- .attr("_dtype_from_pep3118").cast
'
- f'