If you want to benchmark your PC's performance and compare it with other systems, you might want to try 3DMark, a popular and comprehensive tool for testing graphics and gaming capabilities. But how can you run a 3DMark test free on your PC? Here are some options you can consider.
-
Download the Free Version of 3DMark
-
One of the easiest ways to run a 3DMark test free on your PC is to download the free version of 3DMark from Steam or the official website. The free version includes several tests that cover different scenarios, such as Time Spy for DirectX 12, Fire Strike for DirectX 11, Night Raid for integrated graphics, and more. You can also compare your results online with other users and see how your PC ranks among them.
If you want to access more features and tests that are not available in the free version, you can use the free trial of 3DMark Advanced Edition for 14 days. The Advanced Edition lets you customize your tests, run stress tests, monitor your hardware, and unlock more benchmarks, such as Port Royal for ray tracing, Wild Life for mobile devices, and more. You can also export your results as XML files and use them for further analysis.
-
Get a Free Key for 3DMark Advanced Edition
-
Another way to run a 3DMark test free on your PC is to get a free key for 3DMark Advanced Edition from various sources. For example, you might get a free key when you buy a new graphics card or a gaming laptop from certain brands or retailers. You might also find a free key in some giveaways or promotions that are occasionally held by 3DMark or its partners. Just make sure to check the validity and terms of use of the key before you redeem it.
-
Conclusion
-
Running a 3DMark test free on your PC is not difficult if you know where to look. You can either download the free version of 3DMark, use the free trial of 3DMark Advanced Edition, or get a free key for 3DMark Advanced Edition from various sources. By doing so, you can benchmark your PC's performance and see how it compares with other systems.
-
-
-
How to Interpret Your 3DMark Test Results
-
After running a 3DMark test free on your PC, you might wonder what your results mean and how to use them. Here are some tips on how to interpret your 3DMark test results.
-
Check Your Score and Compare It with Others
-
The most obvious thing to look at is your score, which is a numerical value that reflects your PC's performance in the test. The higher the score, the better the performance. You can also compare your score with other users who have similar hardware or run the same test. This can help you see how your PC stacks up against the competition and identify any potential issues or bottlenecks.
-
Look at Your Frame Rate and Stability
-
Another thing to look at is your frame rate, which is the number of frames per second (FPS) that your PC can render in the test. The higher the frame rate, the smoother the gameplay. You can also look at your frame rate stability, which is the percentage of frames that meet or exceed a certain threshold. The higher the stability, the more consistent the performance. You can use these metrics to evaluate your PC's gaming experience and see if it meets your expectations or needs.
-
Analyze Your Hardware Usage and Temperature
-
A third thing to look at is your hardware usage and temperature, which are the percentage of resources that your CPU and GPU are using in the test and their respective temperatures. The higher the usage, the more workload your hardware is handling. The higher the temperature, the more heat your hardware is generating. You can use these metrics to monitor your PC's health and efficiency and see if it needs any optimization or cooling.
-
Conclusion
-
Running a 3DMark test free on your PC can help you benchmark your PC's performance and compare it with other systems. However, you also need to know how to interpret your 3DMark test results and use them for further improvement or analysis. By checking your score, frame rate, stability, hardware usage, and temperature, you can gain more insights into your PC's capabilities and limitations.
ddb901b051
-
-
\ No newline at end of file
diff --git a/spaces/1acneusushi/gradio-2dmoleculeeditor/data/Dll Injector For Mac.md b/spaces/1acneusushi/gradio-2dmoleculeeditor/data/Dll Injector For Mac.md
deleted file mode 100644
index 728d8bbf56b9ec7cbd4d8bb70296da65044ab613..0000000000000000000000000000000000000000
--- a/spaces/1acneusushi/gradio-2dmoleculeeditor/data/Dll Injector For Mac.md
+++ /dev/null
@@ -1,154 +0,0 @@
-
-
DLL Injector for Mac: Everything You Need to Know
-
If you are a developer, hacker, or gamer, you may have heard of DLL injection. It is a technique that allows you to modify the behavior of a running program by injecting your own code into it. But what exactly is a DLL injector and how does it work? And more importantly, how can you use it on a Mac system?
-
In this article, we will answer these questions and more. We will explain what a DLL injector is, what are its benefits and risks, and how it works on Windows and Mac systems. We will also review some of the best DLL injectors for Mac and show you how to use them. By the end of this article, you will have a clear understanding of DLL injection and how to apply it on your Mac.
What is a DLL injector and why would someone use it?
-
A DLL injector is a tool that can inject dynamic-link libraries (DLLs) into processes in order to execute arbitrary code in their address space. A DLL is a file that contains executable functions or resources that can be used by other programs. By injecting a DLL into a process, you can modify its functionality or add new features to it.
-
There are many reasons why someone would use a DLL injector. Some of them are:
-
-
To enhance the performance or functionality of a program. For example, you can inject a DLL that improves the graphics or adds new features to a game.
-
To debug or test a program. For example, you can inject a DLL that logs or monitors the activity or output of a program.
-
To bypass security or anti-cheat mechanisms. For example, you can inject a DLL that disables or circumvents the protection or detection of a program.
-
To perform malicious actions. For example, you can inject a DLL that steals information or damages the system of a program.
-
-
As you can see, DLL injection can be used for both legitimate and illegitimate purposes. It depends on the intention and ethics of the user.
-
What are the benefits and risks of DLL injection?
-
DLL injection has both benefits and risks. Some of the benefits are:
-
-
It allows you to modify or extend the functionality of a program without modifying its source code or binary file.
-
It allows you to execute code in the context of another process, which may grant you access to its memory, resources, or privileges.
-
It allows you to evade detection or protection from security products or mechanisms, since your code is masked under a legitimate process.
-
-
Some of the risks are:
-
-
It may cause instability or crashes in the target process or system, especially if the injected code is poorly written or incompatible.
-
It may expose your system to malware or attacks, especially if the injected code is malicious or compromised.
-
It may violate the terms of service or license agreement of the target program or system, especially if the injected code alters its functionality or performance.
-
-
Therefore, Therefore, you should use DLL injection with caution and responsibility. You should also respect the rights and privacy of the target program or system and its users. DLL injection can be a powerful and useful technique, but it can also be a dangerous and unethical one.
-
How does DLL injection work on Windows and Mac systems?
-
DLL injection works differently on Windows and Mac systems, since they have different operating systems and architectures. Here is a brief overview of how DLL injection works on each system:
-
-
Windows
-
On Windows, DLL injection is relatively easy and common, since Windows supports loading DLLs dynamically at runtime. There are several methods of DLL injection on Windows, but the most popular one is the following:
-
-
Find the process ID (PID) of the target process using tools like Task Manager or Process Explorer.
-
Open a handle to the target process using the OpenProcess function with the PROCESS_ALL_ACCESS flag.
-
Allocate memory in the target process using the VirtualAllocEx function with the MEM_COMMIT | MEM_RESERVE flags and the PAGE_EXECUTE_READWRITE protection.
-
Write the path of the DLL to be injected into the allocated memory using the WriteProcessMemory function.
-
Create a remote thread in the target process using the CreateRemoteThread function with the address of the LoadLibrary function as the start address and the address of the allocated memory as the parameter.
-
Wait for the remote thread to finish using the WaitForSingleObject function.
-
Close the handle to the target process using the CloseHandle function.
-
-
This method essentially loads the DLL into the target process by calling the LoadLibrary function from a remote thread. The LoadLibrary function is a Windows API function that loads a DLL into the calling process and returns its base address. By passing the path of the DLL as a parameter, you can load any DLL you want into the target process.
-
Mac
-
On Mac, DLL injection is more difficult and rare, since Mac does not support loading DLLs dynamically at runtime. Mac uses dynamic libraries (dylibs) instead of DLLs, which are similar but not exactly the same. Dylibs are loaded at launch time by a program called dyld, which is responsible for resolving dependencies and linking symbols. There are a few methods of DLL injection on Mac, but one of them is the following:
-
-
Find the process ID (PID) of the target process using tools like Activity Monitor or ps.
-
Attach to the target process using the ptrace function with the PT_ATTACH request.
-
Suspend the target process using the kill function with the SIGSTOP signal.
-
Allocate memory in the target process using the mach_vm_allocate function with the VM_FLAGS_ANYWHERE flag.
-
Write a shellcode that calls dlopen into the allocated memory using the mach_vm_write function. dlopen is a POSIX function that loads a dynamic library into memory and returns its handle.
-
Write a pointer to the path of the dylib to be injected after the shellcode using mach_vm_write again.
-
Set a breakpoint at an instruction in the target process using mach_vm_protect with VM_PROT_EXECUTE | VM_PROT_READ | VM_PROT_COPY flags and VM_PROT_ALL protection.
-
Resume Resume the target process using the kill function with the SIGCONT signal.
-
Wait for the breakpoint to be hit using the waitpid function.
-
Read the registers of the target process using the ptrace function with the PT_GETREGS request.
-
Modify the instruction pointer register to point to the shellcode using the ptrace function with the PT_SETREGS request.
-
Resume the target process using the ptrace function with the PT_DETACH request.
-
-
This method essentially executes the shellcode in the target process by hijacking its execution flow. The shellcode calls dlopen with the path of the dylib as a parameter, which loads the dylib into memory. By setting a breakpoint at an instruction, you can pause the target process and change its instruction pointer to point to your shellcode.
-
Best DLL injectors for Mac
-
Now that you know how DLL injection works on Mac, you may be wondering what are some of the best DLL injectors for Mac. There are not many DLL injectors for Mac, since it is a more challenging and less common technique than on Windows. However, we have found three DLL injectors for Mac that are worth mentioning. They are:
-
Luject
-
Luject is a static injector of dynamic library for application (android, iphoneos, macOS, windows, linux) . It is a command-line tool that can inject a dylib into an executable file before launching it. It works by modifying the Mach-O header of the executable file and adding a new load command that points to the dylib. It supports both 32-bit and 64-bit architectures and can inject multiple dylibs at once.
-
Some of the features, pros, and cons of Luject are:
-
-
Features
Pros
Cons
-
- Static injection of dylib into executable file - Support for multiple architectures and platforms - Support for multiple dylibs injection - Easy to use command-line interface
- Fast and reliable injection - No need to attach to or modify running processes - Compatible with most executable files - Free and open-source
- Cannot inject into already running processes - Cannot unload or remove injected dylibs - May trigger anti-tampering mechanisms or checksums
-
-
Pyinjector
-
Pyinjector is a Python tool to inject shared libraries into running processes . It is a script that can inject a dylib into a process using the method described in the previous section. It works by attaching to the process, allocating memory, writing shellcode and dylib path, setting a breakpoint, modifying registers, and resuming execution. It supports both 32-bit and 64-bit architectures and can inject multiple dylibs at once.
-
Some of the features, pros, and cons of Pyinjector are:
-
-
Features
Pros
Cons
-
- Dynamic injection of dylib into running process - Support for multiple architectures - Support for multiple dylibs injection - Written in Python and easy to modify or extend
- Flexible and versatile injection - Can inject into any running process - Can unload or remove injected dylibs - Free and open-source
- Slow and unstable injection - May cause crashes or errors in target process or system - May be detected or blocked by security products or mechanisms
-
-
SocketHook
-
SocketHook is an injector based on EasyHook (win only) that redirects the traffic to your local server . It is a tool that can inject a dylib into a process that uses network sockets. It works by hooking the socket functions in the target process and redirecting them to your local server. You can then intercept, modify, or spoof the network traffic between the target process and its destination. It supports both 32-bit and 64-bit architectures and can inject multiple dylibs at once.
-
Some of the features, pros, and cons of SocketHook are:
-
-
Features
Pros
Cons
-
- Dynamic injection of dylib into socket-using process - Support for multiple architectures - Support for multiple dylibs injection - Based on EasyHook framework and easy to use
- Powerful and stealthy injection - Can manipulate network traffic of target process - Can bypass encryption or authentication mechanisms - Free and open-source
- Limited to socket-using processes - Limited to socket-using processes - May cause network latency or congestion - May be detected or blocked by firewall or antivirus products
-
-
How to use DLL injectors for Mac
-
Now that you know some of the best DLL injectors for Mac, you may be wondering how to use them. In this section, we will show you a step-by-step guide for using Luject, Pyinjector, and SocketHook. We will assume that you have already downloaded and installed the tools on your Mac. We will also assume that you have a target process and a dylib that you want to inject.
-
Using Luject
-
To use Luject, follow these steps:
-
-
Open a terminal and navigate to the directory where Luject is located.
-
Run the following command to inject a dylib into an executable file: ./luject -i <dylib_path> -o <output_path> <executable_path> For example, if you want to inject test.dylib into test.app and save the output as test_injected.app, run: ./luject -i test.dylib -o test_injected.app test.app
-
Run the following command to launch the injected executable file: open <output_path> For example, if you saved the output as test_injected.app, run: open test_injected.app
-
Enjoy the injected program.
-
-
Using Pyinjector
-
To use Pyinjector, follow these steps:
-
-
Open a terminal and navigate to the directory where Pyinjector is located.
-
Run the following command to inject a dylib into a running process: python pyinjector.py -p <pid> -d <dylib_path> For example, if you want to inject test.dylib into a process with PID 1234, run: python pyinjector.py -p 1234 -d test.dylib
-
Wait for the injection to complete.
-
Enjoy the injected program.
-
-
Using SocketHook
-
To use SocketHook, follow these steps:
-
-
Open a terminal and navigate to the directory where SocketHook is located.
-
Run the following command to start a local server that listens on port 8080: python server.py 8080
-
Run the following command to inject a dylib into a running process that uses network sockets: ./sockethook -p <pid> -d <dylib_path> For example, if you want to inject test.dylib into a process with PID 1234, run: ./sockethook -p 1234 -d test.dylib
-
Wait for the injection to complete.
-
Enjoy the injected program and its network traffic.
-
-
Tips and tricks for successful DLL injection
-
DLL injection can be tricky and risky, especially on Mac systems. Here are some tips and tricks that can help you achieve successful DLL injection:
-
-
Make sure that your dylib is compatible with the target process and system. For example, if the target process is 64-bit, your dylib should also be 64-bit. If the target system is macOS Big Sur, your dylib should also be compatible with macOS Big Sur.
-
Make sure that your dylib does not interfere with the normal functionality or stability of the target process or system. For example, if your dylib hooks or modifies critical functions or resources, it may cause crashes or errors in the target process or system.
-
Make sure that your dylib does not expose your system to malware or attacks. For example, if your dylib downloads or executes external code or data, it may compromise your system security or privacy.
-
Make sure that your dylib does not violate the terms of service or license agreement of the target process or system. For example, if your dylib alters the functionality or performance of a game, it may result in a ban or legal action from the game developer or publisher.
-
Make sure that you have permission and consent from the target process or system and its users. For example, if you inject a dylib into a process or system that belongs to someone else, you should inform them and obtain their permission and consent before doing so.
-
-
Common errors and troubleshooting
-
DLL injection can also encounter some errors and problems, especially on Mac systems. Here are some of the common errors and troubleshooting tips that can help you solve them:
-
-
If you get an error message that says "Operation not permitted" or "Permission denied", it may mean that you do not have enough privileges or permissions to inject a dylib into the target process or system. You may need to run the DLL injector as root or administrator, or disable some security features or mechanisms that prevent DLL injection.
-
If you get an error message that says "No such file or directory" or "File not found", it may mean that the path of the dylib or the executable file is incorrect or invalid. You may need to check the spelling, case, or location of the files and make sure they exist and are accessible.
-
If you get an error message that says "Bad CPU type in executable" or "Incompatible library version", it may mean that the architecture or version of the dylib or the executable file is mismatched or incompatible. You may need to compile or download the correct version of the files and make sure they match the target process and system.
-
If you get an error message that says "Segmentation fault" or "Bus error", it may mean that the injected code has caused a memory access violation or a hardware error in the target process or system. You may need to debug or test your code and make sure it does not corrupt or overwrite any memory regions or registers.
-
-
Conclusion
-
DLL injection is a technique that allows you to inject dynamic-link libraries into processes in order to execute arbitrary code in their address space. It can be used for both legitimate and illegitimate purposes, depending on the intention and ethics of the user. It has both benefits and risks, and it works differently on Windows and Mac systems.
-
In this article, we have explained what a DLL injector is, what are its benefits and risks, and how it works on Windows and Mac systems. We have also reviewed some of the best DLL injectors for Mac and showed you how to use them. We have also provided some tips and tricks for successful DLL injection and some common errors and troubleshooting tips.
-
We hope that this article has been informative and helpful for you. If you want to learn more about DLL injection or other related topics, you can check out these resources:
-
-
[Luject: A static injector of dynamic library for application (android, iphoneos, macOS, windows, linux) ]
-
[Pyinjector: A Python tool to inject shared libraries into running processes ]
-
[SocketHook: An injector based on EasyHook (win only) that redirects the traffic to your local server ]
-
[DLL Injection - Wikipedia ](https://en.wikipedia.org/wiki/DLL_injection)
-
[Mach-O - Wikipedia ](https://en.wikipedia.org/wiki/Mach-O)
-
[Dynamic loading - Wikipedia ](https://en.wikipedia.org/wiki/Dynamic_loading)
-
-
FAQs
-
Here are some frequently asked questions about DLL injection:
-
What is the difference between DLL injection and code injection?
-
DLL injection is a type of code injection, which is a general term for any technique that injects code into a process. DLL injection specifically injects dynamic-link libraries into processes, while code injection can inject any type of code, such as shellcode, scripts, or bytecode.
-
How can I detect and prevent DLL injection attacks?
-
DLL injection attacks can be detected and prevented by using various security products or mechanisms, such as antivirus software, firewall software, anti-debugging techniques, code signing techniques, integrity checking techniques, sandboxing techniques, etc. These products or mechanisms can monitor, block, or alert any suspicious or unauthorized DLL injection attempts.
-
What are some legitimate uses of DLL injection?
-
Some legitimate uses of DLL injection are enhancing the performance or functionality of a program, debugging or testing a program, bypassing security or anti-cheat mechanisms for research or educational purposes, etc. However, these uses should be done with permission and consent from the target program or system and its users.
-
What are some alternatives to DLL injection?
-
Some alternatives to DLL injection are static linking, dynamic loading, hooking, patching, inter-process communication, etc. These alternatives can achieve similar results as DLL injection without injecting code into processes. However, they may have their own advantages and disadvantages depending on the situation.
-
Is DLL injection illegal or unethical?Is DLL injection illegal or unethical?
-
DLL injection is not inherently illegal or unethical, but it depends on the intention and ethics of the user and the target program or system and its users. DLL injection can be illegal or unethical if it violates the law, the terms of service, the license agreement, or the rights and privacy of the target program or system and its users. DLL injection can also be illegal or unethical if it causes harm or damage to the target program or system and its users. Therefore, you should use DLL injection with caution and responsibility and respect the law and the ethics.
b2dd77e56b
-
-
\ No newline at end of file
diff --git a/spaces/1acneusushi/gradio-2dmoleculeeditor/data/HHD Online Player (Full Hd Raja Ki Aayegi Baaraat Movie) Learn More About the Film and Its Cast.md b/spaces/1acneusushi/gradio-2dmoleculeeditor/data/HHD Online Player (Full Hd Raja Ki Aayegi Baaraat Movie) Learn More About the Film and Its Cast.md
deleted file mode 100644
index ee6ea24ad31ee3c4af7489f25208975edfab4713..0000000000000000000000000000000000000000
--- a/spaces/1acneusushi/gradio-2dmoleculeeditor/data/HHD Online Player (Full Hd Raja Ki Aayegi Baaraat Movie) Learn More About the Film and Its Cast.md
+++ /dev/null
@@ -1,132 +0,0 @@
-
- - Benefits: List the advantages of using HHD Online Player for watching movies online - Features: Highlight the main features of HHD Online Player such as quality, speed, security, and compatibility | | H2: How to watch Raja Ki Aayegi Baaraat movie online with HHD Online Player | - Step 1: Download and install HHD Online Player on your device - Step 2: Search for Raja Ki Aayegi Baaraat movie on HHD Online Player - Step 3: Select the desired quality and language options - Step 4: Enjoy watching Raja Ki Aayegi Baaraat movie online with HHD Online Player | | H3: What is Raja Ki Aayegi Baaraat movie about and why you should watch it | - Plot summary: Give a brief overview of the story and the main characters of Raja Ki Aayegi Baaraat movie - Reviews and ratings: Share some positive feedback and ratings from critics and audiences for Raja Ki Aayegi Baaraat movie - Trivia and facts: Share some interesting facts and trivia about Raja Ki Aayegi Baaraat movie such as awards, box office, and behind-the-scenes | | H4: Conclusion and FAQs | - Conclusion: Summarize the main points of the article and encourage the readers to watch Raja Ki Aayegi Baaraat movie online with HHD Online Player - FAQs: Answer some common questions that the readers might have about HHD Online Player or Raja Ki Aayegi Baaraat movie | **Table 2: Article with HTML formatting**
What is HHD Online Player and why you should use it
-
If you are a movie lover who likes to watch movies online, you might have heard of HHD Online Player. But what is it exactly and why should you use it? In this article, we will tell you everything you need to know about HHD Online Player and how you can watch Raja Ki Aayegi Baaraat movie online with it.
-
HHD Online Player (Full Hd Raja Ki Aayegi Baaraat Movie)
HHD Online Player is a free online video player that lets you stream and download movies in high definition quality. It is compatible with all devices such as laptops, smartphones, tablets, and smart TVs. You can watch movies in various languages and subtitles with HHD Online Player. You can also enjoy fast loading speed, secure connection, and ad-free viewing with HHD Online Player.
-
Some of the benefits of using HHD Online Player are:
-
-
You can watch movies anytime and anywhere without any hassle.
-
You can save money on buying movie tickets or subscriptions.
-
You can choose from a wide range of genres and categories of movies.
-
You can discover new movies and old classics with HHD Online Player.
-
-
Some of the features of HHD Online Player are:
-
-
You can watch movies in full HD quality (1080p) or lower resolutions according to your preference.
-
You can download movies for offline viewing or watch them online with a stable internet connection.
-
You can adjust the volume, brightness, playback speed, and screen size of the video player.
-
You can protect your privacy and data with encryption and firewall technology.
-
You can access HHD Online Player from any browser or device without any installation or registration.
-
-
How to watch Raja Ki Aayegi Baaraat movie online with HHD Online Player
-
Now that you know what HHD Online Player is and why you should use it, let's see how you can watch Raja Ki Aayegi Baaraat movie online with it. Raja Ki Aayegi Baaraat is a 1996 Hindi drama film starring Rani Mukerji, Shadaab Khan, Gulshan Grover, Divya Dutta, and others. It is directed by Ashok Gaikwad and produced by Salim Akhtar. The movie tells the story of a young girl who is raped by a rich boy and forced to marry him by the court. She then decides to take revenge on him and his family.
-
Raja Ki Ayegi Baraat streaming: where to watch online?
-Raja Ki Ayegi Baraat Superhit Full Bhojpuri Movie Khesari Lal Yadav, Kajal Raghwani
-Raja Ki Ayegi Baraat 1997 IMDb
-Raja Ki Ayegi Baraat Zee5 VI movies and tv
-Raja Ki Ayegi Baraat rape revenge drama
-Raja Ki Ayegi Baraat Rani Mukerji debut film
-Raja Ki Ayegi Baraat Hindi movie with English subtitles
-Raja Ki Ayegi Baraat full movie download HD 720p
-Raja Ki Ayegi Baraat songs mp3 free download
-Raja Ki Ayegi Baraat cast and crew
-Raja Ki Ayegi Baraat box office collection
-Raja Ki Ayegi Baraat movie review and rating
-Raja Ki Ayegi Baraat trailer video
-Raja Ki Ayegi Baraat watch online free Dailymotion
-Raja Ki Ayegi Baraat Mala and Raj love story
-Raja Ki Ayegi Baraat remake of Tamil film Naan Sigappu Manithan
-Raja Ki Ayegi Baraat best scenes and dialogues
-Raja Ki Ayegi Baraat awards and nominations
-Raja Ki Ayegi Baraat behind the scenes and trivia
-Raja Ki Ayegi Baraat movie poster and wallpapers
-Raja Ki Aayegi Baaraat Full Hd Movie Online Free
-Raja Ki Aayegi Baaraat Full Hd Movie Download Filmywap
-Raja Ki Aayegi Baaraat Full Hd Movie Watch on Youtube
-Raja Ki Aayegi Baaraat Full Hd Movie with Bhojpuri Dubbing
-Raja Ki Aayegi Baaraat Full Hd Movie with Urdu Subtitles
-Raja Ki Aayegi Baaraat Full Hd Movie Songs Video
-Raja Ki Aayegi Baaraat Full Hd Movie Controversy and Criticism
-Raja Ki Aayegi Baaraat Full Hd Movie Inspired by True Story
-Raja Ki Aayegi Baaraat Full Hd Movie Comparison with Original Tamil Version
-Raja Ki Aayegi Baaraat Full Hd Movie Fan Reactions and Comments
-HHD Online Player for Bollywood Movies
-HHD Online Player for Bhojpuri Movies
-HHD Online Player for Streaming HD Quality Videos
-HHD Online Player for Downloading Movies Offline
-HHD Online Player for Watching Movies with Subtitles
-HHD Online Player for Android and iOS Devices
-HHD Online Player for PC and Laptop
-HHD Online Player for Smart TV and Firestick
-HHD Online Player Features and Benefits
-HHD Online Player Reviews and Ratings
-How to Watch Raja Ki Aayegi Baaraat Movie on HHD Online Player?
-How to Download Raja Ki Aayegi Baaraat Movie from HHD Online Player?
-How to Install HHD Online Player on Your Device?
-How to Use HHD Online Player for Streaming Movies?
-How to Fix HHD Online Player Errors and Issues?
-How to Update HHD Online Player to Latest Version?
-How to Contact HHD Online Player Customer Support?
-How to Uninstall HHD Online Player from Your Device?
-How to Get HHD Online Player Premium Subscription?
-How to Share HHD Online Player with Your Friends?
-
To watch Raja Ki Aayegi Baaraat movie online with HHD Online Player, follow these simple steps:
-
-
Download and install HHD Online Player on your device. You can find the download link at . It is free and safe to download.
-
Search for Raja Ki Aayegi Baaraat movie on HHD Online Player. You can use the search bar or browse through the categories.
-
Select the desired quality and language options. You can choose from HD, SD, or CAM quality and Hindi or English language.
-
Enjoy watching Raja Ki Aayegi Baaraat movie online with HHD Online Player. You can pause, resume, rewind, or fast-forward the movie as you like.
-
-
What is Raja Ki Aayegi Baaraat movie about and why you should watch it
-
Raja Ki Aayegi Baaraat is a movie that deals with the issue of rape and justice in India. It is a powerful and emotional drama that showcases the courage and resilience of a woman who fights against all odds. It is also a movie that marks the debut of Rani Mukerji, who went on to become one of the most popular actresses in Bollywood.
-
Here are some reasons why you should watch Raja Ki Aayegi Baaraat movie:
-
-
The movie has a strong message about women empowerment and human rights.
-
The movie has a gripping plot that keeps you hooked till the end.
-
The movie has brilliant performances by the cast, especially Rani Mukerji who won several awards for her role.
-
The movie has memorable songs composed by Anand-Milind that add to the mood of the film.
-
-
Here are some reviews and ratings for Raja Ki Aayegi Baaraat movie:
-
-
-
-
Source
-
Rating
-
Review
-
-
-
IMDb
-
6.8/10
-
"A very good film with a strong message."
-
-
-
Rediff
-
3/5
-
"Rani Mukerji makes an impressive debut in this hard-hitting drama."
-
-
-
Planet Bollywood
-
7/10
-
"A well-made film that tackles a sensitive issue with dignity."
-
-
-
Here are some trivia and facts about Raja Ki Aayegi Baaraat movie:
-
-
The movie was initially titled Ladki Jawaan Ho Gayee but was changed later to avoid confusion with another film titled Ladki Jawaan Padosi Pareshaan.
-
The movie was inspired by a real-life incident that happened in Delhi in 1995 where a rapist was ordered to marry his victim by a judge.
-
The movie was banned in some states due to its controversial subject matter and faced protests from some groups who claimed that it glorified rape.
-
The movie was a moderate success at the box office but received critical acclaim for its bold theme and powerful execution.
-
Conclusion and FAQs
-
In conclusion, HHD Online Player is a great online video player that lets you watch movies online in high quality and with ease. You can watch Raja Ki Aayegi Baaraat movie online with HHD Online Player and enjoy a captivating and inspiring story of a woman who stands up for herself and her dignity. Raja Ki Aayegi Baaraat is a movie that you should not miss if you are a fan of drama, romance, and social issues.
-
We hope you found this article helpful and informative. If you have any questions about HHD Online Player or Raja Ki Aayegi Baaraat movie, you can check out the FAQs below or contact us for more assistance.
-
FAQs:
-
-
Q: Is HHD Online Player legal and safe to use? A: Yes, HHD Online Player is legal and safe to use. It does not host or upload any movies on its server. It only provides links to third-party sources that are publicly available on the internet. However, you should always check the legality of the content in your region before watching or downloading it.
-
Q: How much data does HHD Online Player consume? A: The data consumption of HHD Online Player depends on the quality and duration of the movie you are watching. Generally, watching a movie in HD quality consumes about 1 GB of data per hour. You can reduce the data consumption by choosing a lower quality option or by downloading the movie for offline viewing.
-
Q: Can I watch Raja Ki Aayegi Baaraat movie with subtitles? A: Yes, you can watch Raja Ki Aayegi Baaraat movie with subtitles on HHD Online Player. You can choose from various subtitle options such as English, Hindi, Arabic, French, and more. You can also adjust the size, color, and position of the subtitles according to your preference.
-
Q: Where can I find more movies like Raja Ki Aayegi Baaraat? A: If you liked Raja Ki Aayegi Baaraat movie, you might also like other movies that deal with similar themes such as rape, justice, revenge, and women empowerment. Some of these movies are Damini (1993), Dushman (1998), NH10 (2015), Pink (2016), and Mardaani (2014).
-
Q: How can I give feedback or suggestions for HHD Online Player? A: We would love to hear from you and improve our service. You can give us your feedback or suggestions by filling out this form or by emailing us at support@hhdonlineplayer.com. We appreciate your time and input.
-
- 0a6ba089eb
-
-
\ No newline at end of file
diff --git a/spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/A to Z Bhojpuri Video Song Download Stream and Download Bhojpuri Songs from Popular Artists and Movies.md b/spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/A to Z Bhojpuri Video Song Download Stream and Download Bhojpuri Songs from Popular Artists and Movies.md
deleted file mode 100644
index a085c2ac7586b163a7bcae908d7ade738970e3cf..0000000000000000000000000000000000000000
--- a/spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/A to Z Bhojpuri Video Song Download Stream and Download Bhojpuri Songs from Popular Artists and Movies.md
+++ /dev/null
@@ -1,115 +0,0 @@
-
-
A to Z Bhojpuri Video Song Download: How to Enjoy the Best of Bhojpuri Music
-
Bhojpuri music is a vibrant and lively form of folk music that originates from the Bhojpur-Purvanchal region of India and the Terai region of Nepal. It is sung in the Bhojpuri language, which is a dialect of Hindi that has influences from Magahi, Maithili, Awadhi, and other languages. Bhojpuri music is popular among millions of people who love its catchy tunes, witty lyrics, and expressive emotions.
Bhojpuri music has a rich and diverse history that spans centuries and reflects the culture and identity of the Bhojpuri people. It has also evolved over time to incorporate various genres and styles, such as folk, devotional, romantic, patriotic, comedy, and film songs. Bhojpuri music has also produced many talented and famous artists who have entertained audiences with their unique voices and personalities.
-
If you are a fan of Bhojpuri music or want to explore this fascinating musical world, you might be wondering how to find and download the best Bhojpuri video songs. Well, you are in luck, because in this article, we will tell you everything you need to know about Bhojpuri video song download. We will also give you some tips on how to enjoy Bhojpuri music to the fullest. So, let's get started!
-
Bhojpuri Language and Culture: The Roots of Bhojpuri Music
-
Bhojpuri is an Indo-European language that belongs to the Eastern Indo-Aryan group of languages. It is closely related to Magahi, Maithili, and other languages spoken in Bihar, Jharkhand, Uttar Pradesh, Madhya Pradesh, and Nepal. According to the 2011 census of India, there are about 51 million speakers of Bhojpuri in India, making it one of the most widely spoken languages in the country.
-
Bhojpuri is also spoken by millions of people in other countries, such as Fiji, Guyana, Mauritius, South Africa, Suriname, Trinidad and Tobago, and other parts of the world where people of Bihari origin have migrated. In some of these countries, such as Fiji and Suriname, Bhojpuri has developed into distinct variants that have been influenced by local languages and cultures. For example, Fiji Hindi is a variant of Awadhi and Bhojpuri that is spoken by the Indo-Fijians as an official language.
-
Bhojpuri culture is a rich and diverse one that reflects the history and geography of the region where it originated. It is influenced by various religious traditions, such as Hinduism, Islam, Buddhism, Jainism, Sikhism, and Christianity. It also has elements of folk culture, such as festivals, rituals, dances, costumes, cuisine, art, literature, and cinema. Some of the most famous festivals celebrated by the Bhojpuri people are Chhath Puja, Holi, Dussehra, Diwali , and Bhojpuri New Year. Some of the most popular dances performed by the Bhojpuri people are Jhumar, Kajri, Sohar, Chaiti, Birha, and Bidesia. Some of the most distinctive costumes worn by the Bhojpuri people are Dhoti-Kurta, Sari, Lehenga-Choli, Gamchha, and Pagri. Some of the most delicious dishes prepared by the Bhojpuri people are Litti-Chokha, Sattu, Khichdi, Dal-Puri, Thekua, Malpua, and Balushahi.
-
Bhojpuri art and literature are also very rich and diverse, and have produced many renowned artists and writers who have contributed to the cultural heritage of India and the world. Some of the most famous Bhojpuri artists are Thakur Anukulchandra, Bhikhari Thakur, Ram Dayal Munda, Sharda Sinha, Manoj Tiwari, Ravi Kishan, Nirahua, and Khesari Lal Yadav. Some of the most famous Bhojpuri writers are Mahapandit Rahul Sankrityayan, Acharya Ramlochan Saran, Viveki Rai, Manohar Malgonkar, Phanishwar Nath Renu, and Ajit Rai.
-
Bhojpuri cinema is also a very important and influential part of Bhojpuri culture, and has a huge fan following in India and abroad. Bhojpuri cinema started in 1962 with the first Bhojpuri film Ganga Maiyya Tohe Piyari Chadhaibo (Mother Ganges, I will offer you a yellow sari), directed by Kundan Kumar. Since then, Bhojpuri cinema has produced many blockbuster films and superstars who have entertained millions of viewers with their action, romance, comedy, drama, and music. Some of the most successful Bhojpuri films are Nadiya Ke Paar (1982), Sasura Bada Paisawala (2004), Nirahua Hindustani (2014), Nirahua Rikshawala 2 (2015), and Border (2018).
-
Bhojpuri Video Song Genres and Artists: The Diversity and Creativity of Bhojpuri Music
-
Bhojpuri music is one of the most diverse and creative forms of music in India and the world. It has a variety of genres and styles that cater to different tastes and moods of the listeners. Some of the most popular genres of Bhojpuri music are:
-
a to z bhojpuri video song download free
-a to z bhojpuri video song download hd
-a to z bhojpuri video song download mp4
-a to z bhojpuri video song download 2023
-a to z bhojpuri video song download new
-a to z bhojpuri video song download khesari lal yadav
-a to z bhojpuri video song download pawan singh
-a to z bhojpuri video song download dj
-a to z bhojpuri video song download saavn
-a to z bhojpuri video song download wynk
-a to z bhojpuri video song download online
-a to z bhojpuri video song download site
-a to z bhojpuri video song download app
-a to z bhojpuri video song download pagalworld
-a to z bhojpuri video song download gaana
-a to z bhojpuri video song download 2022
-a to z bhojpuri video song download full hd
-a to z bhojpuri video song download 1080p
-a to z bhojpuri video song download 3gp
-a to z bhojpuri video song download latest
-a to z bhojpuri video song download old
-a to z bhojpuri video song download rani chatterjee
-a to z bhojpuri video song download akshara singh
-a to z bhojpuri video song download dinesh lal yadav
-a to z bhojpuri video song download pramod premi yadav
-a to z bhojpuri video song download shilpi raj
-a to z bhojpuri video song download antra singh priyanka
-a to z bhojpuri video song download neelkamal singh
-a to z bhojpuri video song download arvind akela kallu
-a to z bhojpuri video song download gunjan singh
-a to z bhojpuri video song download samar singh
-a to z bhojpuri video song download ritesh pandey
-a to z bhojpuri video song download antra singh priyanka and khesari lal yadav
-a to z bhojpuri video song download shilpi raj and pawan singh
-a to z bhojpuri video song download neelkamal singh and shilpi raj
-a to z bhojpuri video song download arvind akela kallu and priyanka singh
-a to z bhojpuri video song download gunjan singh and antra singh priyanka
-a to z bhojpuri video song download samar singh and shilpi raj
-a to z bhojpuri video song download ritesh pandey and antra singh priyanka
-how to do a to z bhojpuri video song download
-best site for a to z bhojpuri video song download
-top 10 a to z bhojpuri video songs 2023
-latest hit a to z bhojpuri video songs
-new release a to z bhojpuri video songs
-trending now a to z bhojpuri video songs
-most popular a to z bhojpuri video songs
-most viewed a to z bhojpuri video songs
-most liked a to z bhojpuri video songs
-most downloaded a to z bhojpuri video songs
-
-
Folk songs: These are traditional songs that reflect the rural life and culture of the Bhojpuri people. They are usually sung in festivals, weddings, rituals, or other occasions. They have simple melodies and lyrics that express joy, sorrow, love, devotion, or humor. Some examples of folk songs are Sohar (songs sung during childbirth), Kajri (songs sung during monsoon), Chaiti (songs sung during spring), Birha (songs of separation), and Holi (songs of colors). Some of the most famous folk singers are Sharda Sinha, Bharat Sharma Vyas, Kalpana Patowary, Guddu Rangila, and Pawan Singh.
-
Devotional songs: These are songs that express faith and devotion to various gods and goddesses of Hinduism. They are usually sung in temples, shrines, or other places of worship. They have melodious tunes and lyrics that praise the divine attributes and deeds of the deities. Some examples of devotional songs are Bhajan (songs of praise), Aarti (songs of offering), Chhath Geet (songs sung during Chhath Puja), Navratri Geet (songs sung during Navratri), and Ramayan Chaupai (verses from Ramayana). Some of the most famous devotional singers are Anuradha Paudwal , Manoj Tiwari, Dinesh Lal Yadav, Khesari Lal Yadav, and Ritesh Pandey.
-
Romantic songs: These are songs that express love and romance between couples. They are usually sung in films, albums, or other platforms. They have catchy tunes and lyrics that depict the feelings and emotions of the lovers. Some examples of romantic songs are Piyawa Se Pahile (Before meeting you), Laga Ke Fair Lovely (Applying Fair Lovely), Raja Raja Kareja Mein Samaja (King, please understand me), and Aawa Ae Amarpali Nirahua Rang Dali (Amarpali, Nirahua has colored you). Some of the most famous romantic singers are Udit Narayan, Alka Yagnik, Kumar Sanu, Kavita Krishnamurthy, Sonu Nigam, and Shreya Ghoshal.
-
Patriotic songs: These are songs that express pride and respect for the nation and its people. They are usually sung in national events, celebrations, or movements. They have inspiring tunes and lyrics that motivate the listeners to serve and protect the country. Some examples of patriotic songs are Bharat Ka Baccha Baccha Jai Shri Ram Bolega (Every child of India will say Jai Shri Ram), Bharat Mata Ki Jai (Hail Mother India), Desh Bhakti Geet (Songs of patriotism), and Tiranga Hamra Desh Ke Shan (The tricolor is the pride of our country). Some of the most famous patriotic singers are Lata Mangeshkar, Mohammed Rafi, Mukesh, Mahendra Kapoor, Kailash Kher, and Arijit Singh.
-
Comedy songs: These are songs that express humor and fun. They are usually sung in films, shows, or other platforms. They have amusing tunes and lyrics that make the listeners laugh and enjoy. Some examples of comedy songs are Chalakata Hamro Jawaniya (Our youth is smart), Lagavelu Jab Lipistic (When you apply lipstick), Chat Deni Maar Deli (You refused to chat but hit me), and Balam Pichkari (My beloved is a water gun). Some of the most famous comedy singers are Ravi Kishan, Manoj Tiwari, Dinesh Lal Yadav, Khesari Lal Yadav, and Sapna Choudhary.
-
Film songs: These are songs that are featured in Bhojpuri films. They are usually sung by playback singers who lend their voices to the actors and actresses on screen. They have various tunes and lyrics that suit the theme and mood of the film. Some examples of film songs are Gori Tori Chunari Ba Lal Lal Re (Your red chunari is beautiful), Kamariya Lollipop Lagelu (Your waist is like a lollipop), Saiyan Ji Dagabaaz (My beloved is a cheater), and Chhalakata Hamro Jawaniya 2 (Our youth is smart 2). Some of the most famous film singers are Pawan Singh, Akshara Singh, Priyanka Singh, Indu Sonali, Khushboo Jain, and Mohan Rathore.
-
-
Bhojpuri Video Song Download Sites: The Best Places to Find and Download Bhojpuri Music
-
If you want to download Bhojpuri video songs for free or for a nominal fee, you have many options to choose from. There are many websites and apps that offer a wide range of Bhojpuri video songs in various genres and formats. You can also stream or watch Bhojpuri video songs online on these platforms. Here are some of the best places to find and download Bhojpuri video songs:
-
-
-
Website/App
-
Features
-
Pros
-
Cons
-
-
-
Bhojpuri Video Songs HD
-
- A website that provides high-quality Bhojpuri video songs in HD format. - It has a large collection of Bhojpuri video songs from various genres and artists. - It allows users to download Bhojpuri video songs for free or for a nominal fee. - It also has a blog section that provides news and updates about Bhojpuri music and cinema.
-
- It has a user-friendly interface and easy navigation. - It has a fast downloading speed and no ads. - It has a rating and review system that helps users to find the best Bhojpuri video songs.
-
- It requires registration and login to download Bhojpuri video songs. - It has limited search options and filters.
-
-
-
Bhojpuri Video Songs App
-
- An app that provides Bhojpuri video songs in various formats and resolutions. - It has a huge collection of Bhojpuri video songs from various genres and artists. - It allows users to download Bhojpuri video songs for free or for a nominal fee. - It also has a radio feature that plays Bhojpuri songs online.
-
- It has a simple and attractive interface and easy navigation. - It has a smooth streaming and downloading speed and no ads. - It has a playlist and favorite feature that helps users to organize and save their Bhojpuri video songs.
-
- It requires installation and permission to access the device's storage and media. - It has limited search options and filters. - It has some bugs and errors that affect the performance of the app.
-
-
-
Bhojpuri Video Songs YouTube
-
- A website and app that provides Bhojpuri video songs in various formats and resolutions. - It has a massive collection of Bhojpuri video songs from various genres and artists. - It allows users to stream or watch Bhojpuri video songs online for free or for a premium subscription. - It also has a community feature that allows users to interact with other Bhojpuri music fans and creators.
-
- It has a versatile and dynamic interface and easy navigation. - It has a fast streaming and downloading speed and minimal ads. - It has a recommendation and feedback system that helps users to discover new and relevant Bhojpuri video songs.
-
- It does not allow users to download Bhojpuri video songs directly from the website or app. - It has many search options and filters, but they are not specific to Bhojpuri music. - It has some content that is inappropriate or infringing the rights of the original creators.
-
-
-
Conclusion: How to Enjoy Bhojpuri Music to the Fullest
-
Bhojpuri music is a wonderful and unique form of music that deserves more recognition and appreciation. It is not only entertaining, but also informative, inspiring, and empowering. It showcases the culture, identity, and creativity of the Bhojpuri people. It also connects them with their roots, their values, and their aspirations.
-
If you want to enjoy Bhojpuri music to the fullest, you should try to explore its different genres and styles, listen to its different artists and singers, watch its different films and shows, and learn about its different aspects and features. You should also try to understand its language and lyrics, appreciate its melody and rhythm, feel its emotion and expression, and share its joy and fun. You should also try to support its growth and development, promote its quality and originality, respect its diversity and authenticity, and celebrate its success and glory.
-
Bhojpuri music is a treasure that belongs to everyone who loves music. It is a gift that can enrich your life with happiness, beauty, and wisdom. So, what are you waiting for? Go ahead and download your favorite Bhojpuri video songs today!
-
FAQs: Some Common Questions and Answers about Bhojpuri Music
-
Here are some common questions and answers about Bhojpuri music that you might find helpful:
-
-
What is the difference between Bhojpuri music and Bollywood music? Bollywood music is the generic term for the popular music of Hindi cinema, which is produced in Mumbai, the entertainment capital of India. Bollywood music is influenced by various musical traditions, such as Indian classical, folk, pop, rock, jazz, hip hop, etc. Bollywood music is sung in Hindi or other languages, such as Urdu, Punjabi, English, etc. Bollywood music is widely popular across India and the world. Bhojpuri music is the specific term for the folk music of the Bhojpur-Purvanchal region of India and the Terai region of Nepal. Bhojpuri music is influenced by the local culture and traditions of the Bhojpuri people. Bhojpuri music is sung in the Bhojpuri language, which is a dialect of Hindi that has influences from other languages. Bhojpuri music is popular among the Bhojpuri speakers and other people who love its folk flavor and charm.
-
Who are some of the most famous Bhojpuri singers and actors? Some of the most famous Bhojpuri singers are Sharda Sinha, Bharat Sharma Vyas, Kalpana Patowary, Manoj Tiwari, Dinesh Lal Yadav, Khesari Lal Yadav, Pawan Singh, Akshara Singh, Priyanka Singh, Ritesh Pandey, Indu Sonali, Khushboo Jain, Mohan Rathore, etc. Some of the most famous Bhojpuri actors are Ravi Kishan, Manoj Tiwari, Dinesh Lal Yadav, Khesari Lal Yadav, Pawan Singh, Akshara Singh, Amrapali Dubey, Monalisa, Anjana Singh, Kajal Raghwani, etc.
-
How can I learn Bhojpuri language and lyrics? If you want to learn Bhojpuri language and lyrics, you can use various online resources and tools that can help you. For example, you can use online dictionaries and translators that can provide you with the meanings and pronunciations of Bhojpuri words and phrases. You can also use online courses and videos that can teach you the basics and nuances of Bhojpuri grammar and vocabulary. You can also use online lyrics sites and apps that can provide you with the lyrics and translations of Bhojpuri songs. You can also listen to Bhojpuri songs and watch Bhojpuri films and shows that can help you improve your listening and speaking skills.
-
What are some of the benefits of listening to Bhojpuri music? Listening to Bhojpuri music can have many benefits for your physical, mental, and emotional well-being. For example, listening to Bhojpuri music can help you relax and reduce stress by releasing endorphins and serotonin in your brain. It can also help you boost your mood and energy by stimulating your brain waves and nervous system. It can also help you improve your memory and concentration by enhancing your cognitive functions and neural connections. It can also help you express your feelings and emotions by resonating with your inner self and others. It can also help you learn about new cultures and perspectives by exposing you to different sounds and meanings.
-
How can I support Bhojpuri music and cinema? If you love Bhojpuri music and cinema, you can support them in various ways. For example, you can download or stream Bhojpuri songs and films from legal and ethical sources that respect the rights of the creators and pay them fairly. You can also share or recommend Bhojpuri songs and films to your friends and family who might enjoy them too. You can also follow or subscribe to Bhojpuri singers and actors on their social media platforms and show them your appreciation and feedback. You can also participate in online or offline events and activities that celebrate or promote Bhojpuri music and cinema.
-
-
I hope this article has helped you learn more about Bhojpuri music and how to enjoy it to the fullest. If you have any questions or comments, please feel free to leave them below. Thank you for reading!
197e85843d
-
-
\ No newline at end of file
diff --git a/spaces/1phancelerku/anime-remove-background/Bad 2 Bad Apocalypse - The Ultimate Open World Survival RPG Game APK.md b/spaces/1phancelerku/anime-remove-background/Bad 2 Bad Apocalypse - The Ultimate Open World Survival RPG Game APK.md
deleted file mode 100644
index cf86078d98d83100e56ac1eff37b12f388f46dc6..0000000000000000000000000000000000000000
--- a/spaces/1phancelerku/anime-remove-background/Bad 2 Bad Apocalypse - The Ultimate Open World Survival RPG Game APK.md
+++ /dev/null
@@ -1,172 +0,0 @@
-
-
Bad 2 Bad: Apocalypse APK - A Survival RPG Game for Android
-
If you are looking for a challenging and immersive survival RPG game for your Android device, you might want to check out Bad 2 Bad: Apocalypse APK. This is a game that will test your skills, strategy, and creativity as you explore, gather, craft, and fight in a vast open world. In this article, we will tell you everything you need to know about this game, including what it is, how to download and install it, how to play it, and why you should play it.
Bad 2 Bad: Apocalypse APK is an Android game developed by DAWINSTONE, a Korean studio that specializes in creating action-packed and realistic games. It is the sequel to Bad 2 Bad: Delta and Extinction, two previous games that introduced the world and the characters of the series.
-
The sequel to Bad 2 Bad: Delta and Extinction
-
Bad 2 Bad: Apocalypse APK follows the story of the Delta Team, a group of elite soldiers led by Major Pan, who are trying to save and rebuild the world that has been ravaged by a virus from the Human Forces. The virus has turned most of the humans into zombies, mutants, or cyborgs, and has also infected some of the animals, creating wild and dangerous creatures. The Delta Team has to face these enemies, as well as other factions that are competing for resources and power in the post-apocalyptic world.
-
The story of the Delta Team and their mission
-
The game has a rich and engaging storyline that will keep you hooked as you progress through the game. You will get to know the members of the Delta Team, each with their own personality, background, and skills. You will also encounter various characters that will help or hinder you along the way. You will have to make choices that will affect the outcome of the story and the fate of the world.
-
The features of the game
-
Bad 2 Bad: Apocalypse APK has many features that make it a fun and exciting game to play. Some of these features are:
-
-
A vast open world RPG with over 60 maps and regions to explore
-
Exploration, gathering, fishing, and crafting for survival
-
More than 300 items and weapons to collect and use
-
More detailed character customization and appearance options
-
A squad system that allows you to create and upgrade your own special forces team
-
Artillery support, air support, drones, and battle armor for combat
-
World missions that take place across the globe
-
Advanced graphics and sound effects
-
-
How to download and install Bad 2 Bad: Apocalypse APK?
-
If you want to play this game on your Android device, you will need to download and install the APK file from a reliable source. Here are some things you need to know before doing so:
-
bad 2 bad apocalypse apk download
-bad 2 bad apocalypse game
-bad 2 bad apocalypse mod apk
-bad 2 bad apocalypse android
-bad 2 bad apocalypse latest version
-bad 2 bad apocalypse xapk
-bad 2 bad apocalypse apk pure
-bad 2 bad apocalypse offline
-bad 2 bad apocalypse hack
-bad 2 bad apocalypse cheats
-bad 2 bad apocalypse review
-bad 2 bad apocalypse gameplay
-bad 2 bad apocalypse tips
-bad 2 bad apocalypse guide
-bad 2 bad apocalypse wiki
-bad 2 bad apocalypse update
-bad 2 bad apocalypse free download
-bad 2 bad apocalypse unlimited money
-bad 2 bad apocalypse pc
-bad 2 bad apocalypse online
-bad 2 bad apocalypse apk mirror
-bad 2 bad apocalypse apk mod menu
-bad 2 bad apocalypse best weapons
-bad 2 bad apocalypse characters
-bad 2 bad apocalypse delta team
-bad 2 bad apocalypse apk obb
-bad 2 bad apocalypse rexdl
-bad 2 bad apocalypse apkpure.com
-bad 2 bad apocalypse apkcombo.com
-bad 2 bad apocalypse dawinstone
-how to play bad 2 bad apocalypse
-how to install xapk of b2b:apocalypse
-how to get more resources in b2b:apocalypse
-how to upgrade base camp in b2b:apocalypse
-how to unlock battle armor in b2b:apocalypse
-how to craft equipment in b2b:apocalypse
-how to fish in b2b:apocalypse
-how to explore the world in b2b:apocalypse
-how to survive the virus in b2b:apocalypse
-how to complete world missions in b2b:apocalypse
-how to customize your character in b2b:apocalypse
-how to use artillery support in b2b:apocalypse
-how to use air support in b2b:apocalypse
-how to use drones in b2b:apocalypse
-what is the story of b2b:apocalypse
-what are the features of b2b:apocalypse
-what are the differences between b2b:delta and b2b:apocalypse
-
The requirements for the game
-
The game requires Android 7.0 or higher and at least 188 MB of free storage space on your device. It also requires an internet connection for some features, such as world missions and updates. The game is rated for ages 12+ due
The steps to download and install the APK file
-
To download and install the APK file of Bad 2 Bad: Apocalypse, you can follow these simple steps:
-
-
Go to a trusted website that offers the APK file, such as [APKCombo].
-
Search for the game by typing "Bad 2 Bad: Apocalypse" in the search bar.
-
Click on the download button and choose the version you want to download.
-
Wait for the download to finish and locate the APK file on your device.
-
Tap on the APK file and allow the installation from unknown sources if prompted.
-
Follow the instructions on the screen and wait for the installation to complete.
-
Launch the game and enjoy!
-
-
The precautions to take before installing the game
-
Before you install the game, you should take some precautions to ensure a safe and smooth experience. Here are some tips:
-
-
Make sure your device meets the requirements for the game and has enough storage space.
-
Download the APK file from a reputable source and scan it for viruses or malware.
-
Backup your data and settings in case something goes wrong during the installation.
-
Close any other apps or programs that are running in the background to avoid interference or conflicts.
-
Read the permissions and terms of service of the game carefully and agree only if you are comfortable with them.
-
-
How to play Bad 2 Bad: Apocalypse APK?
-
Once you have installed the game, you can start playing it by following these basic steps:
-
The basic gameplay and controls
-
The game is a survival RPG that combines exploration, combat, and crafting. You can control your character using the virtual joystick on the left side of the screen and use the buttons on the right side to perform actions such as shooting, reloading, switching weapons, using items, calling support, etc. You can also swipe on the screen to move the camera and zoom in or out. You can access the menu by tapping on the icon on the top left corner of the screen, where you can see your inventory, map, missions, settings, etc.
-
The tips and tricks for survival and combat
-
The game is not easy and you will face many challenges and dangers in your journey. Here are some tips and tricks that will help you survive and win:
-
-
Explore as much as you can and collect resources, items, and weapons that will help you craft useful things and improve your equipment.
-
Fish for food and water to replenish your health and stamina. You can also cook your fish for better effects.
-
Avoid unnecessary fights and use stealth or diplomacy when possible. You can also use traps, mines, grenades, or snipers to deal with enemies from a distance.
-
Use cover, dodge, and roll to avoid enemy attacks and bullets. You can also use shields, armor, or medkits to protect yourself.
-
Use your squad members wisely and assign them roles according to their skills. You can also upgrade them with better gear and skills.
-
Use your support options such as artillery, air support, drones, or battle armor when you are in trouble or need extra firepower.
-
The customization and upgrade options
-
The game allows you to customize and upgrade your character and your squad in various ways. You can change your appearance, clothes, accessories, and weapons. You can also improve your skills, stats, and abilities by leveling up and using skill points. You can also craft and enhance your items and weapons using the materials you find or buy. You can also unlock new features and modes as you progress through the game.
-
Why should you play Bad 2 Bad: Apocalypse APK?
-
Bad 2 Bad: Apocalypse APK is a game that will appeal to fans of survival RPG games, action games, and post-apocalyptic stories. Here are some reasons why you should play this game:
-
The pros and cons of the game
-
The game has many pros and cons that you should consider before playing it. Here are some of them:
-
-
-
Pros
-
Cons
-
-
-
A captivating and immersive storyline with multiple endings
-
A complex and challenging gameplay that requires patience and strategy
-
-
-
A vast and diverse open world with many locations and secrets to discover
-
A high requirement for device performance and storage space
-
-
-
A realistic and detailed graphics and sound effects that create a great atmosphere
-
A need for internet connection for some features and updates
-
-
-
A variety of items, weapons, skills, and customization options to suit your preferences
-
A possibility of bugs, glitches, or crashes that may affect your experience
-
-
-
A fun and exciting squad system that lets you create and manage your own team
-
A lack of multiplayer or co-op mode that limits your interaction with other players
-
-
-
The ratings and reviews of the game
-
The game has received mostly positive ratings and reviews from players who have tried it. It has a 4.5 out of 5 stars rating on [APKCombo], based on over 1,000 reviews. Here are some of the comments from the users:
-
-
"This game is awesome! The graphics are amazing, the story is interesting, the gameplay is challenging, and the customization is cool. I love the squad system and the support options. It's like playing a console game on my phone."
-
"This game is very good, but it needs some improvements. The game is too hard sometimes, especially when you face many enemies at once. The game also takes too much space on my device and drains my battery fast. The game also crashes sometimes when I play for too long."
-
"This game is one of the best survival RPG games I have ever played. The game has a lot of content and features that keep me entertained for hours. The game also has a great story with different endings that make me want to replay it. The game is worth every penny."
-
"This game is not bad, but it's not great either. The game has a decent graphics and sound effects, but they are not very impressive. The game also has a boring and repetitive gameplay that makes me lose interest quickly. The game also has a lot of ads and in-app purchases that annoy me."
-
"This game is a masterpiece! The game has everything I want in a survival RPG game: a rich and immersive story, a vast and diverse world, a realistic and detailed graphics, a variety of items, weapons, skills, customization options, squad system, support options, world missions, etc. The game is perfect!"
-
-
The alternatives to the game
-
If you are looking for other games that are similar to Bad 2 Bad: Apocalypse APK, you can try these alternatives:
-
-
[Last Day on Earth: Survival] - A zombie survival RPG game that lets you build your base, craft your weapons, join clans, raid other players' bases, etc.
-
[Fallout Shelter] - A post-apocalyptic simulation game that lets you manage your own vault, recruit dwellers, explore the wasteland, fight enemies, etc.
-
[Day R Survival] - A survival RPG game that lets you travel across a nuclear war-torn Soviet Union, scavenge for resources, fight mutants, join factions, etc.
-
[Dead Trigger 2] - A zombie shooter game that lets you join the global resistance, complete missions, use various weapons, kill hordes of zombies, etc.
-
[The Walking Dead: Road to Survival] - A strategy RPG game based on the popular comic series that lets you build your team, fight walkers, make choices that affect the story, etc.
-
Conclusion
-
Bad 2 Bad: Apocalypse APK is a survival RPG game that will challenge and entertain you with its story, gameplay, graphics, and features. It is a game that you can download and install on your Android device and play for hours. It is a game that will make you feel like you are part of the Delta Team and their mission to save the world. It is a game that you should try if you are a fan of survival RPG games, action games, and post-apocalyptic stories.
-
FAQs
-
Here are some of the frequently asked questions about Bad 2 Bad: Apocalypse APK:
-
-
Is Bad 2 Bad: Apocalypse APK free to play?
-
Yes, the game is free to download and play, but it contains ads and in-app purchases that you can choose to buy or not.
-
Is Bad 2 Bad: Apocalypse APK safe to download and install?
-
Yes, the game is safe to download and install, as long as you get it from a trusted source and scan it for viruses or malware. You should also take some precautions before installing the game, such as backing up your data and closing other apps.
-
Is Bad 2 Bad: Apocalypse APK compatible with my device?
-
The game is compatible with Android devices that have Android 7.0 or higher and at least 188 MB of free storage space. You should also check the performance and battery of your device before playing the game, as it may consume a lot of resources.
-
How can I update Bad 2 Bad: Apocalypse APK?
-
You can update the game by downloading and installing the latest version of the APK file from the same source you got it from. You should also check for updates regularly to get new features and bug fixes.
-
How can I contact the developer of Bad 2 Bad: Apocalypse APK?
-
You can contact the developer of the game by sending an email to [dawinstone@gmail.com] or visiting their website at [http://dawinstone.com]. You can also follow them on Facebook, Twitter, Instagram, or YouTube for more information and news about the game.
- 197e85843d
-
-
\ No newline at end of file
diff --git a/spaces/1phancelerku/anime-remove-background/Download Real Football Soccer 2023 APK and Become a Soccer Champion.md b/spaces/1phancelerku/anime-remove-background/Download Real Football Soccer 2023 APK and Become a Soccer Champion.md
deleted file mode 100644
index 4571af1fde8bf405c114b7085aa82258d98f1560..0000000000000000000000000000000000000000
--- a/spaces/1phancelerku/anime-remove-background/Download Real Football Soccer 2023 APK and Become a Soccer Champion.md
+++ /dev/null
@@ -1,109 +0,0 @@
-
-
Real Football 2023 APK Download: Everything You Need to Know
-
If you're a fan of soccer games, you might want to check out Real Football 2023, a free-to-play mobile game that offers a realistic and immersive soccer experience. With stunning graphics, realistic physics, and various game modes, Real Football 2023 lets you enjoy the thrill of the beautiful game like never before. In this article, we will tell you everything you need to know about Real Football 2023 apk download, including its features, system requirements, tips and tricks, and reviews.
-
Features
-
Real Football 2023 has a lot of features that make it stand out from other soccer games. Here are some of them:
Career mode: In this mode, you can create your own dream team and lead them to glory in the most prestigious soccer tournaments around the world. You can train your players, sign new ones, negotiate contracts, develop youth talent, and build a winning squad.
-
Authentic teams: You can choose from a wide selection of international clubs from top leagues such as La Liga, Premier League, Bundesliga, Serie A, Ligue 1, and more. You can also play with national teams from all over the world.
-
PvP matches: You can challenge other players online in thrilling PvP matches and prove your skills and tactics. You can also join leagues and compete with other teams for rankings and rewards.
-
Realistic graphics and gameplay: Real Football 2023 boasts realistic graphics and animations that make you feel like you're watching a real match. The game also features realistic physics and ball movement that make the gameplay more dynamic and challenging.
-
Intuitive controls and skills: The game has intuitive controls that let you perform various actions such as passing, shooting, dribbling, tackling, crossing, etc. You can also use skills and techniques to outsmart your opponents and score amazing goals.
-
-
System requirements
-
To play Real Football 2023 on your PC or Android device, you need to meet the following system requirements:
-
-
-
Platform
-
Minimum
-
Recommended
-
-
-
PC (Windows)
-
OS: Windows 10 - 64 bit
CPU: Intel Core i5-2300 / AMD FX-4350
RAM: 8 GB
GPU: GeForce GTX 660 Ti / Radeon HD 7790
Storage: 50 GB
-
OS: Windows 10 - 64 bit
CPU: Intel Core i5-7600 / AMD Ryzen 5 1600
RAM: 8 GB
GPU: GeForce GTX 1060 / AMD Radeon RX 590
Storage: 50 GB
-
-
-
Android
-
OS: Android 4.4 or higher
CPU: Quad-core or higher
RAM: 2 GB or higher
Storage: 1 GB or higher
-
N/A
-
-
-
Tips and tricks
-
If you want to improve your performance in Real Football 2023, here are some tips and tricks that might help you:
-
-
Practice your skills: The game has a training mode where you can practice your skills and techniques. You can also customize your training sessions to focus on specific aspects of the game, such as shooting, passing, dribbling, etc.
-
Use the right formation and strategy: Depending on your play style and the opponent's team, you might want to use different formations and strategies. You can change your formation and tactics before and during the match. You can also assign different roles and instructions to your players, such as captain, free kick taker, target man, etc.
-
Manage your stamina and morale: Your players have stamina and morale bars that affect their performance on the pitch. Stamina decreases as the player runs, sprints, or performs actions. Morale increases or decreases depending on the player's performance, team's performance, and match events. You can use substitutions, timeouts, and pep talks to restore your players' stamina and morale.
-
Use the power-ups: The game has various power-ups that you can use to gain an advantage over your opponent. Some of the power-ups are: speed boost, accuracy boost, shield, freeze, magnet, etc. You can activate them by tapping on the screen or using the buttons on the bottom right corner.
-
Collect and upgrade cards: The game has a card system that lets you collect and upgrade different types of cards. There are player cards, coach cards, stadium cards, and sponsor cards. Each card has a rarity level and a set of attributes that affect your team's performance. You can upgrade your cards by using coins or gems.
-
-
Reviews
-
Real Football 2023 has received mostly positive reviews from critics and players alike. Here are some of the reviews from different sources:
-
-
"Real Football 2023 is a great soccer game that offers a lot of fun and challenge for soccer fans. The graphics are amazing, the gameplay is smooth and realistic, and the game modes are varied and engaging. The game is also free to play, which is a big plus." - Android Authority
-
"If you're looking for a soccer game that delivers a realistic and immersive experience, Real Football 2023 is the game for you. The game has everything you need to enjoy the beautiful game: authentic teams, realistic physics, intuitive controls, and various game modes. The game is also updated regularly with new content and features." - PC Gamer
-
"Real Football 2023 is one of the best soccer games I've ever played. The game is very addictive and fun to play. The graphics are stunning, the gameplay is challenging and rewarding, and the game modes are diverse and exciting. The game is also very user-friendly and easy to play." - Google Play user
-
-
Conclusion
-
Real Football 2023 is a game that every soccer fan should try. The game offers a realistic and immersive soccer experience that will keep you hooked for hours. Whether you want to create your own dream team, challenge other players online, or just enjoy a casual match, Real Football 2023 has something for everyone. You can download Real Football 2023 apk for free from the official website or from Google Play Store.
-
real football: soccer 2023 apk free download
-download real football 2023 android game apk
-real football 2023 apk latest version download
-real football 2023 apk mod unlimited money download
-how to download real football 2023 apk for pc
-real football 2023 apk offline download
-real football 2023 apk full game download
-real football 2023 apk + data download
-real football 2023 apk hack download
-real football 2023 apk obb download
-real football 2023 apk update download
-real football 2023 apk online download
-real football 2023 apk cracked download
-real football 2023 apk premium download
-real football 2023 apk pro download
-real football 2023 apk file download
-real football 2023 apk mirror download
-real football 2023 apk direct download
-real football 2023 apk play store download
-real football 2023 apk old version download
-real football 2023 apk new version download
-real football 2023 apk beta download
-real football 2023 apk original download
-real football 2023 apk review download
-real football 2023 apk cheat download
-real football 2023 apk patch download
-real football 2023 apk install download
-real football 2023 apk android tv download
-real football 2023 apk android tablet download
-real football 2023 apk android phone download
-real football 2023 apk android emulator download
-real football 2023 apk android studio download
-real football 2023 apk android app download
-real football 2023 apk android gamepad download
-real football 2023 apk android device download
-real football 2023 apk android sdk download
-real football 2023 apk android oreo download
-real football 2023 apk android pie download
-real football 2023 apk android q download
-real football 2023 apk android r download
-real football 2023 apk android s download
-real football 2023 apk gameloft se download
-real football: soccer game by magic app - free - mobile game for android - latest version:0.5 - updated:23 - com.mt.football.sports.action.soccer.games - free - mobile game for android - latest version:0.5 - updated:23 - com.mt.football.sports.action.soccer.games - free - mobile game for android - latest version:0.5 - updated:23 - com.mt.football.sports.action.soccer.games - free - mobile game for android - latest version:0.5 - updated:23 - com.mt.football.sports.action.soccer.games - free - mobile game for android - latest version:0.5 - updated:23 - com.mt.football.sports.action.soccer.games - free - mobile game for android - latest version:0.5 - updated:23 - com.mt.football.sports.action.soccer.games
-
FAQs
-
Here are some of the frequently asked questions about Real Football 2023:
-
-
Q: How do I download Real Football 2023 apk?
-
A: You can download Real Football 2023 apk from the official website or from Google Play Store. Just follow the instructions on the screen and install the game on your device.
-
Q: Is Real Football 2023 offline or online?
-
A: Real Football 2023 can be played both offline and online. You can play offline in career mode or training mode. You can play online in PvP matches or leagues.
-
Q: How do I get coins and gems in Real Football 2023?
-
A: You can get coins and gems in Real Football 2023 by playing matches, completing achievements, watching ads, or buying them with real money.
-
Q: How do I unlock new teams and players in Real Football 2023?
-
A: You can unlock new teams and players in Real Football 2023 by collecting and upgrading cards. You can get cards by opening packs, winning matches, or buying them with coins or gems.
-
Q: How do I contact the support team of Real Football 2023?
A: You can contact the support team of Real Football 2023 by sending an email to support@realfootball2023.com or by visiting the official website and filling out the contact form.
-
-
I hope you enjoyed this article and learned something new about Real Football 2023 apk download. If you have any questions or feedback, feel free to leave a comment below. Thank you for reading and have fun playing Real Football 2023!
197e85843d
-
-
\ No newline at end of file
diff --git a/spaces/1phancelerku/anime-remove-background/Enjoy Football Strike with MOD APK and Unlimited Money on Android 1.md b/spaces/1phancelerku/anime-remove-background/Enjoy Football Strike with MOD APK and Unlimited Money on Android 1.md
deleted file mode 100644
index e3b94df00c64533ed23a9cef5944a0053871aa3b..0000000000000000000000000000000000000000
--- a/spaces/1phancelerku/anime-remove-background/Enjoy Football Strike with MOD APK and Unlimited Money on Android 1.md
+++ /dev/null
@@ -1,83 +0,0 @@
-
-
Football Strike Mod APK Android 1: A Fun and Exciting Soccer Game
-
Introduction
-
If you are a fan of soccer games, you might have heard of Football Strike, a popular free-kick game developed by Miniclip. In this game, you can challenge your friends or other players from around the world in various modes, such as free kick, shooting race, or career. You can also customize your striker and goalkeeper with different outfits, balls, gloves, and shoes.
-
However, if you want to enjoy the game to the fullest, you might need to spend some real money to unlock all the items and features. That's why many players are looking for a modded version of Football Strike that can give them unlimited money and other benefits. In this article, we will introduce you to Football Strike Mod APK Android 1, a modified version of the game that can provide you with unlimited fun and excitement.
Football Strike Mod APK Android 1 is a hacked version of the original game that can give you access to all the premium features without spending a dime. By downloading this modded version, you can enjoy the following benefits:
-
Features of Football Strike Mod APK Android 1
-
Unlimited money
-
With Football Strike Mod APK Android 1, you can get unlimited money in your account. You can use this money to buy any item or upgrade you want in the game. You can also unlock all the stadiums, leagues, and tournaments without any hassle.
-
Multiplayer mode
-
Football Strike Mod APK Android 1 allows you to play online with your friends or other players from around the world. You can choose from different modes, such as free kick, shooting race, or career. You can also chat with your opponents and send them emojis and stickers.
-
Career mode
-
If you want to test your skills and become a soccer legend, you can try the career mode in Football Strike Mod APK Android 1. In this mode, you can play against different teams and players in various challenges and tournaments. You can also earn trophies and rewards as you progress.
-
Customization options
-
Football Strike Mod APK Android 1 gives you the freedom to customize your striker and goalkeeper with tons of items. You can choose from different outfits, balls, gloves, shoes, hairstyles, tattoos, and more. You can also show off your style or represent your team's colors.
-
Realistic graphics and sound effects
-
Football Strike Mod APK Android 1 has stunning graphics and sound effects that make the game more realistic and immersive. You can enjoy the smooth animations and physics of the game, as well as the cheering crowds and commentary. You can also adjust the graphics settings according to your device's performance.
-
How to download and install Football Strike Mod APK Android 1
-
If you are interested in downloading and installing Football Strike Mod APK Android 1 on your Android device, you can follow these simple steps:
-
football strike hack apk download for android
-football strike unlimited money mod apk latest version
-football strike multiplayer soccer mod apk free
-football strike miniclip mod apk android 1
-football strike modded apk online game
-football strike cheats apk no root
-football strike premium mod apk unlocked
-football strike mod apk unlimited cash and coins
-football strike hack mod apk 2023
-football strike vip mod apk download
-football strike pro mod apk revdl
-football strike mod apk offline mode
-football strike mod apk android republic
-football strike mega mod apk unlimited everything
-football strike mod apk new update
-football strike hack tool apk without verification
-football strike cracked mod apk full version
-football strike mod apk all balls unlocked
-football strike hack generator apk no survey
-football strike mod menu apk god mode
-football strike extreme mod apk unlimited gems
-football strike super mod apk anti ban
-football strike mod apk obb data file
-football strike hack version apk original
-football strike beta mod apk latest
-football strike real mod apk no ads
-football strike ultimate mod apk high damage
-football strike hack online apk easy
-football strike mod apk rexdl.com
-football strike private server mod apk working
-football strike hack appvn apk safe
-football strike best mod apk 1.43.2
-football strike old version mod apk 1.0.0
-football strike lite mod apk low mb
-football strike gold mod apk unlimited keys
-football strike fun mod apk with friends
-football strike lucky patcher mod apk 2023/06/16
-football strike xmodgames mod apk ios
-football strike master mod apk android oyun club
-football strike royal mod apk android 1.com
-
Step 1: Enable unknown sources
-
Before you can install any APK file on your device, you need to enable unknown sources in your security settings. To do this, go to Settings > Security > Unknown Sources and toggle it on.
-
Step 2: Download the APK file
-
Next, you need to download the APK file of Football Strike Mod APK Android 1 from a reliable source.
Step 3: Install the APK file
-
After downloading the APK file, you need to locate it in your file manager and tap on it to start the installation process. You might see a pop-up asking for your permission to install the app. Just tap on Install and wait for a few seconds.
-
Step 4: Launch the game and enjoy
-
Once the installation is complete, you can launch the game from your app drawer or home screen. You can now enjoy Football Strike Mod APK Android 1 with unlimited money and other features.
-
Conclusion
-
Football Strike Mod APK Android 1 is a great soccer game that can provide you with hours of fun and excitement. You can play online with your friends or other players, customize your striker and goalkeeper, and enjoy realistic graphics and sound effects. You can also get unlimited money and access to all the items and features in the game without spending any real money. If you are looking for a modded version of Football Strike, you should definitely try Football Strike Mod APK Android 1.
-
FAQs
-
Is Football Strike Mod APK Android 1 safe to download and install?
-
Yes, Football Strike Mod APK Android 1 is safe to download and install on your Android device. It does not contain any viruses or malware that can harm your device or data. However, you should always download it from a trusted source and enable unknown sources in your security settings before installing it.
-
Does Football Strike Mod APK Android 1 require root access?
-
No, Football Strike Mod APK Android 1 does not require root access to work on your device. You can install and play it without rooting your device or modifying any system files.
-
Can I play Football Strike Mod APK Android 1 offline?
-
No, Football Strike Mod APK Android 1 requires an internet connection to work properly. You need to connect to the internet to play online with other players, access the career mode, and update the game.
-
Can I update Football Strike Mod APK Android 1 to the latest version?
-
Yes, you can update Football Strike Mod APK Android 1 to the latest version whenever there is a new update available. However, you might need to uninstall the previous version and download the new version from the same source. You might also lose your progress and data if you update the game.
-
Can I use my existing account to play Football Strike Mod APK Android 1?
-
No, you cannot use your existing account to play Football Strike Mod APK Android 1. You need to create a new account or use a guest account to play the modded version of the game. If you use your existing account, you might get banned or suspended by the game developers.
401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/2023Liu2023/bingo/src/lib/hooks/use-bing.ts b/spaces/2023Liu2023/bingo/src/lib/hooks/use-bing.ts
deleted file mode 100644
index dcdb1667ced0cba299b0825c0e91c4732411308c..0000000000000000000000000000000000000000
--- a/spaces/2023Liu2023/bingo/src/lib/hooks/use-bing.ts
+++ /dev/null
@@ -1,173 +0,0 @@
-'use client'
-
-import { useState, useCallback, useEffect, useMemo } from 'react'
-import { useAtom, useAtomValue } from 'jotai'
-import { chatFamily, bingConversationStyleAtom, GreetMessages, hashAtom, voiceAtom } from '@/state'
-import { setConversationMessages } from './chat-history'
-import { ChatMessageModel, BotId, FileItem } from '@/lib/bots/bing/types'
-import { nanoid } from '../utils'
-import { TTS } from '../bots/bing/tts'
-
-export function useBing(botId: BotId = 'bing') {
- const chatAtom = useMemo(() => chatFamily({ botId, page: 'singleton' }), [botId])
- const [enableTTS] = useAtom(voiceAtom)
- const speaker = useMemo(() => new TTS(), [])
- const [hash, setHash] = useAtom(hashAtom)
- const bingConversationStyle = useAtomValue(bingConversationStyleAtom)
- const [chatState, setChatState] = useAtom(chatAtom)
- const [input, setInput] = useState('')
- const [attachmentList, setAttachmentList] = useState([])
-
- const updateMessage = useCallback(
- (messageId: string, updater: (message: ChatMessageModel) => void) => {
- setChatState((draft) => {
- const message = draft.messages.find((m) => m.id === messageId)
- if (message) {
- updater(message)
- }
- })
- },
- [setChatState],
- )
-
- const sendMessage = useCallback(
- async (input: string, options = {}) => {
- const botMessageId = nanoid()
- const imageUrl = attachmentList?.[0]?.status === 'loaded' ? attachmentList[0].url : undefined
- setChatState((draft) => {
- const text = imageUrl ? `${input}\n\n` : input
- draft.messages.push({ id: nanoid(), text, author: 'user' }, { id: botMessageId, text: '', author: 'bot' })
- setAttachmentList([])
- })
- const abortController = new AbortController()
- setChatState((draft) => {
- draft.generatingMessageId = botMessageId
- draft.abortController = abortController
- })
- speaker.reset()
- await chatState.bot.sendMessage({
- prompt: input,
- imageUrl: /\?bcid=([^&]+)/.test(imageUrl ?? '') ? `https://www.bing.com/images/blob?bcid=${RegExp.$1}` : imageUrl,
- options: {
- ...options,
- bingConversationStyle,
- },
- signal: abortController.signal,
- onEvent(event) {
- if (event.type === 'UPDATE_ANSWER') {
- updateMessage(botMessageId, (message) => {
- if (event.data.text.length > message.text.length) {
- message.text = event.data.text
- }
-
- if (event.data.spokenText && enableTTS) {
- speaker.speak(event.data.spokenText)
- }
-
- message.throttling = event.data.throttling || message.throttling
- message.sourceAttributions = event.data.sourceAttributions || message.sourceAttributions
- message.suggestedResponses = event.data.suggestedResponses || message.suggestedResponses
- })
- } else if (event.type === 'ERROR') {
- updateMessage(botMessageId, (message) => {
- message.error = event.error
- })
- setChatState((draft) => {
- draft.abortController = undefined
- draft.generatingMessageId = ''
- })
- } else if (event.type === 'DONE') {
- setChatState((draft) => {
- draft.abortController = undefined
- draft.generatingMessageId = ''
- })
- }
- },
- })
- },
- [botId, attachmentList, chatState.bot, setChatState, updateMessage],
- )
-
- const uploadImage = useCallback(async (imgUrl: string) => {
- setAttachmentList([{ url: imgUrl, status: 'loading' }])
- const response = await chatState.bot.uploadImage(imgUrl, bingConversationStyle)
- if (response?.blobId) {
- setAttachmentList([{ url: `/api/blob?bcid=${response.blobId}`, status: 'loaded' }])
- } else {
- setAttachmentList([{ url: imgUrl, status: 'error' }])
- }
- }, [chatState.bot])
-
- const resetConversation = useCallback(() => {
- chatState.bot.resetConversation()
- speaker.abort()
- setChatState((draft) => {
- draft.abortController = undefined
- draft.generatingMessageId = ''
- draft.messages = [{ author: 'bot', text: GreetMessages[Math.floor(GreetMessages.length * Math.random())], id: nanoid() }]
- draft.conversationId = nanoid()
- })
- }, [chatState.bot, setChatState])
-
- const stopGenerating = useCallback(() => {
- chatState.abortController?.abort()
- if (chatState.generatingMessageId) {
- updateMessage(chatState.generatingMessageId, (message) => {
- if (!message.text && !message.error) {
- message.text = 'Cancelled'
- }
- })
- }
- setChatState((draft) => {
- draft.generatingMessageId = ''
- })
- }, [chatState.abortController, chatState.generatingMessageId, setChatState, updateMessage])
-
- useEffect(() => {
- if (chatState.messages.length) {
- setConversationMessages(botId, chatState.conversationId, chatState.messages)
- }
- }, [botId, chatState.conversationId, chatState.messages])
-
- useEffect(() => {
- if (hash === 'reset') {
- resetConversation()
- setHash('')
- }
- }, [hash, setHash])
-
- const chat = useMemo(
- () => ({
- botId,
- bot: chatState.bot,
- isSpeaking: speaker.isSpeaking,
- messages: chatState.messages,
- sendMessage,
- setInput,
- input,
- resetConversation,
- generating: !!chatState.generatingMessageId,
- stopGenerating,
- uploadImage,
- setAttachmentList,
- attachmentList,
- }),
- [
- botId,
- bingConversationStyle,
- chatState.bot,
- chatState.generatingMessageId,
- chatState.messages,
- speaker.isSpeaking,
- setInput,
- input,
- setAttachmentList,
- attachmentList,
- resetConversation,
- sendMessage,
- stopGenerating,
- ],
- )
-
- return chat
-}
diff --git a/spaces/4Taps/SadTalker/src/face3d/models/arcface_torch/configs/base.py b/spaces/4Taps/SadTalker/src/face3d/models/arcface_torch/configs/base.py
deleted file mode 100644
index 78e4b36a9142b649ec39a8c59331bb2557f2ad57..0000000000000000000000000000000000000000
--- a/spaces/4Taps/SadTalker/src/face3d/models/arcface_torch/configs/base.py
+++ /dev/null
@@ -1,56 +0,0 @@
-from easydict import EasyDict as edict
-
-# make training faster
-# our RAM is 256G
-# mount -t tmpfs -o size=140G tmpfs /train_tmp
-
-config = edict()
-config.loss = "arcface"
-config.network = "r50"
-config.resume = False
-config.output = "ms1mv3_arcface_r50"
-
-config.dataset = "ms1m-retinaface-t1"
-config.embedding_size = 512
-config.sample_rate = 1
-config.fp16 = False
-config.momentum = 0.9
-config.weight_decay = 5e-4
-config.batch_size = 128
-config.lr = 0.1 # batch size is 512
-
-if config.dataset == "emore":
- config.rec = "/train_tmp/faces_emore"
- config.num_classes = 85742
- config.num_image = 5822653
- config.num_epoch = 16
- config.warmup_epoch = -1
- config.decay_epoch = [8, 14, ]
- config.val_targets = ["lfw", ]
-
-elif config.dataset == "ms1m-retinaface-t1":
- config.rec = "/train_tmp/ms1m-retinaface-t1"
- config.num_classes = 93431
- config.num_image = 5179510
- config.num_epoch = 25
- config.warmup_epoch = -1
- config.decay_epoch = [11, 17, 22]
- config.val_targets = ["lfw", "cfp_fp", "agedb_30"]
-
-elif config.dataset == "glint360k":
- config.rec = "/train_tmp/glint360k"
- config.num_classes = 360232
- config.num_image = 17091657
- config.num_epoch = 20
- config.warmup_epoch = -1
- config.decay_epoch = [8, 12, 15, 18]
- config.val_targets = ["lfw", "cfp_fp", "agedb_30"]
-
-elif config.dataset == "webface":
- config.rec = "/train_tmp/faces_webface_112x112"
- config.num_classes = 10572
- config.num_image = "forget"
- config.num_epoch = 34
- config.warmup_epoch = -1
- config.decay_epoch = [20, 28, 32]
- config.val_targets = ["lfw", "cfp_fp", "agedb_30"]
diff --git a/spaces/7hao/bingo/src/components/ui/input.tsx b/spaces/7hao/bingo/src/components/ui/input.tsx
deleted file mode 100644
index 684a857f3d769b78818fb13de1abaebfb09ca79c..0000000000000000000000000000000000000000
--- a/spaces/7hao/bingo/src/components/ui/input.tsx
+++ /dev/null
@@ -1,25 +0,0 @@
-import * as React from 'react'
-
-import { cn } from '@/lib/utils'
-
-export interface InputProps
- extends React.InputHTMLAttributes {}
-
-const Input = React.forwardRef(
- ({ className, type, ...props }, ref) => {
- return (
-
- )
- }
-)
-Input.displayName = 'Input'
-
-export { Input }
diff --git a/spaces/AAYUSH27/Neuro/installation_steps.md b/spaces/AAYUSH27/Neuro/installation_steps.md
deleted file mode 100644
index ce6cb1c86139a97c07799dee1b3c9d4db14f9f5b..0000000000000000000000000000000000000000
--- a/spaces/AAYUSH27/Neuro/installation_steps.md
+++ /dev/null
@@ -1,43 +0,0 @@
-
-## Make sure you have git-lfs installed [Git LFS](https://git-lfs.com) ✅
-# 🧑🏻💻Steps to download the Code
-
-**📌 NOTE-1: If the Llama 2 Model is not donwloaded then the code will not work properly.**
-
-**📌 NOTE-2: If the HuggingFaces API is not in ```.env``` file then generate your own API key from HugginFaces and use it.**
-
----
-
-Step:0
-- Copy and Paste the below command in terminal.
-- This command will help to download the code to your local machine.
-```shell
-git clone https://huggingface.co/spaces/AAYUSH27/Neuro
-```
-- The file is of approx. 5GB
-- If you want to clone without large files (Llama 2 Model).
-```shell
-git clone https://huggingface.co/spaces/AAYUSH27/Neuro
-GIT_LFS_SKIP_SMUDGE=1
-```
-
-Step:1
-- Copy and Paste the below command in terminal.
-- This command helps to go into the project directory.
-```shell
-cd Neuro
-```
-
-Step:2
-- Copy and Paste the below command in terminal.
-- This commmand helps to install all the libraries in one take from ```requirements.txt```.
-```shell
-pip3 install -r requirements.txt
-```
-
-Step:3
-- Copy and Paste the below command in terminal.
-- This command helps to run the code into local host via ```streamlit```.
-```shell
-streamlit run -app.py
-```
\ No newline at end of file
diff --git a/spaces/AIGC-Audio/Make_An_Audio_inpaint/vocoder/bigvgan/activations.py b/spaces/AIGC-Audio/Make_An_Audio_inpaint/vocoder/bigvgan/activations.py
deleted file mode 100644
index 61f2808a5466b3cf4d041059700993af5527dd29..0000000000000000000000000000000000000000
--- a/spaces/AIGC-Audio/Make_An_Audio_inpaint/vocoder/bigvgan/activations.py
+++ /dev/null
@@ -1,120 +0,0 @@
-# Implementation adapted from https://github.com/EdwardDixon/snake under the MIT license.
-# LICENSE is in incl_licenses directory.
-
-import torch
-from torch import nn, sin, pow
-from torch.nn import Parameter
-
-
-class Snake(nn.Module):
- '''
- Implementation of a sine-based periodic activation function
- Shape:
- - Input: (B, C, T)
- - Output: (B, C, T), same shape as the input
- Parameters:
- - alpha - trainable parameter
- References:
- - This activation function is from this paper by Liu Ziyin, Tilman Hartwig, Masahito Ueda:
- https://arxiv.org/abs/2006.08195
- Examples:
- >>> a1 = snake(256)
- >>> x = torch.randn(256)
- >>> x = a1(x)
- '''
- def __init__(self, in_features, alpha=1.0, alpha_trainable=True, alpha_logscale=False):
- '''
- Initialization.
- INPUT:
- - in_features: shape of the input
- - alpha: trainable parameter
- alpha is initialized to 1 by default, higher values = higher-frequency.
- alpha will be trained along with the rest of your model.
- '''
- super(Snake, self).__init__()
- self.in_features = in_features
-
- # initialize alpha
- self.alpha_logscale = alpha_logscale
- if self.alpha_logscale: # log scale alphas initialized to zeros
- self.alpha = Parameter(torch.zeros(in_features) * alpha)
- else: # linear scale alphas initialized to ones
- self.alpha = Parameter(torch.ones(in_features) * alpha)
-
- self.alpha.requires_grad = alpha_trainable
-
- self.no_div_by_zero = 0.000000001
-
- def forward(self, x):
- '''
- Forward pass of the function.
- Applies the function to the input elementwise.
- Snake ∶= x + 1/a * sin^2 (xa)
- '''
- alpha = self.alpha.unsqueeze(0).unsqueeze(-1) # line up with x to [B, C, T]
- if self.alpha_logscale:
- alpha = torch.exp(alpha)
- x = x + (1.0 / (alpha + self.no_div_by_zero)) * pow(sin(x * alpha), 2)
-
- return x
-
-
-class SnakeBeta(nn.Module):
- '''
- A modified Snake function which uses separate parameters for the magnitude of the periodic components
- Shape:
- - Input: (B, C, T)
- - Output: (B, C, T), same shape as the input
- Parameters:
- - alpha - trainable parameter that controls frequency
- - beta - trainable parameter that controls magnitude
- References:
- - This activation function is a modified version based on this paper by Liu Ziyin, Tilman Hartwig, Masahito Ueda:
- https://arxiv.org/abs/2006.08195
- Examples:
- >>> a1 = snakebeta(256)
- >>> x = torch.randn(256)
- >>> x = a1(x)
- '''
- def __init__(self, in_features, alpha=1.0, alpha_trainable=True, alpha_logscale=False):
- '''
- Initialization.
- INPUT:
- - in_features: shape of the input
- - alpha - trainable parameter that controls frequency
- - beta - trainable parameter that controls magnitude
- alpha is initialized to 1 by default, higher values = higher-frequency.
- beta is initialized to 1 by default, higher values = higher-magnitude.
- alpha will be trained along with the rest of your model.
- '''
- super(SnakeBeta, self).__init__()
- self.in_features = in_features
-
- # initialize alpha
- self.alpha_logscale = alpha_logscale
- if self.alpha_logscale: # log scale alphas initialized to zeros
- self.alpha = Parameter(torch.zeros(in_features) * alpha)
- self.beta = Parameter(torch.zeros(in_features) * alpha)
- else: # linear scale alphas initialized to ones
- self.alpha = Parameter(torch.ones(in_features) * alpha)
- self.beta = Parameter(torch.ones(in_features) * alpha)
-
- self.alpha.requires_grad = alpha_trainable
- self.beta.requires_grad = alpha_trainable
-
- self.no_div_by_zero = 0.000000001
-
- def forward(self, x):
- '''
- Forward pass of the function.
- Applies the function to the input elementwise.
- SnakeBeta ∶= x + 1/b * sin^2 (xa)
- '''
- alpha = self.alpha.unsqueeze(0).unsqueeze(-1) # line up with x to [B, C, T]
- beta = self.beta.unsqueeze(0).unsqueeze(-1)
- if self.alpha_logscale:
- alpha = torch.exp(alpha)
- beta = torch.exp(beta)
- x = x + (1.0 / (beta + self.no_div_by_zero)) * pow(sin(x * alpha), 2)
-
- return x
\ No newline at end of file
diff --git a/spaces/AISuperheroes/08GR-KitchenSink-AIUIUX/demos/kitchen_sink/files/Readme.md b/spaces/AISuperheroes/08GR-KitchenSink-AIUIUX/demos/kitchen_sink/files/Readme.md
deleted file mode 100644
index 694750db93d3558b7eedf3846715c7a5a8dd5e43..0000000000000000000000000000000000000000
--- a/spaces/AISuperheroes/08GR-KitchenSink-AIUIUX/demos/kitchen_sink/files/Readme.md
+++ /dev/null
@@ -1 +0,0 @@
-Creates directory on demos/kitchen_sink/files/ to store programmatic load files
\ No newline at end of file
diff --git a/spaces/Ababababababbababa/Ashaar/poetry_diacritizer/util/text_cleaners.py b/spaces/Ababababababbababa/Ashaar/poetry_diacritizer/util/text_cleaners.py
deleted file mode 100644
index 04b66ee7a261feb58e5636147e9af1213abb2c75..0000000000000000000000000000000000000000
--- a/spaces/Ababababababbababa/Ashaar/poetry_diacritizer/util/text_cleaners.py
+++ /dev/null
@@ -1,146 +0,0 @@
-import re
-from .constants import VALID_ARABIC
-from itertools import product, combinations
-
-_whitespace_re = re.compile(r"\s+")
-
-
-def collapse_whitespace(text):
- text = re.sub(_whitespace_re, " ", text)
- return text
-
-
-def basic_cleaners(text):
- text = collapse_whitespace(text)
- return text.strip()
-
-
-# def valid_arabic_cleaners(text):
-# text = filter(lambda char: char in VALID_ARABIC, text)
-# text = collapse_whitespace(''.join(list(text)))
-# return text.strip()
-
-harakat = ["\u0650", "\u064E", "\u064F"] # [kasra, fatha, damma, ]
-sukun = ["\u0652"] # [sukun]
-mostly_saken = [
- "\u0627",
- "\u0648",
- "\u0649",
- "\u064A",
-] # [alef, waw, alef maqsurah, ya'a]
-
-always_saken = [
- "\u0627",
- "\u0649",
-]
-
-tnween_chars = [
- "\u064c",
- "\u064d",
- "\u064b",
-] # damm tanween, kasra tanween, fatha tanween, maddah
-shadda_chars = ["\u0651"]
-all_tashkeel = harakat+tnween_chars+sukun+shadda_chars
-
-
-all_chars = list("إةابتثجحخدذرزسشصضطظعغفقكلمنهويىأءئؤ ")
-prem_chars = harakat + sukun + mostly_saken + tnween_chars + shadda_chars + all_chars
-
-def not_valid_tashkeel_comb(comb):
- all_comb = list(product(harakat+sukun+tnween_chars, repeat = 2))+list(product(shadda_chars+sukun, repeat = 2))
- if comb in all_comb or comb[::-1] in all_comb:
- return True
- else:
- return False
-
-def remove_tanween_on_alef(text):
- text_copy = ""
- for i in range(0, len(text)):
-
- # if there is shaddah or character followed by alef followed by tanween add
- if i < len(text) - 2 and text[i] in all_chars+shadda_chars and text[i+1] in always_saken and text[i+2] == tnween_chars[2]:
- text_copy += text[i] + tnween_chars[2]
-
- #ignore current harakah if there is alef followed by tanween
- elif i < len(text) - 2 and text[i] in harakat and text[i+1] in always_saken and text[i+2] == tnween_chars[2] :
- text_copy += tnween_chars[2]
-
- # if the current char is tanween with alef is the previous character drop tanween
- elif i > 0 and text[i] == tnween_chars[2] and text[i-1] in always_saken:
- continue
-
- else:
- text_copy += text[i]
- return text_copy
-
-def dont_start_by_harakah(text):
- text_copy = ""
- for i, char in enumerate(text):
- if not(char in all_tashkeel):
- text_copy = text[i:]
- break
- return text_copy
-
-def valid_arabic_cleaners(text):
- prev_text = text
- for i in range(5):
- text = prev_text
- cleaned_text = ""
- text = filter(lambda char: char in VALID_ARABIC, text)
- text = collapse_whitespace(''.join(list(text)))
- text = dont_start_by_harakah(text)
- text = text.strip()
- i = 0
- cnt = 0
- len_text = len(text)
- while( i < len_text):
- if text[i] in all_tashkeel:
- cnt += 1
- else:
- cnt = 0
-
- # don't allow three consecutive tashkeel
- if cnt > 2:
- i+= 1
- continue
-
- # remove second tanween and sukun
- if i > 1 and text[i] in tnween_chars+sukun and text[i-2] in tnween_chars+sukun:
- i += 1
- continue
-
- # don't allow harakah followed by shaddah or tanween
- if i < len(text) - 1 and text[i] in harakat and text[i+1] in tnween_chars+sukun+shadda_chars:
- i += 1
- continue
-
- # don't allow harkah on space
- if i> 0 and text[i] in all_tashkeel and text[i-1] == " " :
- i += 1
- continue
-
- # only allow permissable combinations
- if not_valid_tashkeel_comb((text[i], text[i-1])):
- i+=1
- continue
-
- # don't allow harkah on alef, alef maqsura, if there is no tashkeel before move it back
- if i> 1 and text[i] in harakat and text[i-1] in always_saken :
- if text[i-2] in all_tashkeel: # in case there is a tashkeelah before alef
- continue
- else:
- cleaned_text = text[:i-1]+text[i]+ always_saken[always_saken.index(text[i-1])]
- i += 1
-
- if i < len(text):
- cleaned_text+= text[i]
- i += 1
-
- # only allow tanween before alef
- cleaned_text = remove_tanween_on_alef(cleaned_text)
- cleaned_text = re.sub(r" +", " ", cleaned_text).strip()
- if prev_text == cleaned_text:
- break
- else:
- prev_text = cleaned_text
- return cleaned_text
\ No newline at end of file
diff --git a/spaces/Abhilashvj/planogram-compliance/utils/docker/Dockerfile b/spaces/Abhilashvj/planogram-compliance/utils/docker/Dockerfile
deleted file mode 100644
index 98e9c2927b876b28834816235414567265276946..0000000000000000000000000000000000000000
--- a/spaces/Abhilashvj/planogram-compliance/utils/docker/Dockerfile
+++ /dev/null
@@ -1,66 +0,0 @@
-# YOLOv5 🚀 by Ultralytics, GPL-3.0 license
-# Builds ultralytics/yolov5:latest image on DockerHub https://hub.docker.com/r/ultralytics/yolov5
-# Image is CUDA-optimized for YOLOv5 single/multi-GPU training and inference
-
-# Start FROM NVIDIA PyTorch image https://ngc.nvidia.com/catalog/containers/nvidia:pytorch
-FROM nvcr.io/nvidia/pytorch:22.12-py3
-RUN rm -rf /opt/pytorch # remove 1.2GB dir
-
-# Downloads to user config dir
-ADD https://ultralytics.com/assets/Arial.ttf https://ultralytics.com/assets/Arial.Unicode.ttf /root/.config/Ultralytics/
-
-# Install linux packages
-RUN apt update && apt install --no-install-recommends -y zip htop screen libgl1-mesa-glx
-
-# Install pip packages (uninstall torch nightly in favor of stable)
-COPY requirements.txt .
-RUN python -m pip install --upgrade pip wheel
-RUN pip uninstall -y Pillow torchtext torch torchvision
-RUN pip install --no-cache -U pycocotools # install --upgrade
-RUN pip install --no-cache -r requirements.txt albumentations comet gsutil notebook 'opencv-python<4.6.0.66' \
- Pillow>=9.1.0 ultralytics \
- --extra-index-url https://download.pytorch.org/whl/cu113
-
-# Create working directory
-RUN mkdir -p /usr/src/app
-WORKDIR /usr/src/app
-
-# Copy contents
-# COPY . /usr/src/app (issues as not a .git directory)
-RUN git clone https://github.com/ultralytics/yolov5 /usr/src/app
-
-# Set environment variables
-ENV OMP_NUM_THREADS=1
-
-
-# Usage Examples -------------------------------------------------------------------------------------------------------
-
-# Build and Push
-# t=ultralytics/yolov5:latest && sudo docker build -f utils/docker/Dockerfile -t $t . && sudo docker push $t
-
-# Pull and Run
-# t=ultralytics/yolov5:latest && sudo docker pull $t && sudo docker run -it --ipc=host --gpus all $t
-
-# Pull and Run with local directory access
-# t=ultralytics/yolov5:latest && sudo docker pull $t && sudo docker run -it --ipc=host --gpus all -v "$(pwd)"/datasets:/usr/src/datasets $t
-
-# Kill all
-# sudo docker kill $(sudo docker ps -q)
-
-# Kill all image-based
-# sudo docker kill $(sudo docker ps -qa --filter ancestor=ultralytics/yolov5:latest)
-
-# DockerHub tag update
-# t=ultralytics/yolov5:latest tnew=ultralytics/yolov5:v6.2 && sudo docker pull $t && sudo docker tag $t $tnew && sudo docker push $tnew
-
-# Clean up
-# docker system prune -a --volumes
-
-# Update Ubuntu drivers
-# https://www.maketecheasier.com/install-nvidia-drivers-ubuntu/
-
-# DDP test
-# python -m torch.distributed.run --nproc_per_node 2 --master_port 1 train.py --epochs 3
-
-# GCP VM from Image
-# docker.io/ultralytics/yolov5:latest
diff --git a/spaces/AchyuthGamer/OpenGPT-Chat-UI/src/lib/utils/loadClientCerts.ts b/spaces/AchyuthGamer/OpenGPT-Chat-UI/src/lib/utils/loadClientCerts.ts
deleted file mode 100644
index feb8c01e771846cf6191baf1f5d9d7d2b74cde29..0000000000000000000000000000000000000000
--- a/spaces/AchyuthGamer/OpenGPT-Chat-UI/src/lib/utils/loadClientCerts.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-import * as fs from "fs";
-import { setGlobalDispatcher, Agent } from "undici";
-
-/**
- * Load client certificates for mutual TLS authentication. This function must be called before any HTTP requests are made.
- * This is a global setting that affects all HTTP requests made by the application using the native fetch API.
- *
- * @param clientCertPath Path to client certificate
- * @param clientKeyPath Path to client key
- * @param caCertPath Path to CA certificate [optional]
- * @param clientKeyPassword Password for client key [optional]
- * @param rejectUnauthorized Reject unauthorized certificates.
- * Only use for testing/development, not recommended in production environments [optional]
- *
- * @returns void
- *
- * @example
- * ```typescript
- * loadClientCertificates("cert.pem", "key.pem", "ca.pem", "password", false);
- * ```
- *
- * @see
- * [Undici Agent](https://undici.nodejs.org/#/docs/api/Agent)
- * @see
- * [Undici Dispatcher](https://undici.nodejs.org/#/docs/api/Dispatcher)
- * @see
- * [NodeJS Native Fetch API](https://nodejs.org/docs/latest-v19.x/api/globals.html#fetch)
- */
-export function loadClientCertificates(
- clientCertPath: string,
- clientKeyPath: string,
- caCertPath?: string,
- clientKeyPassword?: string,
- rejectUnauthorized?: boolean
-): void {
- const clientCert = fs.readFileSync(clientCertPath);
- const clientKey = fs.readFileSync(clientKeyPath);
- const caCert = caCertPath ? fs.readFileSync(caCertPath) : undefined;
- const agent = new Agent({
- connect: {
- cert: clientCert,
- key: clientKey,
- ca: caCert,
- passphrase: clientKeyPassword,
- rejectUnauthorized: rejectUnauthorized,
- },
- });
-
- setGlobalDispatcher(agent);
-}
diff --git a/spaces/AiMimicry/sovits-models/modules/modules.py b/spaces/AiMimicry/sovits-models/modules/modules.py
deleted file mode 100644
index 54290fd207b25e93831bd21005990ea137e6b50e..0000000000000000000000000000000000000000
--- a/spaces/AiMimicry/sovits-models/modules/modules.py
+++ /dev/null
@@ -1,342 +0,0 @@
-import copy
-import math
-import numpy as np
-import scipy
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
-from torch.nn.utils import weight_norm, remove_weight_norm
-
-import modules.commons as commons
-from modules.commons import init_weights, get_padding
-
-
-LRELU_SLOPE = 0.1
-
-
-class LayerNorm(nn.Module):
- def __init__(self, channels, eps=1e-5):
- super().__init__()
- self.channels = channels
- self.eps = eps
-
- self.gamma = nn.Parameter(torch.ones(channels))
- self.beta = nn.Parameter(torch.zeros(channels))
-
- def forward(self, x):
- x = x.transpose(1, -1)
- x = F.layer_norm(x, (self.channels,), self.gamma, self.beta, self.eps)
- return x.transpose(1, -1)
-
-
-class ConvReluNorm(nn.Module):
- def __init__(self, in_channels, hidden_channels, out_channels, kernel_size, n_layers, p_dropout):
- super().__init__()
- self.in_channels = in_channels
- self.hidden_channels = hidden_channels
- self.out_channels = out_channels
- self.kernel_size = kernel_size
- self.n_layers = n_layers
- self.p_dropout = p_dropout
- assert n_layers > 1, "Number of layers should be larger than 0."
-
- self.conv_layers = nn.ModuleList()
- self.norm_layers = nn.ModuleList()
- self.conv_layers.append(nn.Conv1d(in_channels, hidden_channels, kernel_size, padding=kernel_size//2))
- self.norm_layers.append(LayerNorm(hidden_channels))
- self.relu_drop = nn.Sequential(
- nn.ReLU(),
- nn.Dropout(p_dropout))
- for _ in range(n_layers-1):
- self.conv_layers.append(nn.Conv1d(hidden_channels, hidden_channels, kernel_size, padding=kernel_size//2))
- self.norm_layers.append(LayerNorm(hidden_channels))
- self.proj = nn.Conv1d(hidden_channels, out_channels, 1)
- self.proj.weight.data.zero_()
- self.proj.bias.data.zero_()
-
- def forward(self, x, x_mask):
- x_org = x
- for i in range(self.n_layers):
- x = self.conv_layers[i](x * x_mask)
- x = self.norm_layers[i](x)
- x = self.relu_drop(x)
- x = x_org + self.proj(x)
- return x * x_mask
-
-
-class DDSConv(nn.Module):
- """
- Dialted and Depth-Separable Convolution
- """
- def __init__(self, channels, kernel_size, n_layers, p_dropout=0.):
- super().__init__()
- self.channels = channels
- self.kernel_size = kernel_size
- self.n_layers = n_layers
- self.p_dropout = p_dropout
-
- self.drop = nn.Dropout(p_dropout)
- self.convs_sep = nn.ModuleList()
- self.convs_1x1 = nn.ModuleList()
- self.norms_1 = nn.ModuleList()
- self.norms_2 = nn.ModuleList()
- for i in range(n_layers):
- dilation = kernel_size ** i
- padding = (kernel_size * dilation - dilation) // 2
- self.convs_sep.append(nn.Conv1d(channels, channels, kernel_size,
- groups=channels, dilation=dilation, padding=padding
- ))
- self.convs_1x1.append(nn.Conv1d(channels, channels, 1))
- self.norms_1.append(LayerNorm(channels))
- self.norms_2.append(LayerNorm(channels))
-
- def forward(self, x, x_mask, g=None):
- if g is not None:
- x = x + g
- for i in range(self.n_layers):
- y = self.convs_sep[i](x * x_mask)
- y = self.norms_1[i](y)
- y = F.gelu(y)
- y = self.convs_1x1[i](y)
- y = self.norms_2[i](y)
- y = F.gelu(y)
- y = self.drop(y)
- x = x + y
- return x * x_mask
-
-
-class WN(torch.nn.Module):
- def __init__(self, hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=0, p_dropout=0):
- super(WN, self).__init__()
- assert(kernel_size % 2 == 1)
- self.hidden_channels =hidden_channels
- self.kernel_size = kernel_size,
- self.dilation_rate = dilation_rate
- self.n_layers = n_layers
- self.gin_channels = gin_channels
- self.p_dropout = p_dropout
-
- self.in_layers = torch.nn.ModuleList()
- self.res_skip_layers = torch.nn.ModuleList()
- self.drop = nn.Dropout(p_dropout)
-
- if gin_channels != 0:
- cond_layer = torch.nn.Conv1d(gin_channels, 2*hidden_channels*n_layers, 1)
- self.cond_layer = torch.nn.utils.weight_norm(cond_layer, name='weight')
-
- for i in range(n_layers):
- dilation = dilation_rate ** i
- padding = int((kernel_size * dilation - dilation) / 2)
- in_layer = torch.nn.Conv1d(hidden_channels, 2*hidden_channels, kernel_size,
- dilation=dilation, padding=padding)
- in_layer = torch.nn.utils.weight_norm(in_layer, name='weight')
- self.in_layers.append(in_layer)
-
- # last one is not necessary
- if i < n_layers - 1:
- res_skip_channels = 2 * hidden_channels
- else:
- res_skip_channels = hidden_channels
-
- res_skip_layer = torch.nn.Conv1d(hidden_channels, res_skip_channels, 1)
- res_skip_layer = torch.nn.utils.weight_norm(res_skip_layer, name='weight')
- self.res_skip_layers.append(res_skip_layer)
-
- def forward(self, x, x_mask, g=None, **kwargs):
- output = torch.zeros_like(x)
- n_channels_tensor = torch.IntTensor([self.hidden_channels])
-
- if g is not None:
- g = self.cond_layer(g)
-
- for i in range(self.n_layers):
- x_in = self.in_layers[i](x)
- if g is not None:
- cond_offset = i * 2 * self.hidden_channels
- g_l = g[:,cond_offset:cond_offset+2*self.hidden_channels,:]
- else:
- g_l = torch.zeros_like(x_in)
-
- acts = commons.fused_add_tanh_sigmoid_multiply(
- x_in,
- g_l,
- n_channels_tensor)
- acts = self.drop(acts)
-
- res_skip_acts = self.res_skip_layers[i](acts)
- if i < self.n_layers - 1:
- res_acts = res_skip_acts[:,:self.hidden_channels,:]
- x = (x + res_acts) * x_mask
- output = output + res_skip_acts[:,self.hidden_channels:,:]
- else:
- output = output + res_skip_acts
- return output * x_mask
-
- def remove_weight_norm(self):
- if self.gin_channels != 0:
- torch.nn.utils.remove_weight_norm(self.cond_layer)
- for l in self.in_layers:
- torch.nn.utils.remove_weight_norm(l)
- for l in self.res_skip_layers:
- torch.nn.utils.remove_weight_norm(l)
-
-
-class ResBlock1(torch.nn.Module):
- def __init__(self, channels, kernel_size=3, dilation=(1, 3, 5)):
- super(ResBlock1, self).__init__()
- self.convs1 = nn.ModuleList([
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[0],
- padding=get_padding(kernel_size, dilation[0]))),
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[1],
- padding=get_padding(kernel_size, dilation[1]))),
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[2],
- padding=get_padding(kernel_size, dilation[2])))
- ])
- self.convs1.apply(init_weights)
-
- self.convs2 = nn.ModuleList([
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
- padding=get_padding(kernel_size, 1))),
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
- padding=get_padding(kernel_size, 1))),
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
- padding=get_padding(kernel_size, 1)))
- ])
- self.convs2.apply(init_weights)
-
- def forward(self, x, x_mask=None):
- for c1, c2 in zip(self.convs1, self.convs2):
- xt = F.leaky_relu(x, LRELU_SLOPE)
- if x_mask is not None:
- xt = xt * x_mask
- xt = c1(xt)
- xt = F.leaky_relu(xt, LRELU_SLOPE)
- if x_mask is not None:
- xt = xt * x_mask
- xt = c2(xt)
- x = xt + x
- if x_mask is not None:
- x = x * x_mask
- return x
-
- def remove_weight_norm(self):
- for l in self.convs1:
- remove_weight_norm(l)
- for l in self.convs2:
- remove_weight_norm(l)
-
-
-class ResBlock2(torch.nn.Module):
- def __init__(self, channels, kernel_size=3, dilation=(1, 3)):
- super(ResBlock2, self).__init__()
- self.convs = nn.ModuleList([
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[0],
- padding=get_padding(kernel_size, dilation[0]))),
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[1],
- padding=get_padding(kernel_size, dilation[1])))
- ])
- self.convs.apply(init_weights)
-
- def forward(self, x, x_mask=None):
- for c in self.convs:
- xt = F.leaky_relu(x, LRELU_SLOPE)
- if x_mask is not None:
- xt = xt * x_mask
- xt = c(xt)
- x = xt + x
- if x_mask is not None:
- x = x * x_mask
- return x
-
- def remove_weight_norm(self):
- for l in self.convs:
- remove_weight_norm(l)
-
-
-class Log(nn.Module):
- def forward(self, x, x_mask, reverse=False, **kwargs):
- if not reverse:
- y = torch.log(torch.clamp_min(x, 1e-5)) * x_mask
- logdet = torch.sum(-y, [1, 2])
- return y, logdet
- else:
- x = torch.exp(x) * x_mask
- return x
-
-
-class Flip(nn.Module):
- def forward(self, x, *args, reverse=False, **kwargs):
- x = torch.flip(x, [1])
- if not reverse:
- logdet = torch.zeros(x.size(0)).to(dtype=x.dtype, device=x.device)
- return x, logdet
- else:
- return x
-
-
-class ElementwiseAffine(nn.Module):
- def __init__(self, channels):
- super().__init__()
- self.channels = channels
- self.m = nn.Parameter(torch.zeros(channels,1))
- self.logs = nn.Parameter(torch.zeros(channels,1))
-
- def forward(self, x, x_mask, reverse=False, **kwargs):
- if not reverse:
- y = self.m + torch.exp(self.logs) * x
- y = y * x_mask
- logdet = torch.sum(self.logs * x_mask, [1,2])
- return y, logdet
- else:
- x = (x - self.m) * torch.exp(-self.logs) * x_mask
- return x
-
-
-class ResidualCouplingLayer(nn.Module):
- def __init__(self,
- channels,
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- p_dropout=0,
- gin_channels=0,
- mean_only=False):
- assert channels % 2 == 0, "channels should be divisible by 2"
- super().__init__()
- self.channels = channels
- self.hidden_channels = hidden_channels
- self.kernel_size = kernel_size
- self.dilation_rate = dilation_rate
- self.n_layers = n_layers
- self.half_channels = channels // 2
- self.mean_only = mean_only
-
- self.pre = nn.Conv1d(self.half_channels, hidden_channels, 1)
- self.enc = WN(hidden_channels, kernel_size, dilation_rate, n_layers, p_dropout=p_dropout, gin_channels=gin_channels)
- self.post = nn.Conv1d(hidden_channels, self.half_channels * (2 - mean_only), 1)
- self.post.weight.data.zero_()
- self.post.bias.data.zero_()
-
- def forward(self, x, x_mask, g=None, reverse=False):
- x0, x1 = torch.split(x, [self.half_channels]*2, 1)
- h = self.pre(x0) * x_mask
- h = self.enc(h, x_mask, g=g)
- stats = self.post(h) * x_mask
- if not self.mean_only:
- m, logs = torch.split(stats, [self.half_channels]*2, 1)
- else:
- m = stats
- logs = torch.zeros_like(m)
-
- if not reverse:
- x1 = m + x1 * torch.exp(logs) * x_mask
- x = torch.cat([x0, x1], 1)
- logdet = torch.sum(logs, [1,2])
- return x, logdet
- else:
- x1 = (x1 - m) * torch.exp(-logs) * x_mask
- x = torch.cat([x0, x1], 1)
- return x
diff --git a/spaces/Aki004/herta-so-vits/README.md b/spaces/Aki004/herta-so-vits/README.md
deleted file mode 100644
index f07daeda30658a5fa6b206b53f9907a22b47b197..0000000000000000000000000000000000000000
--- a/spaces/Aki004/herta-so-vits/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Herta So Vits
-emoji: 🦀
-colorFrom: red
-colorTo: yellow
-sdk: gradio
-sdk_version: 3.33.1
-app_file: app.py
-pinned: false
-license: bsd
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
\ No newline at end of file
diff --git a/spaces/AkiKagura/Marco-Generation-Img2img/README.md b/spaces/AkiKagura/Marco-Generation-Img2img/README.md
deleted file mode 100644
index 5c2978b578b2f20ded66f9c1962f26ccc7e048e0..0000000000000000000000000000000000000000
--- a/spaces/AkiKagura/Marco-Generation-Img2img/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Marco Generation Img2img
-emoji: 🦀
-colorFrom: gray
-colorTo: green
-sdk: gradio
-sdk_version: 3.8.1
-app_file: app.py
-pinned: false
-license: creativeml-openrail-m
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/AlexWang/lama/saicinpainting/training/trainers/__init__.py b/spaces/AlexWang/lama/saicinpainting/training/trainers/__init__.py
deleted file mode 100644
index c59241f553efe4e2dd6b198e2e5656a2b1488857..0000000000000000000000000000000000000000
--- a/spaces/AlexWang/lama/saicinpainting/training/trainers/__init__.py
+++ /dev/null
@@ -1,30 +0,0 @@
-import logging
-import torch
-from saicinpainting.training.trainers.default import DefaultInpaintingTrainingModule
-
-
-def get_training_model_class(kind):
- if kind == 'default':
- return DefaultInpaintingTrainingModule
-
- raise ValueError(f'Unknown trainer module {kind}')
-
-
-def make_training_model(config):
- kind = config.training_model.kind
- kwargs = dict(config.training_model)
- kwargs.pop('kind')
- kwargs['use_ddp'] = config.trainer.kwargs.get('accelerator', None) == 'ddp'
-
- logging.info(f'Make training model {kind}')
-
- cls = get_training_model_class(kind)
- return cls(config, **kwargs)
-
-
-def load_checkpoint(train_config, path, map_location='cuda', strict=True):
- model: torch.nn.Module = make_training_model(train_config)
- state = torch.load(path, map_location=map_location)
- model.load_state_dict(state['state_dict'], strict=strict)
- model.on_load_checkpoint(state)
- return model
diff --git a/spaces/Amon1/ChatGPTForAcadamic/crazy_functions/test_project/cpp/cppipc/queue.h b/spaces/Amon1/ChatGPTForAcadamic/crazy_functions/test_project/cpp/cppipc/queue.h
deleted file mode 100644
index a21f3446e06b5826af7b554c8a7d9c5d80848b62..0000000000000000000000000000000000000000
--- a/spaces/Amon1/ChatGPTForAcadamic/crazy_functions/test_project/cpp/cppipc/queue.h
+++ /dev/null
@@ -1,216 +0,0 @@
-#pragma once
-
-#include
-#include
-#include // [[since C++14]]: std::exchange
-#include
-#include
-#include
-#include
-#include
-#include
-#include // assert
-
-#include "libipc/def.h"
-#include "libipc/shm.h"
-#include "libipc/rw_lock.h"
-
-#include "libipc/utility/log.h"
-#include "libipc/platform/detail.h"
-#include "libipc/circ/elem_def.h"
-
-namespace ipc {
-namespace detail {
-
-class queue_conn {
-protected:
- circ::cc_t connected_ = 0;
- shm::handle elems_h_;
-
- template
- Elems* open(char const * name) {
- if (name == nullptr || name[0] == '\0') {
- ipc::error("fail open waiter: name is empty!\n");
- return nullptr;
- }
- if (!elems_h_.acquire(name, sizeof(Elems))) {
- return nullptr;
- }
- auto elems = static_cast(elems_h_.get());
- if (elems == nullptr) {
- ipc::error("fail acquire elems: %s\n", name);
- return nullptr;
- }
- elems->init();
- return elems;
- }
-
- void close() {
- elems_h_.release();
- }
-
-public:
- queue_conn() = default;
- queue_conn(const queue_conn&) = delete;
- queue_conn& operator=(const queue_conn&) = delete;
-
- bool connected() const noexcept {
- return connected_ != 0;
- }
-
- circ::cc_t connected_id() const noexcept {
- return connected_;
- }
-
- template
- auto connect(Elems* elems) noexcept
- /*needs 'optional' here*/
- -> std::tuple().cursor())> {
- if (elems == nullptr) return {};
- // if it's already connected, just return
- if (connected()) return {connected(), false, 0};
- connected_ = elems->connect_receiver();
- return {connected(), true, elems->cursor()};
- }
-
- template
- bool disconnect(Elems* elems) noexcept {
- if (elems == nullptr) return false;
- // if it's already disconnected, just return false
- if (!connected()) return false;
- elems->disconnect_receiver(std::exchange(connected_, 0));
- return true;
- }
-};
-
-template
-class queue_base : public queue_conn {
- using base_t = queue_conn;
-
-public:
- using elems_t = Elems;
- using policy_t = typename elems_t::policy_t;
-
-protected:
- elems_t * elems_ = nullptr;
- decltype(std::declval().cursor()) cursor_ = 0;
- bool sender_flag_ = false;
-
-public:
- using base_t::base_t;
-
- queue_base() = default;
-
- explicit queue_base(char const * name)
- : queue_base{} {
- elems_ = open(name);
- }
-
- explicit queue_base(elems_t * elems) noexcept
- : queue_base{} {
- assert(elems != nullptr);
- elems_ = elems;
- }
-
- /* not virtual */ ~queue_base() {
- base_t::close();
- }
-
- elems_t * elems() noexcept { return elems_; }
- elems_t const * elems() const noexcept { return elems_; }
-
- bool ready_sending() noexcept {
- if (elems_ == nullptr) return false;
- return sender_flag_ || (sender_flag_ = elems_->connect_sender());
- }
-
- void shut_sending() noexcept {
- if (elems_ == nullptr) return;
- if (!sender_flag_) return;
- elems_->disconnect_sender();
- }
-
- bool connect() noexcept {
- auto tp = base_t::connect(elems_);
- if (std::get<0>(tp) && std::get<1>(tp)) {
- cursor_ = std::get<2>(tp);
- return true;
- }
- return std::get<0>(tp);
- }
-
- bool disconnect() noexcept {
- return base_t::disconnect(elems_);
- }
-
- std::size_t conn_count() const noexcept {
- return (elems_ == nullptr) ? static_cast(invalid_value) : elems_->conn_count();
- }
-
- bool valid() const noexcept {
- return elems_ != nullptr;
- }
-
- bool empty() const noexcept {
- return !valid() || (cursor_ == elems_->cursor());
- }
-
- template
- bool push(F&& prep, P&&... params) {
- if (elems_ == nullptr) return false;
- return elems_->push(this, [&](void* p) {
- if (prep(p)) ::new (p) T(std::forward
(params)...);
- }
-
- bool pop(T& item) {
- return base_t::pop(item, [](bool) {});
- }
-
- template
- bool pop(T& item, F&& out) {
- return base_t::pop(item, std::forward(out));
- }
-};
-
-} // namespace ipc
diff --git a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_ldm3d.py b/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_ldm3d.py
deleted file mode 100644
index 88949c5f5e8cea3c77263ee6318bd9fc65e1e224..0000000000000000000000000000000000000000
--- a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_ldm3d.py
+++ /dev/null
@@ -1,661 +0,0 @@
-# Copyright 2023 The Intel Labs Team Authors and 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 dataclasses import dataclass
-from typing import Any, Callable, Dict, List, Optional, Union
-
-import numpy as np
-import PIL
-import torch
-from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer
-
-from ...image_processor import VaeImageProcessorLDM3D
-from ...loaders import FromSingleFileMixin, LoraLoaderMixin, TextualInversionLoaderMixin
-from ...models import AutoencoderKL, UNet2DConditionModel
-from ...schedulers import KarrasDiffusionSchedulers
-from ...utils import (
- BaseOutput,
- is_accelerate_available,
- is_accelerate_version,
- logging,
- randn_tensor,
- replace_example_docstring,
-)
-from ..pipeline_utils import DiffusionPipeline
-from .safety_checker import StableDiffusionSafetyChecker
-
-
-logger = logging.get_logger(__name__) # pylint: disable=invalid-name
-
-EXAMPLE_DOC_STRING = """
- Examples:
- ```py
- >>> import torch
- >>> from diffusers import StableDiffusionPipeline
-
- >>> pipe = StableDiffusionLDM3DPipeline.from_pretrained("Intel/ldm3d")
- >>> pipe = pipe.to("cuda")
-
- >>> prompt = "a photo of an astronaut riding a horse on mars"
- >>> output = pipe(prompt)
- >>> rgb_image, depth_image = output.rgb, output.depth
- >>> rgb_image[0].save("astronaut_ldm3d_rgb.jpg")
- >>> depth_image[0].save("astronaut_ldm3d_depth.png")
- ```
-"""
-
-
-@dataclass
-class LDM3DPipelineOutput(BaseOutput):
- """
- Output class for Stable Diffusion pipelines.
-
- Args:
- images (`List[PIL.Image.Image]` or `np.ndarray`)
- List of denoised PIL images of length `batch_size` or NumPy array of shape `(batch_size, height, width,
- num_channels)`.
- nsfw_content_detected (`List[bool]`)
- List indicating whether the corresponding generated image contains "not-safe-for-work" (nsfw) content or
- `None` if safety checking could not be performed.
- """
-
- rgb: Union[List[PIL.Image.Image], np.ndarray]
- depth: Union[List[PIL.Image.Image], np.ndarray]
- nsfw_content_detected: Optional[List[bool]]
-
-
-class StableDiffusionLDM3DPipeline(
- DiffusionPipeline, TextualInversionLoaderMixin, LoraLoaderMixin, FromSingleFileMixin
-):
- r"""
- Pipeline for text-to-image and 3D generation using LDM3D.
-
- 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.).
-
- The pipeline also inherits the following loading methods:
- - [`~loaders.TextualInversionLoaderMixin.load_textual_inversion`] for loading textual inversion embeddings
- - [`~loaders.LoraLoaderMixin.load_lora_weights`] for loading LoRA weights
- - [`~loaders.LoraLoaderMixin.save_lora_weights`] for saving LoRA weights
- - [`~loaders.FromSingleFileMixin.from_single_file`] for loading `.ckpt` files
-
- Args:
- vae ([`AutoencoderKL`]):
- Variational Auto-Encoder (VAE) model to encode and decode images to and from latent representations.
- text_encoder ([`~transformers.CLIPTextModel`]):
- Frozen text-encoder ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)).
- tokenizer ([`~transformers.CLIPTokenizer`]):
- A `CLIPTokenizer` to tokenize text.
- unet ([`UNet2DConditionModel`]):
- A `UNet2DConditionModel` to denoise the encoded image latents.
- scheduler ([`SchedulerMixin`]):
- A scheduler to be used in combination with `unet` to denoise the encoded image latents. Can be one of
- [`DDIMScheduler`], [`LMSDiscreteScheduler`], or [`PNDMScheduler`].
- safety_checker ([`StableDiffusionSafetyChecker`]):
- Classification module that estimates whether generated images could be considered offensive or harmful.
- Please refer to the [model card](https://huggingface.co/runwayml/stable-diffusion-v1-5) for more details
- about a model's potential harms.
- feature_extractor ([`~transformers.CLIPImageProcessor`]):
- A `CLIPImageProcessor` to extract features from generated images; used as inputs to the `safety_checker`.
- """
- _optional_components = ["safety_checker", "feature_extractor"]
-
- def __init__(
- self,
- vae: AutoencoderKL,
- text_encoder: CLIPTextModel,
- tokenizer: CLIPTokenizer,
- unet: UNet2DConditionModel,
- scheduler: KarrasDiffusionSchedulers,
- safety_checker: StableDiffusionSafetyChecker,
- feature_extractor: CLIPImageProcessor,
- requires_safety_checker: bool = True,
- ):
- super().__init__()
-
- if safety_checker is None and requires_safety_checker:
- logger.warning(
- f"You have disabled the safety checker for {self.__class__} by passing `safety_checker=None`. Ensure"
- " that you abide to the conditions of the Stable Diffusion license and do not expose unfiltered"
- " results in services or applications open to the public. Both the diffusers team and Hugging Face"
- " strongly recommend to keep the safety filter enabled in all public facing circumstances, disabling"
- " it only for use-cases that involve analyzing network behavior or auditing its results. For more"
- " information, please have a look at https://github.com/huggingface/diffusers/pull/254 ."
- )
-
- if safety_checker is not None and feature_extractor is None:
- raise ValueError(
- "Make sure to define a feature extractor when loading {self.__class__} if you want to use the safety"
- " checker. If you do not want to use the safety checker, you can pass `'safety_checker=None'` instead."
- )
-
- self.register_modules(
- vae=vae,
- text_encoder=text_encoder,
- tokenizer=tokenizer,
- unet=unet,
- scheduler=scheduler,
- safety_checker=safety_checker,
- feature_extractor=feature_extractor,
- )
- self.vae_scale_factor = 2 ** (len(self.vae.config.block_out_channels) - 1)
- self.image_processor = VaeImageProcessorLDM3D(vae_scale_factor=self.vae_scale_factor)
- self.register_to_config(requires_safety_checker=requires_safety_checker)
-
- # 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()
-
- # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.enable_vae_tiling
- def enable_vae_tiling(self):
- r"""
- Enable tiled VAE decoding. When this option is enabled, the VAE will split the input tensor into tiles to
- compute decoding and encoding in several steps. This is useful for saving a large amount of memory and to allow
- processing larger images.
- """
- self.vae.enable_tiling()
-
- # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.disable_vae_tiling
- def disable_vae_tiling(self):
- r"""
- Disable tiled VAE decoding. If `enable_vae_tiling` was previously enabled, this method will go back to
- computing decoding in one step.
- """
- self.vae.disable_tiling()
-
- # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.enable_model_cpu_offload
- def enable_model_cpu_offload(self, gpu_id=0):
- r"""
- Offload all models to CPU to reduce memory usage with a low impact on performance. Moves one whole model at a
- time to the GPU when its `forward` method is called, and the model remains in GPU until the next model runs.
- Memory savings are lower than using `enable_sequential_cpu_offload`, but performance is much better due to the
- iterative execution of the `unet`.
- """
- if is_accelerate_available() and is_accelerate_version(">=", "0.17.0.dev0"):
- from accelerate import cpu_offload_with_hook
- else:
- raise ImportError("`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher.")
-
- device = torch.device(f"cuda:{gpu_id}")
-
- if self.device.type != "cpu":
- self.to("cpu", silence_dtype_warnings=True)
- torch.cuda.empty_cache() # otherwise we don't see the memory savings (but they probably exist)
-
- hook = None
- for cpu_offloaded_model in [self.text_encoder, self.unet, self.vae]:
- _, hook = cpu_offload_with_hook(cpu_offloaded_model, device, prev_module_hook=hook)
-
- if self.safety_checker is not None:
- _, hook = cpu_offload_with_hook(self.safety_checker, device, prev_module_hook=hook)
-
- # We'll offload the last model manually.
- self.final_offload_hook = hook
-
- # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._encode_prompt
- def _encode_prompt(
- self,
- prompt,
- device,
- num_images_per_prompt,
- do_classifier_free_guidance,
- negative_prompt=None,
- prompt_embeds: Optional[torch.FloatTensor] = None,
- negative_prompt_embeds: Optional[torch.FloatTensor] = None,
- lora_scale: Optional[float] = 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_images_per_prompt (`int`):
- number of images 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 image 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.
- lora_scale (`float`, *optional*):
- A lora scale that will be applied to all LoRA layers of the text encoder if LoRA layers are loaded.
- """
- # set lora scale so that monkey patched LoRA
- # function of text encoder can correctly access it
- if lora_scale is not None and isinstance(self, LoraLoaderMixin):
- self._lora_scale = lora_scale
-
- 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:
- # textual inversion: procecss multi-vector tokens if necessary
- if isinstance(self, TextualInversionLoaderMixin):
- prompt = self.maybe_convert_prompt(prompt, self.tokenizer)
-
- 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
- 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 CLIP can only handle sequences up to"
- f" {self.tokenizer.model_max_length} tokens: {removed_text}"
- )
-
- if hasattr(self.text_encoder.config, "use_attention_mask") and self.text_encoder.config.use_attention_mask:
- attention_mask = text_inputs.attention_mask.to(device)
- else:
- attention_mask = None
-
- prompt_embeds = self.text_encoder(
- text_input_ids.to(device),
- attention_mask=attention_mask,
- )
- prompt_embeds = prompt_embeds[0]
-
- 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_images_per_prompt, 1)
- prompt_embeds = prompt_embeds.view(bs_embed * num_images_per_prompt, seq_len, -1)
-
- # 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 prompt is not None and 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
-
- # textual inversion: procecss multi-vector tokens if necessary
- if isinstance(self, TextualInversionLoaderMixin):
- uncond_tokens = self.maybe_convert_prompt(uncond_tokens, self.tokenizer)
-
- max_length = prompt_embeds.shape[1]
- uncond_input = self.tokenizer(
- uncond_tokens,
- padding="max_length",
- max_length=max_length,
- truncation=True,
- return_tensors="pt",
- )
-
- if hasattr(self.text_encoder.config, "use_attention_mask") and self.text_encoder.config.use_attention_mask:
- attention_mask = uncond_input.attention_mask.to(device)
- else:
- attention_mask = None
-
- negative_prompt_embeds = self.text_encoder(
- uncond_input.input_ids.to(device),
- attention_mask=attention_mask,
- )
- negative_prompt_embeds = negative_prompt_embeds[0]
-
- 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_images_per_prompt, 1)
- negative_prompt_embeds = negative_prompt_embeds.view(batch_size * num_images_per_prompt, seq_len, -1)
-
- # 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 run_safety_checker(self, image, device, dtype):
- if self.safety_checker is None:
- has_nsfw_concept = None
- else:
- if torch.is_tensor(image):
- feature_extractor_input = self.image_processor.postprocess(image, output_type="pil")
- else:
- feature_extractor_input = self.image_processor.numpy_to_pil(image)
- rgb_feature_extractor_input = feature_extractor_input[0]
- safety_checker_input = self.feature_extractor(rgb_feature_extractor_input, return_tensors="pt").to(device)
- image, has_nsfw_concept = self.safety_checker(
- images=image, clip_input=safety_checker_input.pixel_values.to(dtype)
- )
- return image, has_nsfw_concept
-
- # 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
-
- # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.check_inputs
- def check_inputs(
- self,
- prompt,
- height,
- width,
- callback_steps,
- negative_prompt=None,
- prompt_embeds=None,
- negative_prompt_embeds=None,
- ):
- if height % 8 != 0 or width % 8 != 0:
- raise ValueError(f"`height` and `width` have to be divisible by 8 but are {height} and {width}.")
-
- 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}."
- )
-
- def prepare_latents(self, batch_size, num_channels_latents, height, width, dtype, device, generator, latents=None):
- shape = (batch_size, num_channels_latents, height // self.vae_scale_factor, width // 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,
- height: Optional[int] = None,
- width: Optional[int] = None,
- num_inference_steps: int = 49,
- guidance_scale: float = 5.0,
- negative_prompt: Optional[Union[str, List[str]]] = None,
- num_images_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,
- output_type: Optional[str] = "pil",
- return_dict: bool = True,
- callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None,
- callback_steps: int = 1,
- cross_attention_kwargs: Optional[Dict[str, Any]] = None,
- ):
- r"""
- The call function to the pipeline for generation.
-
- Args:
- prompt (`str` or `List[str]`, *optional*):
- The prompt or prompts to guide image generation. If not defined, you need to pass `prompt_embeds`.
- height (`int`, *optional*, defaults to `self.unet.config.sample_size * self.vae_scale_factor`):
- The height in pixels of the generated image.
- width (`int`, *optional*, defaults to `self.unet.config.sample_size * self.vae_scale_factor`):
- The width in pixels of the generated image.
- num_inference_steps (`int`, *optional*, defaults to 50):
- The number of denoising steps. More denoising steps usually lead to a higher quality image at the
- expense of slower inference.
- guidance_scale (`float`, *optional*, defaults to 5.0):
- A higher guidance scale value encourages the model to generate images closely linked to the text
- `prompt` at the expense of lower image 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 image generation. If not defined, you need to
- pass `negative_prompt_embeds` instead. Ignored when not using guidance (`guidance_scale < 1`).
- num_images_per_prompt (`int`, *optional*, defaults to 1):
- The number of images 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.
- output_type (`str`, *optional*, defaults to `"pil"`):
- The output format of the generated image. Choose between `PIL.Image` or `np.array`.
- 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).
-
- 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 images and the
- second element is a list of `bool`s indicating whether the corresponding generated image contains
- "not-safe-for-work" (nsfw) content.
- """
- # 0. Default height and width to unet
- height = height or self.unet.config.sample_size * self.vae_scale_factor
- width = width or self.unet.config.sample_size * self.vae_scale_factor
-
- # 1. Check inputs. Raise error if not correct
- self.check_inputs(
- prompt, height, width, 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_images_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_images_per_prompt,
- num_channels_latents,
- height,
- width,
- prompt_embeds.dtype,
- device,
- generator,
- latents,
- )
-
- # 6. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline
- 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=prompt_embeds,
- cross_attention_kwargs=cross_attention_kwargs,
- return_dict=False,
- )[0]
-
- # 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, return_dict=False)[0]
-
- # 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)
-
- if not output_type == "latent":
- image = self.vae.decode(latents / self.vae.config.scaling_factor, return_dict=False)[0]
- image, has_nsfw_concept = self.run_safety_checker(image, device, prompt_embeds.dtype)
- else:
- image = latents
- has_nsfw_concept = None
-
- if has_nsfw_concept is None:
- do_denormalize = [True] * image.shape[0]
- else:
- do_denormalize = [not has_nsfw for has_nsfw in has_nsfw_concept]
-
- rgb, depth = self.image_processor.postprocess(image, output_type=output_type, do_denormalize=do_denormalize)
-
- # Offload last model to CPU
- if hasattr(self, "final_offload_hook") and self.final_offload_hook is not None:
- self.final_offload_hook.offload()
-
- if not return_dict:
- return ((rgb, depth), has_nsfw_concept)
-
- return LDM3DPipelineOutput(rgb=rgb, depth=depth, nsfw_content_detected=has_nsfw_concept)
diff --git a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/schedulers/scheduling_pndm.py b/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/schedulers/scheduling_pndm.py
deleted file mode 100644
index 794eb3674c1bb5533b938b00b08d48cd5192c317..0000000000000000000000000000000000000000
--- a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/schedulers/scheduling_pndm.py
+++ /dev/null
@@ -1,462 +0,0 @@
-# Copyright 2023 Zhejiang University Team and 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.
-
-# DISCLAIMER: This file is strongly influenced by https://github.com/ermongroup/ddim
-
-import math
-from typing import List, Optional, Tuple, Union
-
-import numpy as np
-import torch
-
-from ..configuration_utils import ConfigMixin, register_to_config
-from .scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin, SchedulerOutput
-
-
-# Copied from diffusers.schedulers.scheduling_ddpm.betas_for_alpha_bar
-def betas_for_alpha_bar(
- num_diffusion_timesteps,
- max_beta=0.999,
- alpha_transform_type="cosine",
-):
- """
- Create a beta schedule that discretizes the given alpha_t_bar function, which defines the cumulative product of
- (1-beta) over time from t = [0,1].
-
- Contains a function alpha_bar that takes an argument t and transforms it to the cumulative product of (1-beta) up
- to that part of the diffusion process.
-
-
- Args:
- num_diffusion_timesteps (`int`): the number of betas to produce.
- max_beta (`float`): the maximum beta to use; use values lower than 1 to
- prevent singularities.
- alpha_transform_type (`str`, *optional*, default to `cosine`): the type of noise schedule for alpha_bar.
- Choose from `cosine` or `exp`
-
- Returns:
- betas (`np.ndarray`): the betas used by the scheduler to step the model outputs
- """
- if alpha_transform_type == "cosine":
-
- def alpha_bar_fn(t):
- return math.cos((t + 0.008) / 1.008 * math.pi / 2) ** 2
-
- elif alpha_transform_type == "exp":
-
- def alpha_bar_fn(t):
- return math.exp(t * -12.0)
-
- else:
- raise ValueError(f"Unsupported alpha_tranform_type: {alpha_transform_type}")
-
- betas = []
- for i in range(num_diffusion_timesteps):
- t1 = i / num_diffusion_timesteps
- t2 = (i + 1) / num_diffusion_timesteps
- betas.append(min(1 - alpha_bar_fn(t2) / alpha_bar_fn(t1), max_beta))
- return torch.tensor(betas, dtype=torch.float32)
-
-
-class PNDMScheduler(SchedulerMixin, ConfigMixin):
- """
- Pseudo numerical methods for diffusion models (PNDM) proposes using more advanced ODE integration techniques,
- namely Runge-Kutta method and a linear multi-step method.
-
- [`~ConfigMixin`] takes care of storing all config attributes that are passed in the scheduler's `__init__`
- function, such as `num_train_timesteps`. They can be accessed via `scheduler.config.num_train_timesteps`.
- [`SchedulerMixin`] provides general loading and saving functionality via the [`SchedulerMixin.save_pretrained`] and
- [`~SchedulerMixin.from_pretrained`] functions.
-
- For more details, see the original paper: https://arxiv.org/abs/2202.09778
-
- Args:
- num_train_timesteps (`int`): number of diffusion steps used to train the model.
- beta_start (`float`): the starting `beta` value of inference.
- beta_end (`float`): the final `beta` value.
- beta_schedule (`str`):
- the beta schedule, a mapping from a beta range to a sequence of betas for stepping the model. Choose from
- `linear`, `scaled_linear`, or `squaredcos_cap_v2`.
- trained_betas (`np.ndarray`, optional):
- option to pass an array of betas directly to the constructor to bypass `beta_start`, `beta_end` etc.
- skip_prk_steps (`bool`):
- allows the scheduler to skip the Runge-Kutta steps that are defined in the original paper as being required
- before plms steps; defaults to `False`.
- set_alpha_to_one (`bool`, default `False`):
- each diffusion step uses the value of alphas product at that step and at the previous one. For the final
- step there is no previous alpha. When this option is `True` the previous alpha product is fixed to `1`,
- otherwise it uses the value of alpha at step 0.
- prediction_type (`str`, default `epsilon`, optional):
- prediction type of the scheduler function, one of `epsilon` (predicting the noise of the diffusion process)
- or `v_prediction` (see section 2.4 https://imagen.research.google/video/paper.pdf)
- timestep_spacing (`str`, default `"leading"`):
- The way the timesteps should be scaled. Refer to Table 2. of [Common Diffusion Noise Schedules and Sample
- Steps are Flawed](https://arxiv.org/abs/2305.08891) for more information.
- steps_offset (`int`, default `0`):
- an offset added to the inference steps. You can use a combination of `offset=1` and
- `set_alpha_to_one=False`, to make the last step use step 0 for the previous alpha product, as done in
- stable diffusion.
- """
-
- _compatibles = [e.name for e in KarrasDiffusionSchedulers]
- order = 1
-
- @register_to_config
- def __init__(
- self,
- num_train_timesteps: int = 1000,
- beta_start: float = 0.0001,
- beta_end: float = 0.02,
- beta_schedule: str = "linear",
- trained_betas: Optional[Union[np.ndarray, List[float]]] = None,
- skip_prk_steps: bool = False,
- set_alpha_to_one: bool = False,
- prediction_type: str = "epsilon",
- timestep_spacing: str = "leading",
- steps_offset: int = 0,
- ):
- if trained_betas is not None:
- self.betas = torch.tensor(trained_betas, dtype=torch.float32)
- elif beta_schedule == "linear":
- self.betas = torch.linspace(beta_start, beta_end, num_train_timesteps, dtype=torch.float32)
- elif beta_schedule == "scaled_linear":
- # this schedule is very specific to the latent diffusion model.
- self.betas = (
- torch.linspace(beta_start**0.5, beta_end**0.5, num_train_timesteps, dtype=torch.float32) ** 2
- )
- elif beta_schedule == "squaredcos_cap_v2":
- # Glide cosine schedule
- self.betas = betas_for_alpha_bar(num_train_timesteps)
- else:
- raise NotImplementedError(f"{beta_schedule} does is not implemented for {self.__class__}")
-
- self.alphas = 1.0 - self.betas
- self.alphas_cumprod = torch.cumprod(self.alphas, dim=0)
-
- self.final_alpha_cumprod = torch.tensor(1.0) if set_alpha_to_one else self.alphas_cumprod[0]
-
- # standard deviation of the initial noise distribution
- self.init_noise_sigma = 1.0
-
- # For now we only support F-PNDM, i.e. the runge-kutta method
- # For more information on the algorithm please take a look at the paper: https://arxiv.org/pdf/2202.09778.pdf
- # mainly at formula (9), (12), (13) and the Algorithm 2.
- self.pndm_order = 4
-
- # running values
- self.cur_model_output = 0
- self.counter = 0
- self.cur_sample = None
- self.ets = []
-
- # setable values
- self.num_inference_steps = None
- self._timesteps = np.arange(0, num_train_timesteps)[::-1].copy()
- self.prk_timesteps = None
- self.plms_timesteps = None
- self.timesteps = None
-
- def set_timesteps(self, num_inference_steps: int, device: Union[str, torch.device] = None):
- """
- Sets the discrete timesteps used for the diffusion chain. Supporting function to be run before inference.
-
- Args:
- num_inference_steps (`int`):
- the number of diffusion steps used when generating samples with a pre-trained model.
- """
-
- self.num_inference_steps = num_inference_steps
- # "linspace", "leading", "trailing" corresponds to annotation of Table 2. of https://arxiv.org/abs/2305.08891
- if self.config.timestep_spacing == "linspace":
- self._timesteps = (
- np.linspace(0, self.config.num_train_timesteps - 1, num_inference_steps).round().astype(np.int64)
- )
- elif self.config.timestep_spacing == "leading":
- step_ratio = self.config.num_train_timesteps // self.num_inference_steps
- # creates integer timesteps by multiplying by ratio
- # casting to int to avoid issues when num_inference_step is power of 3
- self._timesteps = (np.arange(0, num_inference_steps) * step_ratio).round()
- self._timesteps += self.config.steps_offset
- elif self.config.timestep_spacing == "trailing":
- step_ratio = self.config.num_train_timesteps / self.num_inference_steps
- # creates integer timesteps by multiplying by ratio
- # casting to int to avoid issues when num_inference_step is power of 3
- self._timesteps = np.round(np.arange(self.config.num_train_timesteps, 0, -step_ratio))[::-1].astype(
- np.int64
- )
- self._timesteps -= 1
- else:
- raise ValueError(
- f"{self.config.timestep_spacing} is not supported. Please make sure to choose one of 'linspace', 'leading' or 'trailing'."
- )
-
- if self.config.skip_prk_steps:
- # for some models like stable diffusion the prk steps can/should be skipped to
- # produce better results. When using PNDM with `self.config.skip_prk_steps` the implementation
- # is based on crowsonkb's PLMS sampler implementation: https://github.com/CompVis/latent-diffusion/pull/51
- self.prk_timesteps = np.array([])
- self.plms_timesteps = np.concatenate([self._timesteps[:-1], self._timesteps[-2:-1], self._timesteps[-1:]])[
- ::-1
- ].copy()
- else:
- prk_timesteps = np.array(self._timesteps[-self.pndm_order :]).repeat(2) + np.tile(
- np.array([0, self.config.num_train_timesteps // num_inference_steps // 2]), self.pndm_order
- )
- self.prk_timesteps = (prk_timesteps[:-1].repeat(2)[1:-1])[::-1].copy()
- self.plms_timesteps = self._timesteps[:-3][
- ::-1
- ].copy() # we copy to avoid having negative strides which are not supported by torch.from_numpy
-
- timesteps = np.concatenate([self.prk_timesteps, self.plms_timesteps]).astype(np.int64)
- self.timesteps = torch.from_numpy(timesteps).to(device)
-
- self.ets = []
- self.counter = 0
- self.cur_model_output = 0
-
- def step(
- self,
- model_output: torch.FloatTensor,
- timestep: int,
- sample: torch.FloatTensor,
- return_dict: bool = True,
- ) -> Union[SchedulerOutput, Tuple]:
- """
- Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion
- process from the learned model outputs (most often the predicted noise).
-
- This function calls `step_prk()` or `step_plms()` depending on the internal variable `counter`.
-
- Args:
- model_output (`torch.FloatTensor`): direct output from learned diffusion model.
- timestep (`int`): current discrete timestep in the diffusion chain.
- sample (`torch.FloatTensor`):
- current instance of sample being created by diffusion process.
- return_dict (`bool`): option for returning tuple rather than SchedulerOutput class
-
- Returns:
- [`~schedulers.scheduling_utils.SchedulerOutput`] or `tuple`:
- [`~schedulers.scheduling_utils.SchedulerOutput`] if `return_dict` is True, otherwise a `tuple`. When
- returning a tuple, the first element is the sample tensor.
-
- """
- if self.counter < len(self.prk_timesteps) and not self.config.skip_prk_steps:
- return self.step_prk(model_output=model_output, timestep=timestep, sample=sample, return_dict=return_dict)
- else:
- return self.step_plms(model_output=model_output, timestep=timestep, sample=sample, return_dict=return_dict)
-
- def step_prk(
- self,
- model_output: torch.FloatTensor,
- timestep: int,
- sample: torch.FloatTensor,
- return_dict: bool = True,
- ) -> Union[SchedulerOutput, Tuple]:
- """
- Step function propagating the sample with the Runge-Kutta method. RK takes 4 forward passes to approximate the
- solution to the differential equation.
-
- Args:
- model_output (`torch.FloatTensor`): direct output from learned diffusion model.
- timestep (`int`): current discrete timestep in the diffusion chain.
- sample (`torch.FloatTensor`):
- current instance of sample being created by diffusion process.
- return_dict (`bool`): option for returning tuple rather than SchedulerOutput class
-
- Returns:
- [`~scheduling_utils.SchedulerOutput`] or `tuple`: [`~scheduling_utils.SchedulerOutput`] if `return_dict` is
- True, otherwise a `tuple`. When returning a tuple, the first element is the sample tensor.
-
- """
- if self.num_inference_steps is None:
- raise ValueError(
- "Number of inference steps is 'None', you need to run 'set_timesteps' after creating the scheduler"
- )
-
- diff_to_prev = 0 if self.counter % 2 else self.config.num_train_timesteps // self.num_inference_steps // 2
- prev_timestep = timestep - diff_to_prev
- timestep = self.prk_timesteps[self.counter // 4 * 4]
-
- if self.counter % 4 == 0:
- self.cur_model_output += 1 / 6 * model_output
- self.ets.append(model_output)
- self.cur_sample = sample
- elif (self.counter - 1) % 4 == 0:
- self.cur_model_output += 1 / 3 * model_output
- elif (self.counter - 2) % 4 == 0:
- self.cur_model_output += 1 / 3 * model_output
- elif (self.counter - 3) % 4 == 0:
- model_output = self.cur_model_output + 1 / 6 * model_output
- self.cur_model_output = 0
-
- # cur_sample should not be `None`
- cur_sample = self.cur_sample if self.cur_sample is not None else sample
-
- prev_sample = self._get_prev_sample(cur_sample, timestep, prev_timestep, model_output)
- self.counter += 1
-
- if not return_dict:
- return (prev_sample,)
-
- return SchedulerOutput(prev_sample=prev_sample)
-
- def step_plms(
- self,
- model_output: torch.FloatTensor,
- timestep: int,
- sample: torch.FloatTensor,
- return_dict: bool = True,
- ) -> Union[SchedulerOutput, Tuple]:
- """
- Step function propagating the sample with the linear multi-step method. This has one forward pass with multiple
- times to approximate the solution.
-
- Args:
- model_output (`torch.FloatTensor`): direct output from learned diffusion model.
- timestep (`int`): current discrete timestep in the diffusion chain.
- sample (`torch.FloatTensor`):
- current instance of sample being created by diffusion process.
- return_dict (`bool`): option for returning tuple rather than SchedulerOutput class
-
- Returns:
- [`~scheduling_utils.SchedulerOutput`] or `tuple`: [`~scheduling_utils.SchedulerOutput`] if `return_dict` is
- True, otherwise a `tuple`. When returning a tuple, the first element is the sample tensor.
-
- """
- if self.num_inference_steps is None:
- raise ValueError(
- "Number of inference steps is 'None', you need to run 'set_timesteps' after creating the scheduler"
- )
-
- if not self.config.skip_prk_steps and len(self.ets) < 3:
- raise ValueError(
- f"{self.__class__} can only be run AFTER scheduler has been run "
- "in 'prk' mode for at least 12 iterations "
- "See: https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_pndm.py "
- "for more information."
- )
-
- prev_timestep = timestep - self.config.num_train_timesteps // self.num_inference_steps
-
- if self.counter != 1:
- self.ets = self.ets[-3:]
- self.ets.append(model_output)
- else:
- prev_timestep = timestep
- timestep = timestep + self.config.num_train_timesteps // self.num_inference_steps
-
- if len(self.ets) == 1 and self.counter == 0:
- model_output = model_output
- self.cur_sample = sample
- elif len(self.ets) == 1 and self.counter == 1:
- model_output = (model_output + self.ets[-1]) / 2
- sample = self.cur_sample
- self.cur_sample = None
- elif len(self.ets) == 2:
- model_output = (3 * self.ets[-1] - self.ets[-2]) / 2
- elif len(self.ets) == 3:
- model_output = (23 * self.ets[-1] - 16 * self.ets[-2] + 5 * self.ets[-3]) / 12
- else:
- model_output = (1 / 24) * (55 * self.ets[-1] - 59 * self.ets[-2] + 37 * self.ets[-3] - 9 * self.ets[-4])
-
- prev_sample = self._get_prev_sample(sample, timestep, prev_timestep, model_output)
- self.counter += 1
-
- if not return_dict:
- return (prev_sample,)
-
- return SchedulerOutput(prev_sample=prev_sample)
-
- def scale_model_input(self, sample: torch.FloatTensor, *args, **kwargs) -> torch.FloatTensor:
- """
- Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
- current timestep.
-
- Args:
- sample (`torch.FloatTensor`): input sample
-
- Returns:
- `torch.FloatTensor`: scaled input sample
- """
- return sample
-
- def _get_prev_sample(self, sample, timestep, prev_timestep, model_output):
- # See formula (9) of PNDM paper https://arxiv.org/pdf/2202.09778.pdf
- # this function computes x_(t−δ) using the formula of (9)
- # Note that x_t needs to be added to both sides of the equation
-
- # Notation ( ->
- # alpha_prod_t -> α_t
- # alpha_prod_t_prev -> α_(t−δ)
- # beta_prod_t -> (1 - α_t)
- # beta_prod_t_prev -> (1 - α_(t−δ))
- # sample -> x_t
- # model_output -> e_θ(x_t, t)
- # prev_sample -> x_(t−δ)
- alpha_prod_t = self.alphas_cumprod[timestep]
- alpha_prod_t_prev = self.alphas_cumprod[prev_timestep] if prev_timestep >= 0 else self.final_alpha_cumprod
- beta_prod_t = 1 - alpha_prod_t
- beta_prod_t_prev = 1 - alpha_prod_t_prev
-
- if self.config.prediction_type == "v_prediction":
- model_output = (alpha_prod_t**0.5) * model_output + (beta_prod_t**0.5) * sample
- elif self.config.prediction_type != "epsilon":
- raise ValueError(
- f"prediction_type given as {self.config.prediction_type} must be one of `epsilon` or `v_prediction`"
- )
-
- # corresponds to (α_(t−δ) - α_t) divided by
- # denominator of x_t in formula (9) and plus 1
- # Note: (α_(t−δ) - α_t) / (sqrt(α_t) * (sqrt(α_(t−δ)) + sqr(α_t))) =
- # sqrt(α_(t−δ)) / sqrt(α_t))
- sample_coeff = (alpha_prod_t_prev / alpha_prod_t) ** (0.5)
-
- # corresponds to denominator of e_θ(x_t, t) in formula (9)
- model_output_denom_coeff = alpha_prod_t * beta_prod_t_prev ** (0.5) + (
- alpha_prod_t * beta_prod_t * alpha_prod_t_prev
- ) ** (0.5)
-
- # full formula (9)
- prev_sample = (
- sample_coeff * sample - (alpha_prod_t_prev - alpha_prod_t) * model_output / model_output_denom_coeff
- )
-
- return prev_sample
-
- # Copied from diffusers.schedulers.scheduling_ddpm.DDPMScheduler.add_noise
- def add_noise(
- self,
- original_samples: torch.FloatTensor,
- noise: torch.FloatTensor,
- timesteps: torch.IntTensor,
- ) -> torch.FloatTensor:
- # Make sure alphas_cumprod and timestep have same device and dtype as original_samples
- alphas_cumprod = self.alphas_cumprod.to(device=original_samples.device, dtype=original_samples.dtype)
- timesteps = timesteps.to(original_samples.device)
-
- sqrt_alpha_prod = alphas_cumprod[timesteps] ** 0.5
- sqrt_alpha_prod = sqrt_alpha_prod.flatten()
- while len(sqrt_alpha_prod.shape) < len(original_samples.shape):
- sqrt_alpha_prod = sqrt_alpha_prod.unsqueeze(-1)
-
- sqrt_one_minus_alpha_prod = (1 - alphas_cumprod[timesteps]) ** 0.5
- sqrt_one_minus_alpha_prod = sqrt_one_minus_alpha_prod.flatten()
- while len(sqrt_one_minus_alpha_prod.shape) < len(original_samples.shape):
- sqrt_one_minus_alpha_prod = sqrt_one_minus_alpha_prod.unsqueeze(-1)
-
- noisy_samples = sqrt_alpha_prod * original_samples + sqrt_one_minus_alpha_prod * noise
- return noisy_samples
-
- def __len__(self):
- return self.config.num_train_timesteps
diff --git a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/utils/logging.py b/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/utils/logging.py
deleted file mode 100644
index 4ccc57cd69d57e9bd999e35320cb98416f000522..0000000000000000000000000000000000000000
--- a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/utils/logging.py
+++ /dev/null
@@ -1,339 +0,0 @@
-# coding=utf-8
-# Copyright 2023 Optuna, Hugging Face
-#
-# 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.
-""" Logging utilities."""
-
-import logging
-import os
-import sys
-import threading
-from logging import (
- CRITICAL, # NOQA
- DEBUG, # NOQA
- ERROR, # NOQA
- FATAL, # NOQA
- INFO, # NOQA
- NOTSET, # NOQA
- WARN, # NOQA
- WARNING, # NOQA
-)
-from typing import Optional
-
-from tqdm import auto as tqdm_lib
-
-
-_lock = threading.Lock()
-_default_handler: Optional[logging.Handler] = None
-
-log_levels = {
- "debug": logging.DEBUG,
- "info": logging.INFO,
- "warning": logging.WARNING,
- "error": logging.ERROR,
- "critical": logging.CRITICAL,
-}
-
-_default_log_level = logging.WARNING
-
-_tqdm_active = True
-
-
-def _get_default_logging_level():
- """
- If DIFFUSERS_VERBOSITY env var is set to one of the valid choices return that as the new default level. If it is
- not - fall back to `_default_log_level`
- """
- env_level_str = os.getenv("DIFFUSERS_VERBOSITY", None)
- if env_level_str:
- if env_level_str in log_levels:
- return log_levels[env_level_str]
- else:
- logging.getLogger().warning(
- f"Unknown option DIFFUSERS_VERBOSITY={env_level_str}, "
- f"has to be one of: { ', '.join(log_levels.keys()) }"
- )
- return _default_log_level
-
-
-def _get_library_name() -> str:
- return __name__.split(".")[0]
-
-
-def _get_library_root_logger() -> logging.Logger:
- return logging.getLogger(_get_library_name())
-
-
-def _configure_library_root_logger() -> None:
- global _default_handler
-
- with _lock:
- if _default_handler:
- # This library has already configured the library root logger.
- return
- _default_handler = logging.StreamHandler() # Set sys.stderr as stream.
- _default_handler.flush = sys.stderr.flush
-
- # Apply our default configuration to the library root logger.
- library_root_logger = _get_library_root_logger()
- library_root_logger.addHandler(_default_handler)
- library_root_logger.setLevel(_get_default_logging_level())
- library_root_logger.propagate = False
-
-
-def _reset_library_root_logger() -> None:
- global _default_handler
-
- with _lock:
- if not _default_handler:
- return
-
- library_root_logger = _get_library_root_logger()
- library_root_logger.removeHandler(_default_handler)
- library_root_logger.setLevel(logging.NOTSET)
- _default_handler = None
-
-
-def get_log_levels_dict():
- return log_levels
-
-
-def get_logger(name: Optional[str] = None) -> logging.Logger:
- """
- Return a logger with the specified name.
-
- This function is not supposed to be directly accessed unless you are writing a custom diffusers module.
- """
-
- if name is None:
- name = _get_library_name()
-
- _configure_library_root_logger()
- return logging.getLogger(name)
-
-
-def get_verbosity() -> int:
- """
- Return the current level for the 🤗 Diffusers' root logger as an `int`.
-
- Returns:
- `int`:
- Logging level integers which can be one of:
-
- - `50`: `diffusers.logging.CRITICAL` or `diffusers.logging.FATAL`
- - `40`: `diffusers.logging.ERROR`
- - `30`: `diffusers.logging.WARNING` or `diffusers.logging.WARN`
- - `20`: `diffusers.logging.INFO`
- - `10`: `diffusers.logging.DEBUG`
-
- """
-
- _configure_library_root_logger()
- return _get_library_root_logger().getEffectiveLevel()
-
-
-def set_verbosity(verbosity: int) -> None:
- """
- Set the verbosity level for the 🤗 Diffusers' root logger.
-
- Args:
- verbosity (`int`):
- Logging level which can be one of:
-
- - `diffusers.logging.CRITICAL` or `diffusers.logging.FATAL`
- - `diffusers.logging.ERROR`
- - `diffusers.logging.WARNING` or `diffusers.logging.WARN`
- - `diffusers.logging.INFO`
- - `diffusers.logging.DEBUG`
- """
-
- _configure_library_root_logger()
- _get_library_root_logger().setLevel(verbosity)
-
-
-def set_verbosity_info():
- """Set the verbosity to the `INFO` level."""
- return set_verbosity(INFO)
-
-
-def set_verbosity_warning():
- """Set the verbosity to the `WARNING` level."""
- return set_verbosity(WARNING)
-
-
-def set_verbosity_debug():
- """Set the verbosity to the `DEBUG` level."""
- return set_verbosity(DEBUG)
-
-
-def set_verbosity_error():
- """Set the verbosity to the `ERROR` level."""
- return set_verbosity(ERROR)
-
-
-def disable_default_handler() -> None:
- """Disable the default handler of the 🤗 Diffusers' root logger."""
-
- _configure_library_root_logger()
-
- assert _default_handler is not None
- _get_library_root_logger().removeHandler(_default_handler)
-
-
-def enable_default_handler() -> None:
- """Enable the default handler of the 🤗 Diffusers' root logger."""
-
- _configure_library_root_logger()
-
- assert _default_handler is not None
- _get_library_root_logger().addHandler(_default_handler)
-
-
-def add_handler(handler: logging.Handler) -> None:
- """adds a handler to the HuggingFace Diffusers' root logger."""
-
- _configure_library_root_logger()
-
- assert handler is not None
- _get_library_root_logger().addHandler(handler)
-
-
-def remove_handler(handler: logging.Handler) -> None:
- """removes given handler from the HuggingFace Diffusers' root logger."""
-
- _configure_library_root_logger()
-
- assert handler is not None and handler not in _get_library_root_logger().handlers
- _get_library_root_logger().removeHandler(handler)
-
-
-def disable_propagation() -> None:
- """
- Disable propagation of the library log outputs. Note that log propagation is disabled by default.
- """
-
- _configure_library_root_logger()
- _get_library_root_logger().propagate = False
-
-
-def enable_propagation() -> None:
- """
- Enable propagation of the library log outputs. Please disable the HuggingFace Diffusers' default handler to prevent
- double logging if the root logger has been configured.
- """
-
- _configure_library_root_logger()
- _get_library_root_logger().propagate = True
-
-
-def enable_explicit_format() -> None:
- """
- Enable explicit formatting for every 🤗 Diffusers' logger. The explicit formatter is as follows:
- ```
- [LEVELNAME|FILENAME|LINE NUMBER] TIME >> MESSAGE
- ```
- All handlers currently bound to the root logger are affected by this method.
- """
- handlers = _get_library_root_logger().handlers
-
- for handler in handlers:
- formatter = logging.Formatter("[%(levelname)s|%(filename)s:%(lineno)s] %(asctime)s >> %(message)s")
- handler.setFormatter(formatter)
-
-
-def reset_format() -> None:
- """
- Resets the formatting for 🤗 Diffusers' loggers.
-
- All handlers currently bound to the root logger are affected by this method.
- """
- handlers = _get_library_root_logger().handlers
-
- for handler in handlers:
- handler.setFormatter(None)
-
-
-def warning_advice(self, *args, **kwargs):
- """
- This method is identical to `logger.warning()`, but if env var DIFFUSERS_NO_ADVISORY_WARNINGS=1 is set, this
- warning will not be printed
- """
- no_advisory_warnings = os.getenv("DIFFUSERS_NO_ADVISORY_WARNINGS", False)
- if no_advisory_warnings:
- return
- self.warning(*args, **kwargs)
-
-
-logging.Logger.warning_advice = warning_advice
-
-
-class EmptyTqdm:
- """Dummy tqdm which doesn't do anything."""
-
- def __init__(self, *args, **kwargs): # pylint: disable=unused-argument
- self._iterator = args[0] if args else None
-
- def __iter__(self):
- return iter(self._iterator)
-
- def __getattr__(self, _):
- """Return empty function."""
-
- def empty_fn(*args, **kwargs): # pylint: disable=unused-argument
- return
-
- return empty_fn
-
- def __enter__(self):
- return self
-
- def __exit__(self, type_, value, traceback):
- return
-
-
-class _tqdm_cls:
- def __call__(self, *args, **kwargs):
- if _tqdm_active:
- return tqdm_lib.tqdm(*args, **kwargs)
- else:
- return EmptyTqdm(*args, **kwargs)
-
- def set_lock(self, *args, **kwargs):
- self._lock = None
- if _tqdm_active:
- return tqdm_lib.tqdm.set_lock(*args, **kwargs)
-
- def get_lock(self):
- if _tqdm_active:
- return tqdm_lib.tqdm.get_lock()
-
-
-tqdm = _tqdm_cls()
-
-
-def is_progress_bar_enabled() -> bool:
- """Return a boolean indicating whether tqdm progress bars are enabled."""
- global _tqdm_active
- return bool(_tqdm_active)
-
-
-def enable_progress_bar():
- """Enable tqdm progress bar."""
- global _tqdm_active
- _tqdm_active = True
-
-
-def disable_progress_bar():
- """Disable tqdm progress bar."""
- global _tqdm_active
- _tqdm_active = False
diff --git a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/tests/pipelines/stable_diffusion_2/test_stable_diffusion_diffedit.py b/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/tests/pipelines/stable_diffusion_2/test_stable_diffusion_diffedit.py
deleted file mode 100644
index 88aeb50dc1378d5bb032525491d5a7880ffa7947..0000000000000000000000000000000000000000
--- a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/tests/pipelines/stable_diffusion_2/test_stable_diffusion_diffedit.py
+++ /dev/null
@@ -1,399 +0,0 @@
-# coding=utf-8
-# Copyright 2023 HuggingFace Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import gc
-import random
-import tempfile
-import unittest
-
-import numpy as np
-import torch
-from PIL import Image
-from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer
-
-from diffusers import (
- AutoencoderKL,
- DDIMInverseScheduler,
- DDIMScheduler,
- DPMSolverMultistepInverseScheduler,
- DPMSolverMultistepScheduler,
- StableDiffusionDiffEditPipeline,
- UNet2DConditionModel,
-)
-from diffusers.utils import load_image, slow
-from diffusers.utils.testing_utils import enable_full_determinism, floats_tensor, require_torch_gpu, torch_device
-
-from ..pipeline_params import TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS, TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
-from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin
-
-
-enable_full_determinism()
-
-
-class StableDiffusionDiffEditPipelineFastTests(PipelineLatentTesterMixin, PipelineTesterMixin, unittest.TestCase):
- pipeline_class = StableDiffusionDiffEditPipeline
- params = TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {"height", "width", "image"} | {"image_latents"}
- batch_params = TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS - {"image"} | {"image_latents"}
- image_params = frozenset(
- []
- ) # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
- image_latents_params = frozenset([])
-
- def get_dummy_components(self):
- torch.manual_seed(0)
- unet = UNet2DConditionModel(
- block_out_channels=(32, 64),
- layers_per_block=2,
- sample_size=32,
- in_channels=4,
- out_channels=4,
- down_block_types=("DownBlock2D", "CrossAttnDownBlock2D"),
- up_block_types=("CrossAttnUpBlock2D", "UpBlock2D"),
- cross_attention_dim=32,
- # SD2-specific config below
- attention_head_dim=(2, 4),
- use_linear_projection=True,
- )
- scheduler = DDIMScheduler(
- beta_start=0.00085,
- beta_end=0.012,
- beta_schedule="scaled_linear",
- clip_sample=False,
- set_alpha_to_one=False,
- )
- inverse_scheduler = DDIMInverseScheduler(
- beta_start=0.00085,
- beta_end=0.012,
- beta_schedule="scaled_linear",
- clip_sample=False,
- set_alpha_to_zero=False,
- )
- torch.manual_seed(0)
- vae = AutoencoderKL(
- block_out_channels=[32, 64],
- in_channels=3,
- out_channels=3,
- down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"],
- up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"],
- latent_channels=4,
- sample_size=128,
- )
- torch.manual_seed(0)
- text_encoder_config = CLIPTextConfig(
- bos_token_id=0,
- eos_token_id=2,
- hidden_size=32,
- intermediate_size=37,
- layer_norm_eps=1e-05,
- num_attention_heads=4,
- num_hidden_layers=5,
- pad_token_id=1,
- vocab_size=1000,
- # SD2-specific config below
- hidden_act="gelu",
- projection_dim=512,
- )
- text_encoder = CLIPTextModel(text_encoder_config)
- tokenizer = CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip")
-
- components = {
- "unet": unet,
- "scheduler": scheduler,
- "inverse_scheduler": inverse_scheduler,
- "vae": vae,
- "text_encoder": text_encoder,
- "tokenizer": tokenizer,
- "safety_checker": None,
- "feature_extractor": None,
- }
-
- return components
-
- def get_dummy_inputs(self, device, seed=0):
- mask = floats_tensor((1, 16, 16), rng=random.Random(seed)).to(device)
- latents = floats_tensor((1, 2, 4, 16, 16), rng=random.Random(seed)).to(device)
- if str(device).startswith("mps"):
- generator = torch.manual_seed(seed)
- else:
- generator = torch.Generator(device=device).manual_seed(seed)
- inputs = {
- "prompt": "a dog and a newt",
- "mask_image": mask,
- "image_latents": latents,
- "generator": generator,
- "num_inference_steps": 2,
- "inpaint_strength": 1.0,
- "guidance_scale": 6.0,
- "output_type": "numpy",
- }
-
- return inputs
-
- def get_dummy_mask_inputs(self, device, seed=0):
- image = floats_tensor((1, 3, 32, 32), rng=random.Random(seed)).to(device)
- image = image.cpu().permute(0, 2, 3, 1)[0]
- image = Image.fromarray(np.uint8(image)).convert("RGB")
- if str(device).startswith("mps"):
- generator = torch.manual_seed(seed)
- else:
- generator = torch.Generator(device=device).manual_seed(seed)
- inputs = {
- "image": image,
- "source_prompt": "a cat and a frog",
- "target_prompt": "a dog and a newt",
- "generator": generator,
- "num_inference_steps": 2,
- "num_maps_per_mask": 2,
- "mask_encode_strength": 1.0,
- "guidance_scale": 6.0,
- "output_type": "numpy",
- }
-
- return inputs
-
- def get_dummy_inversion_inputs(self, device, seed=0):
- image = floats_tensor((1, 3, 32, 32), rng=random.Random(seed)).to(device)
- image = image.cpu().permute(0, 2, 3, 1)[0]
- image = Image.fromarray(np.uint8(image)).convert("RGB")
- if str(device).startswith("mps"):
- generator = torch.manual_seed(seed)
- else:
- generator = torch.Generator(device=device).manual_seed(seed)
- inputs = {
- "image": image,
- "prompt": "a cat and a frog",
- "generator": generator,
- "num_inference_steps": 2,
- "inpaint_strength": 1.0,
- "guidance_scale": 6.0,
- "decode_latents": True,
- "output_type": "numpy",
- }
- return inputs
-
- def test_save_load_optional_components(self):
- if not hasattr(self.pipeline_class, "_optional_components"):
- return
-
- components = self.get_dummy_components()
- pipe = self.pipeline_class(**components)
- pipe.to(torch_device)
- pipe.set_progress_bar_config(disable=None)
-
- # set all optional components to None and update pipeline config accordingly
- for optional_component in pipe._optional_components:
- setattr(pipe, optional_component, None)
- pipe.register_modules(**{optional_component: None for optional_component in pipe._optional_components})
-
- inputs = self.get_dummy_inputs(torch_device)
- output = pipe(**inputs)[0]
-
- with tempfile.TemporaryDirectory() as tmpdir:
- pipe.save_pretrained(tmpdir)
- pipe_loaded = self.pipeline_class.from_pretrained(tmpdir)
- pipe_loaded.to(torch_device)
- pipe_loaded.set_progress_bar_config(disable=None)
-
- for optional_component in pipe._optional_components:
- self.assertTrue(
- getattr(pipe_loaded, optional_component) is None,
- f"`{optional_component}` did not stay set to None after loading.",
- )
-
- inputs = self.get_dummy_inputs(torch_device)
- output_loaded = pipe_loaded(**inputs)[0]
-
- max_diff = np.abs(output - output_loaded).max()
- self.assertLess(max_diff, 1e-4)
-
- def test_mask(self):
- device = "cpu"
-
- components = self.get_dummy_components()
- pipe = self.pipeline_class(**components)
- pipe.to(device)
- pipe.set_progress_bar_config(disable=None)
-
- inputs = self.get_dummy_mask_inputs(device)
- mask = pipe.generate_mask(**inputs)
- mask_slice = mask[0, -3:, -3:]
-
- self.assertEqual(mask.shape, (1, 16, 16))
- expected_slice = np.array([0] * 9)
- max_diff = np.abs(mask_slice.flatten() - expected_slice).max()
- self.assertLessEqual(max_diff, 1e-3)
- self.assertEqual(mask[0, -3, -4], 0)
-
- def test_inversion(self):
- device = "cpu"
-
- components = self.get_dummy_components()
- pipe = self.pipeline_class(**components)
- pipe.to(device)
- pipe.set_progress_bar_config(disable=None)
-
- inputs = self.get_dummy_inversion_inputs(device)
- image = pipe.invert(**inputs).images
- image_slice = image[0, -1, -3:, -3:]
-
- self.assertEqual(image.shape, (2, 32, 32, 3))
- expected_slice = np.array(
- [0.5150, 0.5134, 0.5043, 0.5376, 0.4694, 0.5105, 0.5015, 0.4407, 0.4799],
- )
- max_diff = np.abs(image_slice.flatten() - expected_slice).max()
- self.assertLessEqual(max_diff, 1e-3)
-
- def test_inference_batch_single_identical(self):
- super().test_inference_batch_single_identical(expected_max_diff=5e-3)
-
- def test_inversion_dpm(self):
- device = "cpu"
-
- components = self.get_dummy_components()
-
- scheduler_args = {"beta_start": 0.00085, "beta_end": 0.012, "beta_schedule": "scaled_linear"}
- components["scheduler"] = DPMSolverMultistepScheduler(**scheduler_args)
- components["inverse_scheduler"] = DPMSolverMultistepInverseScheduler(**scheduler_args)
-
- pipe = self.pipeline_class(**components)
- pipe.to(device)
- pipe.set_progress_bar_config(disable=None)
-
- inputs = self.get_dummy_inversion_inputs(device)
- image = pipe.invert(**inputs).images
- image_slice = image[0, -1, -3:, -3:]
-
- self.assertEqual(image.shape, (2, 32, 32, 3))
- expected_slice = np.array(
- [0.5305, 0.4673, 0.5314, 0.5308, 0.4886, 0.5279, 0.5142, 0.4724, 0.4892],
- )
- max_diff = np.abs(image_slice.flatten() - expected_slice).max()
- self.assertLessEqual(max_diff, 1e-3)
-
-
-@require_torch_gpu
-@slow
-class StableDiffusionDiffEditPipelineIntegrationTests(unittest.TestCase):
- def tearDown(self):
- super().tearDown()
- gc.collect()
- torch.cuda.empty_cache()
-
- @classmethod
- def setUpClass(cls):
- raw_image = load_image(
- "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/diffedit/fruit.png"
- )
-
- raw_image = raw_image.convert("RGB").resize((768, 768))
-
- cls.raw_image = raw_image
-
- def test_stable_diffusion_diffedit_full(self):
- generator = torch.manual_seed(0)
-
- pipe = StableDiffusionDiffEditPipeline.from_pretrained(
- "stabilityai/stable-diffusion-2-1", safety_checker=None, torch_dtype=torch.float16
- )
- pipe.scheduler = DDIMScheduler.from_config(pipe.scheduler.config)
- pipe.inverse_scheduler = DDIMInverseScheduler.from_config(pipe.scheduler.config)
- pipe.enable_model_cpu_offload()
- pipe.set_progress_bar_config(disable=None)
-
- source_prompt = "a bowl of fruit"
- target_prompt = "a bowl of pears"
-
- mask_image = pipe.generate_mask(
- image=self.raw_image,
- source_prompt=source_prompt,
- target_prompt=target_prompt,
- generator=generator,
- )
-
- inv_latents = pipe.invert(
- prompt=source_prompt, image=self.raw_image, inpaint_strength=0.7, generator=generator
- ).latents
-
- image = pipe(
- prompt=target_prompt,
- mask_image=mask_image,
- image_latents=inv_latents,
- generator=generator,
- negative_prompt=source_prompt,
- inpaint_strength=0.7,
- output_type="numpy",
- ).images[0]
-
- expected_image = (
- np.array(
- load_image(
- "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
- "/diffedit/pears.png"
- ).resize((768, 768))
- )
- / 255
- )
- assert np.abs((expected_image - image).max()) < 5e-1
-
- def test_stable_diffusion_diffedit_dpm(self):
- generator = torch.manual_seed(0)
-
- pipe = StableDiffusionDiffEditPipeline.from_pretrained(
- "stabilityai/stable-diffusion-2-1", safety_checker=None, torch_dtype=torch.float16
- )
- pipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
- pipe.inverse_scheduler = DPMSolverMultistepInverseScheduler.from_config(pipe.scheduler.config)
- pipe.enable_model_cpu_offload()
- pipe.set_progress_bar_config(disable=None)
-
- source_prompt = "a bowl of fruit"
- target_prompt = "a bowl of pears"
-
- mask_image = pipe.generate_mask(
- image=self.raw_image,
- source_prompt=source_prompt,
- target_prompt=target_prompt,
- generator=generator,
- )
-
- inv_latents = pipe.invert(
- prompt=source_prompt,
- image=self.raw_image,
- inpaint_strength=0.7,
- generator=generator,
- num_inference_steps=25,
- ).latents
-
- image = pipe(
- prompt=target_prompt,
- mask_image=mask_image,
- image_latents=inv_latents,
- generator=generator,
- negative_prompt=source_prompt,
- inpaint_strength=0.7,
- num_inference_steps=25,
- output_type="numpy",
- ).images[0]
-
- expected_image = (
- np.array(
- load_image(
- "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
- "/diffedit/pears.png"
- ).resize((768, 768))
- )
- / 255
- )
- assert np.abs((expected_image - image).max()) < 5e-1
diff --git a/spaces/Andy1621/uniformer_image_detection/configs/vfnet/vfnet_r2_101_fpn_mstrain_2x_coco.py b/spaces/Andy1621/uniformer_image_detection/configs/vfnet/vfnet_r2_101_fpn_mstrain_2x_coco.py
deleted file mode 100644
index 2bcf779db008dbbf0c8f3b1fdc84a9940967f78a..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_detection/configs/vfnet/vfnet_r2_101_fpn_mstrain_2x_coco.py
+++ /dev/null
@@ -1,14 +0,0 @@
-_base_ = './vfnet_r50_fpn_mstrain_2x_coco.py'
-model = dict(
- pretrained='open-mmlab://res2net101_v1d_26w_4s',
- backbone=dict(
- type='Res2Net',
- depth=101,
- scales=4,
- base_width=26,
- num_stages=4,
- out_indices=(0, 1, 2, 3),
- frozen_stages=1,
- norm_cfg=dict(type='BN', requires_grad=True),
- norm_eval=True,
- style='pytorch'))
diff --git a/spaces/Andy1621/uniformer_image_detection/mmdet/apis/test.py b/spaces/Andy1621/uniformer_image_detection/mmdet/apis/test.py
deleted file mode 100644
index e54b1b8c24efc448972c31ee5da63041d7f97a47..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_detection/mmdet/apis/test.py
+++ /dev/null
@@ -1,190 +0,0 @@
-import os.path as osp
-import pickle
-import shutil
-import tempfile
-import time
-
-import mmcv
-import torch
-import torch.distributed as dist
-from mmcv.image import tensor2imgs
-from mmcv.runner import get_dist_info
-
-from mmdet.core import encode_mask_results
-
-
-def single_gpu_test(model,
- data_loader,
- show=False,
- out_dir=None,
- show_score_thr=0.3):
- model.eval()
- results = []
- dataset = data_loader.dataset
- prog_bar = mmcv.ProgressBar(len(dataset))
- for i, data in enumerate(data_loader):
- with torch.no_grad():
- result = model(return_loss=False, rescale=True, **data)
-
- batch_size = len(result)
- if show or out_dir:
- if batch_size == 1 and isinstance(data['img'][0], torch.Tensor):
- img_tensor = data['img'][0]
- else:
- img_tensor = data['img'][0].data[0]
- img_metas = data['img_metas'][0].data[0]
- imgs = tensor2imgs(img_tensor, **img_metas[0]['img_norm_cfg'])
- assert len(imgs) == len(img_metas)
-
- for i, (img, img_meta) in enumerate(zip(imgs, img_metas)):
- h, w, _ = img_meta['img_shape']
- img_show = img[:h, :w, :]
-
- ori_h, ori_w = img_meta['ori_shape'][:-1]
- img_show = mmcv.imresize(img_show, (ori_w, ori_h))
-
- if out_dir:
- out_file = osp.join(out_dir, img_meta['ori_filename'])
- else:
- out_file = None
-
- model.module.show_result(
- img_show,
- result[i],
- show=show,
- out_file=out_file,
- score_thr=show_score_thr)
-
- # encode mask results
- if isinstance(result[0], tuple):
- result = [(bbox_results, encode_mask_results(mask_results))
- for bbox_results, mask_results in result]
- results.extend(result)
-
- for _ in range(batch_size):
- prog_bar.update()
- return results
-
-
-def multi_gpu_test(model, data_loader, tmpdir=None, gpu_collect=False):
- """Test model with multiple gpus.
-
- This method tests model with multiple gpus and collects the results
- under two different modes: gpu and cpu modes. By setting 'gpu_collect=True'
- it encodes results to gpu tensors and use gpu communication for results
- collection. On cpu mode it saves the results on different gpus to 'tmpdir'
- and collects them by the rank 0 worker.
-
- Args:
- model (nn.Module): Model to be tested.
- data_loader (nn.Dataloader): Pytorch data loader.
- tmpdir (str): Path of directory to save the temporary results from
- different gpus under cpu mode.
- gpu_collect (bool): Option to use either gpu or cpu to collect results.
-
- Returns:
- list: The prediction results.
- """
- model.eval()
- results = []
- dataset = data_loader.dataset
- rank, world_size = get_dist_info()
- if rank == 0:
- prog_bar = mmcv.ProgressBar(len(dataset))
- time.sleep(2) # This line can prevent deadlock problem in some cases.
- for i, data in enumerate(data_loader):
- with torch.no_grad():
- result = model(return_loss=False, rescale=True, **data)
- # encode mask results
- if isinstance(result[0], tuple):
- result = [(bbox_results, encode_mask_results(mask_results))
- for bbox_results, mask_results in result]
- results.extend(result)
-
- if rank == 0:
- batch_size = len(result)
- for _ in range(batch_size * world_size):
- prog_bar.update()
-
- # collect results from all ranks
- if gpu_collect:
- results = collect_results_gpu(results, len(dataset))
- else:
- results = collect_results_cpu(results, len(dataset), tmpdir)
- return results
-
-
-def collect_results_cpu(result_part, size, tmpdir=None):
- rank, world_size = get_dist_info()
- # create a tmp dir if it is not specified
- if tmpdir is None:
- MAX_LEN = 512
- # 32 is whitespace
- dir_tensor = torch.full((MAX_LEN, ),
- 32,
- dtype=torch.uint8,
- device='cuda')
- if rank == 0:
- mmcv.mkdir_or_exist('.dist_test')
- tmpdir = tempfile.mkdtemp(dir='.dist_test')
- tmpdir = torch.tensor(
- bytearray(tmpdir.encode()), dtype=torch.uint8, device='cuda')
- dir_tensor[:len(tmpdir)] = tmpdir
- dist.broadcast(dir_tensor, 0)
- tmpdir = dir_tensor.cpu().numpy().tobytes().decode().rstrip()
- else:
- mmcv.mkdir_or_exist(tmpdir)
- # dump the part result to the dir
- mmcv.dump(result_part, osp.join(tmpdir, f'part_{rank}.pkl'))
- dist.barrier()
- # collect all parts
- if rank != 0:
- return None
- else:
- # load results of all parts from tmp dir
- part_list = []
- for i in range(world_size):
- part_file = osp.join(tmpdir, f'part_{i}.pkl')
- part_list.append(mmcv.load(part_file))
- # sort the results
- ordered_results = []
- for res in zip(*part_list):
- ordered_results.extend(list(res))
- # the dataloader may pad some samples
- ordered_results = ordered_results[:size]
- # remove tmp dir
- shutil.rmtree(tmpdir)
- return ordered_results
-
-
-def collect_results_gpu(result_part, size):
- rank, world_size = get_dist_info()
- # dump result part to tensor with pickle
- part_tensor = torch.tensor(
- bytearray(pickle.dumps(result_part)), dtype=torch.uint8, device='cuda')
- # gather all result part tensor shape
- shape_tensor = torch.tensor(part_tensor.shape, device='cuda')
- shape_list = [shape_tensor.clone() for _ in range(world_size)]
- dist.all_gather(shape_list, shape_tensor)
- # padding result part tensor to max length
- shape_max = torch.tensor(shape_list).max()
- part_send = torch.zeros(shape_max, dtype=torch.uint8, device='cuda')
- part_send[:shape_tensor[0]] = part_tensor
- part_recv_list = [
- part_tensor.new_zeros(shape_max) for _ in range(world_size)
- ]
- # gather all result part
- dist.all_gather(part_recv_list, part_send)
-
- if rank == 0:
- part_list = []
- for recv, shape in zip(part_recv_list, shape_list):
- part_list.append(
- pickle.loads(recv[:shape[0]].cpu().numpy().tobytes()))
- # sort the results
- ordered_results = []
- for res in zip(*part_list):
- ordered_results.extend(list(res))
- # the dataloader may pad some samples
- ordered_results = ordered_results[:size]
- return ordered_results
diff --git a/spaces/Andy1621/uniformer_image_segmentation/configs/ccnet/ccnet_r50-d8_512x512_80k_ade20k.py b/spaces/Andy1621/uniformer_image_segmentation/configs/ccnet/ccnet_r50-d8_512x512_80k_ade20k.py
deleted file mode 100644
index 1a1f49cf6b112afdadf1841571f51b98c010ddf8..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_segmentation/configs/ccnet/ccnet_r50-d8_512x512_80k_ade20k.py
+++ /dev/null
@@ -1,6 +0,0 @@
-_base_ = [
- '../_base_/models/ccnet_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/Aomsin/Lab10_630510654/README.md b/spaces/Aomsin/Lab10_630510654/README.md
deleted file mode 100644
index 81e23028dd8f28686a270c662646d7903e5a31a2..0000000000000000000000000000000000000000
--- a/spaces/Aomsin/Lab10_630510654/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Eiei
-emoji: 👀
-colorFrom: yellow
-colorTo: gray
-sdk: streamlit
-sdk_version: 1.10.0
-app_file: app.py
-pinned: false
-license: cc-by-nd-4.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/Arnaudding001/OpenAI_whisperLive/vad.py b/spaces/Arnaudding001/OpenAI_whisperLive/vad.py
deleted file mode 100644
index 198e1691b3c00738064fa04a4f451f8b67b506f0..0000000000000000000000000000000000000000
--- a/spaces/Arnaudding001/OpenAI_whisperLive/vad.py
+++ /dev/null
@@ -1,468 +0,0 @@
-from abc import ABC, abstractmethod
-from collections import Counter, deque
-
-from typing import Any, Deque, Iterator, List, Dict
-
-from pprint import pprint
-
-from segments import merge_timestamps
-
-# Workaround for https://github.com/tensorflow/tensorflow/issues/48797
-try:
- import tensorflow as tf
-except ModuleNotFoundError:
- # Error handling
- pass
-
-import torch
-
-import ffmpeg
-import numpy as np
-
-from utils import format_timestamp
-from enum import Enum
-
-class NonSpeechStrategy(Enum):
- """
- Ignore non-speech frames segments.
- """
- SKIP = 1
- """
- Just treat non-speech segments as speech.
- """
- CREATE_SEGMENT = 2
- """
- Expand speech segments into subsequent non-speech segments.
- """
- EXPAND_SEGMENT = 3
-
-# Defaults for Silero
-SPEECH_TRESHOLD = 0.3
-
-# Minimum size of segments to process
-MIN_SEGMENT_DURATION = 1
-
-# The maximum time for texts from old segments to be used in the next segment
-MAX_PROMPT_WINDOW = 0 # seconds (0 = disabled)
-PROMPT_NO_SPEECH_PROB = 0.1 # Do not pass the text from segments with a no speech probability higher than this
-
-VAD_MAX_PROCESSING_CHUNK = 60 * 60 # 60 minutes of audio
-
-class TranscriptionConfig(ABC):
- def __init__(self, non_speech_strategy: NonSpeechStrategy = NonSpeechStrategy.SKIP,
- segment_padding_left: float = None, segment_padding_right = None, max_silent_period: float = None,
- max_merge_size: float = None, max_prompt_window: float = None):
- self.non_speech_strategy = non_speech_strategy
- self.segment_padding_left = segment_padding_left
- self.segment_padding_right = segment_padding_right
- self.max_silent_period = max_silent_period
- self.max_merge_size = max_merge_size
- self.max_prompt_window = max_prompt_window
-
-class PeriodicTranscriptionConfig(TranscriptionConfig):
- def __init__(self, periodic_duration: float, non_speech_strategy: NonSpeechStrategy = NonSpeechStrategy.SKIP,
- segment_padding_left: float = None, segment_padding_right = None, max_silent_period: float = None,
- max_merge_size: float = None, max_prompt_window: float = None):
- super().__init__(non_speech_strategy, segment_padding_left, segment_padding_right, max_silent_period, max_merge_size, max_prompt_window)
- self.periodic_duration = periodic_duration
-
-class AbstractTranscription(ABC):
- def __init__(self, sampling_rate: int = 16000):
- self.sampling_rate = sampling_rate
-
- def get_audio_segment(self, str, start_time: str = None, duration: str = None):
- return load_audio(str, self.sampling_rate, start_time, duration)
-
- @abstractmethod
- def get_transcribe_timestamps(self, audio: str, config: TranscriptionConfig):
- """
- Get the start and end timestamps of the sections that should be transcribed by this VAD method.
- Parameters
- ----------
- audio: str
- The audio file.
- config: TranscriptionConfig
- The transcription configuration.
- Returns
- -------
- A list of start and end timestamps, in fractional seconds.
- """
- return
-
- def transcribe(self, audio: str, whisperCallable, config: TranscriptionConfig):
- """
- Transcribe the given audo file.
- Parameters
- ----------
- audio: str
- The audio file.
- whisperCallable: Callable[[Union[str, np.ndarray, torch.Tensor], int, str, str], dict[str, Union[dict, Any]]]
- The callback that is used to invoke Whisper on an audio file/buffer. The first parameter is the audio file/buffer,
- the second parameter is an optional text prompt, and the last is the current detected language. The return value is the result of the Whisper call.
- Returns
- -------
- A list of start and end timestamps, in fractional seconds.
- """
-
- # get speech timestamps from full audio file
- seconds_timestamps = self.get_transcribe_timestamps(audio, config)
-
- #for seconds_timestamp in seconds_timestamps:
- # print("VAD timestamp ", format_timestamp(seconds_timestamp['start']), " to ", format_timestamp(seconds_timestamp['end']))
-
- merged = merge_timestamps(seconds_timestamps, config.max_silent_period, config.max_merge_size, config.segment_padding_left, config.segment_padding_right)
-
- # A deque of transcribed segments that is passed to the next segment as a prompt
- prompt_window = deque()
-
- print("Timestamps:")
- pprint(merged)
-
- if config.non_speech_strategy != NonSpeechStrategy.SKIP:
- max_audio_duration = get_audio_duration(audio)
-
- # Expand segments to include the gaps between them
- if (config.non_speech_strategy == NonSpeechStrategy.CREATE_SEGMENT):
- # When we have a prompt window, we create speech segments betwen each segment if we exceed the merge size
- merged = self.fill_gaps(merged, total_duration=max_audio_duration, max_expand_size=config.max_merge_size)
- elif config.non_speech_strategy == NonSpeechStrategy.EXPAND_SEGMENT:
- # With no prompt window, it is better to just expand the segments (this effectively passes the prompt to the next segment)
- merged = self.expand_gaps(merged, total_duration=max_audio_duration)
- else:
- raise Exception("Unknown non-speech strategy: " + str(config.non_speech_strategy))
-
- print("Transcribing non-speech:")
- pprint(merged)
-
- result = {
- 'text': "",
- 'segments': [],
- 'language': ""
- }
- languageCounter = Counter()
- detected_language = None
-
- segment_index = -1
-
- # For each time segment, run whisper
- for segment in merged:
- segment_index += 1
- segment_start = segment['start']
- segment_end = segment['end']
- segment_expand_amount = segment.get('expand_amount', 0)
- segment_gap = segment.get('gap', False)
-
- segment_duration = segment_end - segment_start
-
- if segment_duration < MIN_SEGMENT_DURATION:
- continue;
-
- # Audio to run on Whisper
- segment_audio = self.get_audio_segment(audio, start_time = str(segment_start), duration = str(segment_duration))
- # Previous segments to use as a prompt
- segment_prompt = ' '.join([segment['text'] for segment in prompt_window]) if len(prompt_window) > 0 else None
-
- # Detected language
- detected_language = languageCounter.most_common(1)[0][0] if len(languageCounter) > 0 else None
-
- print("Running whisper from ", format_timestamp(segment_start), " to ", format_timestamp(segment_end), ", duration: ",
- segment_duration, "expanded: ", segment_expand_amount, "prompt: ", segment_prompt, "language: ", detected_language)
- segment_result = whisperCallable(segment_audio, segment_index, segment_prompt, detected_language)
-
- adjusted_segments = self.adjust_timestamp(segment_result["segments"], adjust_seconds=segment_start, max_source_time=segment_duration)
-
- # Propagate expand amount to the segments
- if (segment_expand_amount > 0):
- segment_without_expansion = segment_duration - segment_expand_amount
-
- for adjusted_segment in adjusted_segments:
- adjusted_segment_end = adjusted_segment['end']
-
- # Add expand amount if the segment got expanded
- if (adjusted_segment_end > segment_without_expansion):
- adjusted_segment["expand_amount"] = adjusted_segment_end - segment_without_expansion
-
- # Append to output
- result['text'] += segment_result['text']
- result['segments'].extend(adjusted_segments)
-
- # Increment detected language
- if not segment_gap:
- languageCounter[segment_result['language']] += 1
-
- # Update prompt window
- self.__update_prompt_window(prompt_window, adjusted_segments, segment_end, segment_gap, config)
-
- if detected_language is not None:
- result['language'] = detected_language
-
- return result
-
- def __update_prompt_window(self, prompt_window: Deque, adjusted_segments: List, segment_end: float, segment_gap: bool, config: TranscriptionConfig):
- if (config.max_prompt_window is not None and config.max_prompt_window > 0):
- # Add segments to the current prompt window (unless it is a speech gap)
- if not segment_gap:
- for segment in adjusted_segments:
- if segment.get('no_speech_prob', 0) <= PROMPT_NO_SPEECH_PROB:
- prompt_window.append(segment)
-
- while (len(prompt_window) > 0):
- first_end_time = prompt_window[0].get('end', 0)
- # Time expanded in the segments should be discounted from the prompt window
- first_expand_time = prompt_window[0].get('expand_amount', 0)
-
- if (first_end_time - first_expand_time < segment_end - config.max_prompt_window):
- prompt_window.popleft()
- else:
- break
-
- def include_gaps(self, segments: Iterator[dict], min_gap_length: float, total_duration: float):
- result = []
- last_end_time = 0
-
- for segment in segments:
- segment_start = float(segment['start'])
- segment_end = float(segment['end'])
-
- if (last_end_time != segment_start):
- delta = segment_start - last_end_time
-
- if (min_gap_length is None or delta >= min_gap_length):
- result.append( { 'start': last_end_time, 'end': segment_start, 'gap': True } )
-
- last_end_time = segment_end
- result.append(segment)
-
- # Also include total duration if specified
- if (total_duration is not None and last_end_time < total_duration):
- delta = total_duration - segment_start
-
- if (min_gap_length is None or delta >= min_gap_length):
- result.append( { 'start': last_end_time, 'end': total_duration, 'gap': True } )
-
- return result
-
- # Expand the end time of each segment to the start of the next segment
- def expand_gaps(self, segments: List[Dict[str, Any]], total_duration: float):
- result = []
-
- if len(segments) == 0:
- return result
-
- # Add gap at the beginning if needed
- if (segments[0]['start'] > 0):
- result.append({ 'start': 0, 'end': segments[0]['start'], 'gap': True } )
-
- for i in range(len(segments) - 1):
- current_segment = segments[i]
- next_segment = segments[i + 1]
-
- delta = next_segment['start'] - current_segment['end']
-
- # Expand if the gap actually exists
- if (delta >= 0):
- current_segment = current_segment.copy()
- current_segment['expand_amount'] = delta
- current_segment['end'] = next_segment['start']
-
- result.append(current_segment)
-
- # Add last segment
- last_segment = segments[-1]
- result.append(last_segment)
-
- # Also include total duration if specified
- if (total_duration is not None):
- last_segment = result[-1]
-
- if (last_segment['end'] < total_duration):
- last_segment = last_segment.copy()
- last_segment['end'] = total_duration
- result[-1] = last_segment
-
- return result
-
- def fill_gaps(self, segments: List[Dict[str, Any]], total_duration: float, max_expand_size: float = None):
- result = []
-
- if len(segments) == 0:
- return result
-
- # Add gap at the beginning if needed
- if (segments[0]['start'] > 0):
- result.append({ 'start': 0, 'end': segments[0]['start'], 'gap': True } )
-
- for i in range(len(segments) - 1):
- expanded = False
- current_segment = segments[i]
- next_segment = segments[i + 1]
-
- delta = next_segment['start'] - current_segment['end']
-
- if (max_expand_size is not None and delta <= max_expand_size):
- # Just expand the current segment
- current_segment = current_segment.copy()
- current_segment['expand_amount'] = delta
- current_segment['end'] = next_segment['start']
- expanded = True
-
- result.append(current_segment)
-
- # Add a gap to the next segment if needed
- if (delta >= 0 and not expanded):
- result.append({ 'start': current_segment['end'], 'end': next_segment['start'], 'gap': True } )
-
- # Add last segment
- last_segment = segments[-1]
- result.append(last_segment)
-
- # Also include total duration if specified
- if (total_duration is not None):
- last_segment = result[-1]
-
- delta = total_duration - last_segment['end']
-
- if (delta > 0):
- if (max_expand_size is not None and delta <= max_expand_size):
- # Expand the last segment
- last_segment = last_segment.copy()
- last_segment['expand_amount'] = delta
- last_segment['end'] = total_duration
- result[-1] = last_segment
- else:
- result.append({ 'start': last_segment['end'], 'end': total_duration, 'gap': True } )
-
- return result
-
- def adjust_timestamp(self, segments: Iterator[dict], adjust_seconds: float, max_source_time: float = None):
- result = []
-
- for segment in segments:
- segment_start = float(segment['start'])
- segment_end = float(segment['end'])
-
- # Filter segments?
- if (max_source_time is not None):
- if (segment_start > max_source_time):
- continue
- segment_end = min(max_source_time, segment_end)
-
- new_segment = segment.copy()
-
- # Add to start and end
- new_segment['start'] = segment_start + adjust_seconds
- new_segment['end'] = segment_end + adjust_seconds
- result.append(new_segment)
- return result
-
- def multiply_timestamps(self, timestamps: List[Dict[str, Any]], factor: float):
- result = []
-
- for entry in timestamps:
- start = entry['start']
- end = entry['end']
-
- result.append({
- 'start': start * factor,
- 'end': end * factor
- })
- return result
-
-class VadSileroTranscription(AbstractTranscription):
- def __init__(self, sampling_rate: int = 16000):
- super().__init__(sampling_rate=sampling_rate)
-
- self.model, utils = torch.hub.load(repo_or_dir='snakers4/silero-vad', model='silero_vad')
- (self.get_speech_timestamps, _, _, _, _) = utils
-
-
- def get_transcribe_timestamps(self, audio: str, config: TranscriptionConfig):
- audio_duration = get_audio_duration(audio)
- result = []
-
- # Divide procesisng of audio into chunks
- chunk_start = 0.0
-
- while (chunk_start < audio_duration):
- chunk_duration = min(audio_duration - chunk_start, VAD_MAX_PROCESSING_CHUNK)
-
- print("Processing VAD in chunk from {} to {}".format(format_timestamp(chunk_start), format_timestamp(chunk_start + chunk_duration)))
- wav = self.get_audio_segment(audio, str(chunk_start), str(chunk_duration))
-
- sample_timestamps = self.get_speech_timestamps(wav, self.model, sampling_rate=self.sampling_rate, threshold=SPEECH_TRESHOLD)
- seconds_timestamps = self.multiply_timestamps(sample_timestamps, factor=1 / self.sampling_rate)
- adjusted = self.adjust_timestamp(seconds_timestamps, adjust_seconds=chunk_start, max_source_time=chunk_start + chunk_duration)
-
- #pprint(adjusted)
-
- result.extend(adjusted)
- chunk_start += chunk_duration
-
- return result
-
-# A very simple VAD that just marks every N seconds as speech
-class VadPeriodicTranscription(AbstractTranscription):
- def __init__(self, sampling_rate: int = 16000):
- super().__init__(sampling_rate=sampling_rate)
-
- def get_transcribe_timestamps(self, audio: str, config: PeriodicTranscriptionConfig):
- # Get duration in seconds
- audio_duration = get_audio_duration(audio)
- result = []
-
- # Generate a timestamp every N seconds
- start_timestamp = 0
-
- while (start_timestamp < audio_duration):
- end_timestamp = min(start_timestamp + config.periodic_duration, audio_duration)
- segment_duration = end_timestamp - start_timestamp
-
- # Minimum duration is 1 second
- if (segment_duration >= 1):
- result.append( { 'start': start_timestamp, 'end': end_timestamp } )
-
- start_timestamp = end_timestamp
-
- return result
-
-def get_audio_duration(file: str):
- return float(ffmpeg.probe(file)["format"]["duration"])
-
-def load_audio(file: str, sample_rate: int = 16000,
- start_time: str = None, duration: str = None):
- """
- Open an audio file and read as mono waveform, resampling as necessary
- Parameters
- ----------
- file: str
- The audio file to open
- sr: int
- The sample rate to resample the audio if necessary
- start_time: str
- The start time, using the standard FFMPEG time duration syntax, or None to disable.
-
- duration: str
- The duration, using the standard FFMPEG time duration syntax, or None to disable.
- Returns
- -------
- A NumPy array containing the audio waveform, in float32 dtype.
- """
- try:
- inputArgs = {'threads': 0}
-
- if (start_time is not None):
- inputArgs['ss'] = start_time
- if (duration is not None):
- inputArgs['t'] = duration
-
- # This launches a subprocess to decode audio while down-mixing and resampling as necessary.
- # Requires the ffmpeg CLI and `ffmpeg-python` package to be installed.
- out, _ = (
- ffmpeg.input(file, **inputArgs)
- .output("-", format="s16le", acodec="pcm_s16le", ac=1, ar=sample_rate)
- .run(cmd="ffmpeg", capture_stdout=True, capture_stderr=True)
- )
- except ffmpeg.Error as e:
- raise RuntimeError(f"Failed to load audio: {e.stderr.decode()}")
-
- return np.frombuffer(out, np.int16).flatten().astype(np.float32) / 32768.0
\ No newline at end of file
diff --git a/spaces/Arulkumar03/GroundingDINO_SOTA_Zero_Shot_Model/groundingdino/util/misc.py b/spaces/Arulkumar03/GroundingDINO_SOTA_Zero_Shot_Model/groundingdino/util/misc.py
deleted file mode 100644
index d64b84ef24bea0c98e76824feb1903f6bfebe7a5..0000000000000000000000000000000000000000
--- a/spaces/Arulkumar03/GroundingDINO_SOTA_Zero_Shot_Model/groundingdino/util/misc.py
+++ /dev/null
@@ -1,717 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-"""
-Misc functions, including distributed helpers.
-
-Mostly copy-paste from torchvision references.
-"""
-import colorsys
-import datetime
-import functools
-import io
-import json
-import os
-import pickle
-import subprocess
-import time
-from collections import OrderedDict, defaultdict, deque
-from typing import List, Optional
-
-import numpy as np
-import torch
-import torch.distributed as dist
-
-# needed due to empty tensor bug in pytorch and torchvision 0.5
-import torchvision
-from torch import Tensor
-
-__torchvision_need_compat_flag = float(torchvision.__version__.split(".")[1]) < 7
-if __torchvision_need_compat_flag:
- from torchvision.ops import _new_empty_tensor
- from torchvision.ops.misc import _output_size
-
-
-class SmoothedValue(object):
- """Track a series of values and provide access to smoothed values over a
- window or the global series average.
- """
-
- def __init__(self, window_size=20, fmt=None):
- if fmt is None:
- fmt = "{median:.4f} ({global_avg:.4f})"
- self.deque = deque(maxlen=window_size)
- self.total = 0.0
- self.count = 0
- self.fmt = fmt
-
- def update(self, value, n=1):
- self.deque.append(value)
- self.count += n
- self.total += value * n
-
- def synchronize_between_processes(self):
- """
- Warning: does not synchronize the deque!
- """
- if not is_dist_avail_and_initialized():
- return
- t = torch.tensor([self.count, self.total], dtype=torch.float64, device="cuda")
- dist.barrier()
- dist.all_reduce(t)
- t = t.tolist()
- self.count = int(t[0])
- self.total = t[1]
-
- @property
- def median(self):
- d = torch.tensor(list(self.deque))
- if d.shape[0] == 0:
- return 0
- return d.median().item()
-
- @property
- def avg(self):
- d = torch.tensor(list(self.deque), dtype=torch.float32)
- return d.mean().item()
-
- @property
- def global_avg(self):
- if os.environ.get("SHILONG_AMP", None) == "1":
- eps = 1e-4
- else:
- eps = 1e-6
- return self.total / (self.count + eps)
-
- @property
- def max(self):
- return max(self.deque)
-
- @property
- def value(self):
- return self.deque[-1]
-
- def __str__(self):
- return self.fmt.format(
- median=self.median,
- avg=self.avg,
- global_avg=self.global_avg,
- max=self.max,
- value=self.value,
- )
-
-
-@functools.lru_cache()
-def _get_global_gloo_group():
- """
- Return a process group based on gloo backend, containing all the ranks
- The result is cached.
- """
-
- if dist.get_backend() == "nccl":
- return dist.new_group(backend="gloo")
-
- return dist.group.WORLD
-
-
-def all_gather_cpu(data):
- """
- Run all_gather on arbitrary picklable data (not necessarily tensors)
- Args:
- data: any picklable object
- Returns:
- list[data]: list of data gathered from each rank
- """
-
- world_size = get_world_size()
- if world_size == 1:
- return [data]
-
- cpu_group = _get_global_gloo_group()
-
- buffer = io.BytesIO()
- torch.save(data, buffer)
- data_view = buffer.getbuffer()
- device = "cuda" if cpu_group is None else "cpu"
- tensor = torch.ByteTensor(data_view).to(device)
-
- # obtain Tensor size of each rank
- local_size = torch.tensor([tensor.numel()], device=device, dtype=torch.long)
- size_list = [torch.tensor([0], device=device, dtype=torch.long) for _ in range(world_size)]
- if cpu_group is None:
- dist.all_gather(size_list, local_size)
- else:
- print("gathering on cpu")
- dist.all_gather(size_list, local_size, group=cpu_group)
- size_list = [int(size.item()) for size in size_list]
- max_size = max(size_list)
- assert isinstance(local_size.item(), int)
- local_size = int(local_size.item())
-
- # receiving Tensor from all ranks
- # we pad the tensor because torch all_gather does not support
- # gathering tensors of different shapes
- tensor_list = []
- for _ in size_list:
- tensor_list.append(torch.empty((max_size,), dtype=torch.uint8, device=device))
- if local_size != max_size:
- padding = torch.empty(size=(max_size - local_size,), dtype=torch.uint8, device=device)
- tensor = torch.cat((tensor, padding), dim=0)
- if cpu_group is None:
- dist.all_gather(tensor_list, tensor)
- else:
- dist.all_gather(tensor_list, tensor, group=cpu_group)
-
- data_list = []
- for size, tensor in zip(size_list, tensor_list):
- tensor = torch.split(tensor, [size, max_size - size], dim=0)[0]
- buffer = io.BytesIO(tensor.cpu().numpy())
- obj = torch.load(buffer)
- data_list.append(obj)
-
- return data_list
-
-
-def all_gather(data):
- """
- Run all_gather on arbitrary picklable data (not necessarily tensors)
- Args:
- data: any picklable object
- Returns:
- list[data]: list of data gathered from each rank
- """
-
- if os.getenv("CPU_REDUCE") == "1":
- return all_gather_cpu(data)
-
- world_size = get_world_size()
- if world_size == 1:
- return [data]
-
- # serialized to a Tensor
- buffer = pickle.dumps(data)
- storage = torch.ByteStorage.from_buffer(buffer)
- tensor = torch.ByteTensor(storage).to("cuda")
-
- # obtain Tensor size of each rank
- local_size = torch.tensor([tensor.numel()], device="cuda")
- size_list = [torch.tensor([0], device="cuda") for _ in range(world_size)]
- dist.all_gather(size_list, local_size)
- size_list = [int(size.item()) for size in size_list]
- max_size = max(size_list)
-
- # receiving Tensor from all ranks
- # we pad the tensor because torch all_gather does not support
- # gathering tensors of different shapes
- tensor_list = []
- for _ in size_list:
- tensor_list.append(torch.empty((max_size,), dtype=torch.uint8, device="cuda"))
- if local_size != max_size:
- padding = torch.empty(size=(max_size - local_size,), dtype=torch.uint8, device="cuda")
- tensor = torch.cat((tensor, padding), dim=0)
- dist.all_gather(tensor_list, tensor)
-
- data_list = []
- for size, tensor in zip(size_list, tensor_list):
- buffer = tensor.cpu().numpy().tobytes()[:size]
- data_list.append(pickle.loads(buffer))
-
- return data_list
-
-
-def reduce_dict(input_dict, average=True):
- """
- Args:
- input_dict (dict): all the values will be reduced
- average (bool): whether to do average or sum
- Reduce the values in the dictionary from all processes so that all processes
- have the averaged results. Returns a dict with the same fields as
- input_dict, after reduction.
- """
- world_size = get_world_size()
- if world_size < 2:
- return input_dict
- with torch.no_grad():
- names = []
- values = []
- # sort the keys so that they are consistent across processes
- for k in sorted(input_dict.keys()):
- names.append(k)
- values.append(input_dict[k])
- values = torch.stack(values, dim=0)
- dist.all_reduce(values)
- if average:
- values /= world_size
- reduced_dict = {k: v for k, v in zip(names, values)}
- return reduced_dict
-
-
-class MetricLogger(object):
- def __init__(self, delimiter="\t"):
- self.meters = defaultdict(SmoothedValue)
- self.delimiter = delimiter
-
- def update(self, **kwargs):
- for k, v in kwargs.items():
- if isinstance(v, torch.Tensor):
- v = v.item()
- assert isinstance(v, (float, int))
- self.meters[k].update(v)
-
- def __getattr__(self, attr):
- if attr in self.meters:
- return self.meters[attr]
- if attr in self.__dict__:
- return self.__dict__[attr]
- raise AttributeError("'{}' object has no attribute '{}'".format(type(self).__name__, attr))
-
- def __str__(self):
- loss_str = []
- for name, meter in self.meters.items():
- # print(name, str(meter))
- # import ipdb;ipdb.set_trace()
- if meter.count > 0:
- loss_str.append("{}: {}".format(name, str(meter)))
- return self.delimiter.join(loss_str)
-
- def synchronize_between_processes(self):
- for meter in self.meters.values():
- meter.synchronize_between_processes()
-
- def add_meter(self, name, meter):
- self.meters[name] = meter
-
- def log_every(self, iterable, print_freq, header=None, logger=None):
- if logger is None:
- print_func = print
- else:
- print_func = logger.info
-
- i = 0
- if not header:
- header = ""
- start_time = time.time()
- end = time.time()
- iter_time = SmoothedValue(fmt="{avg:.4f}")
- data_time = SmoothedValue(fmt="{avg:.4f}")
- space_fmt = ":" + str(len(str(len(iterable)))) + "d"
- if torch.cuda.is_available():
- log_msg = self.delimiter.join(
- [
- header,
- "[{0" + space_fmt + "}/{1}]",
- "eta: {eta}",
- "{meters}",
- "time: {time}",
- "data: {data}",
- "max mem: {memory:.0f}",
- ]
- )
- else:
- log_msg = self.delimiter.join(
- [
- header,
- "[{0" + space_fmt + "}/{1}]",
- "eta: {eta}",
- "{meters}",
- "time: {time}",
- "data: {data}",
- ]
- )
- MB = 1024.0 * 1024.0
- for obj in iterable:
- data_time.update(time.time() - end)
- yield obj
- # import ipdb; ipdb.set_trace()
- iter_time.update(time.time() - end)
- if i % print_freq == 0 or i == len(iterable) - 1:
- eta_seconds = iter_time.global_avg * (len(iterable) - i)
- eta_string = str(datetime.timedelta(seconds=int(eta_seconds)))
- if torch.cuda.is_available():
- print_func(
- log_msg.format(
- i,
- len(iterable),
- eta=eta_string,
- meters=str(self),
- time=str(iter_time),
- data=str(data_time),
- memory=torch.cuda.max_memory_allocated() / MB,
- )
- )
- else:
- print_func(
- log_msg.format(
- i,
- len(iterable),
- eta=eta_string,
- meters=str(self),
- time=str(iter_time),
- data=str(data_time),
- )
- )
- i += 1
- end = time.time()
- total_time = time.time() - start_time
- total_time_str = str(datetime.timedelta(seconds=int(total_time)))
- print_func(
- "{} Total time: {} ({:.4f} s / it)".format(
- header, total_time_str, total_time / len(iterable)
- )
- )
-
-
-def get_sha():
- cwd = os.path.dirname(os.path.abspath(__file__))
-
- def _run(command):
- return subprocess.check_output(command, cwd=cwd).decode("ascii").strip()
-
- sha = "N/A"
- diff = "clean"
- branch = "N/A"
- try:
- sha = _run(["git", "rev-parse", "HEAD"])
- subprocess.check_output(["git", "diff"], cwd=cwd)
- diff = _run(["git", "diff-index", "HEAD"])
- diff = "has uncommited changes" if diff else "clean"
- branch = _run(["git", "rev-parse", "--abbrev-ref", "HEAD"])
- except Exception:
- pass
- message = f"sha: {sha}, status: {diff}, branch: {branch}"
- return message
-
-
-def collate_fn(batch):
- # import ipdb; ipdb.set_trace()
- batch = list(zip(*batch))
- batch[0] = nested_tensor_from_tensor_list(batch[0])
- return tuple(batch)
-
-
-def _max_by_axis(the_list):
- # type: (List[List[int]]) -> List[int]
- maxes = the_list[0]
- for sublist in the_list[1:]:
- for index, item in enumerate(sublist):
- maxes[index] = max(maxes[index], item)
- return maxes
-
-
-class NestedTensor(object):
- def __init__(self, tensors, mask: Optional[Tensor]):
- self.tensors = tensors
- self.mask = mask
- if mask == "auto":
- self.mask = torch.zeros_like(tensors).to(tensors.device)
- if self.mask.dim() == 3:
- self.mask = self.mask.sum(0).to(bool)
- elif self.mask.dim() == 4:
- self.mask = self.mask.sum(1).to(bool)
- else:
- raise ValueError(
- "tensors dim must be 3 or 4 but {}({})".format(
- self.tensors.dim(), self.tensors.shape
- )
- )
-
- def imgsize(self):
- res = []
- for i in range(self.tensors.shape[0]):
- mask = self.mask[i]
- maxH = (~mask).sum(0).max()
- maxW = (~mask).sum(1).max()
- res.append(torch.Tensor([maxH, maxW]))
- return res
-
- def to(self, device):
- # type: (Device) -> NestedTensor # noqa
- cast_tensor = self.tensors.to(device)
- mask = self.mask
- if mask is not None:
- assert mask is not None
- cast_mask = mask.to(device)
- else:
- cast_mask = None
- return NestedTensor(cast_tensor, cast_mask)
-
- def to_img_list_single(self, tensor, mask):
- assert tensor.dim() == 3, "dim of tensor should be 3 but {}".format(tensor.dim())
- maxH = (~mask).sum(0).max()
- maxW = (~mask).sum(1).max()
- img = tensor[:, :maxH, :maxW]
- return img
-
- def to_img_list(self):
- """remove the padding and convert to img list
-
- Returns:
- [type]: [description]
- """
- if self.tensors.dim() == 3:
- return self.to_img_list_single(self.tensors, self.mask)
- else:
- res = []
- for i in range(self.tensors.shape[0]):
- tensor_i = self.tensors[i]
- mask_i = self.mask[i]
- res.append(self.to_img_list_single(tensor_i, mask_i))
- return res
-
- @property
- def device(self):
- return self.tensors.device
-
- def decompose(self):
- return self.tensors, self.mask
-
- def __repr__(self):
- return str(self.tensors)
-
- @property
- def shape(self):
- return {"tensors.shape": self.tensors.shape, "mask.shape": self.mask.shape}
-
-
-def nested_tensor_from_tensor_list(tensor_list: List[Tensor]):
- # TODO make this more general
- if tensor_list[0].ndim == 3:
- if torchvision._is_tracing():
- # nested_tensor_from_tensor_list() does not export well to ONNX
- # call _onnx_nested_tensor_from_tensor_list() instead
- return _onnx_nested_tensor_from_tensor_list(tensor_list)
-
- # TODO make it support different-sized images
- max_size = _max_by_axis([list(img.shape) for img in tensor_list])
- # min_size = tuple(min(s) for s in zip(*[img.shape for img in tensor_list]))
- batch_shape = [len(tensor_list)] + max_size
- b, c, h, w = batch_shape
- dtype = tensor_list[0].dtype
- device = tensor_list[0].device
- tensor = torch.zeros(batch_shape, dtype=dtype, device=device)
- mask = torch.ones((b, h, w), dtype=torch.bool, device=device)
- for img, pad_img, m in zip(tensor_list, tensor, mask):
- pad_img[: img.shape[0], : img.shape[1], : img.shape[2]].copy_(img)
- m[: img.shape[1], : img.shape[2]] = False
- else:
- raise ValueError("not supported")
- return NestedTensor(tensor, mask)
-
-
-# _onnx_nested_tensor_from_tensor_list() is an implementation of
-# nested_tensor_from_tensor_list() that is supported by ONNX tracing.
-@torch.jit.unused
-def _onnx_nested_tensor_from_tensor_list(tensor_list: List[Tensor]) -> NestedTensor:
- max_size = []
- for i in range(tensor_list[0].dim()):
- max_size_i = torch.max(
- torch.stack([img.shape[i] for img in tensor_list]).to(torch.float32)
- ).to(torch.int64)
- max_size.append(max_size_i)
- max_size = tuple(max_size)
-
- # work around for
- # pad_img[: img.shape[0], : img.shape[1], : img.shape[2]].copy_(img)
- # m[: img.shape[1], :img.shape[2]] = False
- # which is not yet supported in onnx
- padded_imgs = []
- padded_masks = []
- for img in tensor_list:
- padding = [(s1 - s2) for s1, s2 in zip(max_size, tuple(img.shape))]
- padded_img = torch.nn.functional.pad(img, (0, padding[2], 0, padding[1], 0, padding[0]))
- padded_imgs.append(padded_img)
-
- m = torch.zeros_like(img[0], dtype=torch.int, device=img.device)
- padded_mask = torch.nn.functional.pad(m, (0, padding[2], 0, padding[1]), "constant", 1)
- padded_masks.append(padded_mask.to(torch.bool))
-
- tensor = torch.stack(padded_imgs)
- mask = torch.stack(padded_masks)
-
- return NestedTensor(tensor, mask=mask)
-
-
-def setup_for_distributed(is_master):
- """
- This function disables printing when not in master process
- """
- import builtins as __builtin__
-
- builtin_print = __builtin__.print
-
- def print(*args, **kwargs):
- force = kwargs.pop("force", False)
- if is_master or force:
- builtin_print(*args, **kwargs)
-
- __builtin__.print = print
-
-
-def is_dist_avail_and_initialized():
- if not dist.is_available():
- return False
- if not dist.is_initialized():
- return False
- return True
-
-
-def get_world_size():
- if not is_dist_avail_and_initialized():
- return 1
- return dist.get_world_size()
-
-
-def get_rank():
- if not is_dist_avail_and_initialized():
- return 0
- return dist.get_rank()
-
-
-def is_main_process():
- return get_rank() == 0
-
-
-def save_on_master(*args, **kwargs):
- if is_main_process():
- torch.save(*args, **kwargs)
-
-
-def init_distributed_mode(args):
- if "WORLD_SIZE" in os.environ and os.environ["WORLD_SIZE"] != "": # 'RANK' in os.environ and
- args.rank = int(os.environ["RANK"])
- args.world_size = int(os.environ["WORLD_SIZE"])
- args.gpu = args.local_rank = int(os.environ["LOCAL_RANK"])
-
- # launch by torch.distributed.launch
- # Single node
- # python -m torch.distributed.launch --nproc_per_node=8 main.py --world-size 1 --rank 0 ...
- # Multi nodes
- # python -m torch.distributed.launch --nproc_per_node=8 main.py --world-size 2 --rank 0 --dist-url 'tcp://IP_OF_NODE0:FREEPORT' ...
- # python -m torch.distributed.launch --nproc_per_node=8 main.py --world-size 2 --rank 1 --dist-url 'tcp://IP_OF_NODE0:FREEPORT' ...
- # args.rank = int(os.environ.get('OMPI_COMM_WORLD_RANK'))
- # local_world_size = int(os.environ['GPU_PER_NODE_COUNT'])
- # args.world_size = args.world_size * local_world_size
- # args.gpu = args.local_rank = int(os.environ['LOCAL_RANK'])
- # args.rank = args.rank * local_world_size + args.local_rank
- print(
- "world size: {}, rank: {}, local rank: {}".format(
- args.world_size, args.rank, args.local_rank
- )
- )
- print(json.dumps(dict(os.environ), indent=2))
- elif "SLURM_PROCID" in os.environ:
- args.rank = int(os.environ["SLURM_PROCID"])
- args.gpu = args.local_rank = int(os.environ["SLURM_LOCALID"])
- args.world_size = int(os.environ["SLURM_NPROCS"])
-
- print(
- "world size: {}, world rank: {}, local rank: {}, device_count: {}".format(
- args.world_size, args.rank, args.local_rank, torch.cuda.device_count()
- )
- )
- else:
- print("Not using distributed mode")
- args.distributed = False
- args.world_size = 1
- args.rank = 0
- args.local_rank = 0
- return
-
- print("world_size:{} rank:{} local_rank:{}".format(args.world_size, args.rank, args.local_rank))
- args.distributed = True
- torch.cuda.set_device(args.local_rank)
- args.dist_backend = "nccl"
- print("| distributed init (rank {}): {}".format(args.rank, args.dist_url), flush=True)
-
- torch.distributed.init_process_group(
- backend=args.dist_backend,
- world_size=args.world_size,
- rank=args.rank,
- init_method=args.dist_url,
- )
-
- print("Before torch.distributed.barrier()")
- torch.distributed.barrier()
- print("End torch.distributed.barrier()")
- setup_for_distributed(args.rank == 0)
-
-
-@torch.no_grad()
-def accuracy(output, target, topk=(1,)):
- """Computes the precision@k for the specified values of k"""
- if target.numel() == 0:
- return [torch.zeros([], device=output.device)]
- maxk = max(topk)
- batch_size = target.size(0)
-
- _, pred = output.topk(maxk, 1, True, True)
- pred = pred.t()
- correct = pred.eq(target.view(1, -1).expand_as(pred))
-
- res = []
- for k in topk:
- correct_k = correct[:k].view(-1).float().sum(0)
- res.append(correct_k.mul_(100.0 / batch_size))
- return res
-
-
-@torch.no_grad()
-def accuracy_onehot(pred, gt):
- """_summary_
-
- Args:
- pred (_type_): n, c
- gt (_type_): n, c
- """
- tp = ((pred - gt).abs().sum(-1) < 1e-4).float().sum()
- acc = tp / gt.shape[0] * 100
- return acc
-
-
-def interpolate(input, size=None, scale_factor=None, mode="nearest", align_corners=None):
- # type: (Tensor, Optional[List[int]], Optional[float], str, Optional[bool]) -> Tensor
- """
- Equivalent to nn.functional.interpolate, but with support for empty batch sizes.
- This will eventually be supported natively by PyTorch, and this
- class can go away.
- """
- if __torchvision_need_compat_flag < 0.7:
- if input.numel() > 0:
- return torch.nn.functional.interpolate(input, size, scale_factor, mode, align_corners)
-
- output_shape = _output_size(2, input, size, scale_factor)
- output_shape = list(input.shape[:-2]) + list(output_shape)
- return _new_empty_tensor(input, output_shape)
- else:
- return torchvision.ops.misc.interpolate(input, size, scale_factor, mode, align_corners)
-
-
-class color_sys:
- def __init__(self, num_colors) -> None:
- self.num_colors = num_colors
- colors = []
- for i in np.arange(0.0, 360.0, 360.0 / num_colors):
- hue = i / 360.0
- lightness = (50 + np.random.rand() * 10) / 100.0
- saturation = (90 + np.random.rand() * 10) / 100.0
- colors.append(
- tuple([int(j * 255) for j in colorsys.hls_to_rgb(hue, lightness, saturation)])
- )
- self.colors = colors
-
- def __call__(self, idx):
- return self.colors[idx]
-
-
-def inverse_sigmoid(x, eps=1e-3):
- x = x.clamp(min=0, max=1)
- x1 = x.clamp(min=eps)
- x2 = (1 - x).clamp(min=eps)
- return torch.log(x1 / x2)
-
-
-def clean_state_dict(state_dict):
- new_state_dict = OrderedDict()
- for k, v in state_dict.items():
- if k[:7] == "module.":
- k = k[7:] # remove `module.`
- new_state_dict[k] = v
- return new_state_dict
diff --git a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_internal/__init__.py b/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_internal/__init__.py
deleted file mode 100644
index 6afb5c627ce3db6e61cbf46276f7ddd42552eb28..0000000000000000000000000000000000000000
--- a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_internal/__init__.py
+++ /dev/null
@@ -1,19 +0,0 @@
-from typing import List, Optional
-
-import pip._internal.utils.inject_securetransport # noqa
-from pip._internal.utils import _log
-
-# init_logging() must be called before any call to logging.getLogger()
-# which happens at import of most modules.
-_log.init_logging()
-
-
-def main(args: (Optional[List[str]]) = None) -> int:
- """This is preserved for old console scripts that may still be referencing
- it.
-
- For additional details, see https://github.com/pypa/pip/issues/7498.
- """
- from pip._internal.utils.entrypoints import _wrapper
-
- return _wrapper(args)
diff --git a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/pygments/plugin.py b/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/pygments/plugin.py
deleted file mode 100644
index 3590bee8d29a7670d5c0e94c2a1c83c83670e766..0000000000000000000000000000000000000000
--- a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/pygments/plugin.py
+++ /dev/null
@@ -1,88 +0,0 @@
-"""
- pygments.plugin
- ~~~~~~~~~~~~~~~
-
- Pygments plugin interface. By default, this tries to use
- ``importlib.metadata``, which is in the Python standard
- library since Python 3.8, or its ``importlib_metadata``
- backport for earlier versions of Python. It falls back on
- ``pkg_resources`` if not found. Finally, if ``pkg_resources``
- is not found either, no plugins are loaded at all.
-
- lexer plugins::
-
- [pygments.lexers]
- yourlexer = yourmodule:YourLexer
-
- formatter plugins::
-
- [pygments.formatters]
- yourformatter = yourformatter:YourFormatter
- /.ext = yourformatter:YourFormatter
-
- As you can see, you can define extensions for the formatter
- with a leading slash.
-
- syntax plugins::
-
- [pygments.styles]
- yourstyle = yourstyle:YourStyle
-
- filter plugin::
-
- [pygments.filter]
- yourfilter = yourfilter:YourFilter
-
-
- :copyright: Copyright 2006-2022 by the Pygments team, see AUTHORS.
- :license: BSD, see LICENSE for details.
-"""
-
-LEXER_ENTRY_POINT = 'pygments.lexers'
-FORMATTER_ENTRY_POINT = 'pygments.formatters'
-STYLE_ENTRY_POINT = 'pygments.styles'
-FILTER_ENTRY_POINT = 'pygments.filters'
-
-
-def iter_entry_points(group_name):
- try:
- from importlib.metadata import entry_points
- except ImportError:
- try:
- from importlib_metadata import entry_points
- except ImportError:
- try:
- from pip._vendor.pkg_resources import iter_entry_points
- except (ImportError, OSError):
- return []
- else:
- return iter_entry_points(group_name)
- groups = entry_points()
- if hasattr(groups, 'select'):
- # New interface in Python 3.10 and newer versions of the
- # importlib_metadata backport.
- return groups.select(group=group_name)
- else:
- # Older interface, deprecated in Python 3.10 and recent
- # importlib_metadata, but we need it in Python 3.8 and 3.9.
- return groups.get(group_name, [])
-
-
-def find_plugin_lexers():
- for entrypoint in iter_entry_points(LEXER_ENTRY_POINT):
- yield entrypoint.load()
-
-
-def find_plugin_formatters():
- for entrypoint in iter_entry_points(FORMATTER_ENTRY_POINT):
- yield entrypoint.name, entrypoint.load()
-
-
-def find_plugin_styles():
- for entrypoint in iter_entry_points(STYLE_ENTRY_POINT):
- yield entrypoint.name, entrypoint.load()
-
-
-def find_plugin_filters():
- for entrypoint in iter_entry_points(FILTER_ENTRY_POINT):
- yield entrypoint.name, entrypoint.load()
diff --git a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/setuptools/command/register.py b/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/setuptools/command/register.py
deleted file mode 100644
index b8266b9a60f8c363ba35f7b73befd7c9c7cb4abc..0000000000000000000000000000000000000000
--- a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/setuptools/command/register.py
+++ /dev/null
@@ -1,18 +0,0 @@
-from distutils import log
-import distutils.command.register as orig
-
-from setuptools.errors import RemovedCommandError
-
-
-class register(orig.register):
- """Formerly used to register packages on PyPI."""
-
- def run(self):
- msg = (
- "The register command has been removed, use twine to upload "
- + "instead (https://pypi.org/p/twine)"
- )
-
- self.announce("ERROR: " + msg, log.ERROR)
-
- raise RemovedCommandError(msg)
diff --git a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/modeling/meta_arch/build.py b/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/modeling/meta_arch/build.py
deleted file mode 100644
index 3427215746c9a146bd902f22ea9b26d121c36b27..0000000000000000000000000000000000000000
--- a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/modeling/meta_arch/build.py
+++ /dev/null
@@ -1,25 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import torch
-
-from detectron2.utils.logger import _log_api_usage
-from detectron2.utils.registry import Registry
-
-META_ARCH_REGISTRY = Registry("META_ARCH") # noqa F401 isort:skip
-META_ARCH_REGISTRY.__doc__ = """
-Registry for meta-architectures, i.e. the whole model.
-
-The registered object will be called with `obj(cfg)`
-and expected to return a `nn.Module` object.
-"""
-
-
-def build_model(cfg):
- """
- Build the whole model architecture, defined by ``cfg.MODEL.META_ARCHITECTURE``.
- Note that it does not load any weights from ``cfg``.
- """
- meta_arch = cfg.MODEL.META_ARCHITECTURE
- model = META_ARCH_REGISTRY.get(meta_arch)(cfg)
- model.to(torch.device(cfg.MODEL.DEVICE))
- _log_api_usage("modeling.meta_arch." + meta_arch)
- return model
diff --git a/spaces/Benson/text-generation/Examples/Apk3163.md b/spaces/Benson/text-generation/Examples/Apk3163.md
deleted file mode 100644
index 98815c1b86b0053fcc500337e689588cb0674504..0000000000000000000000000000000000000000
--- a/spaces/Benson/text-generation/Examples/Apk3163.md
+++ /dev/null
@@ -1,84 +0,0 @@
-
-
¿Qué es APK3163 y por qué debería tomarlo?
-
Si usted está interesado en la nutrición deportiva y quiere aprender cómo optimizar su rendimiento y salud a través de la dieta y el ejercicio, entonces APK3163 es el curso para usted. APK3163 significa Fisiología Aplicada y Kinesiología 3163: Nutrición Deportiva. Es un curso en línea de 3 créditos ofrecido por la Universidad de Florida que aborda los aspectos de la nutrición que están relacionados con el rendimiento del ejercicio.
En este curso, aprenderá sobre los sistemas bioenergéticos, los componentes de la nutrición, las evaluaciones de la composición nutricional y corporal, las ayudas ergogénicas y las modificaciones de la dieta para las personas físicamente activas y los atletas. También aprenderás a aplicar este conocimiento a diferentes escenarios deportivos y de ejercicio.
-
El instructor de este curso es el Dr. Blain Harrison, quien tiene un Ph.D. en Fisiología Aplicada y Kinesiología de UF. También es entrenador deportivo y especialista en fuerza y acondicionamiento. Tiene una amplia experiencia en la enseñanza e investigación de temas de nutrición deportiva. Puede ponerse en contacto con él por correo electrónico a blaincharrison@ufl.edu o por teléfono al 352-294-1704. También tiene horario de oficina los lunes de 1-2 pm o con cita previa a través de Zoom.
-
Materiales y formato del curso
-
Todos los materiales necesarios para el curso se proporcionarán en la página Lienzo de APK3163. Estos materiales incluyen módulos de capítulos semanales escritos por el instructor y varios artículos de investigación de revistas de renombre. También necesitará acceso a una computadora con conexión a Internet y un navegador web que soporte Canvas.
-
-
El curso se imparte en línea a través de Canvas, que es el sistema de gestión de aprendizaje de UF. Accederá a todo el contenido del curso, tareas, exámenes, exámenes, calificaciones y herramientas de comunicación a través de Canvas. También participarás en discusiones en línea con tus compañeros de clase e instructor.
-
-
Evaluación y calificación del curso
-
Su calificación final para este curso se basará en su desempeño en exámenes (20%), tareas (30%), exámenes (40%) y discusiones (10%). Usted tendrá que anotar al menos 60% para pasar este curso.
-
Habrá dos exámenes (mitad y final) que pondrán a prueba tu conocimiento del material del curso. Cada examen constará de preguntas de opción múltiple que cubren todos los temas de los módulos. Tendrá dos horas para completar cada examen en línea a través de Canvas. Los exámenes estarán disponibles durante 24 horas el día del examen asignado.
-
Habrá 14 cuestionarios que evaluarán su comprensión de las lecturas y videos de cada módulo. Cada examen tendrá 10 preguntas de opción múltiple y tendrá 15 minutos para completarlo en línea a través de Canvas. Los cuestionarios estarán disponibles durante una semana después del lanzamiento del módulo.
-
Habrá 7 tareas que requerirán que aplique sus conocimientos de nutrición deportiva a situaciones de la vida real. Cada tarea tendrá un formato e instrucciones diferentes, tales como estudios de caso, análisis dietético, planificación de menús, etc. Usted enviará sus tareas en línea a través de Canvas antes de la fecha de vencimiento asignada.
-
Habrá 14 discusiones que te permitirán interactuar con tus compañeros de clase e instructor sobre diversos temas relacionados con la nutrición deportiva. Cada discusión tendrá un aviso que necesita responder en un mínimo de 250 palabras. También es necesario responder a al menos dos de los mensajes de sus compañeros de clase en un mínimo de 100 palabras cada uno. Publicarás tus respuestas en línea a través de Canvas en la fecha de vencimiento asignada.
-
Se espera que usted siga las políticas de UF sobre asistencia, trabajo tardío, honestidad académica y conducta estudiantil. Usted es responsable de revisar Canvas regularmente para actualizaciones de cursos, anuncios y comentarios. También se le anima a comunicarse con su instructor y compañeros de clase a través de Canvas o correo electrónico si tiene alguna pregunta o inquietud.
-
-
Los principales temas tratados en este curso son:
-
-
Sistemas bioenergéticos y balance energético
-
Carbohidratos, grasas, proteínas y agua
-
Vitaminas, minerales y antioxidantes
-
Evaluaciones de la composición nutricional y corporal
-
Ayudas y suplementos ergogénicos
-
Modificaciones de la dieta para la resistencia, la fuerza, la potencia y los deportes de equipo
-
Nutrición para poblaciones y condiciones especiales
-
-
Los resultados de aprendizaje para cada tema son:
-
-
Explicar el papel de los sistemas bioenergéticos y el equilibrio energético en el rendimiento del ejercicio y la salud.
-
Describir las funciones, fuentes, requerimientos, metabolismo y almacenamiento de carbohidratos, grasas, proteínas y agua.
-
Identificar las funciones, fuentes, requerimientos, deficiencias, toxicidades e interacciones de vitaminas, minerales y antioxidantes.
-
Realizar e interpretar evaluaciones nutricionales y de composición corporal utilizando diversos métodos y herramientas.
-
Evaluar la eficacia, seguridad, legalidad y cuestiones éticas de los suplementos y ayudas ergogénicas.
-
Diseñar e implementar modificaciones en la dieta para diferentes tipos de actividades deportivas y de ejercicio.
-
Aplicar principios de nutrición a poblaciones y condiciones especiales como niños, adultos mayores, vegetarianos, embarazo, diabetes, etc.
-
-
La programación tentativa del curso se muestra en la siguiente tabla:
-
-
Semana
Módulo
Tema
Lecturas
Tareas
-
1
1
Sistemas bioenergéticos y balance energético
Capítulo 1 & Artículo 1
Prueba 1 & Discusión 1
-
2
2
Carbohidratos
Capítulo 2 & Artículo 2
Examen 2 & Discusión 2 & Asignación 1
-
3
3
Fats
Capítulo 3 & Artículo 3
Quiz 3 & Discusión 3 & Asignación 2
-
-
5
5
Vitaminas
Capítulo 5 & Artículo 5
Examen 5 & Discusión 5 & Examen de mitad de período
-
6
6
Minerales
Capítulo 6 & Artículo 6
Examen 6 & Discusión 6 & Asignación 4
-
7
7
Antioxidantes
Capítulo 7 & Artículo 7
8
<8
Capítulo 8 & Artículo
<>
<>Quiz 8 & Asignación/ 6
-
9
9
Evaluaciones de la composición nutricional y corporal
Capítulo 9 & Artículo 9
Examen 9 & Discusión 9 & Asignación 7
-
10
10
Ayudas y suplementos ergogénicos
Capítulo 10 & Artículo 10
Prueba 10 & Discusión 10
-
11
11
Modificaciones de la dieta para deportes de resistencia
Capítulo 11 & Artículo 11
Examen 11 & Discusión 11
-
12
12
Modificaciones de la dieta para deportes de fuerza y potencia
Capítulo 12 & Artículo 12
Prueba 12 & Discusión 12
-
13
13
Modificaciones de la dieta para deportes de equipo
Capítulo 13 & Artículo 13
-
14
14
Nutrición para poblaciones y condiciones especiales
Capítulo 14 & Artículo 14
Prueba 14 & Discusión 14
-
-
Conclusión
-
APK3163 es un curso valioso que le enseñará los fundamentos de la nutrición deportiva y cómo aplicarlos a su propio rendimiento de ejercicio y la salud de otros. Aprenderás de un instructor experto que te guiará a través del contenido del curso y las actividades. También interactuará con sus compañeros que comparten su interés en la nutrición deportiva. Al final de este curso, tendrá una sólida comprensión del papel de la nutrición en la fisiología del ejercicio y la kinesiología.
-
-
APK3163 es un curso divertido y atractivo que te hará disfrutar aprendiendo sobre nutrición deportiva. Descubrirá nuevos hechos, conceptos y estrategias que despertarán su curiosidad e interés. También participarás en varias actividades que desafiarán tu pensamiento crítico y tus habilidades para resolver problemas. Usted encontrará APK3163 para ser una experiencia de aprendizaje gratificante y agradable.
-
Preguntas frecuentes
-
Aquí hay algunas preguntas frecuentes sobre APK3163:
-
-
¿Cómo me registro para APK3163?
-
Puede registrarse para APK3163 a través del portal ONE.UF de UF. Necesita tener los requisitos previos de APK2100C o APK2105C o PET3322C o equivalente con calificaciones mínimas de C.
-
¿Cuánto cuesta APK3163?
-
La cuota de matrícula para APK3163 es de $212.71 por hora de crédito para los residentes de la Florida y $955.86 por hora de crédito para los residentes no Florida. Puede haber cargos adicionales para los cursos en línea.
-
¿Cómo accedo a APK3163 en línea?
-
Puede acceder a APK3163 en línea a través de Canvas, que es el sistema de gestión de aprendizaje de UF. Necesitas tener una cuenta de GatorLink y una contraseña para iniciar sesión en Canvas. También necesitas tener acceso a una computadora con conexión a Internet y un navegador web que soporte Canvas.
-
¿Cómo puedo contactar al instructor de APK3163?
-
Puede ponerse en contacto con el instructor de APK3163 por correo electrónico a blaincharrison@ufl.edu o por teléfono al 352-294-1704. También tiene horario de oficina los lunes de 1-2 pm o con cita previa a través de Zoom.
-
¿Cómo puedo obtener ayuda con APK3163?
-
Puede obtener ayuda con APK3163 utilizando los siguientes recursos:
-
-
El instructor: Puede hacer preguntas o buscar aclaraciones del instructor por correo electrónico, teléfono, Zoom o Canvas.
-
Los compañeros de clase: Puede interactuar con sus compañeros de clase a través de discusiones en Canvas o correo electrónico.
-
-
Las bibliotecas UF: Puede acceder a bases de datos, revistas, libros y otros recursos en línea a través del sitio web de las bibliotecas UF.
-
El estudio de escritura UF: Puede obtener comentarios y orientación sobre sus tareas de escritura a través del sitio web del estudio de escritura UF.
-
- 64aa2da5cf
-
-
\ No newline at end of file
diff --git a/spaces/BigSalmon/GPTJ/README.md b/spaces/BigSalmon/GPTJ/README.md
deleted file mode 100644
index 9810d98673660a6c2808164f3be3b52a3cdb063c..0000000000000000000000000000000000000000
--- a/spaces/BigSalmon/GPTJ/README.md
+++ /dev/null
@@ -1,37 +0,0 @@
----
-title: GPTJ
-emoji: 🦀
-colorFrom: indigo
-colorTo: pink
-sdk: gradio
-app_file: app.py
-pinned: false
----
-
-# Configuration
-
-`title`: _string_
-Display title for the Space
-
-`emoji`: _string_
-Space emoji (emoji-only character allowed)
-
-`colorFrom`: _string_
-Color for Thumbnail gradient (red, yellow, green, blue, indigo, purple, pink, gray)
-
-`colorTo`: _string_
-Color for Thumbnail gradient (red, yellow, green, blue, indigo, purple, pink, gray)
-
-`sdk`: _string_
-Can be either `gradio` or `streamlit`
-
-`sdk_version` : _string_
-Only applicable for `streamlit` SDK.
-See [doc](https://hf.co/docs/hub/spaces) for more info on supported versions.
-
-`app_file`: _string_
-Path to your main application file (which contains either `gradio` or `streamlit` Python code).
-Path is relative to the root of the repository.
-
-`pinned`: _boolean_
-Whether the Space stays on top of your list.
diff --git a/spaces/CForGETaass/vits-uma-genshin-honkai/text/__init__.py b/spaces/CForGETaass/vits-uma-genshin-honkai/text/__init__.py
deleted file mode 100644
index 663c4b6416affb53c9dc56dddbc8b2b65d4bf518..0000000000000000000000000000000000000000
--- a/spaces/CForGETaass/vits-uma-genshin-honkai/text/__init__.py
+++ /dev/null
@@ -1,57 +0,0 @@
-""" from https://github.com/keithito/tacotron """
-from text import cleaners
-from text.symbols import symbols
-
-
-# Mappings from symbol to numeric ID and vice versa:
-_symbol_to_id = {s: i for i, s in enumerate(symbols)}
-_id_to_symbol = {i: s for i, s in enumerate(symbols)}
-
-
-def text_to_sequence(text, symbols, cleaner_names):
- '''Converts a string of text to a sequence of IDs corresponding to the symbols in the text.
- Args:
- text: string to convert to a sequence
- cleaner_names: names of the cleaner functions to run the text through
- Returns:
- List of integers corresponding to the symbols in the text
- '''
- _symbol_to_id = {s: i for i, s in enumerate(symbols)}
- sequence = []
-
- clean_text = _clean_text(text, cleaner_names)
- for symbol in clean_text:
- if symbol not in _symbol_to_id.keys():
- continue
- symbol_id = _symbol_to_id[symbol]
- sequence += [symbol_id]
- return sequence, clean_text
-
-
-def cleaned_text_to_sequence(cleaned_text):
- '''Converts a string of text to a sequence of IDs corresponding to the symbols in the text.
- Args:
- text: string to convert to a sequence
- Returns:
- List of integers corresponding to the symbols in the text
- '''
- sequence = [_symbol_to_id[symbol] for symbol in cleaned_text if symbol in _symbol_to_id.keys()]
- return sequence
-
-
-def sequence_to_text(sequence):
- '''Converts a sequence of IDs back to a string'''
- result = ''
- for symbol_id in sequence:
- s = _id_to_symbol[symbol_id]
- result += s
- return result
-
-
-def _clean_text(text, cleaner_names):
- for name in cleaner_names:
- cleaner = getattr(cleaners, name)
- if not cleaner:
- raise Exception('Unknown cleaner: %s' % name)
- text = cleaner(text)
- return text
diff --git a/spaces/CVH-vn1210/make_hair/minigpt4/common/utils.py b/spaces/CVH-vn1210/make_hair/minigpt4/common/utils.py
deleted file mode 100644
index d536eac1d32b35ad9e97abb29895120d850aacaf..0000000000000000000000000000000000000000
--- a/spaces/CVH-vn1210/make_hair/minigpt4/common/utils.py
+++ /dev/null
@@ -1,424 +0,0 @@
-"""
- Copyright (c) 2022, salesforce.com, inc.
- All rights reserved.
- SPDX-License-Identifier: BSD-3-Clause
- For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
-"""
-
-import io
-import json
-import logging
-import os
-import pickle
-import re
-import shutil
-import urllib
-import urllib.error
-import urllib.request
-from typing import Optional
-from urllib.parse import urlparse
-
-import numpy as np
-import pandas as pd
-import yaml
-from iopath.common.download import download
-from iopath.common.file_io import file_lock, g_pathmgr
-from minigpt4.common.registry import registry
-from torch.utils.model_zoo import tqdm
-from torchvision.datasets.utils import (
- check_integrity,
- download_file_from_google_drive,
- extract_archive,
-)
-
-
-def now():
- from datetime import datetime
-
- return datetime.now().strftime("%Y%m%d%H%M")[:-1]
-
-
-def is_url(url_or_filename):
- parsed = urlparse(url_or_filename)
- return parsed.scheme in ("http", "https")
-
-
-def get_cache_path(rel_path):
- return os.path.expanduser(os.path.join(registry.get_path("cache_root"), rel_path))
-
-
-def get_abs_path(rel_path):
- return os.path.join(registry.get_path("library_root"), rel_path)
-
-
-def load_json(filename):
- with open(filename, "r") as f:
- return json.load(f)
-
-
-# The following are adapted from torchvision and vissl
-# torchvision: https://github.com/pytorch/vision
-# vissl: https://github.com/facebookresearch/vissl/blob/main/vissl/utils/download.py
-
-
-def makedir(dir_path):
- """
- Create the directory if it does not exist.
- """
- is_success = False
- try:
- if not g_pathmgr.exists(dir_path):
- g_pathmgr.mkdirs(dir_path)
- is_success = True
- except BaseException:
- print(f"Error creating directory: {dir_path}")
- return is_success
-
-
-def get_redirected_url(url: str):
- """
- Given a URL, returns the URL it redirects to or the
- original URL in case of no indirection
- """
- import requests
-
- with requests.Session() as session:
- with session.get(url, stream=True, allow_redirects=True) as response:
- if response.history:
- return response.url
- else:
- return url
-
-
-def to_google_drive_download_url(view_url: str) -> str:
- """
- Utility function to transform a view URL of google drive
- to a download URL for google drive
- Example input:
- https://drive.google.com/file/d/137RyRjvTBkBiIfeYBNZBtViDHQ6_Ewsp/view
- Example output:
- https://drive.google.com/uc?export=download&id=137RyRjvTBkBiIfeYBNZBtViDHQ6_Ewsp
- """
- splits = view_url.split("/")
- assert splits[-1] == "view"
- file_id = splits[-2]
- return f"https://drive.google.com/uc?export=download&id={file_id}"
-
-
-def download_google_drive_url(url: str, output_path: str, output_file_name: str):
- """
- Download a file from google drive
- Downloading an URL from google drive requires confirmation when
- the file of the size is too big (google drive notifies that
- anti-viral checks cannot be performed on such files)
- """
- import requests
-
- with requests.Session() as session:
-
- # First get the confirmation token and append it to the URL
- with session.get(url, stream=True, allow_redirects=True) as response:
- for k, v in response.cookies.items():
- if k.startswith("download_warning"):
- url = url + "&confirm=" + v
-
- # Then download the content of the file
- with session.get(url, stream=True, verify=True) as response:
- makedir(output_path)
- path = os.path.join(output_path, output_file_name)
- total_size = int(response.headers.get("Content-length", 0))
- with open(path, "wb") as file:
- from tqdm import tqdm
-
- with tqdm(total=total_size) as progress_bar:
- for block in response.iter_content(
- chunk_size=io.DEFAULT_BUFFER_SIZE
- ):
- file.write(block)
- progress_bar.update(len(block))
-
-
-def _get_google_drive_file_id(url: str) -> Optional[str]:
- parts = urlparse(url)
-
- if re.match(r"(drive|docs)[.]google[.]com", parts.netloc) is None:
- return None
-
- match = re.match(r"/file/d/(?P[^/]*)", parts.path)
- if match is None:
- return None
-
- return match.group("id")
-
-
-def _urlretrieve(url: str, filename: str, chunk_size: int = 1024) -> None:
- with open(filename, "wb") as fh:
- with urllib.request.urlopen(
- urllib.request.Request(url, headers={"User-Agent": "vissl"})
- ) as response:
- with tqdm(total=response.length) as pbar:
- for chunk in iter(lambda: response.read(chunk_size), ""):
- if not chunk:
- break
- pbar.update(chunk_size)
- fh.write(chunk)
-
-
-def download_url(
- url: str,
- root: str,
- filename: Optional[str] = None,
- md5: Optional[str] = None,
-) -> None:
- """Download a file from a url and place it in root.
- Args:
- url (str): URL to download file from
- root (str): Directory to place downloaded file in
- filename (str, optional): Name to save the file under.
- If None, use the basename of the URL.
- md5 (str, optional): MD5 checksum of the download. If None, do not check
- """
- root = os.path.expanduser(root)
- if not filename:
- filename = os.path.basename(url)
- fpath = os.path.join(root, filename)
-
- makedir(root)
-
- # check if file is already present locally
- if check_integrity(fpath, md5):
- print("Using downloaded and verified file: " + fpath)
- return
-
- # expand redirect chain if needed
- url = get_redirected_url(url)
-
- # check if file is located on Google Drive
- file_id = _get_google_drive_file_id(url)
- if file_id is not None:
- return download_file_from_google_drive(file_id, root, filename, md5)
-
- # download the file
- try:
- print("Downloading " + url + " to " + fpath)
- _urlretrieve(url, fpath)
- except (urllib.error.URLError, IOError) as e: # type: ignore[attr-defined]
- if url[:5] == "https":
- url = url.replace("https:", "http:")
- print(
- "Failed download. Trying https -> http instead."
- " Downloading " + url + " to " + fpath
- )
- _urlretrieve(url, fpath)
- else:
- raise e
-
- # check integrity of downloaded file
- if not check_integrity(fpath, md5):
- raise RuntimeError("File not found or corrupted.")
-
-
-def download_and_extract_archive(
- url: str,
- download_root: str,
- extract_root: Optional[str] = None,
- filename: Optional[str] = None,
- md5: Optional[str] = None,
- remove_finished: bool = False,
-) -> None:
- download_root = os.path.expanduser(download_root)
- if extract_root is None:
- extract_root = download_root
- if not filename:
- filename = os.path.basename(url)
-
- download_url(url, download_root, filename, md5)
-
- archive = os.path.join(download_root, filename)
- print("Extracting {} to {}".format(archive, extract_root))
- extract_archive(archive, extract_root, remove_finished)
-
-
-def cache_url(url: str, cache_dir: str) -> str:
- """
- This implementation downloads the remote resource and caches it locally.
- The resource will only be downloaded if not previously requested.
- """
- parsed_url = urlparse(url)
- dirname = os.path.join(cache_dir, os.path.dirname(parsed_url.path.lstrip("/")))
- makedir(dirname)
- filename = url.split("/")[-1]
- cached = os.path.join(dirname, filename)
- with file_lock(cached):
- if not os.path.isfile(cached):
- logging.info(f"Downloading {url} to {cached} ...")
- cached = download(url, dirname, filename=filename)
- logging.info(f"URL {url} cached in {cached}")
- return cached
-
-
-# TODO (prigoyal): convert this into RAII-style API
-def create_file_symlink(file1, file2):
- """
- Simply create the symlinks for a given file1 to file2.
- Useful during model checkpointing to symlinks to the
- latest successful checkpoint.
- """
- try:
- if g_pathmgr.exists(file2):
- g_pathmgr.rm(file2)
- g_pathmgr.symlink(file1, file2)
- except Exception as e:
- logging.info(f"Could NOT create symlink. Error: {e}")
-
-
-def save_file(data, filename, append_to_json=True, verbose=True):
- """
- Common i/o utility to handle saving data to various file formats.
- Supported:
- .pkl, .pickle, .npy, .json
- Specifically for .json, users have the option to either append (default)
- or rewrite by passing in Boolean value to append_to_json.
- """
- if verbose:
- logging.info(f"Saving data to file: {filename}")
- file_ext = os.path.splitext(filename)[1]
- if file_ext in [".pkl", ".pickle"]:
- with g_pathmgr.open(filename, "wb") as fopen:
- pickle.dump(data, fopen, pickle.HIGHEST_PROTOCOL)
- elif file_ext == ".npy":
- with g_pathmgr.open(filename, "wb") as fopen:
- np.save(fopen, data)
- elif file_ext == ".json":
- if append_to_json:
- with g_pathmgr.open(filename, "a") as fopen:
- fopen.write(json.dumps(data, sort_keys=True) + "\n")
- fopen.flush()
- else:
- with g_pathmgr.open(filename, "w") as fopen:
- fopen.write(json.dumps(data, sort_keys=True) + "\n")
- fopen.flush()
- elif file_ext == ".yaml":
- with g_pathmgr.open(filename, "w") as fopen:
- dump = yaml.dump(data)
- fopen.write(dump)
- fopen.flush()
- else:
- raise Exception(f"Saving {file_ext} is not supported yet")
-
- if verbose:
- logging.info(f"Saved data to file: {filename}")
-
-
-def load_file(filename, mmap_mode=None, verbose=True, allow_pickle=False):
- """
- Common i/o utility to handle loading data from various file formats.
- Supported:
- .pkl, .pickle, .npy, .json
- For the npy files, we support reading the files in mmap_mode.
- If the mmap_mode of reading is not successful, we load data without the
- mmap_mode.
- """
- if verbose:
- logging.info(f"Loading data from file: {filename}")
-
- file_ext = os.path.splitext(filename)[1]
- if file_ext == ".txt":
- with g_pathmgr.open(filename, "r") as fopen:
- data = fopen.readlines()
- elif file_ext in [".pkl", ".pickle"]:
- with g_pathmgr.open(filename, "rb") as fopen:
- data = pickle.load(fopen, encoding="latin1")
- elif file_ext == ".npy":
- if mmap_mode:
- try:
- with g_pathmgr.open(filename, "rb") as fopen:
- data = np.load(
- fopen,
- allow_pickle=allow_pickle,
- encoding="latin1",
- mmap_mode=mmap_mode,
- )
- except ValueError as e:
- logging.info(
- f"Could not mmap {filename}: {e}. Trying without g_pathmgr"
- )
- data = np.load(
- filename,
- allow_pickle=allow_pickle,
- encoding="latin1",
- mmap_mode=mmap_mode,
- )
- logging.info("Successfully loaded without g_pathmgr")
- except Exception:
- logging.info("Could not mmap without g_pathmgr. Trying without mmap")
- with g_pathmgr.open(filename, "rb") as fopen:
- data = np.load(fopen, allow_pickle=allow_pickle, encoding="latin1")
- else:
- with g_pathmgr.open(filename, "rb") as fopen:
- data = np.load(fopen, allow_pickle=allow_pickle, encoding="latin1")
- elif file_ext == ".json":
- with g_pathmgr.open(filename, "r") as fopen:
- data = json.load(fopen)
- elif file_ext == ".yaml":
- with g_pathmgr.open(filename, "r") as fopen:
- data = yaml.load(fopen, Loader=yaml.FullLoader)
- elif file_ext == ".csv":
- with g_pathmgr.open(filename, "r") as fopen:
- data = pd.read_csv(fopen)
- else:
- raise Exception(f"Reading from {file_ext} is not supported yet")
- return data
-
-
-def abspath(resource_path: str):
- """
- Make a path absolute, but take into account prefixes like
- "http://" or "manifold://"
- """
- regex = re.compile(r"^\w+://")
- if regex.match(resource_path) is None:
- return os.path.abspath(resource_path)
- else:
- return resource_path
-
-
-def makedir(dir_path):
- """
- Create the directory if it does not exist.
- """
- is_success = False
- try:
- if not g_pathmgr.exists(dir_path):
- g_pathmgr.mkdirs(dir_path)
- is_success = True
- except BaseException:
- logging.info(f"Error creating directory: {dir_path}")
- return is_success
-
-
-def is_url(input_url):
- """
- Check if an input string is a url. look for http(s):// and ignoring the case
- """
- is_url = re.match(r"^(?:http)s?://", input_url, re.IGNORECASE) is not None
- return is_url
-
-
-def cleanup_dir(dir):
- """
- Utility for deleting a directory. Useful for cleaning the storage space
- that contains various training artifacts like checkpoints, data etc.
- """
- if os.path.exists(dir):
- logging.info(f"Deleting directory: {dir}")
- shutil.rmtree(dir)
- logging.info(f"Deleted contents of directory: {dir}")
-
-
-def get_file_size(filename):
- """
- Given a file, get the size of file in MB
- """
- size_in_mb = os.path.getsize(filename) / float(1024**2)
- return size_in_mb
diff --git a/spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/detectron2/data/transforms/transform_gen.py b/spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/detectron2/data/transforms/transform_gen.py
deleted file mode 100644
index d2df19249661c2df397f5a7ef787ec1bc86f01fc..0000000000000000000000000000000000000000
--- a/spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/detectron2/data/transforms/transform_gen.py
+++ /dev/null
@@ -1,447 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-# File: transformer.py
-
-import inspect
-import numpy as np
-import pprint
-import sys
-from abc import ABCMeta, abstractmethod
-from fvcore.transforms.transform import (
- BlendTransform,
- CropTransform,
- HFlipTransform,
- NoOpTransform,
- Transform,
- TransformList,
- VFlipTransform,
-)
-from PIL import Image
-
-from .transform import ExtentTransform, ResizeTransform
-
-__all__ = [
- "RandomBrightness",
- "RandomContrast",
- "RandomCrop",
- "RandomExtent",
- "RandomFlip",
- "RandomSaturation",
- "RandomLighting",
- "Resize",
- "ResizeShortestEdge",
- "TransformGen",
- "apply_transform_gens",
-]
-
-
-def check_dtype(img):
- assert isinstance(img, np.ndarray), "[TransformGen] Needs an numpy array, but got a {}!".format(
- type(img)
- )
- assert not isinstance(img.dtype, np.integer) or (
- img.dtype == np.uint8
- ), "[TransformGen] Got image of type {}, use uint8 or floating points instead!".format(
- img.dtype
- )
- assert img.ndim in [2, 3], img.ndim
-
-
-class TransformGen(metaclass=ABCMeta):
- """
- TransformGen takes an image of type uint8 in range [0, 255], or
- floating point in range [0, 1] or [0, 255] as input.
-
- It creates a :class:`Transform` based on the given image, sometimes with randomness.
- The transform can then be used to transform images
- or other data (boxes, points, annotations, etc.) associated with it.
-
- The assumption made in this class
- is that the image itself is sufficient to instantiate a transform.
- When this assumption is not true, you need to create the transforms by your own.
-
- A list of `TransformGen` can be applied with :func:`apply_transform_gens`.
- """
-
- def _init(self, params=None):
- if params:
- for k, v in params.items():
- if k != "self" and not k.startswith("_"):
- setattr(self, k, v)
-
- @abstractmethod
- def get_transform(self, img):
- pass
-
- def _rand_range(self, low=1.0, high=None, size=None):
- """
- Uniform float random number between low and high.
- """
- if high is None:
- low, high = 0, low
- if size is None:
- size = []
- return np.random.uniform(low, high, size)
-
- def __repr__(self):
- """
- Produce something like:
- "MyTransformGen(field1={self.field1}, field2={self.field2})"
- """
- try:
- sig = inspect.signature(self.__init__)
- classname = type(self).__name__
- argstr = []
- for name, param in sig.parameters.items():
- assert (
- param.kind != param.VAR_POSITIONAL and param.kind != param.VAR_KEYWORD
- ), "The default __repr__ doesn't support *args or **kwargs"
- assert hasattr(self, name), (
- "Attribute {} not found! "
- "Default __repr__ only works if attributes match the constructor.".format(name)
- )
- attr = getattr(self, name)
- default = param.default
- if default is attr:
- continue
- argstr.append("{}={}".format(name, pprint.pformat(attr)))
- return "{}({})".format(classname, ", ".join(argstr))
- except AssertionError:
- return super().__repr__()
-
- __str__ = __repr__
-
-
-class RandomFlip(TransformGen):
- """
- Flip the image horizontally or vertically with the given probability.
- """
-
- def __init__(self, prob=0.5, *, horizontal=True, vertical=False):
- """
- Args:
- prob (float): probability of flip.
- horizontal (boolean): whether to apply horizontal flipping
- vertical (boolean): whether to apply vertical flipping
- """
- super().__init__()
-
- if horizontal and vertical:
- raise ValueError("Cannot do both horiz and vert. Please use two Flip instead.")
- if not horizontal and not vertical:
- raise ValueError("At least one of horiz or vert has to be True!")
- self._init(locals())
-
- def get_transform(self, img):
- h, w = img.shape[:2]
- do = self._rand_range() < self.prob
- if do:
- if self.horizontal:
- return HFlipTransform(w)
- elif self.vertical:
- return VFlipTransform(h)
- else:
- return NoOpTransform()
-
-
-class Resize(TransformGen):
- """ Resize image to a target size"""
-
- def __init__(self, shape, interp=Image.BILINEAR):
- """
- Args:
- shape: (h, w) tuple or a int
- interp: PIL interpolation method
- """
- if isinstance(shape, int):
- shape = (shape, shape)
- shape = tuple(shape)
- self._init(locals())
-
- def get_transform(self, img):
- return ResizeTransform(
- img.shape[0], img.shape[1], self.shape[0], self.shape[1], self.interp
- )
-
-
-class ResizeShortestEdge(TransformGen):
- """
- Scale the shorter edge to the given size, with a limit of `max_size` on the longer edge.
- If `max_size` is reached, then downscale so that the longer edge does not exceed max_size.
- """
-
- def __init__(
- self, short_edge_length, max_size=sys.maxsize, sample_style="range", interp=Image.BILINEAR
- ):
- """
- Args:
- short_edge_length (list[int]): If ``sample_style=="range"``,
- a [min, max] interval from which to sample the shortest edge length.
- If ``sample_style=="choice"``, a list of shortest edge lengths to sample from.
- max_size (int): maximum allowed longest edge length.
- sample_style (str): either "range" or "choice".
- """
- super().__init__()
- assert sample_style in ["range", "choice"], sample_style
-
- self.is_range = sample_style == "range"
- if isinstance(short_edge_length, int):
- short_edge_length = (short_edge_length, short_edge_length)
- self._init(locals())
-
- def get_transform(self, img):
- h, w = img.shape[:2]
-
- if self.is_range:
- size = np.random.randint(self.short_edge_length[0], self.short_edge_length[1] + 1)
- else:
- size = np.random.choice(self.short_edge_length)
- if size == 0:
- return NoOpTransform()
-
- scale = size * 1.0 / min(h, w)
- if h < w:
- newh, neww = size, scale * w
- else:
- newh, neww = scale * h, size
- if max(newh, neww) > self.max_size:
- scale = self.max_size * 1.0 / max(newh, neww)
- newh = newh * scale
- neww = neww * scale
- neww = int(neww + 0.5)
- newh = int(newh + 0.5)
- return ResizeTransform(h, w, newh, neww, self.interp)
-
-
-class RandomCrop(TransformGen):
- """
- Randomly crop a subimage out of an image.
- """
-
- def __init__(self, crop_type: str, crop_size):
- """
- Args:
- crop_type (str): one of "relative_range", "relative", "absolute".
- See `config/defaults.py` for explanation.
- crop_size (tuple[float]): the relative ratio or absolute pixels of
- height and width
- """
- super().__init__()
- assert crop_type in ["relative_range", "relative", "absolute"]
- self._init(locals())
-
- def get_transform(self, img):
- h, w = img.shape[:2]
- croph, cropw = self.get_crop_size((h, w))
- assert h >= croph and w >= cropw, "Shape computation in {} has bugs.".format(self)
- h0 = np.random.randint(h - croph + 1)
- w0 = np.random.randint(w - cropw + 1)
- return CropTransform(w0, h0, cropw, croph)
-
- def get_crop_size(self, image_size):
- """
- Args:
- image_size (tuple): height, width
-
- Returns:
- crop_size (tuple): height, width in absolute pixels
- """
- h, w = image_size
- if self.crop_type == "relative":
- ch, cw = self.crop_size
- return int(h * ch + 0.5), int(w * cw + 0.5)
- elif self.crop_type == "relative_range":
- crop_size = np.asarray(self.crop_size, dtype=np.float32)
- ch, cw = crop_size + np.random.rand(2) * (1 - crop_size)
- return int(h * ch + 0.5), int(w * cw + 0.5)
- elif self.crop_type == "absolute":
- return self.crop_size
- else:
- NotImplementedError("Unknown crop type {}".format(self.crop_type))
-
-
-class RandomExtent(TransformGen):
- """
- Outputs an image by cropping a random "subrect" of the source image.
-
- The subrect can be parameterized to include pixels outside the source image,
- in which case they will be set to zeros (i.e. black). The size of the output
- image will vary with the size of the random subrect.
- """
-
- def __init__(self, scale_range, shift_range):
- """
- Args:
- output_size (h, w): Dimensions of output image
- scale_range (l, h): Range of input-to-output size scaling factor
- shift_range (x, y): Range of shifts of the cropped subrect. The rect
- is shifted by [w / 2 * Uniform(-x, x), h / 2 * Uniform(-y, y)],
- where (w, h) is the (width, height) of the input image. Set each
- component to zero to crop at the image's center.
- """
- super().__init__()
- self._init(locals())
-
- def get_transform(self, img):
- img_h, img_w = img.shape[:2]
-
- # Initialize src_rect to fit the input image.
- src_rect = np.array([-0.5 * img_w, -0.5 * img_h, 0.5 * img_w, 0.5 * img_h])
-
- # Apply a random scaling to the src_rect.
- src_rect *= np.random.uniform(self.scale_range[0], self.scale_range[1])
-
- # Apply a random shift to the coordinates origin.
- src_rect[0::2] += self.shift_range[0] * img_w * (np.random.rand() - 0.5)
- src_rect[1::2] += self.shift_range[1] * img_h * (np.random.rand() - 0.5)
-
- # Map src_rect coordinates into image coordinates (center at corner).
- src_rect[0::2] += 0.5 * img_w
- src_rect[1::2] += 0.5 * img_h
-
- return ExtentTransform(
- src_rect=(src_rect[0], src_rect[1], src_rect[2], src_rect[3]),
- output_size=(int(src_rect[3] - src_rect[1]), int(src_rect[2] - src_rect[0])),
- )
-
-
-class RandomContrast(TransformGen):
- """
- Randomly transforms image contrast.
-
- Contrast intensity is uniformly sampled in (intensity_min, intensity_max).
- - intensity < 1 will reduce contrast
- - intensity = 1 will preserve the input image
- - intensity > 1 will increase contrast
-
- See: https://pillow.readthedocs.io/en/3.0.x/reference/ImageEnhance.html
- """
-
- def __init__(self, intensity_min, intensity_max):
- """
- Args:
- intensity_min (float): Minimum augmentation
- intensity_max (float): Maximum augmentation
- """
- super().__init__()
- self._init(locals())
-
- def get_transform(self, img):
- w = np.random.uniform(self.intensity_min, self.intensity_max)
- return BlendTransform(src_image=img.mean(), src_weight=1 - w, dst_weight=w)
-
-
-class RandomBrightness(TransformGen):
- """
- Randomly transforms image brightness.
-
- Brightness intensity is uniformly sampled in (intensity_min, intensity_max).
- - intensity < 1 will reduce brightness
- - intensity = 1 will preserve the input image
- - intensity > 1 will increase brightness
-
- See: https://pillow.readthedocs.io/en/3.0.x/reference/ImageEnhance.html
- """
-
- def __init__(self, intensity_min, intensity_max):
- """
- Args:
- intensity_min (float): Minimum augmentation
- intensity_max (float): Maximum augmentation
- """
- super().__init__()
- self._init(locals())
-
- def get_transform(self, img):
- w = np.random.uniform(self.intensity_min, self.intensity_max)
- return BlendTransform(src_image=0, src_weight=1 - w, dst_weight=w)
-
-
-class RandomSaturation(TransformGen):
- """
- Randomly transforms image saturation.
-
- Saturation intensity is uniformly sampled in (intensity_min, intensity_max).
- - intensity < 1 will reduce saturation (make the image more grayscale)
- - intensity = 1 will preserve the input image
- - intensity > 1 will increase saturation
-
- See: https://pillow.readthedocs.io/en/3.0.x/reference/ImageEnhance.html
- """
-
- def __init__(self, intensity_min, intensity_max):
- """
- Args:
- intensity_min (float): Minimum augmentation (1 preserves input).
- intensity_max (float): Maximum augmentation (1 preserves input).
- """
- super().__init__()
- self._init(locals())
-
- def get_transform(self, img):
- assert img.shape[-1] == 3, "Saturation only works on RGB images"
- w = np.random.uniform(self.intensity_min, self.intensity_max)
- grayscale = img.dot([0.299, 0.587, 0.114])[:, :, np.newaxis]
- return BlendTransform(src_image=grayscale, src_weight=1 - w, dst_weight=w)
-
-
-class RandomLighting(TransformGen):
- """
- Randomly transforms image color using fixed PCA over ImageNet.
-
- The degree of color jittering is randomly sampled via a normal distribution,
- with standard deviation given by the scale parameter.
- """
-
- def __init__(self, scale):
- """
- Args:
- scale (float): Standard deviation of principal component weighting.
- """
- super().__init__()
- self._init(locals())
- self.eigen_vecs = np.array(
- [[-0.5675, 0.7192, 0.4009], [-0.5808, -0.0045, -0.8140], [-0.5836, -0.6948, 0.4203]]
- )
- self.eigen_vals = np.array([0.2175, 0.0188, 0.0045])
-
- def get_transform(self, img):
- assert img.shape[-1] == 3, "Saturation only works on RGB images"
- weights = np.random.normal(scale=self.scale, size=3)
- return BlendTransform(
- src_image=self.eigen_vecs.dot(weights * self.eigen_vals), src_weight=1.0, dst_weight=1.0
- )
-
-
-def apply_transform_gens(transform_gens, img):
- """
- Apply a list of :class:`TransformGen` on the input image, and
- returns the transformed image and a list of transforms.
-
- We cannot simply create and return all transforms without
- applying it to the image, because a subsequent transform may
- need the output of the previous one.
-
- Args:
- transform_gens (list): list of :class:`TransformGen` instance to
- be applied.
- img (ndarray): uint8 or floating point images with 1 or 3 channels.
-
- Returns:
- ndarray: the transformed image
- TransformList: contain the transforms that's used.
- """
- for g in transform_gens:
- assert isinstance(g, TransformGen), g
-
- check_dtype(img)
-
- tfms = []
- for g in transform_gens:
- tfm = g.get_transform(img)
- assert isinstance(
- tfm, Transform
- ), "TransformGen {} must return an instance of Transform! Got {} instead".format(g, tfm)
- img = tfm.apply_image(img)
- tfms.append(tfm)
- return img, TransformList(tfms)
diff --git a/spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/grid-feats-vqa/grid_feats/roi_heads.py b/spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/grid-feats-vqa/grid_feats/roi_heads.py
deleted file mode 100644
index 275b0455db7c93c2439ad0229ad0c61e8b55d780..0000000000000000000000000000000000000000
--- a/spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/grid-feats-vqa/grid_feats/roi_heads.py
+++ /dev/null
@@ -1,253 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-from detectron2.layers import ShapeSpec
-from detectron2.modeling.roi_heads import (
- build_box_head,
- build_mask_head,
- select_foreground_proposals,
- ROI_HEADS_REGISTRY,
- ROIHeads,
- Res5ROIHeads,
- StandardROIHeads,
-)
-from detectron2.modeling.roi_heads.fast_rcnn import FastRCNNOutputLayers
-from detectron2.modeling.poolers import ROIPooler
-
-
-class AttributePredictor(nn.Module):
- """
- Head for attribute prediction, including feature/score computation and
- loss computation.
-
- """
-
- def __init__(self, cfg, input_dim):
- super().__init__()
-
- # fmt: off
- self.num_objs = cfg.MODEL.ROI_HEADS.NUM_CLASSES
- self.obj_embed_dim = cfg.MODEL.ROI_ATTRIBUTE_HEAD.OBJ_EMBED_DIM
- self.fc_dim = cfg.MODEL.ROI_ATTRIBUTE_HEAD.FC_DIM
- self.num_attributes = cfg.MODEL.ROI_ATTRIBUTE_HEAD.NUM_CLASSES
- self.max_attr_per_ins = cfg.INPUT.MAX_ATTR_PER_INS
- self.loss_weight = cfg.MODEL.ROI_ATTRIBUTE_HEAD.LOSS_WEIGHT
- # fmt: on
-
- # object class embedding, including the background class
- self.obj_embed = nn.Embedding(self.num_objs + 1, self.obj_embed_dim)
- input_dim += self.obj_embed_dim
- self.fc = nn.Sequential(nn.Linear(input_dim, self.fc_dim), nn.ReLU())
- self.attr_score = nn.Linear(self.fc_dim, self.num_attributes)
- nn.init.normal_(self.attr_score.weight, std=0.01)
- nn.init.constant_(self.attr_score.bias, 0)
-
- def forward(self, x, obj_labels):
- attr_feat = torch.cat((x, self.obj_embed(obj_labels)), dim=1)
- return self.attr_score(self.fc(attr_feat))
-
- def loss(self, score, label):
- n = score.shape[0]
- score = score.unsqueeze(1)
- score = score.expand(n, self.max_attr_per_ins, self.num_attributes).contiguous()
- score = score.view(-1, self.num_attributes)
- inv_weights = (
- (label >= 0)
- .sum(dim=1)
- .repeat(self.max_attr_per_ins, 1)
- .transpose(0, 1)
- .flatten()
- )
- weights = inv_weights.float().reciprocal()
- weights[weights > 1] = 0.0
- n_valid = len((label >= 0).sum(dim=1).nonzero())
- label = label.view(-1)
- attr_loss = F.cross_entropy(score, label, reduction="none", ignore_index=-1)
- attr_loss = (attr_loss * weights).view(n, -1).sum(dim=1)
-
- if n_valid > 0:
- attr_loss = attr_loss.sum() * self.loss_weight / n_valid
- else:
- attr_loss = attr_loss.sum() * 0.0
- return {"loss_attr": attr_loss}
-
-
-class AttributeROIHeads(ROIHeads):
- """
- An extension of ROIHeads to include attribute prediction.
- """
-
- def forward_attribute_loss(self, proposals, box_features):
- proposals, fg_selection_attributes = select_foreground_proposals(
- proposals, self.num_classes
- )
- attribute_features = box_features[torch.cat(fg_selection_attributes, dim=0)]
- obj_labels = torch.cat([p.gt_classes for p in proposals])
- attribute_labels = torch.cat([p.gt_attributes for p in proposals], dim=0)
- attribute_scores = self.attribute_predictor(attribute_features, obj_labels)
- return self.attribute_predictor.loss(attribute_scores, attribute_labels)
-
-
-@ROI_HEADS_REGISTRY.register()
-class AttributeRes5ROIHeads(AttributeROIHeads, Res5ROIHeads):
- """
- An extension of Res5ROIHeads to include attribute prediction.
- """
-
- def __init__(self, cfg, input_shape):
- super(Res5ROIHeads, self).__init__(cfg, input_shape)
-
- assert len(self.in_features) == 1
-
- # fmt: off
- pooler_resolution = cfg.MODEL.ROI_BOX_HEAD.POOLER_RESOLUTION
- pooler_type = cfg.MODEL.ROI_BOX_HEAD.POOLER_TYPE
- pooler_scales = (1.0 / input_shape[self.in_features[0]].stride, )
- sampling_ratio = cfg.MODEL.ROI_BOX_HEAD.POOLER_SAMPLING_RATIO
- self.mask_on = cfg.MODEL.MASK_ON
- self.attribute_on = cfg.MODEL.ATTRIBUTE_ON
- # fmt: on
- assert not cfg.MODEL.KEYPOINT_ON
-
- self.pooler = ROIPooler(
- output_size=pooler_resolution,
- scales=pooler_scales,
- sampling_ratio=sampling_ratio,
- pooler_type=pooler_type,
- )
-
- self.res5, out_channels = self._build_res5_block(cfg)
- self.box_predictor = FastRCNNOutputLayers(
- cfg, ShapeSpec(channels=out_channels, height=1, width=1)
- )
-
- if self.mask_on:
- self.mask_head = build_mask_head(
- cfg,
- ShapeSpec(
- channels=out_channels,
- width=pooler_resolution,
- height=pooler_resolution,
- ),
- )
-
- if self.attribute_on:
- self.attribute_predictor = AttributePredictor(cfg, out_channels)
-
- def forward(self, images, features, proposals, targets=None):
- 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
- )
- feature_pooled = box_features.mean(dim=[2, 3])
- predictions = self.box_predictor(feature_pooled)
-
- 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
- )
- mask_features = box_features[torch.cat(fg_selection_masks, dim=0)]
- del box_features
- losses.update(self.mask_head(mask_features, proposals))
- if self.attribute_on:
- losses.update(self.forward_attribute_loss(proposals, feature_pooled))
- 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 get_conv5_features(self, features):
- features = [features[f] for f in self.in_features]
- return self.res5(features[0])
-
-
-@ROI_HEADS_REGISTRY.register()
-class AttributeStandardROIHeads(AttributeROIHeads, StandardROIHeads):
- """
- An extension of StandardROIHeads to include attribute prediction.
- """
-
- def __init__(self, cfg, input_shape):
- super(StandardROIHeads, self).__init__(cfg, input_shape)
- self._init_box_head(cfg, input_shape)
- self._init_mask_head(cfg, input_shape)
- self._init_keypoint_head(cfg, input_shape)
-
- def _init_box_head(self, cfg, input_shape):
- # fmt: off
- pooler_resolution = cfg.MODEL.ROI_BOX_HEAD.POOLER_RESOLUTION
- pooler_scales = tuple(1.0 / input_shape[k].stride for k in self.in_features)
- sampling_ratio = cfg.MODEL.ROI_BOX_HEAD.POOLER_SAMPLING_RATIO
- pooler_type = cfg.MODEL.ROI_BOX_HEAD.POOLER_TYPE
- self.train_on_pred_boxes = cfg.MODEL.ROI_BOX_HEAD.TRAIN_ON_PRED_BOXES
- self.attribute_on = cfg.MODEL.ATTRIBUTE_ON
- # fmt: on
-
- in_channels = [input_shape[f].channels for f in self.in_features]
- assert len(set(in_channels)) == 1, in_channels
- in_channels = in_channels[0]
-
- self.box_pooler = ROIPooler(
- output_size=pooler_resolution,
- scales=pooler_scales,
- sampling_ratio=sampling_ratio,
- pooler_type=pooler_type,
- )
- self.box_head = build_box_head(
- cfg,
- ShapeSpec(
- channels=in_channels, height=pooler_resolution, width=pooler_resolution
- ),
- )
- self.box_predictor = FastRCNNOutputLayers(cfg, self.box_head.output_shape)
-
- if self.attribute_on:
- self.attribute_predictor = AttributePredictor(
- cfg, self.box_head.output_shape.channels
- )
-
- def _forward_box(self, features, proposals):
- features = [features[f] for f in self.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)
-
- if self.training:
- 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)
- losses = self.box_predictor.losses(predictions, proposals)
- if self.attribute_on:
- losses.update(self.forward_attribute_loss(proposals, box_features))
- del box_features
-
- return losses
- else:
- pred_instances, keep = self.box_predictor.inference(predictions, proposals)
- box_features = box_features[keep]
- return pred_instances, box_features
-
- def get_conv5_features(self, features):
- assert len(self.in_features) == 1
-
- features = [features[f] for f in self.in_features]
- return features[0]
diff --git a/spaces/CVPR/LIVE/pybind11/include/pybind11/chrono.h b/spaces/CVPR/LIVE/pybind11/include/pybind11/chrono.h
deleted file mode 100644
index 6127c659bdcef2da89d9fb80568f1c570bbb6534..0000000000000000000000000000000000000000
--- a/spaces/CVPR/LIVE/pybind11/include/pybind11/chrono.h
+++ /dev/null
@@ -1,191 +0,0 @@
-/*
- pybind11/chrono.h: Transparent conversion between std::chrono and python's datetime
-
- Copyright (c) 2016 Trent Houliston and
- 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
-#include
-#include
-#include
-
-// Backport the PyDateTime_DELTA functions from Python3.3 if required
-#ifndef PyDateTime_DELTA_GET_DAYS
-#define PyDateTime_DELTA_GET_DAYS(o) (((PyDateTime_Delta*)o)->days)
-#endif
-#ifndef PyDateTime_DELTA_GET_SECONDS
-#define PyDateTime_DELTA_GET_SECONDS(o) (((PyDateTime_Delta*)o)->seconds)
-#endif
-#ifndef PyDateTime_DELTA_GET_MICROSECONDS
-#define PyDateTime_DELTA_GET_MICROSECONDS(o) (((PyDateTime_Delta*)o)->microseconds)
-#endif
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-PYBIND11_NAMESPACE_BEGIN(detail)
-
-template class duration_caster {
-public:
- typedef typename type::rep rep;
- typedef typename type::period period;
-
- typedef std::chrono::duration> days;
-
- bool load(handle src, bool) {
- using namespace std::chrono;
-
- // Lazy initialise the PyDateTime import
- if (!PyDateTimeAPI) { PyDateTime_IMPORT; }
-
- if (!src) return false;
- // If invoked with datetime.delta object
- if (PyDelta_Check(src.ptr())) {
- value = type(duration_cast>(
- days(PyDateTime_DELTA_GET_DAYS(src.ptr()))
- + seconds(PyDateTime_DELTA_GET_SECONDS(src.ptr()))
- + microseconds(PyDateTime_DELTA_GET_MICROSECONDS(src.ptr()))));
- return true;
- }
- // If invoked with a float we assume it is seconds and convert
- else if (PyFloat_Check(src.ptr())) {
- value = type(duration_cast>(duration(PyFloat_AsDouble(src.ptr()))));
- return true;
- }
- else return false;
- }
-
- // If this is a duration just return it back
- static const std::chrono::duration& get_duration(const std::chrono::duration &src) {
- return src;
- }
-
- // If this is a time_point get the time_since_epoch
- template static std::chrono::duration get_duration(const std::chrono::time_point> &src) {
- return src.time_since_epoch();
- }
-
- static handle cast(const type &src, return_value_policy /* policy */, handle /* parent */) {
- using namespace std::chrono;
-
- // Use overloaded function to get our duration from our source
- // Works out if it is a duration or time_point and get the duration
- auto d = get_duration(src);
-
- // Lazy initialise the PyDateTime import
- if (!PyDateTimeAPI) { PyDateTime_IMPORT; }
-
- // Declare these special duration types so the conversions happen with the correct primitive types (int)
- using dd_t = duration>;
- using ss_t = duration>;
- using us_t = duration;
-
- auto dd = duration_cast(d);
- auto subd = d - dd;
- auto ss = duration_cast(subd);
- auto us = duration_cast(subd - ss);
- return PyDelta_FromDSU(dd.count(), ss.count(), us.count());
- }
-
- PYBIND11_TYPE_CASTER(type, _("datetime.timedelta"));
-};
-
-// This is for casting times on the system clock into datetime.datetime instances
-template class type_caster> {
-public:
- typedef std::chrono::time_point type;
- bool load(handle src, bool) {
- using namespace std::chrono;
-
- // Lazy initialise the PyDateTime import
- if (!PyDateTimeAPI) { PyDateTime_IMPORT; }
-
- if (!src) return false;
-
- std::tm cal;
- microseconds msecs;
-
- if (PyDateTime_Check(src.ptr())) {
- cal.tm_sec = PyDateTime_DATE_GET_SECOND(src.ptr());
- cal.tm_min = PyDateTime_DATE_GET_MINUTE(src.ptr());
- cal.tm_hour = PyDateTime_DATE_GET_HOUR(src.ptr());
- cal.tm_mday = PyDateTime_GET_DAY(src.ptr());
- cal.tm_mon = PyDateTime_GET_MONTH(src.ptr()) - 1;
- cal.tm_year = PyDateTime_GET_YEAR(src.ptr()) - 1900;
- cal.tm_isdst = -1;
- msecs = microseconds(PyDateTime_DATE_GET_MICROSECOND(src.ptr()));
- } else if (PyDate_Check(src.ptr())) {
- cal.tm_sec = 0;
- cal.tm_min = 0;
- cal.tm_hour = 0;
- cal.tm_mday = PyDateTime_GET_DAY(src.ptr());
- cal.tm_mon = PyDateTime_GET_MONTH(src.ptr()) - 1;
- cal.tm_year = PyDateTime_GET_YEAR(src.ptr()) - 1900;
- cal.tm_isdst = -1;
- msecs = microseconds(0);
- } else if (PyTime_Check(src.ptr())) {
- cal.tm_sec = PyDateTime_TIME_GET_SECOND(src.ptr());
- cal.tm_min = PyDateTime_TIME_GET_MINUTE(src.ptr());
- cal.tm_hour = PyDateTime_TIME_GET_HOUR(src.ptr());
- cal.tm_mday = 1; // This date (day, month, year) = (1, 0, 70)
- cal.tm_mon = 0; // represents 1-Jan-1970, which is the first
- cal.tm_year = 70; // earliest available date for Python's datetime
- cal.tm_isdst = -1;
- msecs = microseconds(PyDateTime_TIME_GET_MICROSECOND(src.ptr()));
- }
- else return false;
-
- value = system_clock::from_time_t(std::mktime(&cal)) + msecs;
- return true;
- }
-
- static handle cast(const std::chrono::time_point &src, return_value_policy /* policy */, handle /* parent */) {
- using namespace std::chrono;
-
- // Lazy initialise the PyDateTime import
- if (!PyDateTimeAPI) { PyDateTime_IMPORT; }
-
- // Get out microseconds, and make sure they are positive, to avoid bug in eastern hemisphere time zones
- // (cfr. https://github.com/pybind/pybind11/issues/2417)
- using us_t = duration;
- auto us = duration_cast(src.time_since_epoch() % seconds(1));
- if (us.count() < 0)
- us += seconds(1);
-
- // Subtract microseconds BEFORE `system_clock::to_time_t`, because:
- // > If std::time_t has lower precision, it is implementation-defined whether the value is rounded or truncated.
- // (https://en.cppreference.com/w/cpp/chrono/system_clock/to_time_t)
- std::time_t tt = system_clock::to_time_t(time_point_cast(src - us));
- // this function uses static memory so it's best to copy it out asap just in case
- // otherwise other code that is using localtime may break this (not just python code)
- std::tm localtime = *std::localtime(&tt);
-
- return PyDateTime_FromDateAndTime(localtime.tm_year + 1900,
- localtime.tm_mon + 1,
- localtime.tm_mday,
- localtime.tm_hour,
- localtime.tm_min,
- localtime.tm_sec,
- us.count());
- }
- PYBIND11_TYPE_CASTER(type, _("datetime.datetime"));
-};
-
-// Other clocks that are not the system clock are not measured as datetime.datetime objects
-// since they are not measured on calendar time. So instead we just make them timedeltas
-// Or if they have passed us a time as a float we convert that
-template class type_caster>
-: public duration_caster> {
-};
-
-template class type_caster>
-: public duration_caster> {
-};
-
-PYBIND11_NAMESPACE_END(detail)
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/spaces/CVPR/LIVE/thrust/thrust/system/detail/adl/fill.h b/spaces/CVPR/LIVE/thrust/thrust/system/detail/adl/fill.h
deleted file mode 100644
index f76a81b4f3477d87abe5b88c71f89e4158d68d28..0000000000000000000000000000000000000000
--- a/spaces/CVPR/LIVE/thrust/thrust/system/detail/adl/fill.h
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * Copyright 2008-2013 NVIDIA Corporation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a fill 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.
- */
-
-#pragma once
-
-#include
-
-// the purpose of this header is to #include the fill.h header
-// of the sequential, host, and device systems. It should be #included in any
-// code which uses adl to dispatch fill
-
-#include
-
-// SCons can't see through the #defines below to figure out what this header
-// includes, so we fake it out by specifying all possible files we might end up
-// including inside an #if 0.
-#if 0
-#include
-#include
-#include
-#include
-#endif
-
-#define __THRUST_HOST_SYSTEM_FILL_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/fill.h>
-#include __THRUST_HOST_SYSTEM_FILL_HEADER
-#undef __THRUST_HOST_SYSTEM_FILL_HEADER
-
-#define __THRUST_DEVICE_SYSTEM_FILL_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/fill.h>
-#include __THRUST_DEVICE_SYSTEM_FILL_HEADER
-#undef __THRUST_DEVICE_SYSTEM_FILL_HEADER
-
diff --git a/spaces/CVPR/LIVE/thrust/thrust/system/omp/detail/default_decomposition.h b/spaces/CVPR/LIVE/thrust/thrust/system/omp/detail/default_decomposition.h
deleted file mode 100644
index cb4b03c719b7c89e2b4561066394fc3874971638..0000000000000000000000000000000000000000
--- a/spaces/CVPR/LIVE/thrust/thrust/system/omp/detail/default_decomposition.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * Copyright 2008-2013 NVIDIA Corporation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-
-/*! \file default_decomposition.h
- * \brief Return a decomposition that is appropriate for the OpenMP backend.
- */
-
-#pragma once
-
-#include
-#include
-
-namespace thrust
-{
-namespace system
-{
-namespace omp
-{
-namespace detail
-{
-
-template
-thrust::system::detail::internal::uniform_decomposition default_decomposition(IndexType n);
-
-} // end namespace detail
-} // end namespace omp
-} // end namespace system
-} // end namespace thrust
-
-#include
-
diff --git a/spaces/CVPR/SPOTER_Sign_Language_Recognition/spoter_mod/normalization/hand_normalization.py b/spaces/CVPR/SPOTER_Sign_Language_Recognition/spoter_mod/normalization/hand_normalization.py
deleted file mode 100644
index b39a05c0978d988712f2ae1379a60e5356c2b7ca..0000000000000000000000000000000000000000
--- a/spaces/CVPR/SPOTER_Sign_Language_Recognition/spoter_mod/normalization/hand_normalization.py
+++ /dev/null
@@ -1,192 +0,0 @@
-
-import logging
-import pandas as pd
-
-HAND_IDENTIFIERS = [
- "wrist",
- "indexTip",
- "indexDIP",
- "indexPIP",
- "indexMCP",
- "middleTip",
- "middleDIP",
- "middlePIP",
- "middleMCP",
- "ringTip",
- "ringDIP",
- "ringPIP",
- "ringMCP",
- "littleTip",
- "littleDIP",
- "littlePIP",
- "littleMCP",
- "thumbTip",
- "thumbIP",
- "thumbMP",
- "thumbCMC"
-]
-
-
-def normalize_hands_full(df: pd.DataFrame) -> pd.DataFrame:
- """
- Normalizes the hands position data using the Bohacek-normalization algorithm.
-
- :param df: pd.DataFrame to be normalized
- :return: pd.DataFrame with normalized values for hand pose
- """
-
- # TODO: Fix division by zero
- df.columns = [item.replace("_left_", "_0_").replace("_right_", "_1_") for item in list(df.columns)]
-
- normalized_df = pd.DataFrame(columns=df.columns)
-
- hand_landmarks = {"X": {0: [], 1: []}, "Y": {0: [], 1: []}}
-
- # Determine how many hands are present in the dataset
- range_hand_size = 1
- if "wrist_1_X" in df.columns:
- range_hand_size = 2
-
- # Construct the relevant identifiers
- for identifier in HAND_IDENTIFIERS:
- for hand_index in range(range_hand_size):
- hand_landmarks["X"][hand_index].append(identifier + "_" + str(hand_index) + "_X")
- hand_landmarks["Y"][hand_index].append(identifier + "_" + str(hand_index) + "_Y")
-
- # Iterate over all of the records in the dataset
- for index, row in df.iterrows():
- # Treat each hand individually
- for hand_index in range(range_hand_size):
-
- sequence_size = len(row["wrist_" + str(hand_index) + "_X"])
-
- # Treat each element of the sequence (analyzed frame) individually
- for sequence_index in range(sequence_size):
-
- # Retrieve all of the X and Y values of the current frame
- landmarks_x_values = [row[key][sequence_index] for key in hand_landmarks["X"][hand_index] if row[key][sequence_index] != 0]
- landmarks_y_values = [row[key][sequence_index] for key in hand_landmarks["Y"][hand_index] if row[key][sequence_index] != 0]
-
- # Prevent from even starting the analysis if some necessary elements are not present
- if not landmarks_x_values or not landmarks_y_values:
- logging.warning(
- " HAND LANDMARKS: One frame could not be normalized as there is no data present. Record: " + str(index) +
- ", Frame: " + str(sequence_index))
- continue
-
- # Calculate the deltas
- width, height = max(landmarks_x_values) - min(landmarks_x_values), max(landmarks_y_values) - min(
- landmarks_y_values)
- if width > height:
- delta_x = 0.1 * width
- delta_y = delta_x + ((width - height) / 2)
- else:
- delta_y = 0.1 * height
- delta_x = delta_y + ((height - width) / 2)
-
- # Set the starting and ending point of the normalization bounding box
- starting_point = (min(landmarks_x_values) - delta_x, min(landmarks_y_values) - delta_y)
- ending_point = (max(landmarks_x_values) + delta_x, max(landmarks_y_values) + delta_y)
-
- # Normalize individual landmarks and save the results
- for identifier in HAND_IDENTIFIERS:
- key = identifier + "_" + str(hand_index) + "_"
-
- # Prevent from trying to normalize incorrectly captured points
- if row[key + "X"][sequence_index] == 0 or (ending_point[0] - starting_point[0]) == 0 or (starting_point[1] - ending_point[1]) == 0:
- continue
-
- normalized_x = (row[key + "X"][sequence_index] - starting_point[0]) / (ending_point[0] -
- starting_point[0])
- normalized_y = (row[key + "Y"][sequence_index] - ending_point[1]) / (starting_point[1] -
- ending_point[1])
-
- row[key + "X"][sequence_index] = normalized_x
- row[key + "Y"][sequence_index] = normalized_y
-
- normalized_df = normalized_df.append(row, ignore_index=True)
-
- return normalized_df
-
-
-def normalize_single_dict(row: dict):
- """
- Normalizes the skeletal data for a given sequence of frames with signer's hand pose data. The normalization follows
- the definition from our paper.
-
- :param row: Dictionary containing key-value pairs with joint identifiers and corresponding lists (sequences) of
- that particular joints coordinates
- :return: Dictionary with normalized skeletal data (following the same schema as input data)
- """
-
- hand_landmarks = {0: [], 1: []}
-
- # Determine how many hands are present in the dataset
- range_hand_size = 1
- if "wrist_1" in row.keys():
- range_hand_size = 2
-
- # Construct the relevant identifiers
- for identifier in HAND_IDENTIFIERS:
- for hand_index in range(range_hand_size):
- hand_landmarks[hand_index].append(identifier + "_" + str(hand_index))
-
- # Treat each hand individually
- for hand_index in range(range_hand_size):
-
- sequence_size = len(row["wrist_" + str(hand_index)])
-
- # Treat each element of the sequence (analyzed frame) individually
- for sequence_index in range(sequence_size):
-
- # Retrieve all of the X and Y values of the current frame
- landmarks_x_values = [row[key][sequence_index][0] for key in hand_landmarks[hand_index] if
- row[key][sequence_index][0] != 0]
- landmarks_y_values = [row[key][sequence_index][1] for key in hand_landmarks[hand_index] if
- row[key][sequence_index][1] != 0]
-
- # Prevent from even starting the analysis if some necessary elements are not present
- if not landmarks_x_values or not landmarks_y_values:
- continue
-
- # Calculate the deltas
- width, height = max(landmarks_x_values) - min(landmarks_x_values), max(landmarks_y_values) - min(
- landmarks_y_values)
- if width > height:
- delta_x = 0.1 * width
- delta_y = delta_x + ((width - height) / 2)
- else:
- delta_y = 0.1 * height
- delta_x = delta_y + ((height - width) / 2)
-
- # Set the starting and ending point of the normalization bounding box
- starting_point = [min(landmarks_x_values) - delta_x, min(landmarks_y_values) - delta_y]
- ending_point = [max(landmarks_x_values) + delta_x, max(landmarks_y_values) + delta_y]
- # Ensure that all of the bounding-box-defining coordinates are not out of the picture
- if starting_point[0] < 0: starting_point[0] = 0
- if starting_point[1] > 1: starting_point[1] = 1
- if ending_point[0] < 0: ending_point[0] = 0
- if ending_point[1] > 1: ending_point[1] = 1
-
- # Normalize individual landmarks and save the results
- for identifier in HAND_IDENTIFIERS:
- key = identifier + "_" + str(hand_index)
-
- # Prevent from trying to normalize incorrectly captured points
- if row[key][sequence_index][0] == 0 or (ending_point[0] - starting_point[0]) == 0 or (
- starting_point[1] - ending_point[1]) == 0:
- continue
-
- normalized_x = (row[key][sequence_index][0] - starting_point[0]) / (ending_point[0] - starting_point[0])
- normalized_y = (row[key][sequence_index][1] - starting_point[1]) / (ending_point[1] - starting_point[1])
-
- row[key][sequence_index] = list(row[key][sequence_index])
-
- row[key][sequence_index][0] = normalized_x
- row[key][sequence_index][1] = normalized_y
-
- return row
-
-
-if __name__ == "__main__":
- pass
diff --git a/spaces/CVPR/WALT/mmdet/datasets/wider_face.py b/spaces/CVPR/WALT/mmdet/datasets/wider_face.py
deleted file mode 100644
index 3a13907db87a9986a7d701837259a0b712fc9dca..0000000000000000000000000000000000000000
--- a/spaces/CVPR/WALT/mmdet/datasets/wider_face.py
+++ /dev/null
@@ -1,51 +0,0 @@
-import os.path as osp
-import xml.etree.ElementTree as ET
-
-import mmcv
-
-from .builder import DATASETS
-from .xml_style import XMLDataset
-
-
-@DATASETS.register_module()
-class WIDERFaceDataset(XMLDataset):
- """Reader for the WIDER Face dataset in PASCAL VOC format.
-
- Conversion scripts can be found in
- https://github.com/sovrasov/wider-face-pascal-voc-annotations
- """
- CLASSES = ('face', )
-
- def __init__(self, **kwargs):
- super(WIDERFaceDataset, self).__init__(**kwargs)
-
- def load_annotations(self, ann_file):
- """Load annotation from WIDERFace XML style annotation file.
-
- Args:
- ann_file (str): Path of XML file.
-
- Returns:
- list[dict]: Annotation info from XML file.
- """
-
- data_infos = []
- img_ids = mmcv.list_from_file(ann_file)
- for img_id in img_ids:
- filename = f'{img_id}.jpg'
- xml_path = osp.join(self.img_prefix, 'Annotations',
- f'{img_id}.xml')
- tree = ET.parse(xml_path)
- root = tree.getroot()
- size = root.find('size')
- width = int(size.find('width').text)
- height = int(size.find('height').text)
- folder = root.find('folder').text
- data_infos.append(
- dict(
- id=img_id,
- filename=osp.join(folder, filename),
- width=width,
- height=height))
-
- return data_infos
diff --git a/spaces/Chitranshu/Dashboard-Dmart/README.md b/spaces/Chitranshu/Dashboard-Dmart/README.md
deleted file mode 100644
index c731cf63c62ced7629b7d2c60a4b540803334abb..0000000000000000000000000000000000000000
--- a/spaces/Chitranshu/Dashboard-Dmart/README.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: Dmart-Dashboard
-emoji: 📊
-colorFrom: green
-colorTo: green
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
\ No newline at end of file
diff --git a/spaces/CikeyQI/Yunzai/Yunzai/plugins/ws-plugin/model/CQCode.js b/spaces/CikeyQI/Yunzai/Yunzai/plugins/ws-plugin/model/CQCode.js
deleted file mode 100644
index 3e60e7b5fef08b1c605af412f6ca67d1c82e102f..0000000000000000000000000000000000000000
--- a/spaces/CikeyQI/Yunzai/Yunzai/plugins/ws-plugin/model/CQCode.js
+++ /dev/null
@@ -1,65 +0,0 @@
-
-/**
- * cq码转换Msg
- * @param {*} cq
- */
-function CQToMsg(cq) {
- let msg = [];
- let matches = cq.matchAll(/(\[CQ:(.*?),(.*?)\]|.)/gs);
- let text = '';
- for (const match of matches) {
- if (match[2]) {
- if (text) {
- msg.push({
- type: 'text',
- data: {
- text
- }
- });
- text = '';
- }
- let type = match[2];
- let data = {};
- let pairs = match[3].split(',');
- for (const pair of pairs) {
- let [key, value] = pair.split('=');
- data[key] = value;
- }
- msg.push({ type, data });
- } else {
- text += match[0];
- }
- }
- if (text) {
- msg.push({
- type: 'text',
- data: {
- text
- }
- });
- }
- return msg;
-}
-
-/**
- * msg转换cq码
- * @param {*} msg
- * @returns
- */
-function MsgToCQ(msg) {
- let cq = '';
- for (const item of msg) {
- if (item.type === 'text') {
- cq += item.data.text;
- } else {
- let data = Object.entries(item.data).map(([key, value]) => `${key}=${value}`).join(',');
- cq += `[CQ:${item.type},${data}]`;
- }
- }
- return cq;
-}
-
-export {
- CQToMsg,
- MsgToCQ
-}
\ No newline at end of file
diff --git a/spaces/CofAI/chat.b4/g4f/Provider/Providers/Dfehub.py b/spaces/CofAI/chat.b4/g4f/Provider/Providers/Dfehub.py
deleted file mode 100644
index 2f66f19b50b6b4ab79c012f123c47241141942eb..0000000000000000000000000000000000000000
--- a/spaces/CofAI/chat.b4/g4f/Provider/Providers/Dfehub.py
+++ /dev/null
@@ -1,49 +0,0 @@
-import os
-import requests
-from ...typing import sha256, Dict, get_type_hints
-
-url = "https://chat.dfehub.com"
-model = ['gpt-3.5-turbo', 'gpt-3.5-turbo-16k', 'gpt-4']
-supports_stream = True
-needs_auth = False
-
-
-def _create_completion(model: str, messages: list, stream: bool, **kwargs):
- headers = {
- 'Authority': 'chat.dfehub.com',
- 'Content-Type': 'application/json',
- 'Method': 'POST',
- 'Path': '/api/openai/v1/chat/completions',
- 'Scheme': 'https',
- 'Accept': 'text/event-stream',
- 'Accept-Language': 'pt-BR,pt;q=0.9,en-US;q=0.8,en;q=0.7,zh-CN;q=0.6,zh;q=0.5',
- 'Content-Type': 'application/json',
- 'Origin': 'https://chat.dfehub.com',
- 'Referer': 'https://chat.dfehub.com/',
- 'Sec-Ch-Ua': '"Not.A/Brand";v="8", "Chromium";v="114", "Google Chrome";v="114"',
- '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/114.0.0.0 Safari/537.36',
- 'X-Requested-With': 'XMLHttpRequest',
- }
-
- data = {
- 'model': model,
- 'temperature': 0.7,
- 'max_tokens': '8000',
- 'presence_penalty': 0,
- 'messages': messages,
- }
-
- response = requests.post(url + '/api/openai/v1/chat/completions',
- headers=headers, json=data, stream=stream)
-
- yield response.json()['choices'][0]['message']['content']
-
-
-params = f'g4f.Providers.{os.path.basename(__file__)[:-3]} supports: ' + \
- '(%s)' % ', '.join(
- [f"{name}: {get_type_hints(_create_completion)[name].__name__}" for name in _create_completion.__code__.co_varnames[:_create_completion.__code__.co_argcount]])
diff --git a/spaces/DEfiAnTH/SPSpace/README.md b/spaces/DEfiAnTH/SPSpace/README.md
deleted file mode 100644
index a0871e108ae02a7dbd0153de21a9a3e318d7e8a5..0000000000000000000000000000000000000000
--- a/spaces/DEfiAnTH/SPSpace/README.md
+++ /dev/null
@@ -1,11 +0,0 @@
----
-title: Zenml Server
-emoji: 🧘
-colorFrom: purple
-colorTo: green
-sdk: docker
-pinned: false
-app_port: 8080
-license: apache-2.0
-duplicated_from: zenml/zenml
----
diff --git a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/click/core.py b/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/click/core.py
deleted file mode 100644
index cc65e896bf2d754d74b54a84ac501b80127f83ca..0000000000000000000000000000000000000000
--- a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/click/core.py
+++ /dev/null
@@ -1,3042 +0,0 @@
-import enum
-import errno
-import inspect
-import os
-import sys
-import typing as t
-from collections import abc
-from contextlib import contextmanager
-from contextlib import ExitStack
-from functools import update_wrapper
-from gettext import gettext as _
-from gettext import ngettext
-from itertools import repeat
-from types import TracebackType
-
-from . import types
-from .exceptions import Abort
-from .exceptions import BadParameter
-from .exceptions import ClickException
-from .exceptions import Exit
-from .exceptions import MissingParameter
-from .exceptions import UsageError
-from .formatting import HelpFormatter
-from .formatting import join_options
-from .globals import pop_context
-from .globals import push_context
-from .parser import _flag_needs_value
-from .parser import OptionParser
-from .parser import split_opt
-from .termui import confirm
-from .termui import prompt
-from .termui import style
-from .utils import _detect_program_name
-from .utils import _expand_args
-from .utils import echo
-from .utils import make_default_short_help
-from .utils import make_str
-from .utils import PacifyFlushWrapper
-
-if t.TYPE_CHECKING:
- import typing_extensions as te
- from .shell_completion import CompletionItem
-
-F = t.TypeVar("F", bound=t.Callable[..., t.Any])
-V = t.TypeVar("V")
-
-
-def _complete_visible_commands(
- ctx: "Context", incomplete: str
-) -> t.Iterator[t.Tuple[str, "Command"]]:
- """List all the subcommands of a group that start with the
- incomplete value and aren't hidden.
-
- :param ctx: Invocation context for the group.
- :param incomplete: Value being completed. May be empty.
- """
- multi = t.cast(MultiCommand, ctx.command)
-
- for name in multi.list_commands(ctx):
- if name.startswith(incomplete):
- command = multi.get_command(ctx, name)
-
- if command is not None and not command.hidden:
- yield name, command
-
-
-def _check_multicommand(
- base_command: "MultiCommand", cmd_name: str, cmd: "Command", register: bool = False
-) -> None:
- if not base_command.chain or not isinstance(cmd, MultiCommand):
- return
- if register:
- hint = (
- "It is not possible to add multi commands as children to"
- " another multi command that is in chain mode."
- )
- else:
- hint = (
- "Found a multi command as subcommand to a multi command"
- " that is in chain mode. This is not supported."
- )
- raise RuntimeError(
- f"{hint}. Command {base_command.name!r} is set to chain and"
- f" {cmd_name!r} was added as a subcommand but it in itself is a"
- f" multi command. ({cmd_name!r} is a {type(cmd).__name__}"
- f" within a chained {type(base_command).__name__} named"
- f" {base_command.name!r})."
- )
-
-
-def batch(iterable: t.Iterable[V], batch_size: int) -> t.List[t.Tuple[V, ...]]:
- return list(zip(*repeat(iter(iterable), batch_size)))
-
-
-@contextmanager
-def augment_usage_errors(
- ctx: "Context", param: t.Optional["Parameter"] = None
-) -> t.Iterator[None]:
- """Context manager that attaches extra information to exceptions."""
- try:
- yield
- except BadParameter as e:
- if e.ctx is None:
- e.ctx = ctx
- if param is not None and e.param is None:
- e.param = param
- raise
- except UsageError as e:
- if e.ctx is None:
- e.ctx = ctx
- raise
-
-
-def iter_params_for_processing(
- invocation_order: t.Sequence["Parameter"],
- declaration_order: t.Sequence["Parameter"],
-) -> t.List["Parameter"]:
- """Given a sequence of parameters in the order as should be considered
- for processing and an iterable of parameters that exist, this returns
- a list in the correct order as they should be processed.
- """
-
- def sort_key(item: "Parameter") -> t.Tuple[bool, float]:
- try:
- idx: float = invocation_order.index(item)
- except ValueError:
- idx = float("inf")
-
- return not item.is_eager, idx
-
- return sorted(declaration_order, key=sort_key)
-
-
-class ParameterSource(enum.Enum):
- """This is an :class:`~enum.Enum` that indicates the source of a
- parameter's value.
-
- Use :meth:`click.Context.get_parameter_source` to get the
- source for a parameter by name.
-
- .. versionchanged:: 8.0
- Use :class:`~enum.Enum` and drop the ``validate`` method.
-
- .. versionchanged:: 8.0
- Added the ``PROMPT`` value.
- """
-
- COMMANDLINE = enum.auto()
- """The value was provided by the command line args."""
- ENVIRONMENT = enum.auto()
- """The value was provided with an environment variable."""
- DEFAULT = enum.auto()
- """Used the default specified by the parameter."""
- DEFAULT_MAP = enum.auto()
- """Used a default provided by :attr:`Context.default_map`."""
- PROMPT = enum.auto()
- """Used a prompt to confirm a default or provide a value."""
-
-
-class Context:
- """The context is a special internal object that holds state relevant
- for the script execution at every single level. It's normally invisible
- to commands unless they opt-in to getting access to it.
-
- The context is useful as it can pass internal objects around and can
- control special execution features such as reading data from
- environment variables.
-
- A context can be used as context manager in which case it will call
- :meth:`close` on teardown.
-
- :param command: the command class for this context.
- :param parent: the parent context.
- :param info_name: the info name for this invocation. Generally this
- is the most descriptive name for the script or
- command. For the toplevel script it is usually
- the name of the script, for commands below it it's
- the name of the script.
- :param obj: an arbitrary object of user data.
- :param auto_envvar_prefix: the prefix to use for automatic environment
- variables. If this is `None` then reading
- from environment variables is disabled. This
- does not affect manually set environment
- variables which are always read.
- :param default_map: a dictionary (like object) with default values
- for parameters.
- :param terminal_width: the width of the terminal. The default is
- inherit from parent context. If no context
- defines the terminal width then auto
- detection will be applied.
- :param max_content_width: the maximum width for content rendered by
- Click (this currently only affects help
- pages). This defaults to 80 characters if
- not overridden. In other words: even if the
- terminal is larger than that, Click will not
- format things wider than 80 characters by
- default. In addition to that, formatters might
- add some safety mapping on the right.
- :param resilient_parsing: if this flag is enabled then Click will
- parse without any interactivity or callback
- invocation. Default values will also be
- ignored. This is useful for implementing
- things such as completion support.
- :param allow_extra_args: if this is set to `True` then extra arguments
- at the end will not raise an error and will be
- kept on the context. The default is to inherit
- from the command.
- :param allow_interspersed_args: if this is set to `False` then options
- and arguments cannot be mixed. The
- default is to inherit from the command.
- :param ignore_unknown_options: instructs click to ignore options it does
- not know and keeps them for later
- processing.
- :param help_option_names: optionally a list of strings that define how
- the default help parameter is named. The
- default is ``['--help']``.
- :param token_normalize_func: an optional function that is used to
- normalize tokens (options, choices,
- etc.). This for instance can be used to
- implement case insensitive behavior.
- :param color: controls if the terminal supports ANSI colors or not. The
- default is autodetection. This is only needed if ANSI
- codes are used in texts that Click prints which is by
- default not the case. This for instance would affect
- help output.
- :param show_default: Show the default value for commands. If this
- value is not set, it defaults to the value from the parent
- context. ``Command.show_default`` overrides this default for the
- specific command.
-
- .. versionchanged:: 8.1
- The ``show_default`` parameter is overridden by
- ``Command.show_default``, instead of the other way around.
-
- .. versionchanged:: 8.0
- The ``show_default`` parameter defaults to the value from the
- parent context.
-
- .. versionchanged:: 7.1
- Added the ``show_default`` parameter.
-
- .. versionchanged:: 4.0
- Added the ``color``, ``ignore_unknown_options``, and
- ``max_content_width`` parameters.
-
- .. versionchanged:: 3.0
- Added the ``allow_extra_args`` and ``allow_interspersed_args``
- parameters.
-
- .. versionchanged:: 2.0
- Added the ``resilient_parsing``, ``help_option_names``, and
- ``token_normalize_func`` parameters.
- """
-
- #: The formatter class to create with :meth:`make_formatter`.
- #:
- #: .. versionadded:: 8.0
- formatter_class: t.Type["HelpFormatter"] = HelpFormatter
-
- def __init__(
- self,
- command: "Command",
- parent: t.Optional["Context"] = None,
- info_name: t.Optional[str] = None,
- obj: t.Optional[t.Any] = None,
- auto_envvar_prefix: t.Optional[str] = None,
- default_map: t.Optional[t.MutableMapping[str, t.Any]] = None,
- terminal_width: t.Optional[int] = None,
- max_content_width: t.Optional[int] = None,
- resilient_parsing: bool = False,
- allow_extra_args: t.Optional[bool] = None,
- allow_interspersed_args: t.Optional[bool] = None,
- ignore_unknown_options: t.Optional[bool] = None,
- help_option_names: t.Optional[t.List[str]] = None,
- token_normalize_func: t.Optional[t.Callable[[str], str]] = None,
- color: t.Optional[bool] = None,
- show_default: t.Optional[bool] = None,
- ) -> None:
- #: the parent context or `None` if none exists.
- self.parent = parent
- #: the :class:`Command` for this context.
- self.command = command
- #: the descriptive information name
- self.info_name = info_name
- #: Map of parameter names to their parsed values. Parameters
- #: with ``expose_value=False`` are not stored.
- self.params: t.Dict[str, t.Any] = {}
- #: the leftover arguments.
- self.args: t.List[str] = []
- #: protected arguments. These are arguments that are prepended
- #: to `args` when certain parsing scenarios are encountered but
- #: must be never propagated to another arguments. This is used
- #: to implement nested parsing.
- self.protected_args: t.List[str] = []
- #: the collected prefixes of the command's options.
- self._opt_prefixes: t.Set[str] = set(parent._opt_prefixes) if parent else set()
-
- if obj is None and parent is not None:
- obj = parent.obj
-
- #: the user object stored.
- self.obj: t.Any = obj
- self._meta: t.Dict[str, t.Any] = getattr(parent, "meta", {})
-
- #: A dictionary (-like object) with defaults for parameters.
- if (
- default_map is None
- and info_name is not None
- and parent is not None
- and parent.default_map is not None
- ):
- default_map = parent.default_map.get(info_name)
-
- self.default_map: t.Optional[t.MutableMapping[str, t.Any]] = default_map
-
- #: This flag indicates if a subcommand is going to be executed. A
- #: group callback can use this information to figure out if it's
- #: being executed directly or because the execution flow passes
- #: onwards to a subcommand. By default it's None, but it can be
- #: the name of the subcommand to execute.
- #:
- #: If chaining is enabled this will be set to ``'*'`` in case
- #: any commands are executed. It is however not possible to
- #: figure out which ones. If you require this knowledge you
- #: should use a :func:`result_callback`.
- self.invoked_subcommand: t.Optional[str] = None
-
- if terminal_width is None and parent is not None:
- terminal_width = parent.terminal_width
-
- #: The width of the terminal (None is autodetection).
- self.terminal_width: t.Optional[int] = terminal_width
-
- if max_content_width is None and parent is not None:
- max_content_width = parent.max_content_width
-
- #: The maximum width of formatted content (None implies a sensible
- #: default which is 80 for most things).
- self.max_content_width: t.Optional[int] = max_content_width
-
- if allow_extra_args is None:
- allow_extra_args = command.allow_extra_args
-
- #: Indicates if the context allows extra args or if it should
- #: fail on parsing.
- #:
- #: .. versionadded:: 3.0
- self.allow_extra_args = allow_extra_args
-
- if allow_interspersed_args is None:
- allow_interspersed_args = command.allow_interspersed_args
-
- #: Indicates if the context allows mixing of arguments and
- #: options or not.
- #:
- #: .. versionadded:: 3.0
- self.allow_interspersed_args: bool = allow_interspersed_args
-
- if ignore_unknown_options is None:
- ignore_unknown_options = command.ignore_unknown_options
-
- #: Instructs click to ignore options that a command does not
- #: understand and will store it on the context for later
- #: processing. This is primarily useful for situations where you
- #: want to call into external programs. Generally this pattern is
- #: strongly discouraged because it's not possibly to losslessly
- #: forward all arguments.
- #:
- #: .. versionadded:: 4.0
- self.ignore_unknown_options: bool = ignore_unknown_options
-
- if help_option_names is None:
- if parent is not None:
- help_option_names = parent.help_option_names
- else:
- help_option_names = ["--help"]
-
- #: The names for the help options.
- self.help_option_names: t.List[str] = help_option_names
-
- if token_normalize_func is None and parent is not None:
- token_normalize_func = parent.token_normalize_func
-
- #: An optional normalization function for tokens. This is
- #: options, choices, commands etc.
- self.token_normalize_func: t.Optional[
- t.Callable[[str], str]
- ] = token_normalize_func
-
- #: Indicates if resilient parsing is enabled. In that case Click
- #: will do its best to not cause any failures and default values
- #: will be ignored. Useful for completion.
- self.resilient_parsing: bool = resilient_parsing
-
- # If there is no envvar prefix yet, but the parent has one and
- # the command on this level has a name, we can expand the envvar
- # prefix automatically.
- if auto_envvar_prefix is None:
- if (
- parent is not None
- and parent.auto_envvar_prefix is not None
- and self.info_name is not None
- ):
- auto_envvar_prefix = (
- f"{parent.auto_envvar_prefix}_{self.info_name.upper()}"
- )
- else:
- auto_envvar_prefix = auto_envvar_prefix.upper()
-
- if auto_envvar_prefix is not None:
- auto_envvar_prefix = auto_envvar_prefix.replace("-", "_")
-
- self.auto_envvar_prefix: t.Optional[str] = auto_envvar_prefix
-
- if color is None and parent is not None:
- color = parent.color
-
- #: Controls if styling output is wanted or not.
- self.color: t.Optional[bool] = color
-
- if show_default is None and parent is not None:
- show_default = parent.show_default
-
- #: Show option default values when formatting help text.
- self.show_default: t.Optional[bool] = show_default
-
- self._close_callbacks: t.List[t.Callable[[], t.Any]] = []
- self._depth = 0
- self._parameter_source: t.Dict[str, ParameterSource] = {}
- self._exit_stack = ExitStack()
-
- def to_info_dict(self) -> t.Dict[str, t.Any]:
- """Gather information that could be useful for a tool generating
- user-facing documentation. This traverses the entire CLI
- structure.
-
- .. code-block:: python
-
- with Context(cli) as ctx:
- info = ctx.to_info_dict()
-
- .. versionadded:: 8.0
- """
- return {
- "command": self.command.to_info_dict(self),
- "info_name": self.info_name,
- "allow_extra_args": self.allow_extra_args,
- "allow_interspersed_args": self.allow_interspersed_args,
- "ignore_unknown_options": self.ignore_unknown_options,
- "auto_envvar_prefix": self.auto_envvar_prefix,
- }
-
- def __enter__(self) -> "Context":
- self._depth += 1
- push_context(self)
- return self
-
- def __exit__(
- self,
- exc_type: t.Optional[t.Type[BaseException]],
- exc_value: t.Optional[BaseException],
- tb: t.Optional[TracebackType],
- ) -> None:
- self._depth -= 1
- if self._depth == 0:
- self.close()
- pop_context()
-
- @contextmanager
- def scope(self, cleanup: bool = True) -> t.Iterator["Context"]:
- """This helper method can be used with the context object to promote
- it to the current thread local (see :func:`get_current_context`).
- The default behavior of this is to invoke the cleanup functions which
- can be disabled by setting `cleanup` to `False`. The cleanup
- functions are typically used for things such as closing file handles.
-
- If the cleanup is intended the context object can also be directly
- used as a context manager.
-
- Example usage::
-
- with ctx.scope():
- assert get_current_context() is ctx
-
- This is equivalent::
-
- with ctx:
- assert get_current_context() is ctx
-
- .. versionadded:: 5.0
-
- :param cleanup: controls if the cleanup functions should be run or
- not. The default is to run these functions. In
- some situations the context only wants to be
- temporarily pushed in which case this can be disabled.
- Nested pushes automatically defer the cleanup.
- """
- if not cleanup:
- self._depth += 1
- try:
- with self as rv:
- yield rv
- finally:
- if not cleanup:
- self._depth -= 1
-
- @property
- def meta(self) -> t.Dict[str, t.Any]:
- """This is a dictionary which is shared with all the contexts
- that are nested. It exists so that click utilities can store some
- state here if they need to. It is however the responsibility of
- that code to manage this dictionary well.
-
- The keys are supposed to be unique dotted strings. For instance
- module paths are a good choice for it. What is stored in there is
- irrelevant for the operation of click. However what is important is
- that code that places data here adheres to the general semantics of
- the system.
-
- Example usage::
-
- LANG_KEY = f'{__name__}.lang'
-
- def set_language(value):
- ctx = get_current_context()
- ctx.meta[LANG_KEY] = value
-
- def get_language():
- return get_current_context().meta.get(LANG_KEY, 'en_US')
-
- .. versionadded:: 5.0
- """
- return self._meta
-
- def make_formatter(self) -> HelpFormatter:
- """Creates the :class:`~click.HelpFormatter` for the help and
- usage output.
-
- To quickly customize the formatter class used without overriding
- this method, set the :attr:`formatter_class` attribute.
-
- .. versionchanged:: 8.0
- Added the :attr:`formatter_class` attribute.
- """
- return self.formatter_class(
- width=self.terminal_width, max_width=self.max_content_width
- )
-
- def with_resource(self, context_manager: t.ContextManager[V]) -> V:
- """Register a resource as if it were used in a ``with``
- statement. The resource will be cleaned up when the context is
- popped.
-
- Uses :meth:`contextlib.ExitStack.enter_context`. It calls the
- resource's ``__enter__()`` method and returns the result. When
- the context is popped, it closes the stack, which calls the
- resource's ``__exit__()`` method.
-
- To register a cleanup function for something that isn't a
- context manager, use :meth:`call_on_close`. Or use something
- from :mod:`contextlib` to turn it into a context manager first.
-
- .. code-block:: python
-
- @click.group()
- @click.option("--name")
- @click.pass_context
- def cli(ctx):
- ctx.obj = ctx.with_resource(connect_db(name))
-
- :param context_manager: The context manager to enter.
- :return: Whatever ``context_manager.__enter__()`` returns.
-
- .. versionadded:: 8.0
- """
- return self._exit_stack.enter_context(context_manager)
-
- def call_on_close(self, f: t.Callable[..., t.Any]) -> t.Callable[..., t.Any]:
- """Register a function to be called when the context tears down.
-
- This can be used to close resources opened during the script
- execution. Resources that support Python's context manager
- protocol which would be used in a ``with`` statement should be
- registered with :meth:`with_resource` instead.
-
- :param f: The function to execute on teardown.
- """
- return self._exit_stack.callback(f)
-
- def close(self) -> None:
- """Invoke all close callbacks registered with
- :meth:`call_on_close`, and exit all context managers entered
- with :meth:`with_resource`.
- """
- self._exit_stack.close()
- # In case the context is reused, create a new exit stack.
- self._exit_stack = ExitStack()
-
- @property
- def command_path(self) -> str:
- """The computed command path. This is used for the ``usage``
- information on the help page. It's automatically created by
- combining the info names of the chain of contexts to the root.
- """
- rv = ""
- if self.info_name is not None:
- rv = self.info_name
- if self.parent is not None:
- parent_command_path = [self.parent.command_path]
-
- if isinstance(self.parent.command, Command):
- for param in self.parent.command.get_params(self):
- parent_command_path.extend(param.get_usage_pieces(self))
-
- rv = f"{' '.join(parent_command_path)} {rv}"
- return rv.lstrip()
-
- def find_root(self) -> "Context":
- """Finds the outermost context."""
- node = self
- while node.parent is not None:
- node = node.parent
- return node
-
- def find_object(self, object_type: t.Type[V]) -> t.Optional[V]:
- """Finds the closest object of a given type."""
- node: t.Optional["Context"] = self
-
- while node is not None:
- if isinstance(node.obj, object_type):
- return node.obj
-
- node = node.parent
-
- return None
-
- def ensure_object(self, object_type: t.Type[V]) -> V:
- """Like :meth:`find_object` but sets the innermost object to a
- new instance of `object_type` if it does not exist.
- """
- rv = self.find_object(object_type)
- if rv is None:
- self.obj = rv = object_type()
- return rv
-
- @t.overload
- def lookup_default(
- self, name: str, call: "te.Literal[True]" = True
- ) -> t.Optional[t.Any]:
- ...
-
- @t.overload
- def lookup_default(
- self, name: str, call: "te.Literal[False]" = ...
- ) -> t.Optional[t.Union[t.Any, t.Callable[[], t.Any]]]:
- ...
-
- def lookup_default(self, name: str, call: bool = True) -> t.Optional[t.Any]:
- """Get the default for a parameter from :attr:`default_map`.
-
- :param name: Name of the parameter.
- :param call: If the default is a callable, call it. Disable to
- return the callable instead.
-
- .. versionchanged:: 8.0
- Added the ``call`` parameter.
- """
- if self.default_map is not None:
- value = self.default_map.get(name)
-
- if call and callable(value):
- return value()
-
- return value
-
- return None
-
- def fail(self, message: str) -> "te.NoReturn":
- """Aborts the execution of the program with a specific error
- message.
-
- :param message: the error message to fail with.
- """
- raise UsageError(message, self)
-
- def abort(self) -> "te.NoReturn":
- """Aborts the script."""
- raise Abort()
-
- def exit(self, code: int = 0) -> "te.NoReturn":
- """Exits the application with a given exit code."""
- raise Exit(code)
-
- def get_usage(self) -> str:
- """Helper method to get formatted usage string for the current
- context and command.
- """
- return self.command.get_usage(self)
-
- def get_help(self) -> str:
- """Helper method to get formatted help page for the current
- context and command.
- """
- return self.command.get_help(self)
-
- def _make_sub_context(self, command: "Command") -> "Context":
- """Create a new context of the same type as this context, but
- for a new command.
-
- :meta private:
- """
- return type(self)(command, info_name=command.name, parent=self)
-
- @t.overload
- def invoke(
- __self, # noqa: B902
- __callback: "t.Callable[..., V]",
- *args: t.Any,
- **kwargs: t.Any,
- ) -> V:
- ...
-
- @t.overload
- def invoke(
- __self, # noqa: B902
- __callback: "Command",
- *args: t.Any,
- **kwargs: t.Any,
- ) -> t.Any:
- ...
-
- def invoke(
- __self, # noqa: B902
- __callback: t.Union["Command", "t.Callable[..., V]"],
- *args: t.Any,
- **kwargs: t.Any,
- ) -> t.Union[t.Any, V]:
- """Invokes a command callback in exactly the way it expects. There
- are two ways to invoke this method:
-
- 1. the first argument can be a callback and all other arguments and
- keyword arguments are forwarded directly to the function.
- 2. the first argument is a click command object. In that case all
- arguments are forwarded as well but proper click parameters
- (options and click arguments) must be keyword arguments and Click
- will fill in defaults.
-
- Note that before Click 3.2 keyword arguments were not properly filled
- in against the intention of this code and no context was created. For
- more information about this change and why it was done in a bugfix
- release see :ref:`upgrade-to-3.2`.
-
- .. versionchanged:: 8.0
- All ``kwargs`` are tracked in :attr:`params` so they will be
- passed if :meth:`forward` is called at multiple levels.
- """
- if isinstance(__callback, Command):
- other_cmd = __callback
-
- if other_cmd.callback is None:
- raise TypeError(
- "The given command does not have a callback that can be invoked."
- )
- else:
- __callback = t.cast("t.Callable[..., V]", other_cmd.callback)
-
- ctx = __self._make_sub_context(other_cmd)
-
- for param in other_cmd.params:
- if param.name not in kwargs and param.expose_value:
- kwargs[param.name] = param.type_cast_value( # type: ignore
- ctx, param.get_default(ctx)
- )
-
- # Track all kwargs as params, so that forward() will pass
- # them on in subsequent calls.
- ctx.params.update(kwargs)
- else:
- ctx = __self
-
- with augment_usage_errors(__self):
- with ctx:
- return __callback(*args, **kwargs)
-
- def forward(
- __self, __cmd: "Command", *args: t.Any, **kwargs: t.Any # noqa: B902
- ) -> t.Any:
- """Similar to :meth:`invoke` but fills in default keyword
- arguments from the current context if the other command expects
- it. This cannot invoke callbacks directly, only other commands.
-
- .. versionchanged:: 8.0
- All ``kwargs`` are tracked in :attr:`params` so they will be
- passed if ``forward`` is called at multiple levels.
- """
- # Can only forward to other commands, not direct callbacks.
- if not isinstance(__cmd, Command):
- raise TypeError("Callback is not a command.")
-
- for param in __self.params:
- if param not in kwargs:
- kwargs[param] = __self.params[param]
-
- return __self.invoke(__cmd, *args, **kwargs)
-
- def set_parameter_source(self, name: str, source: ParameterSource) -> None:
- """Set the source of a parameter. This indicates the location
- from which the value of the parameter was obtained.
-
- :param name: The name of the parameter.
- :param source: A member of :class:`~click.core.ParameterSource`.
- """
- self._parameter_source[name] = source
-
- def get_parameter_source(self, name: str) -> t.Optional[ParameterSource]:
- """Get the source of a parameter. This indicates the location
- from which the value of the parameter was obtained.
-
- This can be useful for determining when a user specified a value
- on the command line that is the same as the default value. It
- will be :attr:`~click.core.ParameterSource.DEFAULT` only if the
- value was actually taken from the default.
-
- :param name: The name of the parameter.
- :rtype: ParameterSource
-
- .. versionchanged:: 8.0
- Returns ``None`` if the parameter was not provided from any
- source.
- """
- return self._parameter_source.get(name)
-
-
-class BaseCommand:
- """The base command implements the minimal API contract of commands.
- Most code will never use this as it does not implement a lot of useful
- functionality but it can act as the direct subclass of alternative
- parsing methods that do not depend on the Click parser.
-
- For instance, this can be used to bridge Click and other systems like
- argparse or docopt.
-
- Because base commands do not implement a lot of the API that other
- parts of Click take for granted, they are not supported for all
- operations. For instance, they cannot be used with the decorators
- usually and they have no built-in callback system.
-
- .. versionchanged:: 2.0
- Added the `context_settings` parameter.
-
- :param name: the name of the command to use unless a group overrides it.
- :param context_settings: an optional dictionary with defaults that are
- passed to the context object.
- """
-
- #: The context class to create with :meth:`make_context`.
- #:
- #: .. versionadded:: 8.0
- context_class: t.Type[Context] = Context
- #: the default for the :attr:`Context.allow_extra_args` flag.
- allow_extra_args = False
- #: the default for the :attr:`Context.allow_interspersed_args` flag.
- allow_interspersed_args = True
- #: the default for the :attr:`Context.ignore_unknown_options` flag.
- ignore_unknown_options = False
-
- def __init__(
- self,
- name: t.Optional[str],
- context_settings: t.Optional[t.MutableMapping[str, t.Any]] = None,
- ) -> None:
- #: the name the command thinks it has. Upon registering a command
- #: on a :class:`Group` the group will default the command name
- #: with this information. You should instead use the
- #: :class:`Context`\'s :attr:`~Context.info_name` attribute.
- self.name = name
-
- if context_settings is None:
- context_settings = {}
-
- #: an optional dictionary with defaults passed to the context.
- self.context_settings: t.MutableMapping[str, t.Any] = context_settings
-
- def to_info_dict(self, ctx: Context) -> t.Dict[str, t.Any]:
- """Gather information that could be useful for a tool generating
- user-facing documentation. This traverses the entire structure
- below this command.
-
- Use :meth:`click.Context.to_info_dict` to traverse the entire
- CLI structure.
-
- :param ctx: A :class:`Context` representing this command.
-
- .. versionadded:: 8.0
- """
- return {"name": self.name}
-
- def __repr__(self) -> str:
- return f"<{self.__class__.__name__} {self.name}>"
-
- def get_usage(self, ctx: Context) -> str:
- raise NotImplementedError("Base commands cannot get usage")
-
- def get_help(self, ctx: Context) -> str:
- raise NotImplementedError("Base commands cannot get help")
-
- def make_context(
- self,
- info_name: t.Optional[str],
- args: t.List[str],
- parent: t.Optional[Context] = None,
- **extra: t.Any,
- ) -> Context:
- """This function when given an info name and arguments will kick
- off the parsing and create a new :class:`Context`. It does not
- invoke the actual command callback though.
-
- To quickly customize the context class used without overriding
- this method, set the :attr:`context_class` attribute.
-
- :param info_name: the info name for this invocation. Generally this
- is the most descriptive name for the script or
- command. For the toplevel script it's usually
- the name of the script, for commands below it's
- the name of the command.
- :param args: the arguments to parse as list of strings.
- :param parent: the parent context if available.
- :param extra: extra keyword arguments forwarded to the context
- constructor.
-
- .. versionchanged:: 8.0
- Added the :attr:`context_class` attribute.
- """
- for key, value in self.context_settings.items():
- if key not in extra:
- extra[key] = value
-
- ctx = self.context_class(
- self, info_name=info_name, parent=parent, **extra # type: ignore
- )
-
- with ctx.scope(cleanup=False):
- self.parse_args(ctx, args)
- return ctx
-
- def parse_args(self, ctx: Context, args: t.List[str]) -> t.List[str]:
- """Given a context and a list of arguments this creates the parser
- and parses the arguments, then modifies the context as necessary.
- This is automatically invoked by :meth:`make_context`.
- """
- raise NotImplementedError("Base commands do not know how to parse arguments.")
-
- def invoke(self, ctx: Context) -> t.Any:
- """Given a context, this invokes the command. The default
- implementation is raising a not implemented error.
- """
- raise NotImplementedError("Base commands are not invocable by default")
-
- def shell_complete(self, ctx: Context, incomplete: str) -> t.List["CompletionItem"]:
- """Return a list of completions for the incomplete value. Looks
- at the names of chained multi-commands.
-
- Any command could be part of a chained multi-command, so sibling
- commands are valid at any point during command completion. Other
- command classes will return more completions.
-
- :param ctx: Invocation context for this command.
- :param incomplete: Value being completed. May be empty.
-
- .. versionadded:: 8.0
- """
- from click.shell_completion import CompletionItem
-
- results: t.List["CompletionItem"] = []
-
- while ctx.parent is not None:
- ctx = ctx.parent
-
- if isinstance(ctx.command, MultiCommand) and ctx.command.chain:
- results.extend(
- CompletionItem(name, help=command.get_short_help_str())
- for name, command in _complete_visible_commands(ctx, incomplete)
- if name not in ctx.protected_args
- )
-
- return results
-
- @t.overload
- def main(
- self,
- args: t.Optional[t.Sequence[str]] = None,
- prog_name: t.Optional[str] = None,
- complete_var: t.Optional[str] = None,
- standalone_mode: "te.Literal[True]" = True,
- **extra: t.Any,
- ) -> "te.NoReturn":
- ...
-
- @t.overload
- def main(
- self,
- args: t.Optional[t.Sequence[str]] = None,
- prog_name: t.Optional[str] = None,
- complete_var: t.Optional[str] = None,
- standalone_mode: bool = ...,
- **extra: t.Any,
- ) -> t.Any:
- ...
-
- def main(
- self,
- args: t.Optional[t.Sequence[str]] = None,
- prog_name: t.Optional[str] = None,
- complete_var: t.Optional[str] = None,
- standalone_mode: bool = True,
- windows_expand_args: bool = True,
- **extra: t.Any,
- ) -> t.Any:
- """This is the way to invoke a script with all the bells and
- whistles as a command line application. This will always terminate
- the application after a call. If this is not wanted, ``SystemExit``
- needs to be caught.
-
- This method is also available by directly calling the instance of
- a :class:`Command`.
-
- :param args: the arguments that should be used for parsing. If not
- provided, ``sys.argv[1:]`` is used.
- :param prog_name: the program name that should be used. By default
- the program name is constructed by taking the file
- name from ``sys.argv[0]``.
- :param complete_var: the environment variable that controls the
- bash completion support. The default is
- ``"__COMPLETE"`` with prog_name in
- uppercase.
- :param standalone_mode: the default behavior is to invoke the script
- in standalone mode. Click will then
- handle exceptions and convert them into
- error messages and the function will never
- return but shut down the interpreter. If
- this is set to `False` they will be
- propagated to the caller and the return
- value of this function is the return value
- of :meth:`invoke`.
- :param windows_expand_args: Expand glob patterns, user dir, and
- env vars in command line args on Windows.
- :param extra: extra keyword arguments are forwarded to the context
- constructor. See :class:`Context` for more information.
-
- .. versionchanged:: 8.0.1
- Added the ``windows_expand_args`` parameter to allow
- disabling command line arg expansion on Windows.
-
- .. versionchanged:: 8.0
- When taking arguments from ``sys.argv`` on Windows, glob
- patterns, user dir, and env vars are expanded.
-
- .. versionchanged:: 3.0
- Added the ``standalone_mode`` parameter.
- """
- if args is None:
- args = sys.argv[1:]
-
- if os.name == "nt" and windows_expand_args:
- args = _expand_args(args)
- else:
- args = list(args)
-
- if prog_name is None:
- prog_name = _detect_program_name()
-
- # Process shell completion requests and exit early.
- self._main_shell_completion(extra, prog_name, complete_var)
-
- try:
- try:
- with self.make_context(prog_name, args, **extra) as ctx:
- rv = self.invoke(ctx)
- if not standalone_mode:
- return rv
- # it's not safe to `ctx.exit(rv)` here!
- # note that `rv` may actually contain data like "1" which
- # has obvious effects
- # more subtle case: `rv=[None, None]` can come out of
- # chained commands which all returned `None` -- so it's not
- # even always obvious that `rv` indicates success/failure
- # by its truthiness/falsiness
- ctx.exit()
- except (EOFError, KeyboardInterrupt) as e:
- echo(file=sys.stderr)
- raise Abort() from e
- except ClickException as e:
- if not standalone_mode:
- raise
- e.show()
- sys.exit(e.exit_code)
- except OSError as e:
- if e.errno == errno.EPIPE:
- sys.stdout = t.cast(t.TextIO, PacifyFlushWrapper(sys.stdout))
- sys.stderr = t.cast(t.TextIO, PacifyFlushWrapper(sys.stderr))
- sys.exit(1)
- else:
- raise
- except Exit as e:
- if standalone_mode:
- sys.exit(e.exit_code)
- else:
- # in non-standalone mode, return the exit code
- # note that this is only reached if `self.invoke` above raises
- # an Exit explicitly -- thus bypassing the check there which
- # would return its result
- # the results of non-standalone execution may therefore be
- # somewhat ambiguous: if there are codepaths which lead to
- # `ctx.exit(1)` and to `return 1`, the caller won't be able to
- # tell the difference between the two
- return e.exit_code
- except Abort:
- if not standalone_mode:
- raise
- echo(_("Aborted!"), file=sys.stderr)
- sys.exit(1)
-
- def _main_shell_completion(
- self,
- ctx_args: t.MutableMapping[str, t.Any],
- prog_name: str,
- complete_var: t.Optional[str] = None,
- ) -> None:
- """Check if the shell is asking for tab completion, process
- that, then exit early. Called from :meth:`main` before the
- program is invoked.
-
- :param prog_name: Name of the executable in the shell.
- :param complete_var: Name of the environment variable that holds
- the completion instruction. Defaults to
- ``_{PROG_NAME}_COMPLETE``.
-
- .. versionchanged:: 8.2.0
- Dots (``.``) in ``prog_name`` are replaced with underscores (``_``).
- """
- if complete_var is None:
- complete_name = prog_name.replace("-", "_").replace(".", "_")
- complete_var = f"_{complete_name}_COMPLETE".upper()
-
- instruction = os.environ.get(complete_var)
-
- if not instruction:
- return
-
- from .shell_completion import shell_complete
-
- rv = shell_complete(self, ctx_args, prog_name, complete_var, instruction)
- sys.exit(rv)
-
- def __call__(self, *args: t.Any, **kwargs: t.Any) -> t.Any:
- """Alias for :meth:`main`."""
- return self.main(*args, **kwargs)
-
-
-class Command(BaseCommand):
- """Commands are the basic building block of command line interfaces in
- Click. A basic command handles command line parsing and might dispatch
- more parsing to commands nested below it.
-
- :param name: the name of the command to use unless a group overrides it.
- :param context_settings: an optional dictionary with defaults that are
- passed to the context object.
- :param callback: the callback to invoke. This is optional.
- :param params: the parameters to register with this command. This can
- be either :class:`Option` or :class:`Argument` objects.
- :param help: the help string to use for this command.
- :param epilog: like the help string but it's printed at the end of the
- help page after everything else.
- :param short_help: the short help to use for this command. This is
- shown on the command listing of the parent command.
- :param add_help_option: by default each command registers a ``--help``
- option. This can be disabled by this parameter.
- :param no_args_is_help: this controls what happens if no arguments are
- provided. This option is disabled by default.
- If enabled this will add ``--help`` as argument
- if no arguments are passed
- :param hidden: hide this command from help outputs.
-
- :param deprecated: issues a message indicating that
- the command is deprecated.
-
- .. versionchanged:: 8.1
- ``help``, ``epilog``, and ``short_help`` are stored unprocessed,
- all formatting is done when outputting help text, not at init,
- and is done even if not using the ``@command`` decorator.
-
- .. versionchanged:: 8.0
- Added a ``repr`` showing the command name.
-
- .. versionchanged:: 7.1
- Added the ``no_args_is_help`` parameter.
-
- .. versionchanged:: 2.0
- Added the ``context_settings`` parameter.
- """
-
- def __init__(
- self,
- name: t.Optional[str],
- context_settings: t.Optional[t.MutableMapping[str, t.Any]] = None,
- callback: t.Optional[t.Callable[..., t.Any]] = None,
- params: t.Optional[t.List["Parameter"]] = None,
- help: t.Optional[str] = None,
- epilog: t.Optional[str] = None,
- short_help: t.Optional[str] = None,
- options_metavar: t.Optional[str] = "[OPTIONS]",
- add_help_option: bool = True,
- no_args_is_help: bool = False,
- hidden: bool = False,
- deprecated: bool = False,
- ) -> None:
- super().__init__(name, context_settings)
- #: the callback to execute when the command fires. This might be
- #: `None` in which case nothing happens.
- self.callback = callback
- #: the list of parameters for this command in the order they
- #: should show up in the help page and execute. Eager parameters
- #: will automatically be handled before non eager ones.
- self.params: t.List["Parameter"] = params or []
- self.help = help
- self.epilog = epilog
- self.options_metavar = options_metavar
- self.short_help = short_help
- self.add_help_option = add_help_option
- self.no_args_is_help = no_args_is_help
- self.hidden = hidden
- self.deprecated = deprecated
-
- def to_info_dict(self, ctx: Context) -> t.Dict[str, t.Any]:
- info_dict = super().to_info_dict(ctx)
- info_dict.update(
- params=[param.to_info_dict() for param in self.get_params(ctx)],
- help=self.help,
- epilog=self.epilog,
- short_help=self.short_help,
- hidden=self.hidden,
- deprecated=self.deprecated,
- )
- return info_dict
-
- def get_usage(self, ctx: Context) -> str:
- """Formats the usage line into a string and returns it.
-
- Calls :meth:`format_usage` internally.
- """
- formatter = ctx.make_formatter()
- self.format_usage(ctx, formatter)
- return formatter.getvalue().rstrip("\n")
-
- def get_params(self, ctx: Context) -> t.List["Parameter"]:
- rv = self.params
- help_option = self.get_help_option(ctx)
-
- if help_option is not None:
- rv = [*rv, help_option]
-
- return rv
-
- def format_usage(self, ctx: Context, formatter: HelpFormatter) -> None:
- """Writes the usage line into the formatter.
-
- This is a low-level method called by :meth:`get_usage`.
- """
- pieces = self.collect_usage_pieces(ctx)
- formatter.write_usage(ctx.command_path, " ".join(pieces))
-
- def collect_usage_pieces(self, ctx: Context) -> t.List[str]:
- """Returns all the pieces that go into the usage line and returns
- it as a list of strings.
- """
- rv = [self.options_metavar] if self.options_metavar else []
-
- for param in self.get_params(ctx):
- rv.extend(param.get_usage_pieces(ctx))
-
- return rv
-
- def get_help_option_names(self, ctx: Context) -> t.List[str]:
- """Returns the names for the help option."""
- all_names = set(ctx.help_option_names)
- for param in self.params:
- all_names.difference_update(param.opts)
- all_names.difference_update(param.secondary_opts)
- return list(all_names)
-
- def get_help_option(self, ctx: Context) -> t.Optional["Option"]:
- """Returns the help option object."""
- help_options = self.get_help_option_names(ctx)
-
- if not help_options or not self.add_help_option:
- return None
-
- def show_help(ctx: Context, param: "Parameter", value: str) -> None:
- if value and not ctx.resilient_parsing:
- echo(ctx.get_help(), color=ctx.color)
- ctx.exit()
-
- return Option(
- help_options,
- is_flag=True,
- is_eager=True,
- expose_value=False,
- callback=show_help,
- help=_("Show this message and exit."),
- )
-
- def make_parser(self, ctx: Context) -> OptionParser:
- """Creates the underlying option parser for this command."""
- parser = OptionParser(ctx)
- for param in self.get_params(ctx):
- param.add_to_parser(parser, ctx)
- return parser
-
- def get_help(self, ctx: Context) -> str:
- """Formats the help into a string and returns it.
-
- Calls :meth:`format_help` internally.
- """
- formatter = ctx.make_formatter()
- self.format_help(ctx, formatter)
- return formatter.getvalue().rstrip("\n")
-
- def get_short_help_str(self, limit: int = 45) -> str:
- """Gets short help for the command or makes it by shortening the
- long help string.
- """
- if self.short_help:
- text = inspect.cleandoc(self.short_help)
- elif self.help:
- text = make_default_short_help(self.help, limit)
- else:
- text = ""
-
- if self.deprecated:
- text = _("(Deprecated) {text}").format(text=text)
-
- return text.strip()
-
- def format_help(self, ctx: Context, formatter: HelpFormatter) -> None:
- """Writes the help into the formatter if it exists.
-
- This is a low-level method called by :meth:`get_help`.
-
- This calls the following methods:
-
- - :meth:`format_usage`
- - :meth:`format_help_text`
- - :meth:`format_options`
- - :meth:`format_epilog`
- """
- self.format_usage(ctx, formatter)
- self.format_help_text(ctx, formatter)
- self.format_options(ctx, formatter)
- self.format_epilog(ctx, formatter)
-
- def format_help_text(self, ctx: Context, formatter: HelpFormatter) -> None:
- """Writes the help text to the formatter if it exists."""
- if self.help is not None:
- # truncate the help text to the first form feed
- text = inspect.cleandoc(self.help).partition("\f")[0]
- else:
- text = ""
-
- if self.deprecated:
- text = _("(Deprecated) {text}").format(text=text)
-
- if text:
- formatter.write_paragraph()
-
- with formatter.indentation():
- formatter.write_text(text)
-
- def format_options(self, ctx: Context, formatter: HelpFormatter) -> None:
- """Writes all the options into the formatter if they exist."""
- opts = []
- for param in self.get_params(ctx):
- rv = param.get_help_record(ctx)
- if rv is not None:
- opts.append(rv)
-
- if opts:
- with formatter.section(_("Options")):
- formatter.write_dl(opts)
-
- def format_epilog(self, ctx: Context, formatter: HelpFormatter) -> None:
- """Writes the epilog into the formatter if it exists."""
- if self.epilog:
- epilog = inspect.cleandoc(self.epilog)
- formatter.write_paragraph()
-
- with formatter.indentation():
- formatter.write_text(epilog)
-
- def parse_args(self, ctx: Context, args: t.List[str]) -> t.List[str]:
- if not args and self.no_args_is_help and not ctx.resilient_parsing:
- echo(ctx.get_help(), color=ctx.color)
- ctx.exit()
-
- parser = self.make_parser(ctx)
- opts, args, param_order = parser.parse_args(args=args)
-
- for param in iter_params_for_processing(param_order, self.get_params(ctx)):
- value, args = param.handle_parse_result(ctx, opts, args)
-
- if args and not ctx.allow_extra_args and not ctx.resilient_parsing:
- ctx.fail(
- ngettext(
- "Got unexpected extra argument ({args})",
- "Got unexpected extra arguments ({args})",
- len(args),
- ).format(args=" ".join(map(str, args)))
- )
-
- ctx.args = args
- ctx._opt_prefixes.update(parser._opt_prefixes)
- return args
-
- def invoke(self, ctx: Context) -> t.Any:
- """Given a context, this invokes the attached callback (if it exists)
- in the right way.
- """
- if self.deprecated:
- message = _(
- "DeprecationWarning: The command {name!r} is deprecated."
- ).format(name=self.name)
- echo(style(message, fg="red"), err=True)
-
- if self.callback is not None:
- return ctx.invoke(self.callback, **ctx.params)
-
- def shell_complete(self, ctx: Context, incomplete: str) -> t.List["CompletionItem"]:
- """Return a list of completions for the incomplete value. Looks
- at the names of options and chained multi-commands.
-
- :param ctx: Invocation context for this command.
- :param incomplete: Value being completed. May be empty.
-
- .. versionadded:: 8.0
- """
- from click.shell_completion import CompletionItem
-
- results: t.List["CompletionItem"] = []
-
- if incomplete and not incomplete[0].isalnum():
- for param in self.get_params(ctx):
- if (
- not isinstance(param, Option)
- or param.hidden
- or (
- not param.multiple
- and ctx.get_parameter_source(param.name) # type: ignore
- is ParameterSource.COMMANDLINE
- )
- ):
- continue
-
- results.extend(
- CompletionItem(name, help=param.help)
- for name in [*param.opts, *param.secondary_opts]
- if name.startswith(incomplete)
- )
-
- results.extend(super().shell_complete(ctx, incomplete))
- return results
-
-
-class MultiCommand(Command):
- """A multi command is the basic implementation of a command that
- dispatches to subcommands. The most common version is the
- :class:`Group`.
-
- :param invoke_without_command: this controls how the multi command itself
- is invoked. By default it's only invoked
- if a subcommand is provided.
- :param no_args_is_help: this controls what happens if no arguments are
- provided. This option is enabled by default if
- `invoke_without_command` is disabled or disabled
- if it's enabled. If enabled this will add
- ``--help`` as argument if no arguments are
- passed.
- :param subcommand_metavar: the string that is used in the documentation
- to indicate the subcommand place.
- :param chain: if this is set to `True` chaining of multiple subcommands
- is enabled. This restricts the form of commands in that
- they cannot have optional arguments but it allows
- multiple commands to be chained together.
- :param result_callback: The result callback to attach to this multi
- command. This can be set or changed later with the
- :meth:`result_callback` decorator.
- :param attrs: Other command arguments described in :class:`Command`.
- """
-
- allow_extra_args = True
- allow_interspersed_args = False
-
- def __init__(
- self,
- name: t.Optional[str] = None,
- invoke_without_command: bool = False,
- no_args_is_help: t.Optional[bool] = None,
- subcommand_metavar: t.Optional[str] = None,
- chain: bool = False,
- result_callback: t.Optional[t.Callable[..., t.Any]] = None,
- **attrs: t.Any,
- ) -> None:
- super().__init__(name, **attrs)
-
- if no_args_is_help is None:
- no_args_is_help = not invoke_without_command
-
- self.no_args_is_help = no_args_is_help
- self.invoke_without_command = invoke_without_command
-
- if subcommand_metavar is None:
- if chain:
- subcommand_metavar = "COMMAND1 [ARGS]... [COMMAND2 [ARGS]...]..."
- else:
- subcommand_metavar = "COMMAND [ARGS]..."
-
- self.subcommand_metavar = subcommand_metavar
- self.chain = chain
- # The result callback that is stored. This can be set or
- # overridden with the :func:`result_callback` decorator.
- self._result_callback = result_callback
-
- if self.chain:
- for param in self.params:
- if isinstance(param, Argument) and not param.required:
- raise RuntimeError(
- "Multi commands in chain mode cannot have"
- " optional arguments."
- )
-
- def to_info_dict(self, ctx: Context) -> t.Dict[str, t.Any]:
- info_dict = super().to_info_dict(ctx)
- commands = {}
-
- for name in self.list_commands(ctx):
- command = self.get_command(ctx, name)
-
- if command is None:
- continue
-
- sub_ctx = ctx._make_sub_context(command)
-
- with sub_ctx.scope(cleanup=False):
- commands[name] = command.to_info_dict(sub_ctx)
-
- info_dict.update(commands=commands, chain=self.chain)
- return info_dict
-
- def collect_usage_pieces(self, ctx: Context) -> t.List[str]:
- rv = super().collect_usage_pieces(ctx)
- rv.append(self.subcommand_metavar)
- return rv
-
- def format_options(self, ctx: Context, formatter: HelpFormatter) -> None:
- super().format_options(ctx, formatter)
- self.format_commands(ctx, formatter)
-
- def result_callback(self, replace: bool = False) -> t.Callable[[F], F]:
- """Adds a result callback to the command. By default if a
- result callback is already registered this will chain them but
- this can be disabled with the `replace` parameter. The result
- callback is invoked with the return value of the subcommand
- (or the list of return values from all subcommands if chaining
- is enabled) as well as the parameters as they would be passed
- to the main callback.
-
- Example::
-
- @click.group()
- @click.option('-i', '--input', default=23)
- def cli(input):
- return 42
-
- @cli.result_callback()
- def process_result(result, input):
- return result + input
-
- :param replace: if set to `True` an already existing result
- callback will be removed.
-
- .. versionchanged:: 8.0
- Renamed from ``resultcallback``.
-
- .. versionadded:: 3.0
- """
-
- def decorator(f: F) -> F:
- old_callback = self._result_callback
-
- if old_callback is None or replace:
- self._result_callback = f
- return f
-
- def function(__value, *args, **kwargs): # type: ignore
- inner = old_callback(__value, *args, **kwargs)
- return f(inner, *args, **kwargs)
-
- self._result_callback = rv = update_wrapper(t.cast(F, function), f)
- return rv
-
- return decorator
-
- def format_commands(self, ctx: Context, formatter: HelpFormatter) -> None:
- """Extra format methods for multi methods that adds all the commands
- after the options.
- """
- commands = []
- for subcommand in self.list_commands(ctx):
- cmd = self.get_command(ctx, subcommand)
- # What is this, the tool lied about a command. Ignore it
- if cmd is None:
- continue
- if cmd.hidden:
- continue
-
- commands.append((subcommand, cmd))
-
- # allow for 3 times the default spacing
- if len(commands):
- limit = formatter.width - 6 - max(len(cmd[0]) for cmd in commands)
-
- rows = []
- for subcommand, cmd in commands:
- help = cmd.get_short_help_str(limit)
- rows.append((subcommand, help))
-
- if rows:
- with formatter.section(_("Commands")):
- formatter.write_dl(rows)
-
- def parse_args(self, ctx: Context, args: t.List[str]) -> t.List[str]:
- if not args and self.no_args_is_help and not ctx.resilient_parsing:
- echo(ctx.get_help(), color=ctx.color)
- ctx.exit()
-
- rest = super().parse_args(ctx, args)
-
- if self.chain:
- ctx.protected_args = rest
- ctx.args = []
- elif rest:
- ctx.protected_args, ctx.args = rest[:1], rest[1:]
-
- return ctx.args
-
- def invoke(self, ctx: Context) -> t.Any:
- def _process_result(value: t.Any) -> t.Any:
- if self._result_callback is not None:
- value = ctx.invoke(self._result_callback, value, **ctx.params)
- return value
-
- if not ctx.protected_args:
- if self.invoke_without_command:
- # No subcommand was invoked, so the result callback is
- # invoked with the group return value for regular
- # groups, or an empty list for chained groups.
- with ctx:
- rv = super().invoke(ctx)
- return _process_result([] if self.chain else rv)
- ctx.fail(_("Missing command."))
-
- # Fetch args back out
- args = [*ctx.protected_args, *ctx.args]
- ctx.args = []
- ctx.protected_args = []
-
- # If we're not in chain mode, we only allow the invocation of a
- # single command but we also inform the current context about the
- # name of the command to invoke.
- if not self.chain:
- # Make sure the context is entered so we do not clean up
- # resources until the result processor has worked.
- with ctx:
- cmd_name, cmd, args = self.resolve_command(ctx, args)
- assert cmd is not None
- ctx.invoked_subcommand = cmd_name
- super().invoke(ctx)
- sub_ctx = cmd.make_context(cmd_name, args, parent=ctx)
- with sub_ctx:
- return _process_result(sub_ctx.command.invoke(sub_ctx))
-
- # In chain mode we create the contexts step by step, but after the
- # base command has been invoked. Because at that point we do not
- # know the subcommands yet, the invoked subcommand attribute is
- # set to ``*`` to inform the command that subcommands are executed
- # but nothing else.
- with ctx:
- ctx.invoked_subcommand = "*" if args else None
- super().invoke(ctx)
-
- # Otherwise we make every single context and invoke them in a
- # chain. In that case the return value to the result processor
- # is the list of all invoked subcommand's results.
- contexts = []
- while args:
- cmd_name, cmd, args = self.resolve_command(ctx, args)
- assert cmd is not None
- sub_ctx = cmd.make_context(
- cmd_name,
- args,
- parent=ctx,
- allow_extra_args=True,
- allow_interspersed_args=False,
- )
- contexts.append(sub_ctx)
- args, sub_ctx.args = sub_ctx.args, []
-
- rv = []
- for sub_ctx in contexts:
- with sub_ctx:
- rv.append(sub_ctx.command.invoke(sub_ctx))
- return _process_result(rv)
-
- def resolve_command(
- self, ctx: Context, args: t.List[str]
- ) -> t.Tuple[t.Optional[str], t.Optional[Command], t.List[str]]:
- cmd_name = make_str(args[0])
- original_cmd_name = cmd_name
-
- # Get the command
- cmd = self.get_command(ctx, cmd_name)
-
- # If we can't find the command but there is a normalization
- # function available, we try with that one.
- if cmd is None and ctx.token_normalize_func is not None:
- cmd_name = ctx.token_normalize_func(cmd_name)
- cmd = self.get_command(ctx, cmd_name)
-
- # If we don't find the command we want to show an error message
- # to the user that it was not provided. However, there is
- # something else we should do: if the first argument looks like
- # an option we want to kick off parsing again for arguments to
- # resolve things like --help which now should go to the main
- # place.
- if cmd is None and not ctx.resilient_parsing:
- if split_opt(cmd_name)[0]:
- self.parse_args(ctx, ctx.args)
- ctx.fail(_("No such command {name!r}.").format(name=original_cmd_name))
- return cmd_name if cmd else None, cmd, args[1:]
-
- def get_command(self, ctx: Context, cmd_name: str) -> t.Optional[Command]:
- """Given a context and a command name, this returns a
- :class:`Command` object if it exists or returns `None`.
- """
- raise NotImplementedError
-
- def list_commands(self, ctx: Context) -> t.List[str]:
- """Returns a list of subcommand names in the order they should
- appear.
- """
- return []
-
- def shell_complete(self, ctx: Context, incomplete: str) -> t.List["CompletionItem"]:
- """Return a list of completions for the incomplete value. Looks
- at the names of options, subcommands, and chained
- multi-commands.
-
- :param ctx: Invocation context for this command.
- :param incomplete: Value being completed. May be empty.
-
- .. versionadded:: 8.0
- """
- from click.shell_completion import CompletionItem
-
- results = [
- CompletionItem(name, help=command.get_short_help_str())
- for name, command in _complete_visible_commands(ctx, incomplete)
- ]
- results.extend(super().shell_complete(ctx, incomplete))
- return results
-
-
-class Group(MultiCommand):
- """A group allows a command to have subcommands attached. This is
- the most common way to implement nesting in Click.
-
- :param name: The name of the group command.
- :param commands: A dict mapping names to :class:`Command` objects.
- Can also be a list of :class:`Command`, which will use
- :attr:`Command.name` to create the dict.
- :param attrs: Other command arguments described in
- :class:`MultiCommand`, :class:`Command`, and
- :class:`BaseCommand`.
-
- .. versionchanged:: 8.0
- The ``commands`` argument can be a list of command objects.
- """
-
- #: If set, this is used by the group's :meth:`command` decorator
- #: as the default :class:`Command` class. This is useful to make all
- #: subcommands use a custom command class.
- #:
- #: .. versionadded:: 8.0
- command_class: t.Optional[t.Type[Command]] = None
-
- #: If set, this is used by the group's :meth:`group` decorator
- #: as the default :class:`Group` class. This is useful to make all
- #: subgroups use a custom group class.
- #:
- #: If set to the special value :class:`type` (literally
- #: ``group_class = type``), this group's class will be used as the
- #: default class. This makes a custom group class continue to make
- #: custom groups.
- #:
- #: .. versionadded:: 8.0
- group_class: t.Optional[t.Union[t.Type["Group"], t.Type[type]]] = None
- # Literal[type] isn't valid, so use Type[type]
-
- def __init__(
- self,
- name: t.Optional[str] = None,
- commands: t.Optional[
- t.Union[t.MutableMapping[str, Command], t.Sequence[Command]]
- ] = None,
- **attrs: t.Any,
- ) -> None:
- super().__init__(name, **attrs)
-
- if commands is None:
- commands = {}
- elif isinstance(commands, abc.Sequence):
- commands = {c.name: c for c in commands if c.name is not None}
-
- #: The registered subcommands by their exported names.
- self.commands: t.MutableMapping[str, Command] = commands
-
- def add_command(self, cmd: Command, name: t.Optional[str] = None) -> None:
- """Registers another :class:`Command` with this group. If the name
- is not provided, the name of the command is used.
- """
- name = name or cmd.name
- if name is None:
- raise TypeError("Command has no name.")
- _check_multicommand(self, name, cmd, register=True)
- self.commands[name] = cmd
-
- @t.overload
- def command(self, __func: t.Callable[..., t.Any]) -> Command:
- ...
-
- @t.overload
- def command(
- self, *args: t.Any, **kwargs: t.Any
- ) -> t.Callable[[t.Callable[..., t.Any]], Command]:
- ...
-
- def command(
- self, *args: t.Any, **kwargs: t.Any
- ) -> t.Union[t.Callable[[t.Callable[..., t.Any]], Command], Command]:
- """A shortcut decorator for declaring and attaching a command to
- the group. This takes the same arguments as :func:`command` and
- immediately registers the created command with this group by
- calling :meth:`add_command`.
-
- To customize the command class used, set the
- :attr:`command_class` attribute.
-
- .. versionchanged:: 8.1
- This decorator can be applied without parentheses.
-
- .. versionchanged:: 8.0
- Added the :attr:`command_class` attribute.
- """
- from .decorators import command
-
- func: t.Optional[t.Callable[..., t.Any]] = None
-
- if args and callable(args[0]):
- assert (
- len(args) == 1 and not kwargs
- ), "Use 'command(**kwargs)(callable)' to provide arguments."
- (func,) = args
- args = ()
-
- if self.command_class and kwargs.get("cls") is None:
- kwargs["cls"] = self.command_class
-
- def decorator(f: t.Callable[..., t.Any]) -> Command:
- cmd: Command = command(*args, **kwargs)(f)
- self.add_command(cmd)
- return cmd
-
- if func is not None:
- return decorator(func)
-
- return decorator
-
- @t.overload
- def group(self, __func: t.Callable[..., t.Any]) -> "Group":
- ...
-
- @t.overload
- def group(
- self, *args: t.Any, **kwargs: t.Any
- ) -> t.Callable[[t.Callable[..., t.Any]], "Group"]:
- ...
-
- def group(
- self, *args: t.Any, **kwargs: t.Any
- ) -> t.Union[t.Callable[[t.Callable[..., t.Any]], "Group"], "Group"]:
- """A shortcut decorator for declaring and attaching a group to
- the group. This takes the same arguments as :func:`group` and
- immediately registers the created group with this group by
- calling :meth:`add_command`.
-
- To customize the group class used, set the :attr:`group_class`
- attribute.
-
- .. versionchanged:: 8.1
- This decorator can be applied without parentheses.
-
- .. versionchanged:: 8.0
- Added the :attr:`group_class` attribute.
- """
- from .decorators import group
-
- func: t.Optional[t.Callable[..., t.Any]] = None
-
- if args and callable(args[0]):
- assert (
- len(args) == 1 and not kwargs
- ), "Use 'group(**kwargs)(callable)' to provide arguments."
- (func,) = args
- args = ()
-
- if self.group_class is not None and kwargs.get("cls") is None:
- if self.group_class is type:
- kwargs["cls"] = type(self)
- else:
- kwargs["cls"] = self.group_class
-
- def decorator(f: t.Callable[..., t.Any]) -> "Group":
- cmd: Group = group(*args, **kwargs)(f)
- self.add_command(cmd)
- return cmd
-
- if func is not None:
- return decorator(func)
-
- return decorator
-
- def get_command(self, ctx: Context, cmd_name: str) -> t.Optional[Command]:
- return self.commands.get(cmd_name)
-
- def list_commands(self, ctx: Context) -> t.List[str]:
- return sorted(self.commands)
-
-
-class CommandCollection(MultiCommand):
- """A command collection is a multi command that merges multiple multi
- commands together into one. This is a straightforward implementation
- that accepts a list of different multi commands as sources and
- provides all the commands for each of them.
-
- See :class:`MultiCommand` and :class:`Command` for the description of
- ``name`` and ``attrs``.
- """
-
- def __init__(
- self,
- name: t.Optional[str] = None,
- sources: t.Optional[t.List[MultiCommand]] = None,
- **attrs: t.Any,
- ) -> None:
- super().__init__(name, **attrs)
- #: The list of registered multi commands.
- self.sources: t.List[MultiCommand] = sources or []
-
- def add_source(self, multi_cmd: MultiCommand) -> None:
- """Adds a new multi command to the chain dispatcher."""
- self.sources.append(multi_cmd)
-
- def get_command(self, ctx: Context, cmd_name: str) -> t.Optional[Command]:
- for source in self.sources:
- rv = source.get_command(ctx, cmd_name)
-
- if rv is not None:
- if self.chain:
- _check_multicommand(self, cmd_name, rv)
-
- return rv
-
- return None
-
- def list_commands(self, ctx: Context) -> t.List[str]:
- rv: t.Set[str] = set()
-
- for source in self.sources:
- rv.update(source.list_commands(ctx))
-
- return sorted(rv)
-
-
-def _check_iter(value: t.Any) -> t.Iterator[t.Any]:
- """Check if the value is iterable but not a string. Raises a type
- error, or return an iterator over the value.
- """
- if isinstance(value, str):
- raise TypeError
-
- return iter(value)
-
-
-class Parameter:
- r"""A parameter to a command comes in two versions: they are either
- :class:`Option`\s or :class:`Argument`\s. Other subclasses are currently
- not supported by design as some of the internals for parsing are
- intentionally not finalized.
-
- Some settings are supported by both options and arguments.
-
- :param param_decls: the parameter declarations for this option or
- argument. This is a list of flags or argument
- names.
- :param type: the type that should be used. Either a :class:`ParamType`
- or a Python type. The latter is converted into the former
- automatically if supported.
- :param required: controls if this is optional or not.
- :param default: the default value if omitted. This can also be a callable,
- in which case it's invoked when the default is needed
- without any arguments.
- :param callback: A function to further process or validate the value
- after type conversion. It is called as ``f(ctx, param, value)``
- and must return the value. It is called for all sources,
- including prompts.
- :param nargs: the number of arguments to match. If not ``1`` the return
- value is a tuple instead of single value. The default for
- nargs is ``1`` (except if the type is a tuple, then it's
- the arity of the tuple). If ``nargs=-1``, all remaining
- parameters are collected.
- :param metavar: how the value is represented in the help page.
- :param expose_value: if this is `True` then the value is passed onwards
- to the command callback and stored on the context,
- otherwise it's skipped.
- :param is_eager: eager values are processed before non eager ones. This
- should not be set for arguments or it will inverse the
- order of processing.
- :param envvar: a string or list of strings that are environment variables
- that should be checked.
- :param shell_complete: A function that returns custom shell
- completions. Used instead of the param's type completion if
- given. Takes ``ctx, param, incomplete`` and must return a list
- of :class:`~click.shell_completion.CompletionItem` or a list of
- strings.
-
- .. versionchanged:: 8.0
- ``process_value`` validates required parameters and bounded
- ``nargs``, and invokes the parameter callback before returning
- the value. This allows the callback to validate prompts.
- ``full_process_value`` is removed.
-
- .. versionchanged:: 8.0
- ``autocompletion`` is renamed to ``shell_complete`` and has new
- semantics described above. The old name is deprecated and will
- be removed in 8.1, until then it will be wrapped to match the
- new requirements.
-
- .. versionchanged:: 8.0
- For ``multiple=True, nargs>1``, the default must be a list of
- tuples.
-
- .. versionchanged:: 8.0
- Setting a default is no longer required for ``nargs>1``, it will
- default to ``None``. ``multiple=True`` or ``nargs=-1`` will
- default to ``()``.
-
- .. versionchanged:: 7.1
- Empty environment variables are ignored rather than taking the
- empty string value. This makes it possible for scripts to clear
- variables if they can't unset them.
-
- .. versionchanged:: 2.0
- Changed signature for parameter callback to also be passed the
- parameter. The old callback format will still work, but it will
- raise a warning to give you a chance to migrate the code easier.
- """
-
- param_type_name = "parameter"
-
- def __init__(
- self,
- param_decls: t.Optional[t.Sequence[str]] = None,
- type: t.Optional[t.Union[types.ParamType, t.Any]] = None,
- required: bool = False,
- default: t.Optional[t.Union[t.Any, t.Callable[[], t.Any]]] = None,
- callback: t.Optional[t.Callable[[Context, "Parameter", t.Any], t.Any]] = None,
- nargs: t.Optional[int] = None,
- multiple: bool = False,
- metavar: t.Optional[str] = None,
- expose_value: bool = True,
- is_eager: bool = False,
- envvar: t.Optional[t.Union[str, t.Sequence[str]]] = None,
- shell_complete: t.Optional[
- t.Callable[
- [Context, "Parameter", str],
- t.Union[t.List["CompletionItem"], t.List[str]],
- ]
- ] = None,
- ) -> None:
- self.name: t.Optional[str]
- self.opts: t.List[str]
- self.secondary_opts: t.List[str]
- self.name, self.opts, self.secondary_opts = self._parse_decls(
- param_decls or (), expose_value
- )
- self.type: types.ParamType = types.convert_type(type, default)
-
- # Default nargs to what the type tells us if we have that
- # information available.
- if nargs is None:
- if self.type.is_composite:
- nargs = self.type.arity
- else:
- nargs = 1
-
- self.required = required
- self.callback = callback
- self.nargs = nargs
- self.multiple = multiple
- self.expose_value = expose_value
- self.default = default
- self.is_eager = is_eager
- self.metavar = metavar
- self.envvar = envvar
- self._custom_shell_complete = shell_complete
-
- if __debug__:
- if self.type.is_composite and nargs != self.type.arity:
- raise ValueError(
- f"'nargs' must be {self.type.arity} (or None) for"
- f" type {self.type!r}, but it was {nargs}."
- )
-
- # Skip no default or callable default.
- check_default = default if not callable(default) else None
-
- if check_default is not None:
- if multiple:
- try:
- # Only check the first value against nargs.
- check_default = next(_check_iter(check_default), None)
- except TypeError:
- raise ValueError(
- "'default' must be a list when 'multiple' is true."
- ) from None
-
- # Can be None for multiple with empty default.
- if nargs != 1 and check_default is not None:
- try:
- _check_iter(check_default)
- except TypeError:
- if multiple:
- message = (
- "'default' must be a list of lists when 'multiple' is"
- " true and 'nargs' != 1."
- )
- else:
- message = "'default' must be a list when 'nargs' != 1."
-
- raise ValueError(message) from None
-
- if nargs > 1 and len(check_default) != nargs:
- subject = "item length" if multiple else "length"
- raise ValueError(
- f"'default' {subject} must match nargs={nargs}."
- )
-
- def to_info_dict(self) -> t.Dict[str, t.Any]:
- """Gather information that could be useful for a tool generating
- user-facing documentation.
-
- Use :meth:`click.Context.to_info_dict` to traverse the entire
- CLI structure.
-
- .. versionadded:: 8.0
- """
- return {
- "name": self.name,
- "param_type_name": self.param_type_name,
- "opts": self.opts,
- "secondary_opts": self.secondary_opts,
- "type": self.type.to_info_dict(),
- "required": self.required,
- "nargs": self.nargs,
- "multiple": self.multiple,
- "default": self.default,
- "envvar": self.envvar,
- }
-
- def __repr__(self) -> str:
- return f"<{self.__class__.__name__} {self.name}>"
-
- def _parse_decls(
- self, decls: t.Sequence[str], expose_value: bool
- ) -> t.Tuple[t.Optional[str], t.List[str], t.List[str]]:
- raise NotImplementedError()
-
- @property
- def human_readable_name(self) -> str:
- """Returns the human readable name of this parameter. This is the
- same as the name for options, but the metavar for arguments.
- """
- return self.name # type: ignore
-
- def make_metavar(self) -> str:
- if self.metavar is not None:
- return self.metavar
-
- metavar = self.type.get_metavar(self)
-
- if metavar is None:
- metavar = self.type.name.upper()
-
- if self.nargs != 1:
- metavar += "..."
-
- return metavar
-
- @t.overload
- def get_default(
- self, ctx: Context, call: "te.Literal[True]" = True
- ) -> t.Optional[t.Any]:
- ...
-
- @t.overload
- def get_default(
- self, ctx: Context, call: bool = ...
- ) -> t.Optional[t.Union[t.Any, t.Callable[[], t.Any]]]:
- ...
-
- def get_default(
- self, ctx: Context, call: bool = True
- ) -> t.Optional[t.Union[t.Any, t.Callable[[], t.Any]]]:
- """Get the default for the parameter. Tries
- :meth:`Context.lookup_default` first, then the local default.
-
- :param ctx: Current context.
- :param call: If the default is a callable, call it. Disable to
- return the callable instead.
-
- .. versionchanged:: 8.0.2
- Type casting is no longer performed when getting a default.
-
- .. versionchanged:: 8.0.1
- Type casting can fail in resilient parsing mode. Invalid
- defaults will not prevent showing help text.
-
- .. versionchanged:: 8.0
- Looks at ``ctx.default_map`` first.
-
- .. versionchanged:: 8.0
- Added the ``call`` parameter.
- """
- value = ctx.lookup_default(self.name, call=False) # type: ignore
-
- if value is None:
- value = self.default
-
- if call and callable(value):
- value = value()
-
- return value
-
- def add_to_parser(self, parser: OptionParser, ctx: Context) -> None:
- raise NotImplementedError()
-
- def consume_value(
- self, ctx: Context, opts: t.Mapping[str, t.Any]
- ) -> t.Tuple[t.Any, ParameterSource]:
- value = opts.get(self.name) # type: ignore
- source = ParameterSource.COMMANDLINE
-
- if value is None:
- value = self.value_from_envvar(ctx)
- source = ParameterSource.ENVIRONMENT
-
- if value is None:
- value = ctx.lookup_default(self.name) # type: ignore
- source = ParameterSource.DEFAULT_MAP
-
- if value is None:
- value = self.get_default(ctx)
- source = ParameterSource.DEFAULT
-
- return value, source
-
- def type_cast_value(self, ctx: Context, value: t.Any) -> t.Any:
- """Convert and validate a value against the option's
- :attr:`type`, :attr:`multiple`, and :attr:`nargs`.
- """
- if value is None:
- return () if self.multiple or self.nargs == -1 else None
-
- def check_iter(value: t.Any) -> t.Iterator[t.Any]:
- try:
- return _check_iter(value)
- except TypeError:
- # This should only happen when passing in args manually,
- # the parser should construct an iterable when parsing
- # the command line.
- raise BadParameter(
- _("Value must be an iterable."), ctx=ctx, param=self
- ) from None
-
- if self.nargs == 1 or self.type.is_composite:
-
- def convert(value: t.Any) -> t.Any:
- return self.type(value, param=self, ctx=ctx)
-
- elif self.nargs == -1:
-
- def convert(value: t.Any) -> t.Any: # t.Tuple[t.Any, ...]
- return tuple(self.type(x, self, ctx) for x in check_iter(value))
-
- else: # nargs > 1
-
- def convert(value: t.Any) -> t.Any: # t.Tuple[t.Any, ...]
- value = tuple(check_iter(value))
-
- if len(value) != self.nargs:
- raise BadParameter(
- ngettext(
- "Takes {nargs} values but 1 was given.",
- "Takes {nargs} values but {len} were given.",
- len(value),
- ).format(nargs=self.nargs, len=len(value)),
- ctx=ctx,
- param=self,
- )
-
- return tuple(self.type(x, self, ctx) for x in value)
-
- if self.multiple:
- return tuple(convert(x) for x in check_iter(value))
-
- return convert(value)
-
- def value_is_missing(self, value: t.Any) -> bool:
- if value is None:
- return True
-
- if (self.nargs != 1 or self.multiple) and value == ():
- return True
-
- return False
-
- def process_value(self, ctx: Context, value: t.Any) -> t.Any:
- value = self.type_cast_value(ctx, value)
-
- if self.required and self.value_is_missing(value):
- raise MissingParameter(ctx=ctx, param=self)
-
- if self.callback is not None:
- value = self.callback(ctx, self, value)
-
- return value
-
- def resolve_envvar_value(self, ctx: Context) -> t.Optional[str]:
- if self.envvar is None:
- return None
-
- if isinstance(self.envvar, str):
- rv = os.environ.get(self.envvar)
-
- if rv:
- return rv
- else:
- for envvar in self.envvar:
- rv = os.environ.get(envvar)
-
- if rv:
- return rv
-
- return None
-
- def value_from_envvar(self, ctx: Context) -> t.Optional[t.Any]:
- rv: t.Optional[t.Any] = self.resolve_envvar_value(ctx)
-
- if rv is not None and self.nargs != 1:
- rv = self.type.split_envvar_value(rv)
-
- return rv
-
- def handle_parse_result(
- self, ctx: Context, opts: t.Mapping[str, t.Any], args: t.List[str]
- ) -> t.Tuple[t.Any, t.List[str]]:
- with augment_usage_errors(ctx, param=self):
- value, source = self.consume_value(ctx, opts)
- ctx.set_parameter_source(self.name, source) # type: ignore
-
- try:
- value = self.process_value(ctx, value)
- except Exception:
- if not ctx.resilient_parsing:
- raise
-
- value = None
-
- if self.expose_value:
- ctx.params[self.name] = value # type: ignore
-
- return value, args
-
- def get_help_record(self, ctx: Context) -> t.Optional[t.Tuple[str, str]]:
- pass
-
- def get_usage_pieces(self, ctx: Context) -> t.List[str]:
- return []
-
- def get_error_hint(self, ctx: Context) -> str:
- """Get a stringified version of the param for use in error messages to
- indicate which param caused the error.
- """
- hint_list = self.opts or [self.human_readable_name]
- return " / ".join(f"'{x}'" for x in hint_list)
-
- def shell_complete(self, ctx: Context, incomplete: str) -> t.List["CompletionItem"]:
- """Return a list of completions for the incomplete value. If a
- ``shell_complete`` function was given during init, it is used.
- Otherwise, the :attr:`type`
- :meth:`~click.types.ParamType.shell_complete` function is used.
-
- :param ctx: Invocation context for this command.
- :param incomplete: Value being completed. May be empty.
-
- .. versionadded:: 8.0
- """
- if self._custom_shell_complete is not None:
- results = self._custom_shell_complete(ctx, self, incomplete)
-
- if results and isinstance(results[0], str):
- from click.shell_completion import CompletionItem
-
- results = [CompletionItem(c) for c in results]
-
- return t.cast(t.List["CompletionItem"], results)
-
- return self.type.shell_complete(ctx, self, incomplete)
-
-
-class Option(Parameter):
- """Options are usually optional values on the command line and
- have some extra features that arguments don't have.
-
- All other parameters are passed onwards to the parameter constructor.
-
- :param show_default: Show the default value for this option in its
- help text. Values are not shown by default, unless
- :attr:`Context.show_default` is ``True``. If this value is a
- string, it shows that string in parentheses instead of the
- actual value. This is particularly useful for dynamic options.
- For single option boolean flags, the default remains hidden if
- its value is ``False``.
- :param show_envvar: Controls if an environment variable should be
- shown on the help page. Normally, environment variables are not
- shown.
- :param prompt: If set to ``True`` or a non empty string then the
- user will be prompted for input. If set to ``True`` the prompt
- will be the option name capitalized.
- :param confirmation_prompt: Prompt a second time to confirm the
- value if it was prompted for. Can be set to a string instead of
- ``True`` to customize the message.
- :param prompt_required: If set to ``False``, the user will be
- prompted for input only when the option was specified as a flag
- without a value.
- :param hide_input: If this is ``True`` then the input on the prompt
- will be hidden from the user. This is useful for password input.
- :param is_flag: forces this option to act as a flag. The default is
- auto detection.
- :param flag_value: which value should be used for this flag if it's
- enabled. This is set to a boolean automatically if
- the option string contains a slash to mark two options.
- :param multiple: if this is set to `True` then the argument is accepted
- multiple times and recorded. This is similar to ``nargs``
- in how it works but supports arbitrary number of
- arguments.
- :param count: this flag makes an option increment an integer.
- :param allow_from_autoenv: if this is enabled then the value of this
- parameter will be pulled from an environment
- variable in case a prefix is defined on the
- context.
- :param help: the help string.
- :param hidden: hide this option from help outputs.
- :param attrs: Other command arguments described in :class:`Parameter`.
-
- .. versionchanged:: 8.1.0
- Help text indentation is cleaned here instead of only in the
- ``@option`` decorator.
-
- .. versionchanged:: 8.1.0
- The ``show_default`` parameter overrides
- ``Context.show_default``.
-
- .. versionchanged:: 8.1.0
- The default of a single option boolean flag is not shown if the
- default value is ``False``.
-
- .. versionchanged:: 8.0.1
- ``type`` is detected from ``flag_value`` if given.
- """
-
- param_type_name = "option"
-
- def __init__(
- self,
- param_decls: t.Optional[t.Sequence[str]] = None,
- show_default: t.Union[bool, str, None] = None,
- prompt: t.Union[bool, str] = False,
- confirmation_prompt: t.Union[bool, str] = False,
- prompt_required: bool = True,
- hide_input: bool = False,
- is_flag: t.Optional[bool] = None,
- flag_value: t.Optional[t.Any] = None,
- multiple: bool = False,
- count: bool = False,
- allow_from_autoenv: bool = True,
- type: t.Optional[t.Union[types.ParamType, t.Any]] = None,
- help: t.Optional[str] = None,
- hidden: bool = False,
- show_choices: bool = True,
- show_envvar: bool = False,
- **attrs: t.Any,
- ) -> None:
- if help:
- help = inspect.cleandoc(help)
-
- default_is_missing = "default" not in attrs
- super().__init__(param_decls, type=type, multiple=multiple, **attrs)
-
- if prompt is True:
- if self.name is None:
- raise TypeError("'name' is required with 'prompt=True'.")
-
- prompt_text: t.Optional[str] = self.name.replace("_", " ").capitalize()
- elif prompt is False:
- prompt_text = None
- else:
- prompt_text = prompt
-
- self.prompt = prompt_text
- self.confirmation_prompt = confirmation_prompt
- self.prompt_required = prompt_required
- self.hide_input = hide_input
- self.hidden = hidden
-
- # If prompt is enabled but not required, then the option can be
- # used as a flag to indicate using prompt or flag_value.
- self._flag_needs_value = self.prompt is not None and not self.prompt_required
-
- if is_flag is None:
- if flag_value is not None:
- # Implicitly a flag because flag_value was set.
- is_flag = True
- elif self._flag_needs_value:
- # Not a flag, but when used as a flag it shows a prompt.
- is_flag = False
- else:
- # Implicitly a flag because flag options were given.
- is_flag = bool(self.secondary_opts)
- elif is_flag is False and not self._flag_needs_value:
- # Not a flag, and prompt is not enabled, can be used as a
- # flag if flag_value is set.
- self._flag_needs_value = flag_value is not None
-
- self.default: t.Union[t.Any, t.Callable[[], t.Any]]
-
- if is_flag and default_is_missing and not self.required:
- if multiple:
- self.default = ()
- else:
- self.default = False
-
- if flag_value is None:
- flag_value = not self.default
-
- self.type: types.ParamType
- if is_flag and type is None:
- # Re-guess the type from the flag value instead of the
- # default.
- self.type = types.convert_type(None, flag_value)
-
- self.is_flag: bool = is_flag
- self.is_bool_flag: bool = is_flag and isinstance(self.type, types.BoolParamType)
- self.flag_value: t.Any = flag_value
-
- # Counting
- self.count = count
- if count:
- if type is None:
- self.type = types.IntRange(min=0)
- if default_is_missing:
- self.default = 0
-
- self.allow_from_autoenv = allow_from_autoenv
- self.help = help
- self.show_default = show_default
- self.show_choices = show_choices
- self.show_envvar = show_envvar
-
- if __debug__:
- if self.nargs == -1:
- raise TypeError("nargs=-1 is not supported for options.")
-
- if self.prompt and self.is_flag and not self.is_bool_flag:
- raise TypeError("'prompt' is not valid for non-boolean flag.")
-
- if not self.is_bool_flag and self.secondary_opts:
- raise TypeError("Secondary flag is not valid for non-boolean flag.")
-
- if self.is_bool_flag and self.hide_input and self.prompt is not None:
- raise TypeError(
- "'prompt' with 'hide_input' is not valid for boolean flag."
- )
-
- if self.count:
- if self.multiple:
- raise TypeError("'count' is not valid with 'multiple'.")
-
- if self.is_flag:
- raise TypeError("'count' is not valid with 'is_flag'.")
-
- def to_info_dict(self) -> t.Dict[str, t.Any]:
- info_dict = super().to_info_dict()
- info_dict.update(
- help=self.help,
- prompt=self.prompt,
- is_flag=self.is_flag,
- flag_value=self.flag_value,
- count=self.count,
- hidden=self.hidden,
- )
- return info_dict
-
- def _parse_decls(
- self, decls: t.Sequence[str], expose_value: bool
- ) -> t.Tuple[t.Optional[str], t.List[str], t.List[str]]:
- opts = []
- secondary_opts = []
- name = None
- possible_names = []
-
- for decl in decls:
- if decl.isidentifier():
- if name is not None:
- raise TypeError(f"Name '{name}' defined twice")
- name = decl
- else:
- split_char = ";" if decl[:1] == "/" else "/"
- if split_char in decl:
- first, second = decl.split(split_char, 1)
- first = first.rstrip()
- if first:
- possible_names.append(split_opt(first))
- opts.append(first)
- second = second.lstrip()
- if second:
- secondary_opts.append(second.lstrip())
- if first == second:
- raise ValueError(
- f"Boolean option {decl!r} cannot use the"
- " same flag for true/false."
- )
- else:
- possible_names.append(split_opt(decl))
- opts.append(decl)
-
- if name is None and possible_names:
- possible_names.sort(key=lambda x: -len(x[0])) # group long options first
- name = possible_names[0][1].replace("-", "_").lower()
- if not name.isidentifier():
- name = None
-
- if name is None:
- if not expose_value:
- return None, opts, secondary_opts
- raise TypeError("Could not determine name for option")
-
- if not opts and not secondary_opts:
- raise TypeError(
- f"No options defined but a name was passed ({name})."
- " Did you mean to declare an argument instead? Did"
- f" you mean to pass '--{name}'?"
- )
-
- return name, opts, secondary_opts
-
- def add_to_parser(self, parser: OptionParser, ctx: Context) -> None:
- if self.multiple:
- action = "append"
- elif self.count:
- action = "count"
- else:
- action = "store"
-
- if self.is_flag:
- action = f"{action}_const"
-
- if self.is_bool_flag and self.secondary_opts:
- parser.add_option(
- obj=self, opts=self.opts, dest=self.name, action=action, const=True
- )
- parser.add_option(
- obj=self,
- opts=self.secondary_opts,
- dest=self.name,
- action=action,
- const=False,
- )
- else:
- parser.add_option(
- obj=self,
- opts=self.opts,
- dest=self.name,
- action=action,
- const=self.flag_value,
- )
- else:
- parser.add_option(
- obj=self,
- opts=self.opts,
- dest=self.name,
- action=action,
- nargs=self.nargs,
- )
-
- def get_help_record(self, ctx: Context) -> t.Optional[t.Tuple[str, str]]:
- if self.hidden:
- return None
-
- any_prefix_is_slash = False
-
- def _write_opts(opts: t.Sequence[str]) -> str:
- nonlocal any_prefix_is_slash
-
- rv, any_slashes = join_options(opts)
-
- if any_slashes:
- any_prefix_is_slash = True
-
- if not self.is_flag and not self.count:
- rv += f" {self.make_metavar()}"
-
- return rv
-
- rv = [_write_opts(self.opts)]
-
- if self.secondary_opts:
- rv.append(_write_opts(self.secondary_opts))
-
- help = self.help or ""
- extra = []
-
- if self.show_envvar:
- envvar = self.envvar
-
- if envvar is None:
- if (
- self.allow_from_autoenv
- and ctx.auto_envvar_prefix is not None
- and self.name is not None
- ):
- envvar = f"{ctx.auto_envvar_prefix}_{self.name.upper()}"
-
- if envvar is not None:
- var_str = (
- envvar
- if isinstance(envvar, str)
- else ", ".join(str(d) for d in envvar)
- )
- extra.append(_("env var: {var}").format(var=var_str))
-
- # Temporarily enable resilient parsing to avoid type casting
- # failing for the default. Might be possible to extend this to
- # help formatting in general.
- resilient = ctx.resilient_parsing
- ctx.resilient_parsing = True
-
- try:
- default_value = self.get_default(ctx, call=False)
- finally:
- ctx.resilient_parsing = resilient
-
- show_default = False
- show_default_is_str = False
-
- if self.show_default is not None:
- if isinstance(self.show_default, str):
- show_default_is_str = show_default = True
- else:
- show_default = self.show_default
- elif ctx.show_default is not None:
- show_default = ctx.show_default
-
- if show_default_is_str or (show_default and (default_value is not None)):
- if show_default_is_str:
- default_string = f"({self.show_default})"
- elif isinstance(default_value, (list, tuple)):
- default_string = ", ".join(str(d) for d in default_value)
- elif inspect.isfunction(default_value):
- default_string = _("(dynamic)")
- elif self.is_bool_flag and self.secondary_opts:
- # For boolean flags that have distinct True/False opts,
- # use the opt without prefix instead of the value.
- default_string = split_opt(
- (self.opts if self.default else self.secondary_opts)[0]
- )[1]
- elif self.is_bool_flag and not self.secondary_opts and not default_value:
- default_string = ""
- else:
- default_string = str(default_value)
-
- if default_string:
- extra.append(_("default: {default}").format(default=default_string))
-
- if (
- isinstance(self.type, types._NumberRangeBase)
- # skip count with default range type
- and not (self.count and self.type.min == 0 and self.type.max is None)
- ):
- range_str = self.type._describe_range()
-
- if range_str:
- extra.append(range_str)
-
- if self.required:
- extra.append(_("required"))
-
- if extra:
- extra_str = "; ".join(extra)
- help = f"{help} [{extra_str}]" if help else f"[{extra_str}]"
-
- return ("; " if any_prefix_is_slash else " / ").join(rv), help
-
- @t.overload
- def get_default(
- self, ctx: Context, call: "te.Literal[True]" = True
- ) -> t.Optional[t.Any]:
- ...
-
- @t.overload
- def get_default(
- self, ctx: Context, call: bool = ...
- ) -> t.Optional[t.Union[t.Any, t.Callable[[], t.Any]]]:
- ...
-
- def get_default(
- self, ctx: Context, call: bool = True
- ) -> t.Optional[t.Union[t.Any, t.Callable[[], t.Any]]]:
- # If we're a non boolean flag our default is more complex because
- # we need to look at all flags in the same group to figure out
- # if we're the default one in which case we return the flag
- # value as default.
- if self.is_flag and not self.is_bool_flag:
- for param in ctx.command.params:
- if param.name == self.name and param.default:
- return t.cast(Option, param).flag_value
-
- return None
-
- return super().get_default(ctx, call=call)
-
- def prompt_for_value(self, ctx: Context) -> t.Any:
- """This is an alternative flow that can be activated in the full
- value processing if a value does not exist. It will prompt the
- user until a valid value exists and then returns the processed
- value as result.
- """
- assert self.prompt is not None
-
- # Calculate the default before prompting anything to be stable.
- default = self.get_default(ctx)
-
- # If this is a prompt for a flag we need to handle this
- # differently.
- if self.is_bool_flag:
- return confirm(self.prompt, default)
-
- return prompt(
- self.prompt,
- default=default,
- type=self.type,
- hide_input=self.hide_input,
- show_choices=self.show_choices,
- confirmation_prompt=self.confirmation_prompt,
- value_proc=lambda x: self.process_value(ctx, x),
- )
-
- def resolve_envvar_value(self, ctx: Context) -> t.Optional[str]:
- rv = super().resolve_envvar_value(ctx)
-
- if rv is not None:
- return rv
-
- if (
- self.allow_from_autoenv
- and ctx.auto_envvar_prefix is not None
- and self.name is not None
- ):
- envvar = f"{ctx.auto_envvar_prefix}_{self.name.upper()}"
- rv = os.environ.get(envvar)
-
- if rv:
- return rv
-
- return None
-
- def value_from_envvar(self, ctx: Context) -> t.Optional[t.Any]:
- rv: t.Optional[t.Any] = self.resolve_envvar_value(ctx)
-
- if rv is None:
- return None
-
- value_depth = (self.nargs != 1) + bool(self.multiple)
-
- if value_depth > 0:
- rv = self.type.split_envvar_value(rv)
-
- if self.multiple and self.nargs != 1:
- rv = batch(rv, self.nargs)
-
- return rv
-
- def consume_value(
- self, ctx: Context, opts: t.Mapping[str, "Parameter"]
- ) -> t.Tuple[t.Any, ParameterSource]:
- value, source = super().consume_value(ctx, opts)
-
- # The parser will emit a sentinel value if the option can be
- # given as a flag without a value. This is different from None
- # to distinguish from the flag not being given at all.
- if value is _flag_needs_value:
- if self.prompt is not None and not ctx.resilient_parsing:
- value = self.prompt_for_value(ctx)
- source = ParameterSource.PROMPT
- else:
- value = self.flag_value
- source = ParameterSource.COMMANDLINE
-
- elif (
- self.multiple
- and value is not None
- and any(v is _flag_needs_value for v in value)
- ):
- value = [self.flag_value if v is _flag_needs_value else v for v in value]
- source = ParameterSource.COMMANDLINE
-
- # The value wasn't set, or used the param's default, prompt if
- # prompting is enabled.
- elif (
- source in {None, ParameterSource.DEFAULT}
- and self.prompt is not None
- and (self.required or self.prompt_required)
- and not ctx.resilient_parsing
- ):
- value = self.prompt_for_value(ctx)
- source = ParameterSource.PROMPT
-
- return value, source
-
-
-class Argument(Parameter):
- """Arguments are positional parameters to a command. They generally
- provide fewer features than options but can have infinite ``nargs``
- and are required by default.
-
- All parameters are passed onwards to the constructor of :class:`Parameter`.
- """
-
- param_type_name = "argument"
-
- def __init__(
- self,
- param_decls: t.Sequence[str],
- required: t.Optional[bool] = None,
- **attrs: t.Any,
- ) -> None:
- if required is None:
- if attrs.get("default") is not None:
- required = False
- else:
- required = attrs.get("nargs", 1) > 0
-
- if "multiple" in attrs:
- raise TypeError("__init__() got an unexpected keyword argument 'multiple'.")
-
- super().__init__(param_decls, required=required, **attrs)
-
- if __debug__:
- if self.default is not None and self.nargs == -1:
- raise TypeError("'default' is not supported for nargs=-1.")
-
- @property
- def human_readable_name(self) -> str:
- if self.metavar is not None:
- return self.metavar
- return self.name.upper() # type: ignore
-
- def make_metavar(self) -> str:
- if self.metavar is not None:
- return self.metavar
- var = self.type.get_metavar(self)
- if not var:
- var = self.name.upper() # type: ignore
- if not self.required:
- var = f"[{var}]"
- if self.nargs != 1:
- var += "..."
- return var
-
- def _parse_decls(
- self, decls: t.Sequence[str], expose_value: bool
- ) -> t.Tuple[t.Optional[str], t.List[str], t.List[str]]:
- if not decls:
- if not expose_value:
- return None, [], []
- raise TypeError("Could not determine name for argument")
- if len(decls) == 1:
- name = arg = decls[0]
- name = name.replace("-", "_").lower()
- else:
- raise TypeError(
- "Arguments take exactly one parameter declaration, got"
- f" {len(decls)}."
- )
- return name, [arg], []
-
- def get_usage_pieces(self, ctx: Context) -> t.List[str]:
- return [self.make_metavar()]
-
- def get_error_hint(self, ctx: Context) -> str:
- return f"'{self.make_metavar()}'"
-
- def add_to_parser(self, parser: OptionParser, ctx: Context) -> None:
- parser.add_argument(dest=self.name, nargs=self.nargs, obj=self)
diff --git a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/otlLib/optimize/__init__.py b/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/otlLib/optimize/__init__.py
deleted file mode 100644
index 25bce9cd2cdaa51338c83b7ecb9059b592b5574f..0000000000000000000000000000000000000000
--- a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/otlLib/optimize/__init__.py
+++ /dev/null
@@ -1,53 +0,0 @@
-from argparse import RawTextHelpFormatter
-from fontTools.otlLib.optimize.gpos import COMPRESSION_LEVEL, compact
-from fontTools.ttLib import TTFont
-
-
-def main(args=None):
- """Optimize the layout tables of an existing font"""
- from argparse import ArgumentParser
-
- from fontTools import configLogger
-
- parser = ArgumentParser(
- prog="otlLib.optimize",
- description=main.__doc__,
- formatter_class=RawTextHelpFormatter,
- )
- parser.add_argument("font")
- parser.add_argument(
- "-o", metavar="OUTPUTFILE", dest="outfile", default=None, help="output file"
- )
- parser.add_argument(
- "--gpos-compression-level",
- help=COMPRESSION_LEVEL.help,
- default=COMPRESSION_LEVEL.default,
- choices=list(range(10)),
- type=int,
- )
- logging_group = parser.add_mutually_exclusive_group(required=False)
- logging_group.add_argument(
- "-v", "--verbose", action="store_true", help="Run more verbosely."
- )
- logging_group.add_argument(
- "-q", "--quiet", action="store_true", help="Turn verbosity off."
- )
- options = parser.parse_args(args)
-
- configLogger(
- level=("DEBUG" if options.verbose else "ERROR" if options.quiet else "INFO")
- )
-
- font = TTFont(options.font)
- compact(font, options.gpos_compression_level)
- font.save(options.outfile or options.font)
-
-
-if __name__ == "__main__":
- import sys
-
- if len(sys.argv) > 1:
- sys.exit(main())
- import doctest
-
- sys.exit(doctest.testmod().failed)
diff --git a/spaces/Dagfinn1962/prodia2/nsfw.py b/spaces/Dagfinn1962/prodia2/nsfw.py
deleted file mode 100644
index e493fea9958302dc5375ae1b7ee0057e3385ac80..0000000000000000000000000000000000000000
--- a/spaces/Dagfinn1962/prodia2/nsfw.py
+++ /dev/null
@@ -1,40 +0,0 @@
-import gradio as gr
-import torch
-import numpy as np
-import modin.pandas as pd
-from PIL import Image
-from diffusers import DiffusionPipeline, StableDiffusionLatentUpscalePipeline
-
-device = "cuda" if torch.cuda.is_available() else "cpu"
-pipe = DiffusionPipeline.from_pretrained("models/stablediffusionapi/juggernaut-xl-v5", torch_dtype=torch.float16, safety_checker=None, use_safetensors=False)
-upscaler = StableDiffusionLatentUpscalePipeline.from_pretrained("stabilityai/sd-x2-latent-upscaler", torch_dtype=torch.float16)
-upscaler = upscaler.to(device)
-pipe = pipe.to(device)
-
-def genie (Prompt, negative_prompt, height, width, scale, steps, seed, upscale, upscale_prompt, upscale_neg, upscale_scale, upscale_steps):
- generator = torch.Generator(device=device).manual_seed(seed)
- if upscale == "Yes":
- low_res_latents = pipe(Prompt, negative_prompt=negative_prompt, height=height, width=width, num_inference_steps=steps, guidance_scale=scale, generator=generator, output_type="latent").images
- image = upscaler(prompt=upscale_prompt, negative_prompt=upscale_neg, image=low_res_latents, num_inference_steps=upscale_steps, guidance_scale=upscale_scale, generator=generator).images[0]
- else:
- image = pipe(Prompt, negative_prompt=negative_prompt, height=height, width=width, num_inference_steps=steps, guidance_scale=scale, generator=generator).images[0]
- return image
-
-gr.Interface(theme='ParityError/Anime', fn=genie, inputs=[gr.Textbox(label='Input field right under here(Prompt)'),
- gr.Textbox(label='What You dont want (Negative Prompt)'),
- gr.Slider(512, 1024, 768, step=128, label='Height'),
- gr.Slider(512, 1024, 768, step=128, label='Width'),
- gr.Slider(1, maximum=15, value=10, step=.25),
- gr.Slider(25, maximum=100, value=50, step=25),
- gr.Slider(minimum=1, step=1, maximum=9999999999999999, randomize=True),
- # gr.Radio(["Yes", "No"], label='Upscale?'),
- #gr.Textbox(label='Upscaler Prompt: Optional'),
- #gr.Textbox(label='Upscaler Negative Prompt: Both Optional And Experimental'),
- #gr.Slider(minimum=0, maximum=15, value=0, step=1, label='Upscale Guidance Scale'),
- #gr.Slider(minimum=5, maximum=25, value=5, step=5, label='Upscaler Iterations')
-
- ],
- outputs=gr.Image(label='Generated Image'),
- title="Dream Art (SD) ",
- description="
Info:Dream Art (SD) This App is our favorite now and shows how Stable diffusion works i a good way !
")
- gr.Markdown('''
-## Model Details
-BLOOM is an autoregressive Large Language Model (LLM), trained to continue text
-from a prompt on vast amounts of text data using industrial-scale computational
-resources. As such, it is able to output coherent text in 46 languages and 13
-programming languages that is hardly distinguishable from text written by humans.
-BLOOM can also be instructed to perform text tasks it hasn't been explicitly trained
-for, by casting them as text generation tasks.
-
-## Project Details
-In this project we are going to explore the translation capabitlies of "BLOOM".
-
-## How to use
-At the moment this space has only capacity to translate between English, Spanish and Hindi languages.
-from languange is the languge you put in text box and to langauge is to what language you are intended to translate.
-Select from language from the drop down.
-Select to language from the drop down.
-
-people are encouraged to improve this space by contributing.
-
-this space is created by [Kishore](https://www.linkedin.com/in/kishore-kunisetty-925a3919a/) inorder to participate in [EuroPython22](https://huggingface.co/EuroPython2022)
-please like the project to support my contribution to EuroPython22. 😊
-''')
- with gr.Row():
- from_lang = gr.Dropdown(['English', 'Spanish', 'Hindi' , 'Bangla'],
- value='English',
- label='select From language : ')
- to_lang = gr.Dropdown(['English', 'Spanish', 'Hindi'],
- value='Hindi',
- label= 'select to Language : ')
-
- input_prompt = gr.Textbox(label="Enter the sentence : ",
- value=f"Instruction: ... \ninput: \"from sentence\" \n{to_lang} :",
- lines=6)
-
- generated_txt = gr.Textbox(lines=3)
-
- b1 = gr.Button("translate")
- b1.click(translate,inputs=[ input_prompt, from_lang, to_lang], outputs=generated_txt)
-
-demo.launch(enable_queue=True, debug=True)
-
diff --git a/spaces/FantasticGNU/AnomalyGPT/model/ImageBind/models/helpers.py b/spaces/FantasticGNU/AnomalyGPT/model/ImageBind/models/helpers.py
deleted file mode 100644
index 75ef564d98f58f4135c19d0bfaeaddbc8137a00a..0000000000000000000000000000000000000000
--- a/spaces/FantasticGNU/AnomalyGPT/model/ImageBind/models/helpers.py
+++ /dev/null
@@ -1,139 +0,0 @@
-#!/usr/bin/env python3
-# Portions Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-
-import einops
-import numpy as np
-import torch
-import torch.nn as nn
-
-
-class Normalize(nn.Module):
- def __init__(self, dim: int) -> None:
- super().__init__()
- self.dim = dim
-
- def forward(self, x):
- return torch.nn.functional.normalize(x, dim=self.dim, p=2)
-
-
-class LearnableLogitScaling(nn.Module):
- def __init__(
- self,
- logit_scale_init: float = 1 / 0.07,
- learnable: bool = True,
- max_logit_scale: float = 100,
- ) -> None:
- super().__init__()
- self.max_logit_scale = max_logit_scale
- self.logit_scale_init = logit_scale_init
- self.learnable = learnable
- log_logit_scale = torch.ones([]) * np.log(self.logit_scale_init)
- if learnable:
- self.log_logit_scale = nn.Parameter(log_logit_scale)
- else:
- self.register_buffer("log_logit_scale", log_logit_scale)
-
- def forward(self, x):
- return torch.clip(self.log_logit_scale.exp(), max=self.max_logit_scale) * x
-
- def extra_repr(self):
- st = f"logit_scale_init={self.logit_scale_init},learnable={self.learnable}," \
- f" max_logit_scale={self.max_logit_scale}"
- return st
-
-
-class EinOpsRearrange(nn.Module):
- def __init__(self, rearrange_expr: str, **kwargs) -> None:
- super().__init__()
- self.rearrange_expr = rearrange_expr
- self.kwargs = kwargs
-
- def forward(self, x):
- assert isinstance(x, torch.Tensor)
- return einops.rearrange(x, self.rearrange_expr, **self.kwargs)
-
-
-class VerboseNNModule(nn.Module):
- """
- Wrapper around nn.Module that prints registered buffers and parameter names.
- """
-
- @staticmethod
- def get_readable_tensor_repr(name: str, tensor: torch.Tensor) -> str:
- st = (
- "("
- + name
- + "): "
- + "tensor("
- + str(tuple(tensor[1].shape))
- + ", requires_grad="
- + str(tensor[1].requires_grad)
- + ")\n"
- )
- return st
-
- def extra_repr(self) -> str:
- named_modules = set()
- for p in self.named_modules():
- named_modules.update([p[0]])
- named_modules = list(named_modules)
-
- string_repr = ""
- for p in self.named_parameters():
- name = p[0].split(".")[0]
- if name not in named_modules:
- string_repr += self.get_readable_tensor_repr(name, p)
-
- for p in self.named_buffers():
- name = p[0].split(".")[0]
- string_repr += self.get_readable_tensor_repr(name, p)
-
- return string_repr
-
-
-def cast_if_src_dtype(
- tensor: torch.Tensor, src_dtype: torch.dtype, tgt_dtype: torch.dtype
-):
- updated = False
- if tensor.dtype == src_dtype:
- tensor = tensor.to(dtype=tgt_dtype)
- updated = True
- return tensor, updated
-
-
-class QuickGELU(nn.Module):
- # From https://github.com/openai/CLIP/blob/d50d76daa670286dd6cacf3bcd80b5e4823fc8e1/clip/model.py#L166
- def forward(self, x: torch.Tensor):
- return x * torch.sigmoid(1.702 * x)
-
-
-class SelectElement(nn.Module):
- def __init__(self, index) -> None:
- super().__init__()
- self.index = index
-
- def forward(self, x):
- assert x.ndim >= 3
- return x[:, self.index, ...]
-
-class SelectEOSAndProject(nn.Module):
- """
- Text Pooling used in OpenCLIP
- """
-
- def __init__(self, proj: nn.Module) -> None:
- super().__init__()
- self.proj = proj
-
- def forward(self, x, seq_len):
- assert x.ndim == 3
- # x is of shape B x L x D
- # take features from the eot embedding (eot_token is the highest number in each sequence)
- x = x[torch.arange(x.shape[0]), seq_len]
- x = self.proj(x)
- return x
diff --git a/spaces/Faridmaruf/RVCV2MODEL/app-2.py b/spaces/Faridmaruf/RVCV2MODEL/app-2.py
deleted file mode 100644
index 2ac3c75490ffa9c5724dc745ff51268c6a9327a4..0000000000000000000000000000000000000000
--- a/spaces/Faridmaruf/RVCV2MODEL/app-2.py
+++ /dev/null
@@ -1,518 +0,0 @@
-import os
-import glob
-import json
-import traceback
-import logging
-import gradio as gr
-import numpy as np
-import librosa
-import torch
-import asyncio
-import edge_tts
-import yt_dlp
-import ffmpeg
-import subprocess
-import sys
-import io
-import wave
-from datetime import datetime
-from fairseq import checkpoint_utils
-from lib.infer_pack.models import (
- SynthesizerTrnMs256NSFsid,
- SynthesizerTrnMs256NSFsid_nono,
- SynthesizerTrnMs768NSFsid,
- SynthesizerTrnMs768NSFsid_nono,
-)
-from vc_infer_pipeline import VC
-from config import Config
-config = Config()
-logging.getLogger("numba").setLevel(logging.WARNING)
-limitation = os.getenv("SYSTEM") == "spaces"
-
-audio_mode = []
-f0method_mode = []
-f0method_info = ""
-if limitation is True:
- audio_mode = ["Upload audio", "TTS Audio"]
- f0method_mode = ["pm", "harvest"]
- f0method_info = "PM is fast, Harvest is good but extremely slow. (Default: PM)"
-else:
- audio_mode = ["Input path", "Upload audio", "Youtube", "TTS Audio"]
- f0method_mode = ["pm", "harvest", "crepe"]
- f0method_info = "PM is fast, Harvest is good but extremely slow, and Crepe effect is good but requires GPU (Default: PM)"
-
-def create_vc_fn(model_title, tgt_sr, net_g, vc, if_f0, version, file_index):
- def vc_fn(
- vc_audio_mode,
- vc_input,
- vc_upload,
- tts_text,
- tts_voice,
- f0_up_key,
- f0_method,
- index_rate,
- filter_radius,
- resample_sr,
- rms_mix_rate,
- protect,
- ):
- try:
- if vc_audio_mode == "Input path" or "Youtube" and vc_input != "":
- audio, sr = librosa.load(vc_input, sr=16000, mono=True)
- elif vc_audio_mode == "Upload audio":
- if vc_upload is None:
- return "You need to upload an audio", None
- sampling_rate, audio = vc_upload
- duration = audio.shape[0] / sampling_rate
- if duration > 20 and limitation:
- return "Please upload an audio file that is less than 20 seconds. If you need to generate a longer audio file, please use Colab.", None
- audio = (audio / np.iinfo(audio.dtype).max).astype(np.float32)
- if len(audio.shape) > 1:
- audio = librosa.to_mono(audio.transpose(1, 0))
- if sampling_rate != 16000:
- audio = librosa.resample(audio, orig_sr=sampling_rate, target_sr=16000)
- elif vc_audio_mode == "TTS Audio":
- if len(tts_text) > 100 and limitation:
- return "Text is too long", None
- if tts_text is None or tts_voice is None:
- return "You need to enter text and select a voice", None
- asyncio.run(edge_tts.Communicate(tts_text, "-".join(tts_voice.split('-')[:-1])).save("tts.mp3"))
- audio, sr = librosa.load("tts.mp3", sr=16000, mono=True)
- vc_input = "tts.mp3"
- times = [0, 0, 0]
- f0_up_key = int(f0_up_key)
- audio_opt = vc.pipeline(
- hubert_model,
- net_g,
- 0,
- audio,
- vc_input,
- times,
- f0_up_key,
- f0_method,
- file_index,
- # file_big_npy,
- index_rate,
- if_f0,
- filter_radius,
- tgt_sr,
- resample_sr,
- rms_mix_rate,
- version,
- protect,
- f0_file=None,
- )
- info = f"[{datetime.now().strftime('%Y-%m-%d %H:%M')}]: npy: {times[0]}, f0: {times[1]}s, infer: {times[2]}s"
- print(f"{model_title} | {info}")
- return info, (tgt_sr, audio_opt)
- except:
- info = traceback.format_exc()
- print(info)
- return info, None
- return vc_fn
-
-def load_model():
- categories = []
- with open("weights/folder_info.json", "r", encoding="utf-8") as f:
- folder_info = json.load(f)
- for category_name, category_info in folder_info.items():
- if not category_info['enable']:
- continue
- category_title = category_info['title']
- category_folder = category_info['folder_path']
- description = category_info['description']
- models = []
- with open(f"weights/{category_folder}/model_info.json", "r", encoding="utf-8") as f:
- models_info = json.load(f)
- for character_name, info in models_info.items():
- if not info['enable']:
- continue
- model_title = info['title']
- model_name = info['model_path']
- model_author = info.get("author", None)
- model_cover = f"weights/{category_folder}/{character_name}/{info['cover']}"
- model_index = f"weights/{category_folder}/{character_name}/{info['feature_retrieval_library']}"
- cpt = torch.load(f"weights/{category_folder}/{character_name}/{model_name}", map_location="cpu")
- tgt_sr = cpt["config"][-1]
- cpt["config"][-3] = cpt["weight"]["emb_g.weight"].shape[0] # n_spk
- if_f0 = cpt.get("f0", 1)
- version = cpt.get("version", "v1")
- if version == "v1":
- if if_f0 == 1:
- net_g = SynthesizerTrnMs256NSFsid(*cpt["config"], is_half=config.is_half)
- else:
- net_g = SynthesizerTrnMs256NSFsid_nono(*cpt["config"])
- model_version = "V1"
- elif version == "v2":
- if if_f0 == 1:
- net_g = SynthesizerTrnMs768NSFsid(*cpt["config"], is_half=config.is_half)
- else:
- net_g = SynthesizerTrnMs768NSFsid_nono(*cpt["config"])
- model_version = "V2"
- del net_g.enc_q
- print(net_g.load_state_dict(cpt["weight"], strict=False))
- net_g.eval().to(config.device)
- if config.is_half:
- net_g = net_g.half()
- else:
- net_g = net_g.float()
- vc = VC(tgt_sr, config)
- print(f"Model loaded: {character_name} / {info['feature_retrieval_library']} | ({model_version})")
- models.append((character_name, model_title, model_author, model_cover, model_version, create_vc_fn(model_title, tgt_sr, net_g, vc, if_f0, version, model_index)))
- categories.append([category_title, category_folder, description, models])
- return categories
-
-def cut_vocal_and_inst(url, audio_provider, split_model):
- if url != "":
- if not os.path.exists("dl_audio"):
- os.mkdir("dl_audio")
- if audio_provider == "Youtube":
- ydl_opts = {
- 'noplaylist': True,
- 'format': 'bestaudio/best',
- 'postprocessors': [{
- 'key': 'FFmpegExtractAudio',
- 'preferredcodec': 'wav',
- }],
- "outtmpl": 'dl_audio/youtube_audio',
- }
- with yt_dlp.YoutubeDL(ydl_opts) as ydl:
- ydl.download([url])
- audio_path = "dl_audio/youtube_audio.wav"
- if split_model == "htdemucs":
- command = f"demucs --two-stems=vocals {audio_path} -o output"
- result = subprocess.run(command.split(), stdout=subprocess.PIPE)
- print(result.stdout.decode())
- return "output/htdemucs/youtube_audio/vocals.wav", "output/htdemucs/youtube_audio/no_vocals.wav", audio_path, "output/htdemucs/youtube_audio/vocals.wav"
- else:
- command = f"demucs --two-stems=vocals -n mdx_extra_q {audio_path} -o output"
- result = subprocess.run(command.split(), stdout=subprocess.PIPE)
- print(result.stdout.decode())
- return "output/mdx_extra_q/youtube_audio/vocals.wav", "output/mdx_extra_q/youtube_audio/no_vocals.wav", audio_path, "output/mdx_extra_q/youtube_audio/vocals.wav"
- else:
- raise gr.Error("URL Required!")
- return None, None, None, None
-
-def combine_vocal_and_inst(audio_data, audio_volume, split_model):
- if not os.path.exists("output/result"):
- os.mkdir("output/result")
- vocal_path = "output/result/output.wav"
- output_path = "output/result/combine.mp3"
- if split_model == "htdemucs":
- inst_path = "output/htdemucs/youtube_audio/no_vocals.wav"
- else:
- inst_path = "output/mdx_extra_q/youtube_audio/no_vocals.wav"
- with wave.open(vocal_path, "w") as wave_file:
- wave_file.setnchannels(1)
- wave_file.setsampwidth(2)
- wave_file.setframerate(audio_data[0])
- wave_file.writeframes(audio_data[1].tobytes())
- command = f'ffmpeg -y -i {inst_path} -i {vocal_path} -filter_complex [1:a]volume={audio_volume}dB[v];[0:a][v]amix=inputs=2:duration=longest -b:a 320k -c:a libmp3lame {output_path}'
- result = subprocess.run(command.split(), stdout=subprocess.PIPE)
- print(result.stdout.decode())
- return output_path
-
-def load_hubert():
- global hubert_model
- models, _, _ = checkpoint_utils.load_model_ensemble_and_task(
- ["hubert_base.pt"],
- suffix="",
- )
- hubert_model = models[0]
- hubert_model = hubert_model.to(config.device)
- if config.is_half:
- hubert_model = hubert_model.half()
- else:
- hubert_model = hubert_model.float()
- hubert_model.eval()
-
-def change_audio_mode(vc_audio_mode):
- if vc_audio_mode == "Input path":
- return (
- # Input & Upload
- gr.Textbox.update(visible=True),
- gr.Checkbox.update(visible=False),
- gr.Audio.update(visible=False),
- # Youtube
- gr.Dropdown.update(visible=False),
- gr.Textbox.update(visible=False),
- gr.Dropdown.update(visible=False),
- gr.Button.update(visible=False),
- gr.Audio.update(visible=False),
- gr.Audio.update(visible=False),
- gr.Audio.update(visible=False),
- gr.Slider.update(visible=False),
- gr.Audio.update(visible=False),
- gr.Button.update(visible=False),
- # TTS
- gr.Textbox.update(visible=False),
- gr.Dropdown.update(visible=False)
- )
- elif vc_audio_mode == "Upload audio":
- return (
- # Input & Upload
- gr.Textbox.update(visible=False),
- gr.Checkbox.update(visible=True),
- gr.Audio.update(visible=True),
- # Youtube
- gr.Dropdown.update(visible=False),
- gr.Textbox.update(visible=False),
- gr.Dropdown.update(visible=False),
- gr.Button.update(visible=False),
- gr.Audio.update(visible=False),
- gr.Audio.update(visible=False),
- gr.Audio.update(visible=False),
- gr.Slider.update(visible=False),
- gr.Audio.update(visible=False),
- gr.Button.update(visible=False),
- # TTS
- gr.Textbox.update(visible=False),
- gr.Dropdown.update(visible=False)
- )
- elif vc_audio_mode == "Youtube":
- return (
- # Input & Upload
- gr.Textbox.update(visible=False),
- gr.Checkbox.update(visible=False),
- gr.Audio.update(visible=False),
- # Youtube
- gr.Dropdown.update(visible=True),
- gr.Textbox.update(visible=True),
- gr.Dropdown.update(visible=True),
- gr.Button.update(visible=True),
- gr.Audio.update(visible=True),
- gr.Audio.update(visible=True),
- gr.Audio.update(visible=True),
- gr.Slider.update(visible=True),
- gr.Audio.update(visible=True),
- gr.Button.update(visible=True),
- # TTS
- gr.Textbox.update(visible=False),
- gr.Dropdown.update(visible=False)
- )
- elif vc_audio_mode == "TTS Audio":
- return (
- # Input & Upload
- gr.Textbox.update(visible=False),
- gr.Checkbox.update(visible=False),
- gr.Audio.update(visible=False),
- # Youtube
- gr.Dropdown.update(visible=False),
- gr.Textbox.update(visible=False),
- gr.Dropdown.update(visible=False),
- gr.Button.update(visible=False),
- gr.Audio.update(visible=False),
- gr.Audio.update(visible=False),
- gr.Audio.update(visible=False),
- gr.Slider.update(visible=False),
- gr.Audio.update(visible=False),
- gr.Button.update(visible=False),
- # TTS
- gr.Textbox.update(visible=True),
- gr.Dropdown.update(visible=True)
- )
- else:
- return (
- # Input & Upload
- gr.Textbox.update(visible=False),
- gr.Checkbox.update(visible=True),
- gr.Audio.update(visible=True),
- # Youtube
- gr.Dropdown.update(visible=False),
- gr.Textbox.update(visible=False),
- gr.Dropdown.update(visible=False),
- gr.Button.update(visible=False),
- gr.Audio.update(visible=False),
- gr.Audio.update(visible=False),
- gr.Audio.update(visible=False),
- gr.Slider.update(visible=False),
- gr.Audio.update(visible=False),
- gr.Button.update(visible=False),
- # TTS
- gr.Textbox.update(visible=False),
- gr.Dropdown.update(visible=False)
- )
-
-def use_microphone(microphone):
- if microphone == True:
- return gr.Audio.update(source="microphone")
- else:
- return gr.Audio.update(source="upload")
-
-if __name__ == '__main__':
- load_hubert()
- categories = load_model()
- tts_voice_list = asyncio.get_event_loop().run_until_complete(edge_tts.list_voices())
- voices = [f"{v['ShortName']}-{v['Gender']}" for v in tts_voice_list]
- with gr.Blocks() as app:
- gr.Markdown(
- "
\n\n"+
- "# RVC V2 MODELS GENSHIN IMPACT\n\n"+
- "### Recommended to use Google Colab to use other character and feature.\n\n"+
- "#### All of this voice samples are taken from the game Genshin Impact, and all voice credits belong to hoyoverse.\n\n"+
- "[](https://colab.research.google.com/drive/1EGHCk7wluqMX2krZhPI13Vhs21e07kOv)\n\n"+
- "
\n\n"+
- "[](https://github.com/ArkanDash/Multi-Model-RVC-Inference)"
- )
- for (folder_title, folder, description, models) in categories:
- with gr.TabItem(folder_title):
- if description:
- gr.Markdown(f"###
{description}")
- with gr.Tabs():
- if not models:
- gr.Markdown("#
No Model Loaded.")
- gr.Markdown("##
Please add model or fix your model path.")
- continue
- for (name, title, author, cover, model_version, vc_fn) in models:
- with gr.TabItem(name):
- with gr.Row():
- gr.Markdown(
- '
'
- f'
{title}
\n'+
- f'
RVC {model_version} Model
\n'+
- (f'
Model author: {author}
' if author else "")+
- (f'' if cover else "")+
- '
'
- )
- with gr.Row():
- with gr.Column():
- vc_audio_mode = gr.Dropdown(label="Input voice", choices=audio_mode, allow_custom_value=False, value="Upload audio")
- # Input
- vc_input = gr.Textbox(label="Input audio path", visible=False)
- # Upload
- vc_microphone_mode = gr.Checkbox(label="Use Microphone", value=False, visible=True, interactive=True)
- vc_upload = gr.Audio(label="Upload audio file", source="upload", visible=True, interactive=True)
- # Youtube
- vc_download_audio = gr.Dropdown(label="Provider", choices=["Youtube"], allow_custom_value=False, visible=False, value="Youtube", info="Select provider (Default: Youtube)")
- vc_link = gr.Textbox(label="Youtube URL", visible=False, info="Example: https://www.youtube.com/watch?v=Nc0sB1Bmf-A", placeholder="https://www.youtube.com/watch?v=...")
- vc_split_model = gr.Dropdown(label="Splitter Model", choices=["htdemucs", "mdx_extra_q"], allow_custom_value=False, visible=False, value="htdemucs", info="Select the splitter model (Default: htdemucs)")
- vc_split = gr.Button("Split Audio", variant="primary", visible=False)
- vc_vocal_preview = gr.Audio(label="Vocal Preview", visible=False)
- vc_inst_preview = gr.Audio(label="Instrumental Preview", visible=False)
- vc_audio_preview = gr.Audio(label="Audio Preview", visible=False)
- # TTS
- tts_text = gr.Textbox(visible=False, label="TTS text", info="Text to speech input")
- tts_voice = gr.Dropdown(label="Edge-tts speaker", choices=voices, visible=False, allow_custom_value=False, value="en-US-AnaNeural-Female")
- with gr.Column():
- vc_transform0 = gr.Number(label="Transpose", value=0, info='Type "12" to change from male to female voice. Type "-12" to change female to male voice')
- f0method0 = gr.Radio(
- label="Pitch extraction algorithm",
- info=f0method_info,
- choices=f0method_mode,
- value="pm",
- interactive=True
- )
- index_rate1 = gr.Slider(
- minimum=0,
- maximum=1,
- label="Retrieval feature ratio",
- info="(Default: 0.7)",
- value=0.7,
- interactive=True,
- )
- filter_radius0 = gr.Slider(
- minimum=0,
- maximum=7,
- label="Apply Median Filtering",
- info="The value represents the filter radius and can reduce breathiness.",
- value=3,
- step=1,
- interactive=True,
- )
- resample_sr0 = gr.Slider(
- minimum=0,
- maximum=48000,
- label="Resample the output audio",
- info="Resample the output audio in post-processing to the final sample rate. Set to 0 for no resampling",
- value=0,
- step=1,
- interactive=True,
- )
- rms_mix_rate0 = gr.Slider(
- minimum=0,
- maximum=1,
- label="Volume Envelope",
- info="Use the volume envelope of the input to replace or mix with the volume envelope of the output. The closer the ratio is to 1, the more the output envelope is used",
- value=1,
- interactive=True,
- )
- protect0 = gr.Slider(
- minimum=0,
- maximum=0.5,
- label="Voice Protection",
- info="Protect voiceless consonants and breath sounds to prevent artifacts such as tearing in electronic music. Set to 0.5 to disable. Decrease the value to increase protection, but it may reduce indexing accuracy",
- value=0.5,
- step=0.01,
- interactive=True,
- )
- with gr.Column():
- vc_log = gr.Textbox(label="Output Information", interactive=False)
- vc_output = gr.Audio(label="Output Audio", interactive=False)
- vc_convert = gr.Button("Convert", variant="primary")
- vc_volume = gr.Slider(
- minimum=0,
- maximum=10,
- label="Vocal volume",
- value=4,
- interactive=True,
- step=1,
- info="Adjust vocal volume (Default: 4}",
- visible=False
- )
- vc_combined_output = gr.Audio(label="Output Combined Audio", visible=False)
- vc_combine = gr.Button("Combine",variant="primary", visible=False)
- vc_convert.click(
- fn=vc_fn,
- inputs=[
- vc_audio_mode,
- vc_input,
- vc_upload,
- tts_text,
- tts_voice,
- vc_transform0,
- f0method0,
- index_rate1,
- filter_radius0,
- resample_sr0,
- rms_mix_rate0,
- protect0,
- ],
- outputs=[vc_log ,vc_output]
- )
- vc_split.click(
- fn=cut_vocal_and_inst,
- inputs=[vc_link, vc_download_audio, vc_split_model],
- outputs=[vc_vocal_preview, vc_inst_preview, vc_audio_preview, vc_input]
- )
- vc_combine.click(
- fn=combine_vocal_and_inst,
- inputs=[vc_output, vc_volume, vc_split_model],
- outputs=[vc_combined_output]
- )
- vc_microphone_mode.change(
- fn=use_microphone,
- inputs=vc_microphone_mode,
- outputs=vc_upload
- )
- vc_audio_mode.change(
- fn=change_audio_mode,
- inputs=[vc_audio_mode],
- outputs=[
- vc_input,
- vc_microphone_mode,
- vc_upload,
- vc_download_audio,
- vc_link,
- vc_split_model,
- vc_split,
- vc_vocal_preview,
- vc_inst_preview,
- vc_audio_preview,
- vc_volume,
- vc_combined_output,
- vc_combine,
- tts_text,
- tts_voice
- ]
- )
- app.queue(concurrency_count=1, max_size=20, api_open=config.api).launch(share=config.colab)
\ No newline at end of file
diff --git a/spaces/Felix123456/bingo/src/lib/storage.ts b/spaces/Felix123456/bingo/src/lib/storage.ts
deleted file mode 100644
index a5b7825c4f76a28c704da512ae39e8bb45addd09..0000000000000000000000000000000000000000
--- a/spaces/Felix123456/bingo/src/lib/storage.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-import { getMany, set, del, clear } from 'idb-keyval';
-
-export const Storage = {
- async get(key: string | string[] | null): Promise {
- if (key === null) return null;
- if (typeof key === 'string') {
- key = [key]
- }
- const returnData: Record = {}
- const values = await getMany(key)
- key.forEach((k, idx)=> {
- returnData[k] = values[idx]
- })
- return returnData;
- },
- async set(object: any) {
- for (let key of Object.keys(object)) {
- await set(key, object[key])
- }
- },
- async remove(key: string) {
- return del(key);
- },
- async clear() {
- return clear();
- }
-}
diff --git a/spaces/FelixLuoX/codeformer/CodeFormer/basicsr/models/__init__.py b/spaces/FelixLuoX/codeformer/CodeFormer/basicsr/models/__init__.py
deleted file mode 100644
index 00bde45f003698a5b15d3517ae47b59ef1d86e0c..0000000000000000000000000000000000000000
--- a/spaces/FelixLuoX/codeformer/CodeFormer/basicsr/models/__init__.py
+++ /dev/null
@@ -1,30 +0,0 @@
-import importlib
-from copy import deepcopy
-from os import path as osp
-
-from basicsr.utils import get_root_logger, scandir
-from basicsr.utils.registry import MODEL_REGISTRY
-
-__all__ = ['build_model']
-
-# automatically scan and import model modules for registry
-# scan all the files under the 'models' folder and collect files ending with
-# '_model.py'
-model_folder = osp.dirname(osp.abspath(__file__))
-model_filenames = [osp.splitext(osp.basename(v))[0] for v in scandir(model_folder) if v.endswith('_model.py')]
-# import all the model modules
-_model_modules = [importlib.import_module(f'basicsr.models.{file_name}') for file_name in model_filenames]
-
-
-def build_model(opt):
- """Build model from options.
-
- Args:
- opt (dict): Configuration. It must constain:
- model_type (str): Model type.
- """
- opt = deepcopy(opt)
- model = MODEL_REGISTRY.get(opt['model_type'])(opt)
- logger = get_root_logger()
- logger.info(f'Model [{model.__class__.__name__}] is created.')
- return model
diff --git a/spaces/Filimize/English_To_French/app.py b/spaces/Filimize/English_To_French/app.py
deleted file mode 100644
index 37a7a9f63d24540d80fb7618c289451856d08e9b..0000000000000000000000000000000000000000
--- a/spaces/Filimize/English_To_French/app.py
+++ /dev/null
@@ -1,17 +0,0 @@
-import streamlit as st
-from transformers import pipeline
-
-classifier = pipeline("translation_en_to_fr",model="t5-base")
-def main():
- st.title("English to french")
-
- with st.form("text_field"):
- text = st.text_area('enter some text:')
- # clicked==True only when the button is clicked
- clicked = st.form_submit_button("Submit")
- if clicked:
- results = classifier([text])
- st.json(results)
-
-if __name__ == "__main__":
- main()
\ No newline at end of file
diff --git a/spaces/FritsLyneborg/kunstnerfrits/tools/train/scalable_shampoo/quantization_utils.py b/spaces/FritsLyneborg/kunstnerfrits/tools/train/scalable_shampoo/quantization_utils.py
deleted file mode 100644
index b413d6eafd26d1bd7c3082db05917a7da0d5672b..0000000000000000000000000000000000000000
--- a/spaces/FritsLyneborg/kunstnerfrits/tools/train/scalable_shampoo/quantization_utils.py
+++ /dev/null
@@ -1,124 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The Google Research Authors.
-#
-# 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.
-
-"""Helper routines for quantization."""
-
-from typing import Any
-
-import chex
-import jax.numpy as jnp
-from flax import struct
-
-
-# pylint:disable=no-value-for-parameter
-@struct.dataclass
-class QuantizedValue:
- """State associated with quantized value."""
-
- quantized: chex.Array
- diagonal: chex.Array # Diagonal (if extract_diagonal is set)
- bucket_size: chex.Array
- quantized_dtype: jnp.dtype = struct.field(
- pytree_node=False
- ) # Dtype for the quantized value.
- extract_diagonal: bool = struct.field(pytree_node=False) # In case its centered.
- shape: Any = struct.field(pytree_node=False) # Shape of the tensor.
-
- @classmethod
- def from_float_value(cls, fvalue, quantized_dtype, extract_diagonal=False):
- if isinstance(fvalue, list) and not fvalue:
- return QuantizedValue([], [], [], quantized_dtype, extract_diagonal, [])
- quantized, diagonal_fvalue, bucket_size = QuantizedValue.quantize(
- fvalue, quantized_dtype, extract_diagonal
- )
- return QuantizedValue(
- quantized,
- diagonal_fvalue,
- bucket_size,
- quantized_dtype,
- extract_diagonal,
- list(quantized.shape),
- )
-
- # Quantization is from Lingvo JAX optimizers.
- # We extend it for int16 quantization of PSD matrices.
- @classmethod
- def quantize(cls, fvalue, quantized_dtype, extract_diagonal=False):
- """Returns quantized value and the bucket."""
- if quantized_dtype == jnp.float32:
- return fvalue, [], []
- elif quantized_dtype == jnp.bfloat16:
- return fvalue.astype(jnp.bfloat16), [], []
-
- float_dtype = fvalue.dtype
- if quantized_dtype == jnp.int8:
- # value -128 is not used.
- num_buckets = jnp.array(127.0, dtype=float_dtype)
- elif quantized_dtype == jnp.int16:
- # value -32768 is not used.
- num_buckets = jnp.array(32767.0, dtype=float_dtype)
- else:
- raise ValueError(f"Quantized dtype {quantized_dtype} not supported.")
- # max value is mapped to num_buckets
-
- if extract_diagonal and fvalue.ndim != 2:
- raise ValueError(
- f"Input array {fvalue} must be 2D to work with extract_diagonal."
- )
-
- diagonal_fvalue = []
- if extract_diagonal:
- diagonal_fvalue = jnp.diag(fvalue)
- # Remove the diagonal entries.
- fvalue = fvalue - jnp.diag(diagonal_fvalue)
-
- # TODO(rohananil): Extend this by making use of information about the blocks
- # SM3 style which will be useful for diagonal statistics
- # We first decide the scale.
- if fvalue.ndim < 1:
- raise ValueError(
- f"Input array {fvalue} must have a strictly positive number of "
- "dimensions."
- )
-
- max_abs = jnp.max(jnp.abs(fvalue), axis=0)
- bucket_size = max_abs / num_buckets
- bs_expanded = bucket_size[jnp.newaxis, Ellipsis]
- # To avoid divide by 0.0
- bs_nonzero = jnp.where(
- bs_expanded > 0.0, bs_expanded, jnp.ones_like(bs_expanded)
- )
- ratio = fvalue / bs_nonzero
- # We use rounding to remove bias.
- quantized = jnp.round(ratio)
- return quantized.astype(quantized_dtype), diagonal_fvalue, bucket_size
-
- def to_float(self):
- """Returns the float value."""
- if isinstance(self.quantized, list) and not self.quantized:
- return self.quantized
-
- if self.quantized_dtype == jnp.float32:
- return self.quantized
-
- if self.quantized_dtype == jnp.bfloat16:
- return self.quantized.astype(jnp.float32)
-
- float_dtype = self.bucket_size.dtype
- bucket_size = self.bucket_size[jnp.newaxis, Ellipsis]
- val = self.quantized.astype(float_dtype) * bucket_size
- if self.extract_diagonal:
- val += jnp.diag(self.diagonal)
- return val
diff --git a/spaces/Gradio-Blocks/StyleGAN-NADA/op/upfirdn2d.cpp b/spaces/Gradio-Blocks/StyleGAN-NADA/op/upfirdn2d.cpp
deleted file mode 100644
index d2e633dc896433c205e18bc3e455539192ff968e..0000000000000000000000000000000000000000
--- a/spaces/Gradio-Blocks/StyleGAN-NADA/op/upfirdn2d.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-#include
-
-
-torch::Tensor upfirdn2d_op(const torch::Tensor& input, const torch::Tensor& kernel,
- int up_x, int up_y, int down_x, int down_y,
- int pad_x0, int pad_x1, int pad_y0, int pad_y1);
-
-#define CHECK_CUDA(x) TORCH_CHECK(x.type().is_cuda(), #x " must be a CUDA tensor")
-#define CHECK_CONTIGUOUS(x) TORCH_CHECK(x.is_contiguous(), #x " must be contiguous")
-#define CHECK_INPUT(x) CHECK_CUDA(x); CHECK_CONTIGUOUS(x)
-
-torch::Tensor upfirdn2d(const torch::Tensor& input, const torch::Tensor& kernel,
- int up_x, int up_y, int down_x, int down_y,
- int pad_x0, int pad_x1, int pad_y0, int pad_y1) {
- CHECK_CUDA(input);
- CHECK_CUDA(kernel);
-
- return upfirdn2d_op(input, kernel, up_x, up_y, down_x, down_y, pad_x0, pad_x1, pad_y0, pad_y1);
-}
-
-PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
- m.def("upfirdn2d", &upfirdn2d, "upfirdn2d (CUDA)");
-}
\ No newline at end of file
diff --git a/spaces/Gradio-Themes/text2video2storj/README.md b/spaces/Gradio-Themes/text2video2storj/README.md
deleted file mode 100644
index 3f92ad2ebca0c211dcbe98a3d74f6118f84cefb9..0000000000000000000000000000000000000000
--- a/spaces/Gradio-Themes/text2video2storj/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Text2video2storj
-emoji: 🏢
-colorFrom: blue
-colorTo: blue
-sdk: gradio
-sdk_version: 3.24.1
-app_file: app.py
-pinned: true
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
\ No newline at end of file
diff --git a/spaces/Gregory-L/EleutherAI-gpt-neo-1.3B/README.md b/spaces/Gregory-L/EleutherAI-gpt-neo-1.3B/README.md
deleted file mode 100644
index 46d21768341178d900756bc49a37b10df7aa215f..0000000000000000000000000000000000000000
--- a/spaces/Gregory-L/EleutherAI-gpt-neo-1.3B/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: EleutherAI Gpt Neo 1.3B
-emoji: 🌍
-colorFrom: green
-colorTo: purple
-sdk: gradio
-sdk_version: 3.35.2
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/wav2vec/unsupervised/scripts/normalize_text.py b/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/wav2vec/unsupervised/scripts/normalize_text.py
deleted file mode 100644
index 9d0ffeb27d038a6b82aaf0f6bdf208af565663f6..0000000000000000000000000000000000000000
--- a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/wav2vec/unsupervised/scripts/normalize_text.py
+++ /dev/null
@@ -1,22 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import regex
-import sys
-
-
-def main():
- filter_r = regex.compile(r"[^\p{L}\p{N}\p{M}\' \-]")
-
- for line in sys.stdin:
- line = line.strip()
- line = filter_r.sub(" ", line)
- line = " ".join(line.split())
- print(line)
-
-
-if __name__ == "__main__":
- main()
diff --git a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/fairseq/data/encoders/hf_byte_bpe.py b/spaces/HarryLee/eCommerceImageCaptioning/fairseq/fairseq/data/encoders/hf_byte_bpe.py
deleted file mode 100644
index c508578d41bf6b7ce0a847e0797d71b19beb393d..0000000000000000000000000000000000000000
--- a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/fairseq/data/encoders/hf_byte_bpe.py
+++ /dev/null
@@ -1,50 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-from dataclasses import dataclass, field
-
-from fairseq.data.encoders import register_bpe
-from fairseq.dataclass import FairseqDataclass
-from fairseq import file_utils
-
-
-@dataclass
-class HuggingFaceByteLevelBPEConfig(FairseqDataclass):
- bpe_merges: str = field(default="???", metadata={"help": "path to merges.txt"})
- bpe_vocab: str = field(default="???", metadata={"help": "path to vocab.json"})
- bpe_add_prefix_space: bool = field(
- default=False, metadata={"help": "add prefix space before encoding"}
- )
-
-
-@register_bpe("hf_byte_bpe", dataclass=HuggingFaceByteLevelBPEConfig)
-class HuggingFaceByteLevelBPE(object):
- def __init__(self, cfg):
- try:
- from tokenizers import ByteLevelBPETokenizer
- except ImportError:
- raise ImportError(
- "Please install huggingface/tokenizers with: " "pip install tokenizers"
- )
-
- bpe_vocab = file_utils.cached_path(cfg.bpe_vocab)
- bpe_merges = file_utils.cached_path(cfg.bpe_merges)
-
- self.bpe = ByteLevelBPETokenizer(
- bpe_vocab,
- bpe_merges,
- add_prefix_space=cfg.bpe_add_prefix_space,
- )
-
- def encode(self, x: str) -> str:
- return " ".join(map(str, self.bpe.encode(x).ids))
-
- def decode(self, x: str) -> str:
- return self.bpe.decode(
- [int(tok) if tok not in {"", ""} else tok for tok in x.split()]
- )
-
- def is_beginning_of_word(self, x: str) -> bool:
- return self.decode(x).startswith(" ")
diff --git a/spaces/HarryLee/eCommerceImageCaptioning/trainer.py b/spaces/HarryLee/eCommerceImageCaptioning/trainer.py
deleted file mode 100644
index 17adcbd9d31937c25c965f1ec7d9a2be90c7253d..0000000000000000000000000000000000000000
--- a/spaces/HarryLee/eCommerceImageCaptioning/trainer.py
+++ /dev/null
@@ -1,1531 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-"""
-Train a network across multiple GPUs.
-"""
-
-import contextlib
-import logging
-import sys
-import time
-from argparse import Namespace
-from itertools import chain
-from typing import Any, Dict, List
-
-import torch
-from fairseq import models, optim, utils
-from fairseq.dataclass.configs import FairseqConfig
-from fairseq.dataclass.utils import convert_namespace_to_omegaconf
-from fairseq.distributed import utils as distributed_utils
-from fairseq.file_io import PathManager
-from fairseq.logging import meters, metrics
-from fairseq.models.ema import build_ema
-from fairseq.nan_detector import NanDetector
-from fairseq.optim import lr_scheduler
-from omegaconf import OmegaConf
-
-from utils import checkpoint_utils
-
-logger = logging.getLogger(__name__)
-
-
-class Trainer(object):
- """Main class for data parallel training.
-
- This class supports synchronous distributed data parallel training,
- where multiple workers each have a full model replica and gradients
- are accumulated across workers before each update. We use
- :class:`~torch.nn.parallel.DistributedDataParallel` to handle
- communication of the gradients across workers.
- """
-
- def __init__(self, cfg: FairseqConfig, task, model, criterion, quantizer=None):
-
- if isinstance(cfg, Namespace):
- logger.warning(
- "argparse.Namespace configuration is deprecated! Automatically converting to OmegaConf"
- )
- cfg = convert_namespace_to_omegaconf(cfg)
-
- self.cfg = cfg
- self.task = task
-
- # catalog shared parameters
- shared_params = _catalog_shared_params(model)
- self.tpu = cfg.common.tpu
- self.cuda = torch.cuda.is_available() and not cfg.common.cpu and not self.tpu
- if self.cuda:
- self.device = torch.device("cuda")
- elif self.tpu:
- self.device = utils.get_tpu_device()
- else:
- self.device = torch.device("cpu")
-
- if self.is_fsdp:
- import fairscale
- if self.cfg.common.bf16:
- raise ValueError(
- "FullyShardedDataParallel is not compatible with --bf16 or "
- "--memory-efficient-bf16"
- )
- if self.cfg.distributed_training.zero_sharding != "none":
- raise ValueError(
- "FullyShardedDataParallel is not compatible with --zero-sharding "
- "option (it's already built in)"
- )
- if max(self.cfg.optimization.update_freq) > 1 and fairscale.__version__ < "0.4.0":
- raise RuntimeError(
- "Please update to fairscale 0.4.0 or newer when combining "
- "--update-freq with FullyShardedDataParallel"
- )
- else:
- if (
- hasattr(self.cfg.distributed_training, "cpu_offload")
- and self.cfg.distributed_training.cpu_offload
- ):
- raise ValueError("--cpu-offload requires --ddp-backend=fully_sharded")
-
- # copy model and criterion to current device/dtype
- self._criterion = criterion
- self._model = model
- if not self.is_fsdp:
- if cfg.common.fp16:
- assert not cfg.common.amp, "Cannot use fp16 and AMP together"
- self._criterion = self._criterion.half()
- self._model = self._model.half()
- elif cfg.common.bf16:
- self._criterion = self._criterion.to(dtype=torch.bfloat16)
- self._model = self._model.to(dtype=torch.bfloat16)
- elif cfg.common.amp:
- self._amp_retries = 0
- if (
- not cfg.distributed_training.pipeline_model_parallel
- # the DistributedFairseqModel wrapper will handle moving to device,
- # so only handle cases which don't use the wrapper
- and not self.use_distributed_wrapper
- ):
- self._criterion = self._criterion.to(device=self.device)
- self._model = self._model.to(device=self.device)
- self.pipeline_model_parallel = cfg.distributed_training.pipeline_model_parallel
- self.last_device = None
- if self.cuda and self.pipeline_model_parallel:
- self.last_device = torch.device(
- cfg.distributed_training.pipeline_devices[-1]
- )
-
- # check that shared parameters are preserved after device transfer
- for shared_param in shared_params:
- ref = _get_module_by_path(self._model, shared_param[0])
- for path in shared_param[1:]:
- logger.info(
- "detected shared parameter: {} <- {}".format(shared_param[0], path)
- )
- _set_module_by_path(self._model, path, ref)
-
- self._dummy_batch = None # indicates we don't have a dummy batch at first
- self._lr_scheduler = None
- self._num_updates = 0
- self._num_xla_compiles = 0 # for TPUs
- self._optim_history = None
- self._optimizer = None
- self._warn_once = set()
- self._wrapped_criterion = None
- self._wrapped_model = None
- self._ema = None
-
- # TODO(myleott): support tpu
- if self.cuda and self.data_parallel_world_size > 1:
- self._grad_norm_buf = torch.cuda.DoubleTensor(self.data_parallel_world_size)
- else:
- self._grad_norm_buf = None
-
- self.quantizer = quantizer
- if self.quantizer is not None:
- self.quantizer.set_trainer(self)
-
- # get detailed cuda environment
- if self.cuda:
- self.cuda_env = utils.CudaEnvironment()
- if self.data_parallel_world_size > 1:
- self.cuda_env_arr = distributed_utils.all_gather_list(
- self.cuda_env, group=distributed_utils.get_global_group()
- )
- else:
- self.cuda_env_arr = [self.cuda_env]
- if self.data_parallel_rank == 0:
- utils.CudaEnvironment.pretty_print_cuda_env_list(self.cuda_env_arr)
- else:
- self.cuda_env = None
- self.cuda_env_arr = None
-
- metrics.log_start_time("wall", priority=790, round=0)
-
- self._start_time = time.time()
- self._previous_training_time = 0
- self._cumulative_training_time = None
-
- def reinitialize(self):
- """Reinitialize the Trainer, typically after model params change."""
- self._lr_scheduler = None
- self._optimizer = None
- self._wrapped_criterion = None
- self._wrapped_model = None
-
- @property
- def data_parallel_world_size(self):
- if self.cfg.distributed_training.distributed_world_size == 1:
- return 1
- return distributed_utils.get_data_parallel_world_size()
-
- @property
- def data_parallel_process_group(self):
- return distributed_utils.get_data_parallel_group()
-
- @property
- def data_parallel_rank(self):
- if self.cfg.distributed_training.distributed_world_size == 1:
- return 0
- return distributed_utils.get_data_parallel_rank()
-
- @property
- def is_data_parallel_master(self):
- # NOTE: this returns true for all model parallel replicas with data
- # parallel rank 0
- return self.data_parallel_rank == 0
-
- @property
- def use_distributed_wrapper(self) -> bool:
- return (
- self.data_parallel_world_size > 1 and not self.cfg.optimization.use_bmuf
- ) or (
- self.is_fsdp and self.cfg.distributed_training.cpu_offload
- )
-
- @property
- def should_save_checkpoint_on_current_rank(self) -> bool:
- """Indicates whether to save checkpoints on the current DDP rank."""
- if (
- self.is_fsdp and self.cfg.distributed_training.use_sharded_state
- ) or getattr(self.cfg.model, "base_layers", 0) > 0:
- return True
- else:
- return self.is_data_parallel_master
-
- @property
- def always_call_state_dict_during_save_checkpoint(self) -> bool:
- if self.is_fsdp and not self.cfg.distributed_training.use_sharded_state:
- # FSDP calls communication collective when consolidating checkpoints
- return True
- else:
- return False
-
- @property
- def checkpoint_suffix(self) -> str:
- """Suffix to add to the checkpoint file name."""
- if self.is_fsdp and self.cfg.distributed_training.use_sharded_state:
- return self.cfg.checkpoint.checkpoint_suffix + "-shard{0}".format(
- self.data_parallel_rank
- )
- else:
- return self.cfg.checkpoint.checkpoint_suffix or ""
-
- @property
- def criterion(self):
- if self._wrapped_criterion is None:
- if utils.has_parameters(self._criterion) and self.use_distributed_wrapper:
- self._wrapped_criterion = models.DistributedFairseqModel(
- self.cfg.distributed_training,
- self._criterion,
- process_group=self.data_parallel_process_group,
- device=self.device,
- )
- else:
- self._wrapped_criterion = self._criterion
- return self._wrapped_criterion
-
- @property
- def model(self):
- if self._wrapped_model is None:
- if self.use_distributed_wrapper:
- self._wrapped_model = models.DistributedFairseqModel(
- self.cfg.distributed_training,
- self._model,
- process_group=self.data_parallel_process_group,
- device=self.device,
- )
- else:
- self._wrapped_model = self._model
- return self._wrapped_model
-
- @property
- def ema(self):
- if self._ema is None:
- self._build_ema()
- return self._ema
-
- def _build_ema(self):
- if self.cfg.ema.store_ema:
- self._ema = build_ema(self._model, self.cfg.ema, self.device)
- logger.info(
- "Exponential Moving Average Shadow Model is initialized."
- )
-
- @property
- def optimizer(self):
- if self._optimizer is None:
- self._build_optimizer()
- return self._optimizer
-
- @property
- def lr_scheduler(self):
- if self._lr_scheduler is None:
- self._build_optimizer() # this will initialize self._lr_scheduler
- return self._lr_scheduler
-
- def _build_optimizer(self):
- params = list(
- filter(
- lambda p: p.requires_grad,
- chain(self.model.parameters(), self.criterion.parameters()),
- )
- )
-
- if self.is_fsdp and self.cfg.common.fp16:
- # FullyShardedDataParallel always uses MemoryEfficientFP16 wrapper,
- # mostly for the grad scaling. But if we don't have the
- # --memory-efficient-fp16 flag set, then we're effectively doing
- # regular --fp16 and can allow the use of optimizers that would
- # otherwise be unsupported by MemoryEfficientFP16Optimizer.
- allow_unsupported = not self.cfg.common.memory_efficient_fp16
- self._optimizer = optim.MemoryEfficientFP16Optimizer.build_optimizer(
- self.cfg, params, allow_unsupported=allow_unsupported
- )
- elif self.cfg.common.fp16 or self.cfg.common.bf16 or self.cfg.common.amp:
- if self.cuda and torch.cuda.get_device_capability(0)[0] < 7:
- logger.info(
- "NOTE: your device does NOT support faster training with --fp16 or --amp, "
- "please switch to FP32 which is likely to be faster"
- )
- if (
- self.cfg.common.memory_efficient_fp16
- or self.cfg.common.memory_efficient_bf16
- ):
- self._optimizer = optim.MemoryEfficientFP16Optimizer.build_optimizer(
- self.cfg, params
- )
- elif self.cfg.common.amp:
- self._optimizer = optim.AMPOptimizer.build_optimizer(self.cfg, params)
- else:
- self._optimizer = optim.FP16Optimizer.build_optimizer(self.cfg, params)
- else:
- if self.cuda and torch.cuda.get_device_capability(0)[0] >= 7:
- logger.info("NOTE: your device may support faster training with --fp16 or --amp")
- self._optimizer = optim.build_optimizer(self.cfg.optimizer, params)
-
- if self.is_fsdp:
- assert (
- not self.cfg.optimization.use_bmuf
- ), "--ddp-backend=fully_sharded is not compatible with BMUF"
- assert self._optimizer.supports_flat_params, (
- "--ddp-backend=fully_sharded is only compatible with pointwise "
- "optimizers (e.g., Adam, AdamW, Adadelta, Adamax, SGD, etc.). "
- "However, the sharding will result in slightly different results when "
- "using non-pointwise optimizers (e.g., Adagrad, Adafactor, LAMB)"
- )
-
- if self.cfg.optimization.use_bmuf:
- self._optimizer = optim.FairseqBMUF(
- self.cfg.bmuf,
- self._optimizer,
- )
-
- if self.cfg.distributed_training.zero_sharding == "os":
- if (
- self.cfg.common.fp16
- and not self.cfg.common.memory_efficient_fp16
- and not self.cfg.common.memory_efficient_bf16
- ) and not self.cfg.common.fp16_no_flatten_grads:
- raise ValueError(
- "ZeRO is incomptabile with fp16 and flattened grads. "
- "Please use --fp16-no-flatten-grads"
- )
- else:
- optim.shard_(self._optimizer, self.data_parallel_process_group)
-
- # We should initialize the learning rate scheduler immediately after
- # building the optimizer, so that the initial learning rate is set.
- self._lr_scheduler = lr_scheduler.build_lr_scheduler(
- self.cfg.lr_scheduler,
- self.optimizer,
- )
- self._lr_scheduler.step_update(0)
-
- @property
- def is_fsdp(self):
- return self.cfg.distributed_training.ddp_backend == "fully_sharded"
-
- def consolidate_optimizer(self):
- """For OSS, we need to consolidate the state dict."""
- if self.cfg.checkpoint.no_save_optimizer_state:
- return
- self._gathered_optim_state = None
- if hasattr(self.optimizer.optimizer, "consolidate_state_dict"):
- self.optimizer.optimizer.consolidate_state_dict()
- elif self.is_fsdp and not self.model.use_sharded_state:
- st = self.model.gather_full_optim_state_dict(
- self.optimizer
- ) # only returns on rank 0
- self._gathered_optim_state = st
-
- def state_dict(self):
- state_dict = {
- "args": None, # legacy
- "cfg": (
- OmegaConf.to_container(self.cfg, resolve=True, enum_to_str=True)
- if OmegaConf.is_config(self.cfg)
- else self.cfg
- ),
- "model": self.model.state_dict(),
- "criterion": (
- self.criterion.state_dict()
- if utils.has_parameters(self.criterion)
- else None
- ),
- "optimizer_history": (self._optim_history or [])
- + [
- {
- "criterion_name": self.get_criterion().__class__.__name__,
- "optimizer_name": self.optimizer.__class__.__name__,
- "lr_scheduler_state": self.lr_scheduler.state_dict(),
- "num_updates": self.get_num_updates(),
- }
- ],
- "task_state": self.task.state_dict() if self.task is not None else {},
- "extra_state": {
- "metrics": metrics.state_dict(),
- "previous_training_time": self.cumulative_training_time(),
- },
- }
- if self.cfg.ema.store_ema:
- # Save EMA model state as extra state
- state_dict["extra_state"]["ema"] = self.ema.get_model().state_dict()
- if self.cfg.ema.ema_fp32:
- # Save EMA params in fp32
- state_dict["extra_state"]["ema_fp32_params"] = self.ema.fp32_params
- if not self.cfg.checkpoint.no_save_optimizer_state:
- if self._gathered_optim_state is not None:
- state_dict["last_optimizer_state"] = self._gathered_optim_state
- self._gathered_optim_state = None
- else:
- state_dict["last_optimizer_state"] = self.optimizer.state_dict()
- if self.is_fsdp:
- # save meta data for recombining checkpoint upon loading
- state_dict["fsdp_metadata"] = self.model.local_metadata_dict()
- return state_dict
-
- def save_checkpoint(self, filename, extra_state):
- """Save all training state in a checkpoint file."""
- logger.info(f"Saving checkpoint to {filename}")
- # call state_dict on all ranks in case it needs internal communication
- state_dict = utils.move_to_cpu(self.state_dict())
- state_dict["extra_state"].update(extra_state)
- if self.should_save_checkpoint_on_current_rank:
- checkpoint_utils.torch_persistent_save(
- state_dict,
- filename,
- async_write=self.cfg.checkpoint.write_checkpoints_asynchronously,
- )
- logger.info(f"Finished saving checkpoint to {filename}")
-
- def load_checkpoint(
- self,
- filename,
- reset_optimizer=False,
- reset_lr_scheduler=False,
- optimizer_overrides=None,
- reset_meters=False,
- ):
- """
- Load all training state from a checkpoint file.
- rank = 0 will load the checkpoint, and then broadcast it to all
- other ranks.
- """
- extra_state, self._optim_history, last_optim_state = None, [], None
-
- logger.info(f"Preparing to load checkpoint {filename}")
- is_distributed = self.data_parallel_world_size > 1
- bexists = PathManager.isfile(filename)
- if bexists:
- load_on_all_ranks = (
- self.cfg.checkpoint.load_checkpoint_on_all_dp_ranks
- # TPUs don't support broadcast yet, so load checkpoints
- # on every worker for now
- or self.tpu
- # FSDP requires loading checkpoint shards on all ranks
- or (self.is_fsdp and self.cfg.distributed_training.use_sharded_state)
- or getattr(self.cfg.model, "base_layers", 0) > 0
- )
-
- if load_on_all_ranks or self.data_parallel_rank == 0:
- state = checkpoint_utils.load_checkpoint_to_cpu(
- filename, load_on_all_ranks=load_on_all_ranks
- )
- last_optim_state = state.get("last_optimizer_state", None)
-
- # If doing zero_sharding, do not broadcast global optimizer
- # state. Later we will broadcast sharded states to each rank
- # to avoid memory from exploding.
- if (
- not load_on_all_ranks
- and self.cfg.distributed_training.zero_sharding == "os"
- and "last_optimizer_state" in state
- and is_distributed
- ):
- state["last_optimizer_state"] = "SHARDED"
- else:
- last_optim_state = None
- state = None
-
- if is_distributed and not load_on_all_ranks:
- state = distributed_utils.broadcast_object(
- state,
- src_rank=0,
- group=self.data_parallel_process_group,
- dist_device=self.device,
- )
- if self.data_parallel_rank > 0:
- last_optim_state = state.get("last_optimizer_state", None)
-
- # load model parameters
- try:
- if self.cfg.checkpoint.use_ema_weights_to_init_param and "extra_state" in state and "ema" in state["extra_state"]:
- logger.info("use_ema_weights_to_init_param = True, will use EMA weights in the ckpt to init the model param...")
- ema_state_dict = state["extra_state"]["ema_fp32_params"] if "ema_fp32_params" in state["extra_state"] else state["extra_state"]["ema"]
- self.model.load_state_dict(
- ema_state_dict, strict=True, model_cfg=self.cfg.model
- )
- else:
- self.model.load_state_dict(
- state["model"], strict=True, model_cfg=self.cfg.model
- )
- # save memory for later steps
- if not (self.cfg.ema.store_ema and (self.cfg.checkpoint.use_latest_weights_to_init_ema or not ("extra_state" in state and "ema" in state["extra_state"]))):
- del state["model"]
- if utils.has_parameters(self.get_criterion()):
- self.get_criterion().load_state_dict(
- state["criterion"], strict=True
- )
- del state["criterion"]
-
- except Exception:
- raise Exception(
- "Cannot load model parameters from checkpoint {}; "
- "please ensure that the architectures match.".format(filename)
- )
- extra_state = state["extra_state"]
- self._optim_history = state["optimizer_history"]
-
- if last_optim_state is not None and not reset_optimizer:
- # rebuild optimizer after loading model, since params may have changed
- self._build_optimizer()
-
- # only reload optimizer and lr_scheduler if they match
- last_optim = self._optim_history[-1]
- assert (
- last_optim["criterion_name"] == self.get_criterion().__class__.__name__
- ), f"Criterion does not match; please reset the optimizer (--reset-optimizer). {last_optim['criterion_name']} vs {self.get_criterion().__class__.__name__}"
- assert (
- last_optim["optimizer_name"] == self.optimizer.__class__.__name__
- ), f"Optimizer does not match; please reset the optimizer (--reset-optimizer). {last_optim['optimizer_name']} vs {self.optimizer.__class__.__name__}"
-
- if not reset_lr_scheduler:
- self.lr_scheduler.load_state_dict(last_optim["lr_scheduler_state"])
-
- if self.is_fsdp and not self.model.use_sharded_state:
- # if use_sharded_state, the last_optim_state is already sharded, skip this
- last_optim_state = self.model.get_shard_from_optim_state_dict(
- last_optim_state
- )
- elif not load_on_all_ranks and is_distributed:
- last_optim_state = self.optimizer.broadcast_global_state_dict(
- last_optim_state
- )
-
- self.optimizer.load_state_dict(last_optim_state, optimizer_overrides)
-
- self.set_num_updates(last_optim["num_updates"])
-
- if extra_state is not None:
- itr_state = extra_state["train_iterator"]
- epoch = itr_state["epoch"]
-
- if "previous_training_time" in extra_state:
- self._previous_training_time = extra_state["previous_training_time"]
- self._start_time = time.time()
-
- self.lr_step(epoch)
-
- if (
- itr_state.get("version", 1) >= 2
- and itr_state["iterations_in_epoch"] == 0
- ):
- # reset meters at start of epoch
- reset_meters = True
-
- if "metrics" in extra_state and not reset_meters:
- metrics.load_state_dict(extra_state["metrics"])
-
- # reset TimeMeters, since their start times don't make sense anymore
- for meter in metrics.get_meters("default"):
- if isinstance(meter, meters.TimeMeter):
- meter.reset()
-
- if self.cfg.ema.store_ema:
- if self.cfg.checkpoint.use_latest_weights_to_init_ema or "ema" not in extra_state:
- if "ema" not in extra_state:
- logger.warn(
- "EMA not found in checkpoint. But store_ema is True. "
- "EMA is re-initialized from checkpoint."
- )
- elif self.cfg.checkpoint.use_latest_weights_to_init_ema:
- logger.info(
- "use_latest_weights_to_init_ema = True. EMA is re-initialized from checkpoint."
- )
- self.ema.restore(state["model"], build_fp32_params=self.cfg.ema.ema_fp32)
- del state["model"]
- else:
- logger.info(
- "Loading EMA from checkpoint"
- )
- self.ema.restore(extra_state["ema"], build_fp32_params=False)
-
- if self.cfg.ema.ema_fp32:
- if "ema_fp32_params" in extra_state:
- logger.info(
- "Loading EMA fp32 params from checkpoint"
- )
- self.ema.build_fp32_params(extra_state["ema_fp32_params"])
- else:
- logger.info(
- "Building EMA fp32 params from EMA model in checkpoint"
- )
- self.ema.build_fp32_params()
-
- logger.info(
- "Loaded checkpoint {} (epoch {} @ {} updates)".format(
- filename, epoch, self.get_num_updates()
- )
- )
-
- else:
- logger.info("No existing checkpoint found {}".format(filename))
-
- return extra_state
-
- def get_train_iterator(
- self,
- epoch,
- combine=True,
- load_dataset=True,
- data_selector=None,
- shard_batch_itr=True,
- disable_iterator_cache=False,
- ):
- """Return an EpochBatchIterator over the training set for a given epoch."""
- if load_dataset:
- logger.info("loading train data for epoch {}".format(epoch))
- self.task.load_dataset(
- self.cfg.dataset.train_subset,
- epoch=epoch,
- combine=combine,
- data_selector=data_selector,
- tpu=self.tpu,
- )
- batch_iterator = self.task.get_batch_iterator(
- dataset=self.task.dataset(self.cfg.dataset.train_subset),
- max_tokens=self.cfg.dataset.max_tokens,
- max_sentences=self.cfg.dataset.batch_size,
- max_positions=utils.resolve_max_positions(
- self.task.max_positions(),
- self.model.max_positions(),
- self.cfg.dataset.max_tokens,
- ),
- ignore_invalid_inputs=True,
- required_batch_size_multiple=self.cfg.dataset.required_batch_size_multiple,
- seed=self.cfg.common.seed,
- num_shards=self.data_parallel_world_size if shard_batch_itr else 1,
- shard_id=self.data_parallel_rank if shard_batch_itr else 0,
- num_workers=self.cfg.dataset.num_workers,
- epoch=epoch,
- data_buffer_size=self.cfg.dataset.data_buffer_size,
- disable_iterator_cache=disable_iterator_cache,
- )
- self.reset_dummy_batch(batch_iterator.first_batch)
- batch_iterator.dataset.dataset._seek()
- return batch_iterator
-
- def get_valid_iterator(
- self,
- subset,
- disable_iterator_cache=False,
- ):
- """Return an EpochBatchIterator over given validation subset for a given epoch."""
- self.task.dataset(subset).dataset._seek()
- batch_iterator = self.task.get_batch_iterator(
- dataset=self.task.dataset(subset),
- max_tokens=self.cfg.dataset.max_tokens_valid,
- max_sentences=self.cfg.dataset.batch_size_valid,
- max_positions=utils.resolve_max_positions(
- self.task.max_positions(),
- self.model.max_positions(),
- ),
- ignore_invalid_inputs=self.cfg.dataset.skip_invalid_size_inputs_valid_test,
- required_batch_size_multiple=self.cfg.dataset.required_batch_size_multiple,
- seed=self.cfg.common.seed,
- num_shards=self.data_parallel_world_size,
- shard_id=self.data_parallel_rank,
- num_workers=self.cfg.dataset.num_workers,
- # always pass a fixed "epoch" to keep validation data consistent
- # across training epochs
- epoch=1,
- data_buffer_size=self.cfg.dataset.data_buffer_size,
- disable_iterator_cache=disable_iterator_cache,
- )
- self.reset_dummy_batch(batch_iterator.first_batch)
- batch_iterator.dataset.dataset._seek()
- return batch_iterator
-
- def begin_epoch(self, epoch):
- """Called at the beginning of each epoch."""
- logger.info("begin training epoch {}".format(epoch))
-
- self.lr_step_begin_epoch(epoch)
-
- if self.quantizer is not None:
- self.quantizer.begin_epoch(epoch)
-
- # task specific setup per epoch
- self.task.begin_epoch(epoch, self.get_model())
-
- if self.tpu:
- import torch_xla.core.xla_model as xm
-
- xm.rendezvous("begin_epoch") # wait for all workers
- xm.mark_step()
-
- def begin_valid_epoch(self, epoch):
- """Called at the beginning of each validation epoch."""
-
- # task specific setup per validation epoch
- self.task.begin_valid_epoch(epoch, self.get_model())
-
- def reset_dummy_batch(self, batch):
- self._dummy_batch = batch
-
- @metrics.aggregate("train")
- def train_step(self, samples, raise_oom=False):
- """Do forward, backward and parameter update."""
- self._set_seed()
- self.model.train()
- self.criterion.train()
- self.zero_grad()
-
- metrics.log_start_time("train_wall", priority=800, round=0)
-
- # If EMA is enabled through store_ema=True
- # and task.uses_ema is True, pass the EMA model as a keyword
- # argument to the task.
- extra_kwargs = {}
- if self.cfg.ema.store_ema and getattr(self.task, "uses_ema", False):
- extra_kwargs["ema_model"] = self.ema.get_model()
-
- # forward and backward pass
- logging_outputs, sample_size, ooms = [], 0, 0
- for i, sample in enumerate(samples): # delayed update loop
- sample, is_dummy_batch = self._prepare_sample(sample)
-
- def maybe_no_sync():
- """
- Whenever *samples* contains more than one mini-batch, we
- want to accumulate gradients locally and only call
- all-reduce in the last backwards pass.
- """
- if (
- self.data_parallel_world_size > 1
- and hasattr(self.model, "no_sync")
- and i < len(samples) - 1
- # The no_sync context manager results in increased memory
- # usage with FSDP, since full-size gradients will be
- # accumulated on each GPU. It's typically a better tradeoff
- # to do the extra communication with FSDP.
- and not self.is_fsdp
- ):
- return self.model.no_sync()
- else:
- return contextlib.ExitStack() # dummy contextmanager
-
- try:
- with maybe_no_sync():
- # forward and backward
- loss, sample_size_i, logging_output = self.task.train_step(
- sample=sample,
- model=self.model,
- criterion=self.criterion,
- optimizer=self.optimizer,
- update_num=self.get_num_updates(),
- ignore_grad=is_dummy_batch,
- **extra_kwargs,
- )
- del loss
-
- logging_outputs.append(logging_output)
- sample_size += sample_size_i
-
- # emptying the CUDA cache after the first step can
- # reduce the chance of OOM
- if self.cuda and self.get_num_updates() == 0:
- torch.cuda.empty_cache()
- except RuntimeError as e:
- if "out of memory" in str(e):
- self._log_oom(e)
- if raise_oom:
- raise e
- logger.warning(
- "attempting to recover from OOM in forward/backward pass"
- )
- ooms += 1
- self.zero_grad()
- if self.cuda:
- torch.cuda.empty_cache()
- if self.cfg.distributed_training.distributed_world_size == 1:
- return None
- else:
- raise e
-
- if self.tpu and i < len(samples) - 1:
- # tpu-comment: every XLA operation before marking step is
- # appended to the IR graph, and processing too many batches
- # before marking step can lead to OOM errors.
- # To handle gradient accumulation use case, we explicitly
- # mark step here for every forward pass without a backward pass
- self._xla_markstep_and_send_to_cpu()
-
- if is_dummy_batch:
- if torch.is_tensor(sample_size):
- sample_size.zero_()
- else:
- sample_size *= 0.0
-
- if torch.is_tensor(sample_size):
- sample_size = sample_size.float()
- else:
- sample_size = float(sample_size)
-
- # gather logging outputs from all replicas
- if self._sync_stats():
- train_time = self._local_cumulative_training_time()
- logging_outputs, (
- sample_size,
- ooms,
- total_train_time,
- ) = self._aggregate_logging_outputs(
- logging_outputs, sample_size, ooms, train_time, ignore=is_dummy_batch
- )
- self._cumulative_training_time = (
- total_train_time / self.data_parallel_world_size
- )
-
- overflow = False
- try:
- with torch.autograd.profiler.record_function("reduce-grads"):
- # reduce gradients across workers
- self.optimizer.all_reduce_grads(self.model)
- if utils.has_parameters(self.criterion):
- self.optimizer.all_reduce_grads(self.criterion)
-
- with torch.autograd.profiler.record_function("multiply-grads"):
- # multiply gradients by (data_parallel_size / sample_size) since
- # DDP normalizes by the number of data parallel workers for
- # improved fp16 precision.
- # Thus we get (sum_of_gradients / sample_size) at the end.
- # In case of fp16, this step also undoes loss scaling.
- # (Debugging note: Some optimizers perform this scaling on the
- # fly, so inspecting model.parameters() or optimizer.params may
- # still show the original, unscaled gradients.)
- numer = (
- self.data_parallel_world_size
- if not self.cfg.optimization.use_bmuf or self._sync_stats()
- else 1
- )
- self.optimizer.multiply_grads(numer / (sample_size or 1.0))
- # Note: (sample_size or 1.0) handles the case of a zero gradient, in a
- # way that avoids CPU/device transfers in case sample_size is a GPU or
- # TPU object. The assumption is that the gradient itself is also 0.
-
- with torch.autograd.profiler.record_function("clip-grads"):
- # clip grads
- grad_norm = self.clip_grad_norm(self.cfg.optimization.clip_norm)
-
- # check that grad norms are consistent across workers
- # on tpu check tensor is slow
- if not self.tpu:
- if (
- not self.cfg.optimization.use_bmuf
- and self.cfg.distributed_training.ddp_backend != "slow_mo"
- ):
- self._check_grad_norms(grad_norm)
- if not torch.isfinite(grad_norm).all():
- # in case of AMP, if gradients are Nan/Inf then
- # optimizer step is still required
- if self.cfg.common.amp:
- overflow = True
- else:
- # check local gradnorm single GPU case, trigger NanDetector
- raise FloatingPointError("gradients are Nan/Inf")
-
- with torch.autograd.profiler.record_function("optimizer"):
- # take an optimization step
- self.task.optimizer_step(
- self.optimizer, model=self.model, update_num=self.get_num_updates()
- )
- if self.cfg.common.amp and overflow:
- if self._amp_retries == self.cfg.common.amp_batch_retries:
- logger.info("AMP: skipping this batch.")
- self._amp_retries = 0
- else:
- self._amp_retries += 1
- return self.train_step(samples, raise_oom) # recursion to feed in same batch
-
- except FloatingPointError:
- # re-run the forward and backward pass with hooks attached to print
- # out where it fails
- self.zero_grad()
- with NanDetector(self.get_model()):
- for _, sample in enumerate(samples):
- sample, _ = self._prepare_sample(sample)
- self.task.train_step(
- sample,
- self.model,
- self.criterion,
- self.optimizer,
- self.get_num_updates(),
- ignore_grad=False,
- **extra_kwargs,
- )
- raise
- except OverflowError as e:
- overflow = True
- logger.info(
- f"NOTE: gradient overflow detected, ignoring gradient, {str(e)}"
- )
- grad_norm = torch.tensor(0.0).cuda()
- self.zero_grad()
- except RuntimeError as e:
- if "out of memory" in str(e):
- self._log_oom(e)
- logger.error("OOM during optimization, irrecoverable")
- raise e
-
- # Some distributed wrappers (e.g., SlowMo) need access to the optimizer
- # after the step
- if hasattr(self.model, "perform_additional_optimizer_actions"):
- if hasattr(self.optimizer, "fp32_params"):
- self.model.perform_additional_optimizer_actions(
- self.optimizer.optimizer, self.optimizer.fp32_params
- )
- else:
- self.model.perform_additional_optimizer_actions(
- self.optimizer.optimizer
- )
-
- logging_output = None
- if not overflow or self.cfg.distributed_training.ddp_backend == "slow_mo":
- self.set_num_updates(self.get_num_updates() + 1)
-
- if self.cfg.ema.store_ema:
- # Step EMA forward with new model.
- self.ema.step(
- self.get_model(),
- self.get_num_updates(),
- )
- metrics.log_scalar(
- "ema_decay",
- self.ema.get_decay(),
- priority=10000,
- round=5,
- weight=0,
- )
-
- if self.tpu:
- import torch_xla.core.xla_model as xm
-
- # mark step on TPUs
- self._xla_markstep_and_send_to_cpu()
-
- # only log stats every log_interval steps
- # this causes wps to be misreported when log_interval > 1
- logging_output = {}
- if self.get_num_updates() % self.cfg.common.log_interval == 0:
- # log memory usage
- mem_info = xm.get_memory_info(self.device)
- gb_free = mem_info["kb_free"] / 1024 / 1024
- gb_total = mem_info["kb_total"] / 1024 / 1024
- metrics.log_scalar(
- "gb_free", gb_free, priority=1500, round=1, weight=0
- )
- metrics.log_scalar(
- "gb_total", gb_total, priority=1600, round=1, weight=0
- )
- logging_outputs = self._xla_markstep_and_send_to_cpu(
- logging_outputs
- )
- logging_output = self._reduce_and_log_stats(
- logging_outputs, sample_size, grad_norm
- )
-
- # log whenever there's an XLA compilation, since these
- # slow down training and may indicate opportunities for
- # optimization
- self._check_xla_compilation()
- else:
- if self.cuda and self.cuda_env is not None:
- # log minimum free memory over the iteration
- gb_used = torch.cuda.max_memory_allocated() / 1024 / 1024 / 1024
- torch.cuda.reset_peak_memory_stats()
- gb_free = self.cuda_env.total_memory_in_GB - gb_used
- metrics.log_scalar(
- "gb_free", gb_free, priority=1500, round=1, weight=0
- )
-
- # log stats
- logging_output = self._reduce_and_log_stats(
- logging_outputs, sample_size, grad_norm
- )
-
- # clear CUDA cache to reduce memory fragmentation
- if (
- self.cuda
- and self.cfg.common.empty_cache_freq > 0
- and (
- (self.get_num_updates() + self.cfg.common.empty_cache_freq - 1)
- % self.cfg.common.empty_cache_freq
- )
- == 0
- ):
- torch.cuda.empty_cache()
-
- if self.cfg.common.fp16 or self.cfg.common.amp:
- metrics.log_scalar(
- "loss_scale",
- (
- self.optimizer.scaler.loss_scale
- if self.cfg.common.fp16
- else self.optimizer.scaler.get_scale()
- ),
- priority=700,
- round=4,
- weight=0,
- )
-
- metrics.log_stop_time("train_wall")
- return logging_output
-
- @metrics.aggregate("valid")
- def valid_step(self, sample, raise_oom=False):
- """Do forward pass in evaluation mode."""
- if self.tpu:
- import torch_xla.core.xla_model as xm
-
- xm.rendezvous("valid_step") # wait for all workers
-
- # If EMA is enabled through store_ema=True
- # and task.uses_ema is True, pass the EMA model as a keyword
- # argument to the task.
- extra_kwargs = {}
- if self.cfg.ema.store_ema and getattr(self.task, "uses_ema", False):
- extra_kwargs["ema_model"] = self.ema.get_model()
-
- with torch.no_grad():
- self.model.eval()
- self.criterion.eval()
-
- sample, is_dummy_batch = self._prepare_sample(sample)
-
- try:
- _loss, sample_size, logging_output = self.task.valid_step(
- sample, self.model, self.criterion, **extra_kwargs
- )
- except RuntimeError as e:
- if "out of memory" in str(e):
- self._log_oom(e)
- if not raise_oom:
- logger.warning(
- "ran out of memory in validation step, retrying batch"
- )
- for p in self.model.parameters():
- if p.grad is not None:
- p.grad = None # free some memory
- if self.cuda:
- torch.cuda.empty_cache()
- return self.valid_step(sample, raise_oom=True)
- raise e
-
- logging_outputs = [logging_output]
- if is_dummy_batch:
- if torch.is_tensor(sample_size):
- sample_size.zero_()
- else:
- sample_size *= 0.0
-
- # gather logging outputs from all replicas
- if self.data_parallel_world_size > 1:
- logging_outputs, (sample_size,) = self._aggregate_logging_outputs(
- logging_outputs,
- sample_size,
- ignore=is_dummy_batch,
- )
-
- # log validation stats
- if self.tpu:
- logging_outputs = self._xla_markstep_and_send_to_cpu(logging_outputs)
- logging_output = self._reduce_and_log_stats(logging_outputs, sample_size)
-
- return logging_output
-
- def zero_grad(self):
- self.optimizer.zero_grad()
-
- def lr_step_begin_epoch(self, epoch):
- """Adjust the learning rate at the beginning of the epoch."""
- self.lr_scheduler.step_begin_epoch(epoch)
- # prefer updating the LR based on the number of steps
- return self.lr_step_update()
-
- def lr_reinit(self, total_updates, num_updates):
- self.lr_scheduler.reinit(total_updates, num_updates)
-
- def lr_step(self, epoch, val_loss=None):
- """Adjust the learning rate at the end of the epoch."""
- self.lr_scheduler.step(epoch, val_loss)
- # prefer updating the LR based on the number of steps
- return self.lr_step_update()
-
- def lr_step_update(self):
- """Update the learning rate after each update."""
- new_lr = self.lr_scheduler.step_update(self.get_num_updates())
- if isinstance(new_lr, dict):
- for k, v in new_lr.items():
- metrics.log_scalar(f"lr_{k}", v, weight=0, priority=300)
- new_lr = new_lr.get("default", next(iter(new_lr.values())))
- else:
- metrics.log_scalar("lr", new_lr, weight=0, priority=300)
- return new_lr
-
- def get_lr(self):
- """Get the current learning rate."""
- return self.optimizer.get_lr()
-
- def get_model(self):
- """Get the (non-wrapped) model instance."""
- return self._model
-
- def get_criterion(self):
- """Get the (non-wrapped) criterion instance."""
- return self._criterion
-
- def get_meter(self, name):
- """[deprecated] Get a specific meter by name."""
- from fairseq import meters
-
- if "get_meter" not in self._warn_once:
- self._warn_once.add("get_meter")
- utils.deprecation_warning(
- "Trainer.get_meter is deprecated. Please use fairseq.metrics instead."
- )
-
- train_meters = metrics.get_meters("train")
- if train_meters is None:
- train_meters = {}
-
- if name == "train_loss" and "loss" in train_meters:
- return train_meters["loss"]
- elif name == "train_nll_loss":
- # support for legacy train.py, which assumed this meter is
- # always initialized
- m = train_meters.get("nll_loss", None)
- return m or meters.AverageMeter()
- elif name == "wall":
- # support for legacy train.py, which assumed this meter is
- # always initialized
- m = metrics.get_meter("default", "wall")
- return m or meters.TimeMeter()
- elif name == "wps":
- m = metrics.get_meter("train", "wps")
- return m or meters.TimeMeter()
- elif name in {"valid_loss", "valid_nll_loss"}:
- # support for legacy train.py, which assumed these meters
- # are always initialized
- k = name[len("valid_") :]
- m = metrics.get_meter("valid", k)
- return m or meters.AverageMeter()
- elif name == "oom":
- return meters.AverageMeter()
- elif name in train_meters:
- return train_meters[name]
- return None
-
- def get_num_updates(self):
- """Get the number of parameters updates."""
- return self._num_updates
-
- def set_num_updates(self, num_updates):
- """Set the number of parameters updates."""
- self._num_updates = num_updates
- self.lr_step_update()
- if self.quantizer:
- self.quantizer.step_update(self._num_updates)
- metrics.log_scalar("num_updates", self._num_updates, weight=0, priority=200)
-
- def clip_grad_norm(self, clip_norm):
- def agg_norm_fn(total_norm):
- total_norm = total_norm.cuda().float() ** 2
- total_norm = distributed_utils.all_reduce(
- total_norm, group=self.data_parallel_process_group
- )
- return total_norm ** 0.5
-
- should_agg_norm = (
- self.is_fsdp
- and (
- self.data_parallel_process_group is not None
- or torch.distributed.is_initialized()
- )
- )
- return self.optimizer.clip_grad_norm(
- clip_norm, aggregate_norm_fn=agg_norm_fn if should_agg_norm else None
- )
-
- def cumulative_training_time(self):
- if self._cumulative_training_time is None:
- # single GPU
- return self._local_cumulative_training_time()
- else:
- return self._cumulative_training_time
-
- def _local_cumulative_training_time(self):
- """Aggregate training time in seconds."""
- return time.time() - self._start_time + self._previous_training_time
-
- def _fp_convert_sample(self, sample):
- def apply_half(t):
- if t.dtype is torch.float32:
- return t.to(dtype=torch.half)
- return t
-
- def apply_bfloat16(t):
- if t.dtype is torch.float32:
- return t.to(dtype=torch.bfloat16)
- return t
-
- if self.cfg.common.fp16:
- sample = utils.apply_to_sample(apply_half, sample)
-
- if self.cfg.common.bf16:
- sample = utils.apply_to_sample(apply_bfloat16, sample)
-
- return sample
-
- def _prepare_sample(self, sample, is_dummy=False):
- if sample == "DUMMY":
- raise Exception(
- "Trying to use an uninitialized 'dummy' batch. This usually indicates "
- "that the total number of batches is smaller than the number of "
- "participating GPUs. Try reducing the batch size or using fewer GPUs."
- )
-
- if sample is None or len(sample) == 0:
- assert (
- self._dummy_batch is not None and len(self._dummy_batch) > 0
- ), "Invalid dummy batch: {}".format(self._dummy_batch)
- sample, _ = self._prepare_sample(self._dummy_batch, is_dummy=True)
- return sample, True
-
- # Given that PCIe/NVLink bandwidth is significantly smaller than DRAM bandwidth
- # it makes sense to do the format conversion on the CPU and then transfer
- # a smaller buffer to the device. This also saves GPU memory capacity.
-
- if self.cfg.common.on_cpu_convert_precision:
- sample = self._fp_convert_sample(sample)
-
- if self.cuda:
- if self.pipeline_model_parallel:
- if 'target' in sample:
- sample['target'] = utils.move_to_cuda(sample['target'], device=self.last_device)
- else:
- sample = utils.move_to_cuda(sample)
- elif self.tpu and is_dummy:
- # the dummy batch may not be on the appropriate device
- sample = utils.move_to_cuda(sample, device=self.device)
-
- if not self.cfg.common.on_cpu_convert_precision:
- sample = self._fp_convert_sample(sample)
-
- if self._dummy_batch == "DUMMY":
- self._dummy_batch = sample
-
- return sample, False
-
- def _set_seed(self):
- # Set seed based on args.seed and the update number so that we get
- # reproducible results when resuming from checkpoints
- seed = self.cfg.common.seed + self.get_num_updates()
- utils.set_torch_seed(seed)
-
- def _sync_stats(self):
- # Return True if it's using multiple GPUs and DDP or multiple GPUs with
- # BMUF and it's a bmuf sync with warmup iterations completed before.
- if self.data_parallel_world_size == 1:
- return False
- elif self.cfg.optimization.use_bmuf:
- return (
- self.get_num_updates() + 1
- ) % self.cfg.bmuf.global_sync_iter == 0 and (
- self.get_num_updates() + 1
- ) > self.cfg.bmuf.warmup_iterations
- else:
- return True
-
- def _log_oom(self, exc):
- msg = "OOM: Ran out of memory with exception: {}".format(exc)
- logger.warning(msg)
- if torch.cuda.is_available() and hasattr(torch.cuda, "memory_summary"):
- for device_idx in range(torch.cuda.device_count()):
- logger.warning(torch.cuda.memory_summary(device=device_idx))
- sys.stderr.flush()
-
- def _aggregate_logging_outputs(
- self,
- logging_outputs: List[Dict[str, Any]],
- *extra_stats_to_sum,
- ignore=False,
- ):
- if self.task.__class__.logging_outputs_can_be_summed(self.get_criterion()):
- return self._fast_stat_sync_sum(
- logging_outputs, *extra_stats_to_sum, ignore=ignore
- )
- else:
- return self._all_gather_list_sync(
- logging_outputs, *extra_stats_to_sum, ignore=ignore
- )
-
- def _all_gather_list_sync(
- self,
- logging_outputs: List[Dict[str, Any]],
- *extra_stats_to_sum,
- ignore=False,
- ):
- """
- Sync logging outputs across workers. all_gather_list_sync is
- suitable when logging outputs are complex types.
- """
- if self.tpu:
- raise NotImplementedError
- if ignore:
- logging_outputs = []
- results = list(
- zip(
- *distributed_utils.all_gather_list(
- [logging_outputs] + list(extra_stats_to_sum),
- max_size=getattr(self.cfg.common, "all_gather_list_size", 16384),
- group=self.data_parallel_process_group,
- )
- )
- )
- logging_outputs, extra_stats_to_sum = results[0], results[1:]
- logging_outputs = list(chain.from_iterable(logging_outputs))
- extra_stats_to_sum = [sum(s) for s in extra_stats_to_sum]
- return logging_outputs, extra_stats_to_sum
-
- def _fast_stat_sync_sum(
- self,
- logging_outputs: List[Dict[str, Any]],
- *extra_stats_to_sum,
- ignore=False,
- ):
- """
- Sync logging outputs across workers. fast_stat_sync_sum is
- faster than all_gather_list_sync, but is only suitable when
- logging outputs are scalars and can be summed. Note that
- *logging_outputs* cannot contain any nested dicts/lists.
- """
- data = {}
- for i, stat in enumerate(extra_stats_to_sum):
- data["extra_stats_" + str(i)] = stat
- if len(logging_outputs) > 0:
- log_keys = list(logging_outputs[0].keys())
- for k in log_keys:
- if not ignore:
- v = sum(log[k] for log in logging_outputs if k in log)
- else:
- v = logging_outputs[0][k]
- v = torch.zeros_like(v) if torch.is_tensor(v) else 0
- data["logging_outputs_" + k] = v
- else:
- log_keys = None
-
- data = distributed_utils.all_reduce_dict(
- data, device=self.device, group=self.data_parallel_process_group
- )
-
- extra_stats_to_sum = [
- data["extra_stats_" + str(i)] for i in range(len(extra_stats_to_sum))
- ]
- if log_keys is not None:
- logging_outputs = [{k: data["logging_outputs_" + k] for k in log_keys}]
- else:
- logging_outputs = []
- return logging_outputs, extra_stats_to_sum
-
- def _check_grad_norms(self, grad_norm):
- """Check that grad norms are consistent across workers."""
- if self._grad_norm_buf is not None:
- self._grad_norm_buf.zero_()
- self._grad_norm_buf[self.data_parallel_rank] = grad_norm
- distributed_utils.all_reduce(
- self._grad_norm_buf, group=self.data_parallel_process_group
- )
-
- def is_consistent(tensor):
- max_abs_diff = torch.max(torch.abs(tensor - tensor[0]))
- return (
- (torch.isfinite(tensor).all()
- and (max_abs_diff / (tensor[0] + 1e-6) < 1e-6).all())
- or
- (self.cfg.common.amp and not torch.isfinite(tensor).all())
- # in case of amp non-finite grads are fine
- )
-
- if not is_consistent(self._grad_norm_buf):
- pretty_detail = "\n".join(
- "rank {:3d} = {:.8f}".format(r, n)
- for r, n in enumerate(self._grad_norm_buf.tolist())
- )
- error_detail = "grad_norm across the workers:\n{}\n".format(
- pretty_detail
- )
- # use FloatingPointError to trigger NanDetector
- raise FloatingPointError(
- "Fatal error: gradients are inconsistent between workers. "
- "Try --ddp-backend=legacy_ddp. "
- "Or are you mixing up different generation of GPUs in training?"
- + "\n"
- + "-" * 80
- + "\n{}\n".format(error_detail)
- + "-" * 80
- )
-
- def _reduce_and_log_stats(self, logging_outputs, sample_size, grad_norm=None):
- if grad_norm is not None and (
- not torch.is_tensor(grad_norm) or torch.isfinite(grad_norm)
- ):
- metrics.log_speed("ups", 1.0, priority=100, round=2)
- metrics.log_scalar("gnorm", grad_norm, priority=400, round=3)
- if self.cfg.optimization.clip_norm > 0:
- metrics.log_scalar(
- "clip",
- torch.where(
- grad_norm > self.cfg.optimization.clip_norm,
- grad_norm.new_tensor(100),
- grad_norm.new_tensor(0),
- ),
- priority=500,
- round=1,
- )
-
- with metrics.aggregate() as agg:
- if logging_outputs is not None:
- self.task.reduce_metrics(logging_outputs, self.get_criterion())
- del logging_outputs
-
- # extra warning for criterions that don't properly log a loss value
- if "loss" not in agg:
- if "loss" not in self._warn_once:
- self._warn_once.add("loss")
- logger.warning(
- "Criterion.reduce_metrics did not log a 'loss' value, "
- "which may break some functionality"
- )
- metrics.log_scalar("loss", -1)
-
- # support legacy interface
- if self.tpu:
- logging_output = {}
- else:
- logging_output = agg.get_smoothed_values()
- logging_output["sample_size"] = sample_size
- for key_to_delete in ["ppl", "wps", "wpb", "bsz"]:
- if key_to_delete in logging_output:
- del logging_output[key_to_delete]
- return logging_output
-
- def _check_xla_compilation(self):
- import torch_xla.debug.metrics as met
-
- compile_stats = met.metric_data("CompileTime")
- if compile_stats is None:
- return
- num_xla_compiles = compile_stats[0]
- if num_xla_compiles > self._num_xla_compiles:
- logger.warning(
- "XLA compilation detected on device #{}; too many of these can lead "
- "to slow training, but we expect a few in the beginning".format(
- self.cfg.distributed_training.distributed_rank
- )
- )
- self._num_xla_compiles = num_xla_compiles
-
- def _xla_markstep_and_send_to_cpu(self, data=None):
- import torch_xla.core.xla_model as xm
-
- xm.mark_step()
- if data is not None:
- from fairseq.utils import xla_device_to_cpu
-
- return xla_device_to_cpu(data)
-
-
-def _catalog_shared_params(module, memo=None, prefix=""):
- if memo is None:
- first_call = True
- memo = {}
- else:
- first_call = False
- for name, param in module._parameters.items():
- param_prefix = prefix + ("." if prefix else "") + name
- if param not in memo:
- memo[param] = []
- memo[param].append(param_prefix)
- for name, m in module._modules.items():
- if m is None:
- continue
- submodule_prefix = prefix + ("." if prefix else "") + name
- _catalog_shared_params(m, memo, submodule_prefix)
- if first_call:
- return [x for x in memo.values() if len(x) > 1]
-
-
-def _get_module_by_path(module, path):
- path = path.split(".")
- for name in path:
- module = getattr(module, name)
- return module
-
-
-def _set_module_by_path(module, path, value):
- path = path.split(".")
- for name in path[:-1]:
- module = getattr(module, name)
- setattr(module, path[-1], value)
diff --git a/spaces/Ibtehaj10/cheating-detection-FYP/yolovs5/train.py b/spaces/Ibtehaj10/cheating-detection-FYP/yolovs5/train.py
deleted file mode 100644
index 8b5446e58f2de7155e80c7e9f50c205a20bc6e5d..0000000000000000000000000000000000000000
--- a/spaces/Ibtehaj10/cheating-detection-FYP/yolovs5/train.py
+++ /dev/null
@@ -1,633 +0,0 @@
-# YOLOv5 🚀 by Ultralytics, GPL-3.0 license
-"""
-Train a YOLOv5 model on a custom dataset.
-Models and datasets download automatically from the latest YOLOv5 release.
-
-Usage - Single-GPU training:
- $ python train.py --data coco128.yaml --weights yolov5s.pt --img 640 # from pretrained (recommended)
- $ python train.py --data coco128.yaml --weights '' --cfg yolov5s.yaml --img 640 # from scratch
-
-Usage - Multi-GPU DDP training:
- $ python -m torch.distributed.run --nproc_per_node 4 --master_port 1 train.py --data coco128.yaml --weights yolov5s.pt --img 640 --device 0,1,2,3
-
-Models: https://github.com/ultralytics/yolov5/tree/master/models
-Datasets: https://github.com/ultralytics/yolov5/tree/master/data
-Tutorial: https://github.com/ultralytics/yolov5/wiki/Train-Custom-Data
-"""
-
-import argparse
-import math
-import os
-import random
-import sys
-import time
-from copy import deepcopy
-from datetime import datetime
-from pathlib import Path
-
-import numpy as np
-import torch
-import torch.distributed as dist
-import torch.nn as nn
-import yaml
-from torch.optim import lr_scheduler
-from tqdm import tqdm
-
-FILE = Path(__file__).resolve()
-ROOT = FILE.parents[0] # YOLOv5 root directory
-if str(ROOT) not in sys.path:
- sys.path.append(str(ROOT)) # add ROOT to PATH
-ROOT = Path(os.path.relpath(ROOT, Path.cwd())) # relative
-
-import val as validate # for end-of-epoch mAP
-from models.experimental import attempt_load
-from models.yolo import Model
-from utils.autoanchor import check_anchors
-from utils.autobatch import check_train_batch_size
-from utils.callbacks import Callbacks
-from utils.dataloaders import create_dataloader
-from utils.downloads import attempt_download, is_url
-from utils.general import (LOGGER, TQDM_BAR_FORMAT, check_amp, check_dataset, check_file, check_git_info,
- check_git_status, check_img_size, check_requirements, check_suffix, check_yaml, colorstr,
- get_latest_run, increment_path, init_seeds, intersect_dicts, labels_to_class_weights,
- labels_to_image_weights, methods, one_cycle, print_args, print_mutation, strip_optimizer,
- yaml_save)
-from utils.loggers import Loggers
-from utils.loggers.comet.comet_utils import check_comet_resume
-from utils.loss import ComputeLoss
-from utils.metrics import fitness
-from utils.plots import plot_evolve
-from utils.torch_utils import (EarlyStopping, ModelEMA, de_parallel, select_device, smart_DDP, smart_optimizer,
- smart_resume, torch_distributed_zero_first)
-
-LOCAL_RANK = int(os.getenv('LOCAL_RANK', -1)) # https://pytorch.org/docs/stable/elastic/run.html
-RANK = int(os.getenv('RANK', -1))
-WORLD_SIZE = int(os.getenv('WORLD_SIZE', 1))
-GIT_INFO = check_git_info()
-
-
-def train(hyp, opt, device, callbacks): # hyp is path/to/hyp.yaml or hyp dictionary
- save_dir, epochs, batch_size, weights, single_cls, evolve, data, cfg, resume, noval, nosave, workers, freeze = \
- Path(opt.save_dir), opt.epochs, opt.batch_size, opt.weights, opt.single_cls, opt.evolve, opt.data, opt.cfg, \
- opt.resume, opt.noval, opt.nosave, opt.workers, opt.freeze
- callbacks.run('on_pretrain_routine_start')
-
- # Directories
- w = save_dir / 'weights' # weights dir
- (w.parent if evolve else w).mkdir(parents=True, exist_ok=True) # make dir
- last, best = w / 'last.pt', w / 'best.pt'
-
- # Hyperparameters
- if isinstance(hyp, str):
- with open(hyp, errors='ignore') as f:
- hyp = yaml.safe_load(f) # load hyps dict
- LOGGER.info(colorstr('hyperparameters: ') + ', '.join(f'{k}={v}' for k, v in hyp.items()))
- opt.hyp = hyp.copy() # for saving hyps to checkpoints
-
- # Save run settings
- if not evolve:
- yaml_save(save_dir / 'hyp.yaml', hyp)
- yaml_save(save_dir / 'opt.yaml', vars(opt))
-
- # Loggers
- data_dict = None
- if RANK in {-1, 0}:
- loggers = Loggers(save_dir, weights, opt, hyp, LOGGER) # loggers instance
-
- # Register actions
- for k in methods(loggers):
- callbacks.register_action(k, callback=getattr(loggers, k))
-
- # Process custom dataset artifact link
- data_dict = loggers.remote_dataset
- if resume: # If resuming runs from remote artifact
- weights, epochs, hyp, batch_size = opt.weights, opt.epochs, opt.hyp, opt.batch_size
-
- # Config
- plots = not evolve and not opt.noplots # create plots
- cuda = device.type != 'cpu'
- init_seeds(opt.seed + 1 + RANK, deterministic=True)
- with torch_distributed_zero_first(LOCAL_RANK):
- data_dict = data_dict or check_dataset(data) # check if None
- train_path, val_path = data_dict['train'], data_dict['val']
- nc = 1 if single_cls else int(data_dict['nc']) # number of classes
- names = {0: 'item'} if single_cls and len(data_dict['names']) != 1 else data_dict['names'] # class names
- is_coco = isinstance(val_path, str) and val_path.endswith('coco/val2017.txt') # COCO dataset
-
- # Model
- check_suffix(weights, '.pt') # check weights
- pretrained = weights.endswith('.pt')
- if pretrained:
- with torch_distributed_zero_first(LOCAL_RANK):
- weights = attempt_download(weights) # download if not found locally
- ckpt = torch.load(weights, map_location='cpu') # load checkpoint to CPU to avoid CUDA memory leak
- model = Model(cfg or ckpt['model'].yaml, ch=3, nc=nc, anchors=hyp.get('anchors')).to(device) # create
- exclude = ['anchor'] if (cfg or hyp.get('anchors')) and not resume else [] # exclude keys
- csd = ckpt['model'].float().state_dict() # checkpoint state_dict as FP32
- csd = intersect_dicts(csd, model.state_dict(), exclude=exclude) # intersect
- model.load_state_dict(csd, strict=False) # load
- LOGGER.info(f'Transferred {len(csd)}/{len(model.state_dict())} items from {weights}') # report
- else:
- model = Model(cfg, ch=3, nc=nc, anchors=hyp.get('anchors')).to(device) # create
- amp = check_amp(model) # check AMP
-
- # Freeze
- freeze = [f'model.{x}.' for x in (freeze if len(freeze) > 1 else range(freeze[0]))] # layers to freeze
- for k, v in model.named_parameters():
- v.requires_grad = True # train all layers
- # v.register_hook(lambda x: torch.nan_to_num(x)) # NaN to 0 (commented for erratic training results)
- if any(x in k for x in freeze):
- LOGGER.info(f'freezing {k}')
- v.requires_grad = False
-
- # Image size
- gs = max(int(model.stride.max()), 32) # grid size (max stride)
- imgsz = check_img_size(opt.imgsz, gs, floor=gs * 2) # verify imgsz is gs-multiple
-
- # Batch size
- if RANK == -1 and batch_size == -1: # single-GPU only, estimate best batch size
- batch_size = check_train_batch_size(model, imgsz, amp)
- loggers.on_params_update({"batch_size": batch_size})
-
- # Optimizer
- nbs = 64 # nominal batch size
- accumulate = max(round(nbs / batch_size), 1) # accumulate loss before optimizing
- hyp['weight_decay'] *= batch_size * accumulate / nbs # scale weight_decay
- optimizer = smart_optimizer(model, opt.optimizer, hyp['lr0'], hyp['momentum'], hyp['weight_decay'])
-
- # Scheduler
- if opt.cos_lr:
- lf = one_cycle(1, hyp['lrf'], epochs) # cosine 1->hyp['lrf']
- else:
- lf = lambda x: (1 - x / epochs) * (1.0 - hyp['lrf']) + hyp['lrf'] # linear
- scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda=lf) # plot_lr_scheduler(optimizer, scheduler, epochs)
-
- # EMA
- ema = ModelEMA(model) if RANK in {-1, 0} else None
-
- # Resume
- best_fitness, start_epoch = 0.0, 0
- if pretrained:
- if resume:
- best_fitness, start_epoch, epochs = smart_resume(ckpt, optimizer, ema, weights, epochs, resume)
- del ckpt, csd
-
- # DP mode
- if cuda and RANK == -1 and torch.cuda.device_count() > 1:
- LOGGER.warning('WARNING ⚠️ DP not recommended, use torch.distributed.run for best DDP Multi-GPU results.\n'
- 'See Multi-GPU Tutorial at https://github.com/ultralytics/yolov5/issues/475 to get started.')
- model = torch.nn.DataParallel(model)
-
- # SyncBatchNorm
- if opt.sync_bn and cuda and RANK != -1:
- model = torch.nn.SyncBatchNorm.convert_sync_batchnorm(model).to(device)
- LOGGER.info('Using SyncBatchNorm()')
-
- # Trainloader
- train_loader, dataset = create_dataloader(train_path,
- imgsz,
- batch_size // WORLD_SIZE,
- gs,
- single_cls,
- hyp=hyp,
- augment=True,
- cache=None if opt.cache == 'val' else opt.cache,
- rect=opt.rect,
- rank=LOCAL_RANK,
- workers=workers,
- image_weights=opt.image_weights,
- quad=opt.quad,
- prefix=colorstr('train: '),
- shuffle=True)
- labels = np.concatenate(dataset.labels, 0)
- mlc = int(labels[:, 0].max()) # max label class
- assert mlc < nc, f'Label class {mlc} exceeds nc={nc} in {data}. Possible class labels are 0-{nc - 1}'
-
- # Process 0
- if RANK in {-1, 0}:
- val_loader = create_dataloader(val_path,
- imgsz,
- batch_size // WORLD_SIZE * 2,
- gs,
- single_cls,
- hyp=hyp,
- cache=None if noval else opt.cache,
- rect=True,
- rank=-1,
- workers=workers * 2,
- pad=0.5,
- prefix=colorstr('val: '))[0]
-
- if not resume:
- if not opt.noautoanchor:
- check_anchors(dataset, model=model, thr=hyp['anchor_t'], imgsz=imgsz) # run AutoAnchor
- model.half().float() # pre-reduce anchor precision
-
- callbacks.run('on_pretrain_routine_end', labels, names)
-
- # DDP mode
- if cuda and RANK != -1:
- model = smart_DDP(model)
-
- # Model attributes
- nl = de_parallel(model).model[-1].nl # number of detection layers (to scale hyps)
- hyp['box'] *= 3 / nl # scale to layers
- hyp['cls'] *= nc / 80 * 3 / nl # scale to classes and layers
- hyp['obj'] *= (imgsz / 640) ** 2 * 3 / nl # scale to image size and layers
- hyp['label_smoothing'] = opt.label_smoothing
- model.nc = nc # attach number of classes to model
- model.hyp = hyp # attach hyperparameters to model
- model.class_weights = labels_to_class_weights(dataset.labels, nc).to(device) * nc # attach class weights
- model.names = names
-
- # Start training
- t0 = time.time()
- nb = len(train_loader) # number of batches
- nw = max(round(hyp['warmup_epochs'] * nb), 100) # number of warmup iterations, max(3 epochs, 100 iterations)
- # nw = min(nw, (epochs - start_epoch) / 2 * nb) # limit warmup to < 1/2 of training
- last_opt_step = -1
- maps = np.zeros(nc) # mAP per class
- results = (0, 0, 0, 0, 0, 0, 0) # P, R, mAP@.5, mAP@.5-.95, val_loss(box, obj, cls)
- scheduler.last_epoch = start_epoch - 1 # do not move
- scaler = torch.cuda.amp.GradScaler(enabled=amp)
- stopper, stop = EarlyStopping(patience=opt.patience), False
- compute_loss = ComputeLoss(model) # init loss class
- callbacks.run('on_train_start')
- LOGGER.info(f'Image sizes {imgsz} train, {imgsz} val\n'
- f'Using {train_loader.num_workers * WORLD_SIZE} dataloader workers\n'
- f"Logging results to {colorstr('bold', save_dir)}\n"
- f'Starting training for {epochs} epochs...')
- for epoch in range(start_epoch, epochs): # epoch ------------------------------------------------------------------
- callbacks.run('on_train_epoch_start')
- model.train()
-
- # Update image weights (optional, single-GPU only)
- if opt.image_weights:
- cw = model.class_weights.cpu().numpy() * (1 - maps) ** 2 / nc # class weights
- iw = labels_to_image_weights(dataset.labels, nc=nc, class_weights=cw) # image weights
- dataset.indices = random.choices(range(dataset.n), weights=iw, k=dataset.n) # rand weighted idx
-
- # Update mosaic border (optional)
- # b = int(random.uniform(0.25 * imgsz, 0.75 * imgsz + gs) // gs * gs)
- # dataset.mosaic_border = [b - imgsz, -b] # height, width borders
-
- mloss = torch.zeros(3, device=device) # mean losses
- if RANK != -1:
- train_loader.sampler.set_epoch(epoch)
- pbar = enumerate(train_loader)
- LOGGER.info(('\n' + '%11s' * 7) % ('Epoch', 'GPU_mem', 'box_loss', 'obj_loss', 'cls_loss', 'Instances', 'Size'))
- if RANK in {-1, 0}:
- pbar = tqdm(pbar, total=nb, bar_format=TQDM_BAR_FORMAT) # progress bar
- optimizer.zero_grad()
- for i, (imgs, targets, paths, _) in pbar: # batch -------------------------------------------------------------
- callbacks.run('on_train_batch_start')
- ni = i + nb * epoch # number integrated batches (since train start)
- imgs = imgs.to(device, non_blocking=True).float() / 255 # uint8 to float32, 0-255 to 0.0-1.0
-
- # Warmup
- if ni <= nw:
- xi = [0, nw] # x interp
- # compute_loss.gr = np.interp(ni, xi, [0.0, 1.0]) # iou loss ratio (obj_loss = 1.0 or iou)
- accumulate = max(1, np.interp(ni, xi, [1, nbs / batch_size]).round())
- for j, x in enumerate(optimizer.param_groups):
- # bias lr falls from 0.1 to lr0, all other lrs rise from 0.0 to lr0
- x['lr'] = np.interp(ni, xi, [hyp['warmup_bias_lr'] if j == 0 else 0.0, x['initial_lr'] * lf(epoch)])
- if 'momentum' in x:
- x['momentum'] = np.interp(ni, xi, [hyp['warmup_momentum'], hyp['momentum']])
-
- # Multi-scale
- if opt.multi_scale:
- sz = random.randrange(imgsz * 0.5, imgsz * 1.5 + gs) // gs * gs # size
- sf = sz / max(imgs.shape[2:]) # scale factor
- if sf != 1:
- ns = [math.ceil(x * sf / gs) * gs for x in imgs.shape[2:]] # new shape (stretched to gs-multiple)
- imgs = nn.functional.interpolate(imgs, size=ns, mode='bilinear', align_corners=False)
-
- # Forward
- with torch.cuda.amp.autocast(amp):
- pred = model(imgs) # forward
- loss, loss_items = compute_loss(pred, targets.to(device)) # loss scaled by batch_size
- if RANK != -1:
- loss *= WORLD_SIZE # gradient averaged between devices in DDP mode
- if opt.quad:
- loss *= 4.
-
- # Backward
- scaler.scale(loss).backward()
-
- # Optimize - https://pytorch.org/docs/master/notes/amp_examples.html
- if ni - last_opt_step >= accumulate:
- scaler.unscale_(optimizer) # unscale gradients
- torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=10.0) # clip gradients
- scaler.step(optimizer) # optimizer.step
- scaler.update()
- optimizer.zero_grad()
- if ema:
- ema.update(model)
- last_opt_step = ni
-
- # Log
- if RANK in {-1, 0}:
- mloss = (mloss * i + loss_items) / (i + 1) # update mean losses
- mem = f'{torch.cuda.memory_reserved() / 1E9 if torch.cuda.is_available() else 0:.3g}G' # (GB)
- pbar.set_description(('%11s' * 2 + '%11.4g' * 5) %
- (f'{epoch}/{epochs - 1}', mem, *mloss, targets.shape[0], imgs.shape[-1]))
- callbacks.run('on_train_batch_end', model, ni, imgs, targets, paths, list(mloss))
- if callbacks.stop_training:
- return
- # end batch ------------------------------------------------------------------------------------------------
-
- # Scheduler
- lr = [x['lr'] for x in optimizer.param_groups] # for loggers
- scheduler.step()
-
- if RANK in {-1, 0}:
- # mAP
- callbacks.run('on_train_epoch_end', epoch=epoch)
- ema.update_attr(model, include=['yaml', 'nc', 'hyp', 'names', 'stride', 'class_weights'])
- final_epoch = (epoch + 1 == epochs) or stopper.possible_stop
- if not noval or final_epoch: # Calculate mAP
- results, maps, _ = validate.run(data_dict,
- batch_size=batch_size // WORLD_SIZE * 2,
- imgsz=imgsz,
- half=amp,
- model=ema.ema,
- single_cls=single_cls,
- dataloader=val_loader,
- save_dir=save_dir,
- plots=False,
- callbacks=callbacks,
- compute_loss=compute_loss)
-
- # Update best mAP
- fi = fitness(np.array(results).reshape(1, -1)) # weighted combination of [P, R, mAP@.5, mAP@.5-.95]
- stop = stopper(epoch=epoch, fitness=fi) # early stop check
- if fi > best_fitness:
- best_fitness = fi
- log_vals = list(mloss) + list(results) + lr
- callbacks.run('on_fit_epoch_end', log_vals, epoch, best_fitness, fi)
-
- # Save model
- if (not nosave) or (final_epoch and not evolve): # if save
- ckpt = {
- 'epoch': epoch,
- 'best_fitness': best_fitness,
- 'model': deepcopy(de_parallel(model)).half(),
- 'ema': deepcopy(ema.ema).half(),
- 'updates': ema.updates,
- 'optimizer': optimizer.state_dict(),
- 'opt': vars(opt),
- 'git': GIT_INFO, # {remote, branch, commit} if a git repo
- 'date': datetime.now().isoformat()}
-
- # Save last, best and delete
- torch.save(ckpt, last)
- if best_fitness == fi:
- torch.save(ckpt, best)
- if opt.save_period > 0 and epoch % opt.save_period == 0:
- torch.save(ckpt, w / f'epoch{epoch}.pt')
- del ckpt
- callbacks.run('on_model_save', last, epoch, final_epoch, best_fitness, fi)
-
- # EarlyStopping
- if RANK != -1: # if DDP training
- broadcast_list = [stop if RANK == 0 else None]
- dist.broadcast_object_list(broadcast_list, 0) # broadcast 'stop' to all ranks
- if RANK != 0:
- stop = broadcast_list[0]
- if stop:
- break # must break all DDP ranks
-
- # end epoch ----------------------------------------------------------------------------------------------------
- # end training -----------------------------------------------------------------------------------------------------
- if RANK in {-1, 0}:
- LOGGER.info(f'\n{epoch - start_epoch + 1} epochs completed in {(time.time() - t0) / 3600:.3f} hours.')
- for f in last, best:
- if f.exists():
- strip_optimizer(f) # strip optimizers
- if f is best:
- LOGGER.info(f'\nValidating {f}...')
- results, _, _ = validate.run(
- data_dict,
- batch_size=batch_size // WORLD_SIZE * 2,
- imgsz=imgsz,
- model=attempt_load(f, device).half(),
- iou_thres=0.65 if is_coco else 0.60, # best pycocotools at iou 0.65
- single_cls=single_cls,
- dataloader=val_loader,
- save_dir=save_dir,
- save_json=is_coco,
- verbose=True,
- plots=plots,
- callbacks=callbacks,
- compute_loss=compute_loss) # val best model with plots
- if is_coco:
- callbacks.run('on_fit_epoch_end', list(mloss) + list(results) + lr, epoch, best_fitness, fi)
-
- callbacks.run('on_train_end', last, best, epoch, results)
-
- torch.cuda.empty_cache()
- return results
-
-
-def parse_opt(known=False):
- parser = argparse.ArgumentParser()
- parser.add_argument('--weights', type=str, default=ROOT / 'yolov5s.pt', help='initial weights path')
- parser.add_argument('--cfg', type=str, default='', help='model.yaml path')
- parser.add_argument('--data', type=str, default=ROOT / 'data/coco128.yaml', help='dataset.yaml path')
- parser.add_argument('--hyp', type=str, default=ROOT / 'data/hyps/hyp.scratch-low.yaml', help='hyperparameters path')
- parser.add_argument('--epochs', type=int, default=100, help='total training epochs')
- parser.add_argument('--batch-size', type=int, default=16, help='total batch size for all GPUs, -1 for autobatch')
- parser.add_argument('--imgsz', '--img', '--img-size', type=int, default=640, help='train, val image size (pixels)')
- parser.add_argument('--rect', action='store_true', help='rectangular training')
- parser.add_argument('--resume', nargs='?', const=True, default=False, help='resume most recent training')
- parser.add_argument('--nosave', action='store_true', help='only save final checkpoint')
- parser.add_argument('--noval', action='store_true', help='only validate final epoch')
- parser.add_argument('--noautoanchor', action='store_true', help='disable AutoAnchor')
- parser.add_argument('--noplots', action='store_true', help='save no plot files')
- parser.add_argument('--evolve', type=int, nargs='?', const=300, help='evolve hyperparameters for x generations')
- parser.add_argument('--bucket', type=str, default='', help='gsutil bucket')
- parser.add_argument('--cache', type=str, nargs='?', const='ram', help='image --cache ram/disk')
- parser.add_argument('--image-weights', action='store_true', help='use weighted image selection for training')
- parser.add_argument('--device', default='', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
- parser.add_argument('--multi-scale', action='store_true', help='vary img-size +/- 50%%')
- parser.add_argument('--single-cls', action='store_true', help='train multi-class data as single-class')
- parser.add_argument('--optimizer', type=str, choices=['SGD', 'Adam', 'AdamW'], default='SGD', help='optimizer')
- parser.add_argument('--sync-bn', action='store_true', help='use SyncBatchNorm, only available in DDP mode')
- parser.add_argument('--workers', type=int, default=8, help='max dataloader workers (per RANK in DDP mode)')
- parser.add_argument('--project', default=ROOT / 'runs/train', help='save to project/name')
- parser.add_argument('--name', default='exp', help='save to project/name')
- parser.add_argument('--exist-ok', action='store_true', help='existing project/name ok, do not increment')
- parser.add_argument('--quad', action='store_true', help='quad dataloader')
- parser.add_argument('--cos-lr', action='store_true', help='cosine LR scheduler')
- parser.add_argument('--label-smoothing', type=float, default=0.0, help='Label smoothing epsilon')
- parser.add_argument('--patience', type=int, default=100, help='EarlyStopping patience (epochs without improvement)')
- parser.add_argument('--freeze', nargs='+', type=int, default=[0], help='Freeze layers: backbone=10, first3=0 1 2')
- parser.add_argument('--save-period', type=int, default=-1, help='Save checkpoint every x epochs (disabled if < 1)')
- parser.add_argument('--seed', type=int, default=0, help='Global training seed')
- parser.add_argument('--local_rank', type=int, default=-1, help='Automatic DDP Multi-GPU argument, do not modify')
-
- # Logger arguments
- parser.add_argument('--entity', default=None, help='Entity')
- parser.add_argument('--upload_dataset', nargs='?', const=True, default=False, help='Upload data, "val" option')
- parser.add_argument('--bbox_interval', type=int, default=-1, help='Set bounding-box image logging interval')
- parser.add_argument('--artifact_alias', type=str, default='latest', help='Version of dataset artifact to use')
-
- return parser.parse_known_args()[0] if known else parser.parse_args()
-
-
-def main(opt, callbacks=Callbacks()):
- # Checks
- if RANK in {-1, 0}:
- print_args(vars(opt))
- check_git_status()
- check_requirements()
-
- # Resume (from specified or most recent last.pt)
- if opt.resume and not check_comet_resume(opt) and not opt.evolve:
- last = Path(check_file(opt.resume) if isinstance(opt.resume, str) else get_latest_run())
- opt_yaml = last.parent.parent / 'opt.yaml' # train options yaml
- opt_data = opt.data # original dataset
- if opt_yaml.is_file():
- with open(opt_yaml, errors='ignore') as f:
- d = yaml.safe_load(f)
- else:
- d = torch.load(last, map_location='cpu')['opt']
- opt = argparse.Namespace(**d) # replace
- opt.cfg, opt.weights, opt.resume = '', str(last), True # reinstate
- if is_url(opt_data):
- opt.data = check_file(opt_data) # avoid HUB resume auth timeout
- else:
- opt.data, opt.cfg, opt.hyp, opt.weights, opt.project = \
- check_file(opt.data), check_yaml(opt.cfg), check_yaml(opt.hyp), str(opt.weights), str(opt.project) # checks
- assert len(opt.cfg) or len(opt.weights), 'either --cfg or --weights must be specified'
- if opt.evolve:
- if opt.project == str(ROOT / 'runs/train'): # if default project name, rename to runs/evolve
- opt.project = str(ROOT / 'runs/evolve')
- opt.exist_ok, opt.resume = opt.resume, False # pass resume to exist_ok and disable resume
- if opt.name == 'cfg':
- opt.name = Path(opt.cfg).stem # use model.yaml as name
- opt.save_dir = str(increment_path(Path(opt.project) / opt.name, exist_ok=opt.exist_ok))
-
- # DDP mode
- device = select_device(opt.device, batch_size=opt.batch_size)
- if LOCAL_RANK != -1:
- msg = 'is not compatible with YOLOv5 Multi-GPU DDP training'
- assert not opt.image_weights, f'--image-weights {msg}'
- assert not opt.evolve, f'--evolve {msg}'
- assert opt.batch_size != -1, f'AutoBatch with --batch-size -1 {msg}, please pass a valid --batch-size'
- assert opt.batch_size % WORLD_SIZE == 0, f'--batch-size {opt.batch_size} must be multiple of WORLD_SIZE'
- assert torch.cuda.device_count() > LOCAL_RANK, 'insufficient CUDA devices for DDP command'
- torch.cuda.set_device(LOCAL_RANK)
- device = torch.device('cuda', LOCAL_RANK)
- dist.init_process_group(backend="nccl" if dist.is_nccl_available() else "gloo")
-
- # Train
- if not opt.evolve:
- train(opt.hyp, opt, device, callbacks)
-
- # Evolve hyperparameters (optional)
- else:
- # Hyperparameter evolution metadata (mutation scale 0-1, lower_limit, upper_limit)
- meta = {
- 'lr0': (1, 1e-5, 1e-1), # initial learning rate (SGD=1E-2, Adam=1E-3)
- 'lrf': (1, 0.01, 1.0), # final OneCycleLR learning rate (lr0 * lrf)
- 'momentum': (0.3, 0.6, 0.98), # SGD momentum/Adam beta1
- 'weight_decay': (1, 0.0, 0.001), # optimizer weight decay
- 'warmup_epochs': (1, 0.0, 5.0), # warmup epochs (fractions ok)
- 'warmup_momentum': (1, 0.0, 0.95), # warmup initial momentum
- 'warmup_bias_lr': (1, 0.0, 0.2), # warmup initial bias lr
- 'box': (1, 0.02, 0.2), # box loss gain
- 'cls': (1, 0.2, 4.0), # cls loss gain
- 'cls_pw': (1, 0.5, 2.0), # cls BCELoss positive_weight
- 'obj': (1, 0.2, 4.0), # obj loss gain (scale with pixels)
- 'obj_pw': (1, 0.5, 2.0), # obj BCELoss positive_weight
- 'iou_t': (0, 0.1, 0.7), # IoU training threshold
- 'anchor_t': (1, 2.0, 8.0), # anchor-multiple threshold
- 'anchors': (2, 2.0, 10.0), # anchors per output grid (0 to ignore)
- 'fl_gamma': (0, 0.0, 2.0), # focal loss gamma (efficientDet default gamma=1.5)
- 'hsv_h': (1, 0.0, 0.1), # image HSV-Hue augmentation (fraction)
- 'hsv_s': (1, 0.0, 0.9), # image HSV-Saturation augmentation (fraction)
- 'hsv_v': (1, 0.0, 0.9), # image HSV-Value augmentation (fraction)
- 'degrees': (1, 0.0, 45.0), # image rotation (+/- deg)
- 'translate': (1, 0.0, 0.9), # image translation (+/- fraction)
- 'scale': (1, 0.0, 0.9), # image scale (+/- gain)
- 'shear': (1, 0.0, 10.0), # image shear (+/- deg)
- 'perspective': (0, 0.0, 0.001), # image perspective (+/- fraction), range 0-0.001
- 'flipud': (1, 0.0, 1.0), # image flip up-down (probability)
- 'fliplr': (0, 0.0, 1.0), # image flip left-right (probability)
- 'mosaic': (1, 0.0, 1.0), # image mixup (probability)
- 'mixup': (1, 0.0, 1.0), # image mixup (probability)
- 'copy_paste': (1, 0.0, 1.0)} # segment copy-paste (probability)
-
- with open(opt.hyp, errors='ignore') as f:
- hyp = yaml.safe_load(f) # load hyps dict
- if 'anchors' not in hyp: # anchors commented in hyp.yaml
- hyp['anchors'] = 3
- if opt.noautoanchor:
- del hyp['anchors'], meta['anchors']
- opt.noval, opt.nosave, save_dir = True, True, Path(opt.save_dir) # only val/save final epoch
- # ei = [isinstance(x, (int, float)) for x in hyp.values()] # evolvable indices
- evolve_yaml, evolve_csv = save_dir / 'hyp_evolve.yaml', save_dir / 'evolve.csv'
- if opt.bucket:
- os.system(f'gsutil cp gs://{opt.bucket}/evolve.csv {evolve_csv}') # download evolve.csv if exists
-
- for _ in range(opt.evolve): # generations to evolve
- if evolve_csv.exists(): # if evolve.csv exists: select best hyps and mutate
- # Select parent(s)
- parent = 'single' # parent selection method: 'single' or 'weighted'
- x = np.loadtxt(evolve_csv, ndmin=2, delimiter=',', skiprows=1)
- n = min(5, len(x)) # number of previous results to consider
- x = x[np.argsort(-fitness(x))][:n] # top n mutations
- w = fitness(x) - fitness(x).min() + 1E-6 # weights (sum > 0)
- if parent == 'single' or len(x) == 1:
- # x = x[random.randint(0, n - 1)] # random selection
- x = x[random.choices(range(n), weights=w)[0]] # weighted selection
- elif parent == 'weighted':
- x = (x * w.reshape(n, 1)).sum(0) / w.sum() # weighted combination
-
- # Mutate
- mp, s = 0.8, 0.2 # mutation probability, sigma
- npr = np.random
- npr.seed(int(time.time()))
- g = np.array([meta[k][0] for k in hyp.keys()]) # gains 0-1
- ng = len(meta)
- v = np.ones(ng)
- while all(v == 1): # mutate until a change occurs (prevent duplicates)
- v = (g * (npr.random(ng) < mp) * npr.randn(ng) * npr.random() * s + 1).clip(0.3, 3.0)
- for i, k in enumerate(hyp.keys()): # plt.hist(v.ravel(), 300)
- hyp[k] = float(x[i + 7] * v[i]) # mutate
-
- # Constrain to limits
- for k, v in meta.items():
- hyp[k] = max(hyp[k], v[1]) # lower limit
- hyp[k] = min(hyp[k], v[2]) # upper limit
- hyp[k] = round(hyp[k], 5) # significant digits
-
- # Train mutation
- results = train(hyp.copy(), opt, device, callbacks)
- callbacks = Callbacks()
- # Write mutation results
- keys = ('metrics/precision', 'metrics/recall', 'metrics/mAP_0.5', 'metrics/mAP_0.5:0.95', 'val/box_loss',
- 'val/obj_loss', 'val/cls_loss')
- print_mutation(keys, results, hyp.copy(), save_dir, opt.bucket)
-
- # Plot results
- plot_evolve(evolve_csv)
- LOGGER.info(f'Hyperparameter evolution finished {opt.evolve} generations\n'
- f"Results saved to {colorstr('bold', save_dir)}\n"
- f'Usage example: $ python train.py --hyp {evolve_yaml}')
-
-
-def run(**kwargs):
- # Usage: import train; train.run(data='coco128.yaml', imgsz=320, weights='yolov5m.pt')
- opt = parse_opt(True)
- for k, v in kwargs.items():
- setattr(opt, k, v)
- main(opt)
- return opt
-
-
-if __name__ == "__main__":
- opt = parse_opt()
- main(opt)
diff --git a/spaces/IntelligenzaArtificiale/ChatGLM-6B-Int4-API-OpenAI-Compatible/models/models--silver--chatglm-6b-int4-slim/snapshots/02e096b3805c579caf5741a6d8eddd5ba7a74e0d/quantization.py b/spaces/IntelligenzaArtificiale/ChatGLM-6B-Int4-API-OpenAI-Compatible/models/models--silver--chatglm-6b-int4-slim/snapshots/02e096b3805c579caf5741a6d8eddd5ba7a74e0d/quantization.py
deleted file mode 100644
index 69c502b4eb71836464037cfd1703762c5be0cfa4..0000000000000000000000000000000000000000
--- a/spaces/IntelligenzaArtificiale/ChatGLM-6B-Int4-API-OpenAI-Compatible/models/models--silver--chatglm-6b-int4-slim/snapshots/02e096b3805c579caf5741a6d8eddd5ba7a74e0d/quantization.py
+++ /dev/null
@@ -1,469 +0,0 @@
-from torch.nn import Linear, Embedding
-from torch.nn.parameter import Parameter
-import torch.nn.functional as F
-
-import os
-import bz2
-import torch
-import base64
-import ctypes
-
-from typing import List
-from functools import partial
-from cpm_kernels.kernels.base import LazyKernelCModule, KernelFunction, round_up
-
-
-class W8A16Linear(torch.autograd.Function):
- @staticmethod
- def forward(ctx, inp: torch.Tensor, quant_w: torch.Tensor, scale_w: torch.Tensor, weight_bit_width):
- ctx.inp_shape = inp.size()
- ctx.weight_shape = quant_w.size()
- ctx.weight_bit_width = weight_bit_width
- out_features = quant_w.size(0)
- inp = inp.contiguous().view(-1, inp.size(-1))
- weight = extract_weight_to_half(quant_w, scale_w, weight_bit_width)
- output = inp.mm(weight.t())
- ctx.save_for_backward(inp, quant_w, scale_w)
- return output.view(*(ctx.inp_shape[:-1] + (out_features,)))
-
- @staticmethod
- def backward(ctx, grad_output: torch.Tensor):
- inp, quant_w, scale_w = ctx.saved_tensors
- weight = extract_weight_to_half(quant_w, scale_w, ctx.weight_bit_width)
- grad_output = grad_output.contiguous().view(-1, weight.size(0))
- grad_input = grad_output.mm(weight)
- grad_weight = grad_output.t().mm(inp)
- return grad_input.view(ctx.inp_shape), grad_weight.view(ctx.weight_shape), None
-
-
-class W8A16LinearCPU(torch.autograd.Function):
- @staticmethod
- def forward(ctx, inp: torch.Tensor, quant_w: torch.Tensor, scale_w: torch.Tensor, weight_bit_width, quantization_cache=None):
- ctx.inp_shape = inp.size()
- ctx.weight_shape = quant_w.size()
- ctx.weight_bit_width = weight_bit_width
- out_features = quant_w.size(0)
- inp = inp.contiguous().view(-1, inp.size(-1))
- weight = extract_weight_to_float(quant_w, scale_w, weight_bit_width, quantization_cache=quantization_cache)
- output = inp.mm(weight.t())
- ctx.save_for_backward(inp, quant_w, scale_w)
- return output.view(*(ctx.inp_shape[:-1] + (out_features,)))
-
- @staticmethod
- def backward(ctx, grad_output: torch.Tensor):
- inp, quant_w, scale_w = ctx.saved_tensors
- weight = extract_weight_to_float(quant_w, scale_w, ctx.weight_bit_width)
- grad_output = grad_output.contiguous().view(-1, weight.size(0))
- grad_input = grad_output.mm(weight)
- grad_weight = grad_output.t().mm(inp)
- return grad_input.view(ctx.inp_shape), grad_weight.view(ctx.weight_shape), None
-
-
-class Kernel:
- def __init__(self, code: bytes, function_names: List[str]):
- self.code = code
- self._function_names = function_names
- self._cmodule = LazyKernelCModule(self.code)
-
- for name in self._function_names:
- setattr(self, name, KernelFunction(self._cmodule, name))
-
-default_cpu_kernel_code_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "quantization_kernels.c")
-default_cpu_kernel_code = "QlpoOTFBWSZTWXLbSoQAAgzbgERwQXxmTwAAr/ff3kABt0Q2oRVT0hpo9RtEAAAAyBEiSQ9EGjQGQAAAwANGhowjJoNGmgMEUplMTNSMJ5TQaDJpsoMyRMj8P4mZzFSVVwqSXG8GG7MlVwiToYEQwVD7noBxMhNfkeZYtYFtbgOBUSIGtIQjhNHCEnPJsadhb3yBmRIOD3TeAtNLSaU5GgvKUBWSNuuOIHmVt0YhW6rsmDMDUjeUJGJ64R1Jm5lrh0Aa0tKjhFwPdWcGogxLDSXPWQUWTM8Sd3Qz1HMYNxx3HMeiNqNo4jeRDEfZ3gUSHIcU/heomq0vEzL1Msz5KKGxH8FrNOYw3KaxdqaEmNHYMxJFgQbR0DyRknL2L4kwUSxKRdhjRpEtUqilVfggFL1klaMS3PPRDfNqbBOPWO7m4JTVGhS9QTBDDJaEbLbrUQNB+IpJSKQbG5SZZ5gkwJEhJ3aYKJipZ/i7kinChIOW2lQg"
-default_cpu_parallel_kernel_code_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "quantization_kernels_parallel.c")
-default_cpu_parallel_kernel_code = "QlpoOTFBWSZTWZzWK2UAALXbgERwSX1mTwAAr/ff3kACNyXSbZYwBpoaNGIyAaADQwRRFT/UKDINANqAD1NABFQlPUzaaJHppGRmoAG01ARKKaaMp4gmgaNAaDQDIKVKfZ/g6v1Kem5ZsWZmZtSXS5ZwRAzKmjr1E1lKMEoQNCPkEYPACgcR5I9w/0k6JrJYHqFuHnChcD7N+DHeOQ0ajF83Tc40jgmQbOB5wt3TEHyTObDBLoxrJGBuJmNbxYZwAoKTjbIcI7GsbuVRERAR8wqwhXQjQOxiHQlgSnHjQjddXERojNmQYJJVoM2xxawMeI9asi6E1rfd7GO8S0S5vacCNGry4F1nyZbcTvSBXEMipuPfM7i0Y8kjirpbxb05jpIQjCGE8DYBNCAZyHz9EoOpDRST/I1aFCNpcjoXgyc3NjVsUvYIaYq7xopYJqcxg2g4qXofm7AaGNTzJSNguOQw4utKcEl0F1UOgI+T1hk5LusbGZ9udC1CiBeGwwFxR/QdbZDndehRPxyGt3Me1DBW45MXIY24ZD30aFNuSEUdu5LWx1sSJWLGgsmqUIFTgWhU0gfxXpzhghr2AYpV3hE06mGk1I2JyuZiFgkiz/i7kinChITmsVso"
-
-
-class CPUKernel:
- def __init__(self, kernel_file="", source_code=default_cpu_kernel_code_path, compile_parallel_kernel=None, parallel_num=None):
- self.load =False
- self.int8WeightExtractionFloat = None
- self.int4WeightExtractionFloat = None
- self.int4WeightCompression = None
- self.SetNumThreads = None
-
- try:
- if not os.path.exists(default_cpu_kernel_code_path):
- with open(default_cpu_kernel_code_path, "w", encoding="utf-8") as file:
- code = default_cpu_kernel_code
- cpu_quantization_code = bz2.decompress(base64.b64decode(code)).decode()
- file.write(cpu_quantization_code)
-
- if not os.path.exists(default_cpu_parallel_kernel_code_path):
- with open(default_cpu_parallel_kernel_code_path, "w", encoding="utf-8") as file:
- code = default_cpu_parallel_kernel_code
- cpu_quantization_code = bz2.decompress(base64.b64decode(code)).decode()
- file.write(cpu_quantization_code)
-
- except Exception as ex:
- print("Error when generating default cpu kernel code(can be ignored when using custom kernels).")
-
- if compile_parallel_kernel is None:
- compile_parallel_kernel = bool(int(os.cpu_count()) >= 4)
-
- if compile_parallel_kernel and source_code == default_cpu_kernel_code_path:
- source_code = default_cpu_parallel_kernel_code_path
-
- if (not kernel_file) or (not os.path.exists(kernel_file)):
- print("No compiled kernel found.")
- try:
- if os.path.exists(source_code):
- print("Compiling kernels :", source_code)
- kernel_file = source_code[:-2] + ".so"
- if compile_parallel_kernel:
- compile_command = "gcc -O3 -pthread -fopenmp -std=c99 {} -shared -o {}".format(source_code, kernel_file)
- print("Compiling", compile_command)
- exit_state = os.system(compile_command)
- if exit_state:
- print("Compile failed, using default cpu kernel code.")
- compile_parallel_kernel = False
- source_code = default_cpu_kernel_code_path
- kernel_file = source_code[:-2] + ".so"
- compile_command = "gcc -O3 -fPIC -std=c99 {} -shared -o {}".format(source_code, kernel_file)
- print("Compiling", compile_command)
- else:
- compile_command = "gcc -O3 -fPIC -std=c99 {} -shared -o {}".format(source_code, kernel_file)
- print("Compiling", compile_command)
- exit_state = os.system(compile_command)
-
- print("Kernels compiled :", kernel_file)
- else:
- print("Kernel source code not found.")
- return
- except:
- print("Failed to build kernel.")
- return
- if kernel_file:
- kernels = ctypes.cdll.LoadLibrary(kernel_file)
- self.int8WeightExtractionFloat = kernels.extract_int8_weight_to_float
- self.int4WeightExtractionFloat = kernels.extract_int4_weight_to_float
- self.int4WeightCompression = kernels.compress_int4_weight
- if compile_parallel_kernel:
- try:
- self.SetNumThreads = kernels.set_num_threads
- except:
- print("No set_num_threads() found in kernel.")
- self.SetNumThreads = lambda x: x
- self.load = True
- print("Load kernel :", kernel_file)
- else:
- print("Failed to load kernel.")
-
- if compile_parallel_kernel:
- if parallel_num is None:
- parallel_num = max(os.cpu_count() // 2, 1)
- print("Setting CPU quantization kernel threads to", parallel_num)
- if parallel_num < 4:
- print("Parallel kernel is not recommended when parallel num < 4.")
- self.SetNumThreads(parallel_num)
-
- self.parallel_num = parallel_num
-
-
-cpu_kernels = None
-
-quantization_code = "$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"
-
-kernels = Kernel(
- bz2.decompress(base64.b64decode(quantization_code)),
- [
- "int4WeightCompression",
- "int4WeightExtractionFloat",
- "int4WeightExtractionHalf",
- "int8WeightExtractionFloat",
- "int8WeightExtractionHalf",
- ],
-)
-
-
-def compress_int4_weight(weight: torch.Tensor): # (n, m)
- """compress weight on cpu or cuda to int4"""
- if weight.device == torch.device("cpu"):
- assert isinstance(cpu_kernels, CPUKernel)
- n, m = weight.size(0), weight.size(1)
- assert m % 2 == 0
- m = m // 2
- out = torch.empty(n, m, dtype=torch.int8, device="cpu")
- cpu_kernels.int4WeightCompression(
- ctypes.c_void_p(weight.data_ptr()),
- ctypes.c_void_p(out.data_ptr()),
- ctypes.c_int32(n),
- ctypes.c_int32(m)
- )
- return out
- else:
- with torch.cuda.device(weight.device):
- n, m = weight.size(0), weight.size(1)
- assert m % 2 == 0
- m = m // 2
- out = torch.empty(n, m, dtype=torch.int8, device="cuda")
- stream = torch.cuda.current_stream()
-
- gridDim = (n, 1, 1)
- blockDim = (min(round_up(m, 32), 1024), 1, 1)
-
- kernels.int4WeightCompression(
- gridDim,
- blockDim,
- 0,
- stream,
- [ctypes.c_void_p(weight.data_ptr()), ctypes.c_void_p(out.data_ptr()), ctypes.c_int32(n), ctypes.c_int32(m)],
- )
- return out
-
-
-def extract_weight_to_half(weight: torch.Tensor, scale_list: torch.Tensor, source_bit_width: int):
- if source_bit_width == 8:
- func = kernels.int8WeightExtractionHalf
- elif source_bit_width == 4:
- func = kernels.int4WeightExtractionHalf
- else:
- assert False, "Unsupported bit-width"
-
- with torch.cuda.device(weight.device):
- n, m = weight.size(0), weight.size(1)
- out = torch.empty(n, m * (8 // source_bit_width), dtype=torch.half, device="cuda")
- stream = torch.cuda.current_stream()
-
- gridDim = (n, 1, 1)
- blockDim = (min(round_up(m, 32), 1024), 1, 1)
-
- func(
- gridDim,
- blockDim,
- 0,
- stream,
- [
- ctypes.c_void_p(weight.data_ptr()),
- ctypes.c_void_p(scale_list.data_ptr()),
- ctypes.c_void_p(out.data_ptr()),
- ctypes.c_int32(n),
- ctypes.c_int32(m),
- ],
- )
- return out
-
-
-def extract_weight_to_float(weight: torch.Tensor, scale_list: torch.Tensor, source_bit_width: int, quantization_cache=None):
- """extract weight on cpu to float32"""
- if source_bit_width == 8:
- func = cpu_kernels.int8WeightExtractionFloat
- elif source_bit_width == 4:
- func = cpu_kernels.int4WeightExtractionFloat
- else:
- assert False, "Unsupported bit-width"
-
- n, m = weight.size(0), weight.size(1)
-
- if quantization_cache is not None:
- out = quantization_cache
- func(
- ctypes.c_void_p(weight.data_ptr()),
- ctypes.c_void_p(scale_list.data_ptr()),
- ctypes.c_void_p(out.data_ptr()),
- ctypes.c_int32(n),
- ctypes.c_int32(m)
- )
- return out.tensor
- else:
- out = torch.empty(n, m * (8 // source_bit_width), dtype=torch.float, device="cpu")
- func(
- ctypes.c_void_p(weight.data_ptr()),
- ctypes.c_void_p(scale_list.data_ptr()),
- ctypes.c_void_p(out.data_ptr()),
- ctypes.c_int32(n),
- ctypes.c_int32(m)
- )
- return out
-
-
-class CacheTensor():
- def __init__(self, *args, **kwargs):
- self.tensor = torch.empty(*args, **kwargs)
-
- def to(self, *args, **kwargs):
- self.tensor = self.tensor.to(*args, **kwargs)
-
- def data_ptr(self):
- return self.tensor.data_ptr()
-
-
-class QuantizedLinear(Linear):
- def __init__(self, weight_bit_width: int, weight_tensor=None, bias_tensor=None, quantized_weight=None, quantized_weight_scale=None, quantization_cache=None, empty_init=False, *args, **kwargs):
- super(QuantizedLinear, self).__init__(*args, **kwargs)
- self.weight_bit_width = weight_bit_width
- self.quantization_cache = quantization_cache
-
- if (quantized_weight is not None) and (quantized_weight_scale is not None):
- del self.weight
- self.weight = Parameter(quantized_weight.to(kwargs["device"]), requires_grad=False)
- self.weight_scale = Parameter(quantized_weight_scale.to(kwargs["device"]), requires_grad=False)
- else:
- shape = self.weight.shape
- del self.weight
-
- if weight_tensor is None or empty_init:
- self.weight = torch.empty(
- shape[0], shape[1] * weight_bit_width // 8, dtype=torch.int8, device=kwargs["device"]
- )
- self.weight_scale = torch.empty(shape[0], dtype=kwargs["dtype"], device=kwargs["device"])
- else:
- self.weight_scale = (weight_tensor.abs().max(dim=-1).values / ((2 ** (weight_bit_width - 1)) - 1)).to(kwargs["dtype"])
- self.weight = torch.round(weight_tensor / self.weight_scale[:, None]).to(torch.int8)
- if weight_bit_width == 4:
- self.weight = compress_int4_weight(self.weight)
-
- self.weight = Parameter(self.weight.to(kwargs["device"]), requires_grad=False)
- self.weight_scale = Parameter(self.weight_scale.to(kwargs["device"]), requires_grad=False)
-
- if bias_tensor is not None:
- self.bias = Parameter(bias_tensor.to(kwargs["device"]), requires_grad=False)
- else:
- self.bias = None
-
- def reset_parameters(self):
- """To accelerate initialization"""
- pass
-
- def forward(self, input):
- if self.weight.device == torch.device("cpu"):
- output = W8A16LinearCPU.apply(input, self.weight, self.weight_scale, self.weight_bit_width, self.quantization_cache)
- else:
- output = W8A16Linear.apply(input, self.weight, self.weight_scale, self.weight_bit_width)
- if self.bias is not None:
- output = output + self.bias
- return output
-
- def _apply(self, fn):
- self_obj = super()._apply(fn)
- if self.quantization_cache is not None:
- self.quantization_cache.to(self_obj.weight.device)
- self.quantization_cache.to(self_obj.weight_scale.dtype)
- return self_obj
-
-
-class QuantizedEmbedding(Embedding): # TODO: backward, check empty_init
- def __init__(self, weight_bit_width: int, weight_tensor=None, quantized_weight=None, quantized_weight_scale=None, empty_init=False, *args, **kwargs):
- super(QuantizedEmbedding, self).__init__(*args, **kwargs)
- self.weight_bit_width = weight_bit_width
-
- if (quantized_weight is not None) and (quantized_weight_scale is not None):
- del self.weight
- self.weight = Parameter(quantized_weight.to(kwargs["device"]), requires_grad=False)
- self.weight_scale = Parameter(quantized_weight_scale.to(kwargs["device"]), requires_grad=False)
- else:
- shape = self.weight.shape
- del self.weight
-
- if weight_tensor is None or empty_init:
- self.weight = torch.empty(
- shape[0], shape[1] * weight_bit_width // 8, dtype=torch.int8, device=kwargs["device"]
- )
- self.weight_scale = torch.empty(shape[0], dtype=kwargs["dtype"], device=kwargs["device"])
- else:
- self.weight_scale = (weight_tensor.abs().max(dim=-1).values / ((2 ** (weight_bit_width - 1)) - 1)).half()
- self.weight = torch.round(weight_tensor / self.weight_scale[:, None]).to(torch.int8)
- if weight_bit_width == 4:
- self.weight = compress_int4_weight(self.weight)
-
- self.weight = Parameter(self.weight.to(kwargs["device"]), requires_grad=False)
- self.weight_scale = Parameter(self.weight_scale.to(kwargs["device"]), requires_grad=False)
-
- def forward(self, input):
- if self.weight.device == torch.device("cpu"):
- original_weight = extract_weight_to_float(weight=self.weight, scale_list=self.weight_scale, source_bit_width=self.weight_bit_width)
- else:
- original_weight = extract_weight_to_half(weight=self.weight, scale_list=self.weight_scale, source_bit_width=self.weight_bit_width)
- output = F.embedding(
- input, original_weight, self.padding_idx, self.max_norm,
- self.norm_type, self.scale_grad_by_freq, self.sparse
- )
- return output
-
-
-def load_cpu_kernel(**kwargs):
- global cpu_kernels
- cpu_kernels = CPUKernel(**kwargs)
- assert cpu_kernels.load
-
-
-def quantize(model, weight_bit_width, use_quantization_cache=False, empty_init=False, **kwargs):
- """Replace fp16 linear with quantized linear"""
-
- query_key_value_quantization_cache = None
- dense_quantization_cache = None
- dense_h_to_4h_quantization_cache = None
- dense_4h_to_h_quantization_cache = None
-
- try:
- load_cpu_kernel(**kwargs)
- except:
- print("Cannot load cpu kernel, don't use quantized model on cpu.")
-
- current_device = model.device
-
- if model.device == torch.device("cpu"):
- dtype=torch.float32
- else:
- dtype = torch.half
-
- QuantizedLinearWithPara = partial(
- QuantizedLinear,
- weight_bit_width=weight_bit_width,
- bias=True,
- dtype=dtype,
- empty_init=empty_init
- )
-
- if use_quantization_cache:
- print("Using quantization cache")
- layer = model.layers[0]
- weight = layer.attention.query_key_value.weight
- n, m = weight.size(0), weight.size(1)
- query_key_value_quantization_cache = CacheTensor(n, m, dtype=dtype, device=current_device, requires_grad=False)
- weight = layer.attention.dense.weight
- n, m = weight.size(0), weight.size(1)
- dense_quantization_cache = CacheTensor(n, m, dtype=dtype, device=current_device, requires_grad=False)
- weight = layer.mlp.dense_h_to_4h.weight
- n, m = weight.size(0), weight.size(1)
- dense_h_to_4h_quantization_cache = CacheTensor(n, m, dtype=dtype, device=current_device, requires_grad=False)
- weight = layer.mlp.dense_4h_to_h.weight
- n, m = weight.size(0), weight.size(1)
- dense_4h_to_h_quantization_cache = CacheTensor(n, m, dtype=dtype, device=current_device, requires_grad=False)
-
- print("Applying quantization to glm layers")
-
- for layer in model.layers:
- layer.attention.query_key_value = QuantizedLinearWithPara(
- weight_tensor=layer.attention.query_key_value.weight.to(current_device),
- bias_tensor=layer.attention.query_key_value.bias,
- in_features=layer.attention.query_key_value.in_features,
- out_features=layer.attention.query_key_value.out_features,
- device=layer.attention.query_key_value.weight.device,
- quantization_cache=query_key_value_quantization_cache
- )
- layer.attention.dense = QuantizedLinearWithPara(
- weight_tensor=layer.attention.dense.weight.to(current_device),
- bias_tensor=layer.attention.dense.bias,
- in_features=layer.attention.dense.in_features,
- out_features=layer.attention.dense.out_features,
- device=layer.attention.dense.weight.device,
- quantization_cache=dense_quantization_cache
- )
- layer.mlp.dense_h_to_4h = QuantizedLinearWithPara(
- weight_tensor=layer.mlp.dense_h_to_4h.weight.to(current_device),
- bias_tensor=layer.mlp.dense_h_to_4h.bias,
- in_features=layer.mlp.dense_h_to_4h.in_features,
- out_features=layer.mlp.dense_h_to_4h.out_features,
- device=layer.mlp.dense_h_to_4h.weight.device,
- quantization_cache=dense_h_to_4h_quantization_cache
- )
- layer.mlp.dense_4h_to_h = QuantizedLinearWithPara(
- weight_tensor=layer.mlp.dense_4h_to_h.weight.to(current_device),
- bias_tensor=layer.mlp.dense_4h_to_h.bias,
- in_features=layer.mlp.dense_4h_to_h.in_features,
- out_features=layer.mlp.dense_4h_to_h.out_features,
- device=layer.mlp.dense_4h_to_h.weight.device,
- quantization_cache=dense_4h_to_h_quantization_cache
- )
- return model
diff --git a/spaces/Kangarroar/ApplioRVC-Inference/infer/lib/infer_pack/modules.py b/spaces/Kangarroar/ApplioRVC-Inference/infer/lib/infer_pack/modules.py
deleted file mode 100644
index 2201a58bee9b7808d386b3ef9ac2d1f9630e56ef..0000000000000000000000000000000000000000
--- a/spaces/Kangarroar/ApplioRVC-Inference/infer/lib/infer_pack/modules.py
+++ /dev/null
@@ -1,521 +0,0 @@
-import copy
-import math
-
-import numpy as np
-import scipy
-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, weight_norm
-
-from infer.lib.infer_pack import commons
-from infer.lib.infer_pack.commons import get_padding, init_weights
-from infer.lib.infer_pack.transforms import piecewise_rational_quadratic_transform
-
-LRELU_SLOPE = 0.1
-
-
-class LayerNorm(nn.Module):
- def __init__(self, channels, eps=1e-5):
- super().__init__()
- self.channels = channels
- self.eps = eps
-
- self.gamma = nn.Parameter(torch.ones(channels))
- self.beta = nn.Parameter(torch.zeros(channels))
-
- def forward(self, x):
- x = x.transpose(1, -1)
- x = F.layer_norm(x, (self.channels,), self.gamma, self.beta, self.eps)
- return x.transpose(1, -1)
-
-
-class ConvReluNorm(nn.Module):
- def __init__(
- self,
- in_channels,
- hidden_channels,
- out_channels,
- kernel_size,
- n_layers,
- p_dropout,
- ):
- super().__init__()
- self.in_channels = in_channels
- self.hidden_channels = hidden_channels
- self.out_channels = out_channels
- self.kernel_size = kernel_size
- self.n_layers = n_layers
- self.p_dropout = p_dropout
- assert n_layers > 1, "Number of layers should be larger than 0."
-
- self.conv_layers = nn.ModuleList()
- self.norm_layers = nn.ModuleList()
- self.conv_layers.append(
- nn.Conv1d(
- in_channels, hidden_channels, kernel_size, padding=kernel_size // 2
- )
- )
- self.norm_layers.append(LayerNorm(hidden_channels))
- self.relu_drop = nn.Sequential(nn.ReLU(), nn.Dropout(p_dropout))
- for _ in range(n_layers - 1):
- self.conv_layers.append(
- nn.Conv1d(
- hidden_channels,
- hidden_channels,
- kernel_size,
- padding=kernel_size // 2,
- )
- )
- self.norm_layers.append(LayerNorm(hidden_channels))
- self.proj = nn.Conv1d(hidden_channels, out_channels, 1)
- self.proj.weight.data.zero_()
- self.proj.bias.data.zero_()
-
- def forward(self, x, x_mask):
- x_org = x
- for i in range(self.n_layers):
- x = self.conv_layers[i](x * x_mask)
- x = self.norm_layers[i](x)
- x = self.relu_drop(x)
- x = x_org + self.proj(x)
- return x * x_mask
-
-
-class DDSConv(nn.Module):
- """
- Dialted and Depth-Separable Convolution
- """
-
- def __init__(self, channels, kernel_size, n_layers, p_dropout=0.0):
- super().__init__()
- self.channels = channels
- self.kernel_size = kernel_size
- self.n_layers = n_layers
- self.p_dropout = p_dropout
-
- self.drop = nn.Dropout(p_dropout)
- self.convs_sep = nn.ModuleList()
- self.convs_1x1 = nn.ModuleList()
- self.norms_1 = nn.ModuleList()
- self.norms_2 = nn.ModuleList()
- for i in range(n_layers):
- dilation = kernel_size**i
- padding = (kernel_size * dilation - dilation) // 2
- self.convs_sep.append(
- nn.Conv1d(
- channels,
- channels,
- kernel_size,
- groups=channels,
- dilation=dilation,
- padding=padding,
- )
- )
- self.convs_1x1.append(nn.Conv1d(channels, channels, 1))
- self.norms_1.append(LayerNorm(channels))
- self.norms_2.append(LayerNorm(channels))
-
- def forward(self, x, x_mask, g=None):
- if g is not None:
- x = x + g
- for i in range(self.n_layers):
- y = self.convs_sep[i](x * x_mask)
- y = self.norms_1[i](y)
- y = F.gelu(y)
- y = self.convs_1x1[i](y)
- y = self.norms_2[i](y)
- y = F.gelu(y)
- y = self.drop(y)
- x = x + y
- return x * x_mask
-
-
-class WN(torch.nn.Module):
- def __init__(
- self,
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- gin_channels=0,
- p_dropout=0,
- ):
- super(WN, self).__init__()
- assert kernel_size % 2 == 1
- self.hidden_channels = hidden_channels
- self.kernel_size = (kernel_size,)
- self.dilation_rate = dilation_rate
- self.n_layers = n_layers
- self.gin_channels = gin_channels
- self.p_dropout = p_dropout
-
- self.in_layers = torch.nn.ModuleList()
- self.res_skip_layers = torch.nn.ModuleList()
- self.drop = nn.Dropout(p_dropout)
-
- if gin_channels != 0:
- cond_layer = torch.nn.Conv1d(
- gin_channels, 2 * hidden_channels * n_layers, 1
- )
- self.cond_layer = torch.nn.utils.weight_norm(cond_layer, name="weight")
-
- for i in range(n_layers):
- dilation = dilation_rate**i
- padding = int((kernel_size * dilation - dilation) / 2)
- in_layer = torch.nn.Conv1d(
- hidden_channels,
- 2 * hidden_channels,
- kernel_size,
- dilation=dilation,
- padding=padding,
- )
- in_layer = torch.nn.utils.weight_norm(in_layer, name="weight")
- self.in_layers.append(in_layer)
-
- # last one is not necessary
- if i < n_layers - 1:
- res_skip_channels = 2 * hidden_channels
- else:
- res_skip_channels = hidden_channels
-
- res_skip_layer = torch.nn.Conv1d(hidden_channels, res_skip_channels, 1)
- res_skip_layer = torch.nn.utils.weight_norm(res_skip_layer, name="weight")
- self.res_skip_layers.append(res_skip_layer)
-
- def forward(self, x, x_mask, g=None, **kwargs):
- output = torch.zeros_like(x)
- n_channels_tensor = torch.IntTensor([self.hidden_channels])
-
- if g is not None:
- g = self.cond_layer(g)
-
- for i in range(self.n_layers):
- x_in = self.in_layers[i](x)
- if g is not None:
- cond_offset = i * 2 * self.hidden_channels
- g_l = g[:, cond_offset : cond_offset + 2 * self.hidden_channels, :]
- else:
- g_l = torch.zeros_like(x_in)
-
- acts = commons.fused_add_tanh_sigmoid_multiply(x_in, g_l, n_channels_tensor)
- acts = self.drop(acts)
-
- res_skip_acts = self.res_skip_layers[i](acts)
- if i < self.n_layers - 1:
- res_acts = res_skip_acts[:, : self.hidden_channels, :]
- x = (x + res_acts) * x_mask
- output = output + res_skip_acts[:, self.hidden_channels :, :]
- else:
- output = output + res_skip_acts
- return output * x_mask
-
- def remove_weight_norm(self):
- if self.gin_channels != 0:
- torch.nn.utils.remove_weight_norm(self.cond_layer)
- for l in self.in_layers:
- torch.nn.utils.remove_weight_norm(l)
- for l in self.res_skip_layers:
- torch.nn.utils.remove_weight_norm(l)
-
-
-class ResBlock1(torch.nn.Module):
- def __init__(self, channels, kernel_size=3, dilation=(1, 3, 5)):
- super(ResBlock1, self).__init__()
- self.convs1 = nn.ModuleList(
- [
- weight_norm(
- Conv1d(
- channels,
- channels,
- kernel_size,
- 1,
- dilation=dilation[0],
- padding=get_padding(kernel_size, dilation[0]),
- )
- ),
- weight_norm(
- Conv1d(
- channels,
- channels,
- kernel_size,
- 1,
- dilation=dilation[1],
- padding=get_padding(kernel_size, dilation[1]),
- )
- ),
- weight_norm(
- Conv1d(
- channels,
- channels,
- kernel_size,
- 1,
- dilation=dilation[2],
- padding=get_padding(kernel_size, dilation[2]),
- )
- ),
- ]
- )
- self.convs1.apply(init_weights)
-
- self.convs2 = nn.ModuleList(
- [
- weight_norm(
- Conv1d(
- channels,
- channels,
- kernel_size,
- 1,
- dilation=1,
- padding=get_padding(kernel_size, 1),
- )
- ),
- weight_norm(
- Conv1d(
- channels,
- channels,
- kernel_size,
- 1,
- dilation=1,
- padding=get_padding(kernel_size, 1),
- )
- ),
- weight_norm(
- Conv1d(
- channels,
- channels,
- kernel_size,
- 1,
- dilation=1,
- padding=get_padding(kernel_size, 1),
- )
- ),
- ]
- )
- self.convs2.apply(init_weights)
-
- def forward(self, x, x_mask=None):
- for c1, c2 in zip(self.convs1, self.convs2):
- xt = F.leaky_relu(x, LRELU_SLOPE)
- if x_mask is not None:
- xt = xt * x_mask
- xt = c1(xt)
- xt = F.leaky_relu(xt, LRELU_SLOPE)
- if x_mask is not None:
- xt = xt * x_mask
- xt = c2(xt)
- x = xt + x
- if x_mask is not None:
- x = x * x_mask
- return x
-
- def remove_weight_norm(self):
- for l in self.convs1:
- remove_weight_norm(l)
- for l in self.convs2:
- remove_weight_norm(l)
-
-
-class ResBlock2(torch.nn.Module):
- def __init__(self, channels, kernel_size=3, dilation=(1, 3)):
- super(ResBlock2, self).__init__()
- self.convs = nn.ModuleList(
- [
- weight_norm(
- Conv1d(
- channels,
- channels,
- kernel_size,
- 1,
- dilation=dilation[0],
- padding=get_padding(kernel_size, dilation[0]),
- )
- ),
- weight_norm(
- Conv1d(
- channels,
- channels,
- kernel_size,
- 1,
- dilation=dilation[1],
- padding=get_padding(kernel_size, dilation[1]),
- )
- ),
- ]
- )
- self.convs.apply(init_weights)
-
- def forward(self, x, x_mask=None):
- for c in self.convs:
- xt = F.leaky_relu(x, LRELU_SLOPE)
- if x_mask is not None:
- xt = xt * x_mask
- xt = c(xt)
- x = xt + x
- if x_mask is not None:
- x = x * x_mask
- return x
-
- def remove_weight_norm(self):
- for l in self.convs:
- remove_weight_norm(l)
-
-
-class Log(nn.Module):
- def forward(self, x, x_mask, reverse=False, **kwargs):
- if not reverse:
- y = torch.log(torch.clamp_min(x, 1e-5)) * x_mask
- logdet = torch.sum(-y, [1, 2])
- return y, logdet
- else:
- x = torch.exp(x) * x_mask
- return x
-
-
-class Flip(nn.Module):
- def forward(self, x, *args, reverse=False, **kwargs):
- x = torch.flip(x, [1])
- if not reverse:
- logdet = torch.zeros(x.size(0)).to(dtype=x.dtype, device=x.device)
- return x, logdet
- else:
- return x
-
-
-class ElementwiseAffine(nn.Module):
- def __init__(self, channels):
- super().__init__()
- self.channels = channels
- self.m = nn.Parameter(torch.zeros(channels, 1))
- self.logs = nn.Parameter(torch.zeros(channels, 1))
-
- def forward(self, x, x_mask, reverse=False, **kwargs):
- if not reverse:
- y = self.m + torch.exp(self.logs) * x
- y = y * x_mask
- logdet = torch.sum(self.logs * x_mask, [1, 2])
- return y, logdet
- else:
- x = (x - self.m) * torch.exp(-self.logs) * x_mask
- return x
-
-
-class ResidualCouplingLayer(nn.Module):
- def __init__(
- self,
- channels,
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- p_dropout=0,
- gin_channels=0,
- mean_only=False,
- ):
- assert channels % 2 == 0, "channels should be divisible by 2"
- super().__init__()
- self.channels = channels
- self.hidden_channels = hidden_channels
- self.kernel_size = kernel_size
- self.dilation_rate = dilation_rate
- self.n_layers = n_layers
- self.half_channels = channels // 2
- self.mean_only = mean_only
-
- self.pre = nn.Conv1d(self.half_channels, hidden_channels, 1)
- self.enc = WN(
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- p_dropout=p_dropout,
- gin_channels=gin_channels,
- )
- self.post = nn.Conv1d(hidden_channels, self.half_channels * (2 - mean_only), 1)
- self.post.weight.data.zero_()
- self.post.bias.data.zero_()
-
- def forward(self, x, x_mask, g=None, reverse=False):
- x0, x1 = torch.split(x, [self.half_channels] * 2, 1)
- h = self.pre(x0) * x_mask
- h = self.enc(h, x_mask, g=g)
- stats = self.post(h) * x_mask
- if not self.mean_only:
- m, logs = torch.split(stats, [self.half_channels] * 2, 1)
- else:
- m = stats
- logs = torch.zeros_like(m)
-
- if not reverse:
- x1 = m + x1 * torch.exp(logs) * x_mask
- x = torch.cat([x0, x1], 1)
- logdet = torch.sum(logs, [1, 2])
- return x, logdet
- else:
- x1 = (x1 - m) * torch.exp(-logs) * x_mask
- x = torch.cat([x0, x1], 1)
- return x
-
- def remove_weight_norm(self):
- self.enc.remove_weight_norm()
-
-
-class ConvFlow(nn.Module):
- def __init__(
- self,
- in_channels,
- filter_channels,
- kernel_size,
- n_layers,
- num_bins=10,
- tail_bound=5.0,
- ):
- super().__init__()
- self.in_channels = in_channels
- self.filter_channels = filter_channels
- self.kernel_size = kernel_size
- self.n_layers = n_layers
- self.num_bins = num_bins
- self.tail_bound = tail_bound
- self.half_channels = in_channels // 2
-
- self.pre = nn.Conv1d(self.half_channels, filter_channels, 1)
- self.convs = DDSConv(filter_channels, kernel_size, n_layers, p_dropout=0.0)
- self.proj = nn.Conv1d(
- filter_channels, self.half_channels * (num_bins * 3 - 1), 1
- )
- self.proj.weight.data.zero_()
- self.proj.bias.data.zero_()
-
- def forward(self, x, x_mask, g=None, reverse=False):
- x0, x1 = torch.split(x, [self.half_channels] * 2, 1)
- h = self.pre(x0)
- h = self.convs(h, x_mask, g=g)
- h = self.proj(h) * x_mask
-
- b, c, t = x0.shape
- h = h.reshape(b, c, -1, t).permute(0, 1, 3, 2) # [b, cx?, t] -> [b, c, t, ?]
-
- unnormalized_widths = h[..., : self.num_bins] / math.sqrt(self.filter_channels)
- unnormalized_heights = h[..., self.num_bins : 2 * self.num_bins] / math.sqrt(
- self.filter_channels
- )
- unnormalized_derivatives = h[..., 2 * self.num_bins :]
-
- x1, logabsdet = piecewise_rational_quadratic_transform(
- x1,
- unnormalized_widths,
- unnormalized_heights,
- unnormalized_derivatives,
- inverse=reverse,
- tails="linear",
- tail_bound=self.tail_bound,
- )
-
- x = torch.cat([x0, x1], 1) * x_mask
- logdet = torch.sum(logabsdet * x_mask, [1, 2])
- if not reverse:
- return x, logdet
- else:
- return x
diff --git a/spaces/KyanChen/RSPrompter/mmdet/models/necks/__init__.py b/spaces/KyanChen/RSPrompter/mmdet/models/necks/__init__.py
deleted file mode 100644
index 2194780c853ccca66e8e7d070e17a7d613514fae..0000000000000000000000000000000000000000
--- a/spaces/KyanChen/RSPrompter/mmdet/models/necks/__init__.py
+++ /dev/null
@@ -1,25 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from .bfp import BFP
-from .channel_mapper import ChannelMapper
-from .cspnext_pafpn import CSPNeXtPAFPN
-from .ct_resnet_neck import CTResNetNeck
-from .dilated_encoder import DilatedEncoder
-from .dyhead import DyHead
-from .fpg import FPG
-from .fpn import FPN
-from .fpn_carafe import FPN_CARAFE
-from .hrfpn import HRFPN
-from .nas_fpn import NASFPN
-from .nasfcos_fpn import NASFCOS_FPN
-from .pafpn import PAFPN
-from .rfp import RFP
-from .ssd_neck import SSDNeck
-from .ssh import SSH
-from .yolo_neck import YOLOV3Neck
-from .yolox_pafpn import YOLOXPAFPN
-
-__all__ = [
- 'FPN', 'BFP', 'ChannelMapper', 'HRFPN', 'NASFPN', 'FPN_CARAFE', 'PAFPN',
- 'NASFCOS_FPN', 'RFP', 'YOLOV3Neck', 'FPG', 'DilatedEncoder',
- 'CTResNetNeck', 'SSDNeck', 'YOLOXPAFPN', 'DyHead', 'CSPNeXtPAFPN', 'SSH'
-]
diff --git a/spaces/KyanChen/RSPrompter/mmpl/datasets/builder.py b/spaces/KyanChen/RSPrompter/mmpl/datasets/builder.py
deleted file mode 100644
index b33d0afef3af275f81953aa7777341ac496c498f..0000000000000000000000000000000000000000
--- a/spaces/KyanChen/RSPrompter/mmpl/datasets/builder.py
+++ /dev/null
@@ -1,25 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmpl.registry import DATASETS
-
-
-def build_dataset(cfg):
- """Build dataset.
-
- Examples:
- >>> from mmpl.datasets import build_dataset
- >>> mnist_train = build_dataset(
- ... dict(type='MNIST', data_prefix='data/mnist/', test_mode=False))
- >>> print(mnist_train)
- Dataset MNIST
- Number of samples: 60000
- Number of categories: 10
- Prefix of data: data/mnist/
- >>> mnist_test = build_dataset(
- ... dict(type='MNIST', data_prefix='data/mnist/', test_mode=True))
- >>> print(mnist_test)
- Dataset MNIST
- Number of samples: 10000
- Number of categories: 10
- Prefix of data: data/mnist/
- """
- return DATASETS.build(cfg)
diff --git a/spaces/KyanChen/RSPrompter/mmpl/evaluation/metrics/coco_pl_metric.py b/spaces/KyanChen/RSPrompter/mmpl/evaluation/metrics/coco_pl_metric.py
deleted file mode 100644
index a2b31b9ec5783996ccbb12e9620c8b27e0b10d64..0000000000000000000000000000000000000000
--- a/spaces/KyanChen/RSPrompter/mmpl/evaluation/metrics/coco_pl_metric.py
+++ /dev/null
@@ -1,629 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import datetime
-import itertools
-import os.path as osp
-import tempfile
-from collections import OrderedDict
-from typing import Dict, List, Optional, Sequence, Union
-
-import lightning
-import mmengine
-import numpy as np
-import torch
-from mmengine.fileio import dump, get_local_path, load
-from mmengine.logging import MMLogger
-from terminaltables import AsciiTable
-
-from mmdet.datasets.api_wrappers import COCO, COCOeval
-from mmdet.structures.mask import encode_mask_results
-from mmdet.evaluation.functional import eval_recalls
-from torchmetrics import Metric
-from mmpl.registry import METRICS
-from torchmetrics.utilities import rank_zero_info
-
-
-@METRICS.register_module()
-class CocoPLMetric(Metric):
- """COCO evaluation metric.
-
- Evaluate AR, AP, and mAP for detection tasks including proposal/box
- detection and instance segmentation. Please refer to
- https://cocodataset.org/#detection-eval for more details.
-
- Args:
- ann_file (str, optional): Path to the coco format annotation file.
- If not specified, ground truth annotations from the dataset will
- be converted to coco format. Defaults to None.
- metric (str | List[str]): Metrics to be evaluated. Valid metrics
- include 'bbox', 'segm', 'proposal', and 'proposal_fast'.
- Defaults to 'bbox'.
- classwise (bool): Whether to evaluate the metric class-wise.
- Defaults to False.
- proposal_nums (Sequence[int]): Numbers of proposals to be evaluated.
- Defaults to (100, 300, 1000).
- iou_thrs (float | List[float], optional): IoU threshold to compute AP
- and AR. If not specified, IoUs from 0.5 to 0.95 will be used.
- Defaults to None.
- metric_items (List[str], optional): Metric result names to be
- recorded in the evaluation result. Defaults to None.
- format_only (bool): Format the output results without perform
- evaluation. It is useful when you want to format the result
- to a specific format and submit it to the test server.
- Defaults to False.
- outfile_prefix (str, optional): The prefix of json files. It includes
- the file path and the prefix of filename, e.g., "a/b/prefix".
- If not specified, a temp file will be created. Defaults to None.
- file_client_args (dict, optional): Arguments to instantiate the
- corresponding backend in mmdet <= 3.0.0rc6. Defaults to None.
- backend_args (dict, optional): Arguments to instantiate the
- corresponding backend. Defaults to None.
- collect_device (str): Device name used for collecting results from
- different ranks during distributed training. Must be 'cpu' or
- 'gpu'. Defaults to 'cpu'.
- prefix (str, optional): The prefix that will be added in the metric
- names to disambiguate homonymous metrics of different evaluators.
- If prefix is not provided in the argument, self.default_prefix
- will be used instead. Defaults to None.
- sort_categories (bool): Whether sort categories in annotations. Only
- used for `Objects365V1Dataset`. Defaults to False.
- """
- # default_prefix: Optional[str] = 'coco'
-
- def __init__(self,
- ann_file: Optional[str] = None,
- metric: Union[str, List[str]] = 'bbox',
- classwise: bool = False,
- proposal_nums: Sequence[int] = (100, 300, 1000),
- iou_thrs: Optional[Union[float, Sequence[float]]] = None,
- metric_items: Optional[Sequence[str]] = None,
- format_only: bool = False,
- outfile_prefix: Optional[str] = None,
- file_client_args: dict = None,
- backend_args: dict = None,
- collect_device: str = 'cpu',
- prefix: Optional[str] = None,
- sort_categories: bool = False,
- **kwargs
- ) -> None:
- super().__init__(**kwargs)
- self._dataset_meta: Union[None, dict] = None
- # coco evaluation metrics
- self.metrics = metric if isinstance(metric, list) else [metric]
- allowed_metrics = ['bbox', 'segm', 'proposal', 'proposal_fast']
- for metric in self.metrics:
- if metric not in allowed_metrics:
- raise KeyError(
- "metric should be one of 'bbox', 'segm', 'proposal', "
- f"'proposal_fast', but got {metric}.")
-
- # do class wise evaluation, default False
- self.classwise = classwise
-
- # proposal_nums used to compute recall or precision.
- self.proposal_nums = list(proposal_nums)
-
- # iou_thrs used to compute recall or precision.
- if iou_thrs is None:
- iou_thrs = np.linspace(
- .5, 0.95, int(np.round((0.95 - .5) / .05)) + 1, endpoint=True)
- self.iou_thrs = iou_thrs
- self.metric_items = metric_items
- self.format_only = format_only
- if self.format_only:
- assert outfile_prefix is not None, 'outfile_prefix must be not'
- 'None when format_only is True, otherwise the result files will'
- 'be saved to a temp directory which will be cleaned up at the end.'
-
- self.outfile_prefix = outfile_prefix
-
- self.backend_args = backend_args
- if file_client_args is not None:
- raise RuntimeError(
- 'The `file_client_args` is deprecated, '
- 'please use `backend_args` instead, please refer to'
- 'https://github.com/open-mmlab/mmdetection/blob/main/configs/_base_/datasets/coco_detection.py' # noqa: E501
- )
-
- # if ann_file is not specified,
- # initialize coco api with the converted dataset
- if ann_file is not None:
- with get_local_path(
- ann_file, backend_args=self.backend_args) as local_path:
- self._coco_api = COCO(local_path)
- if sort_categories:
- # 'categories' list in objects365_train.json and
- # objects365_val.json is inconsistent, need sort
- # list(or dict) before get cat_ids.
- cats = self._coco_api.cats
- sorted_cats = {i: cats[i] for i in sorted(cats)}
- self._coco_api.cats = sorted_cats
- categories = self._coco_api.dataset['categories']
- sorted_categories = sorted(
- categories, key=lambda i: i['id'])
- self._coco_api.dataset['categories'] = sorted_categories
- else:
- self._coco_api = None
-
- # handle dataset lazy init
- self.cat_ids = None
- self.img_ids = None
-
- self.add_state('results', default=[], dist_reduce_fx=None)
-
- @property
- def dataset_meta(self) -> Optional[dict]:
- """Optional[dict]: Meta info of the dataset."""
- return self._dataset_meta
-
- @dataset_meta.setter
- def dataset_meta(self, dataset_meta: dict) -> None:
- """Set the dataset meta info to the metric."""
- self._dataset_meta = dataset_meta
-
- def fast_eval_recall(self,
- results: List[dict],
- proposal_nums: Sequence[int],
- iou_thrs: Sequence[float],
- logger: Optional[MMLogger] = None) -> np.ndarray:
- """Evaluate proposal recall with COCO's fast_eval_recall.
-
- Args:
- results (List[dict]): Results of the dataset.
- proposal_nums (Sequence[int]): Proposal numbers used for
- evaluation.
- iou_thrs (Sequence[float]): IoU thresholds used for evaluation.
- logger (MMLogger, optional): Logger used for logging the recall
- summary.
- Returns:
- np.ndarray: Averaged recall results.
- """
- gt_bboxes = []
- pred_bboxes = [result['bboxes'] for result in results]
- for i in range(len(self.img_ids)):
- ann_ids = self._coco_api.get_ann_ids(img_ids=self.img_ids[i])
- ann_info = self._coco_api.load_anns(ann_ids)
- if len(ann_info) == 0:
- gt_bboxes.append(np.zeros((0, 4)))
- continue
- bboxes = []
- for ann in ann_info:
- if ann.get('ignore', False) or ann['iscrowd']:
- continue
- x1, y1, w, h = ann['bbox']
- bboxes.append([x1, y1, x1 + w, y1 + h])
- bboxes = np.array(bboxes, dtype=np.float32)
- if bboxes.shape[0] == 0:
- bboxes = np.zeros((0, 4))
- gt_bboxes.append(bboxes)
-
- recalls = eval_recalls(
- gt_bboxes, pred_bboxes, proposal_nums, iou_thrs, logger=logger)
- ar = recalls.mean(axis=1)
- return ar
-
- def xyxy2xywh(self, bbox: np.ndarray) -> list:
- """Convert ``xyxy`` style bounding boxes to ``xywh`` style for COCO
- evaluation.
-
- Args:
- bbox (numpy.ndarray): The bounding boxes, shape (4, ), in
- ``xyxy`` order.
-
- Returns:
- list[float]: The converted bounding boxes, in ``xywh`` order.
- """
-
- _bbox: List = bbox.tolist()
- return [
- _bbox[0],
- _bbox[1],
- _bbox[2] - _bbox[0],
- _bbox[3] - _bbox[1],
- ]
-
- def results2json(self, results: Sequence[dict],
- outfile_prefix: str) -> dict:
- """Dump the detection results to a COCO style json file.
-
- There are 3 types of results: proposals, bbox predictions, mask
- predictions, and they have different data types. This method will
- automatically recognize the type, and dump them to json files.
-
- Args:
- results (Sequence[dict]): Testing results of the
- dataset.
- outfile_prefix (str): The filename prefix of the json files. If the
- prefix is "somepath/xxx", the json files will be named
- "somepath/xxx.bbox.json", "somepath/xxx.segm.json",
- "somepath/xxx.proposal.json".
-
- Returns:
- dict: Possible keys are "bbox", "segm", "proposal", and
- values are corresponding filenames.
- """
- bbox_json_results = []
- segm_json_results = [] if 'masks' in results[0] else None
- for idx, result in enumerate(results):
- image_id = result.get('img_id', idx)
- labels = result['labels']
- bboxes = result['bboxes']
- scores = result['scores']
- # bbox results
- for i, label in enumerate(labels):
- data = dict()
- data['image_id'] = image_id
- data['bbox'] = self.xyxy2xywh(bboxes[i])
- data['score'] = float(scores[i])
- data['category_id'] = self.cat_ids[label]
- bbox_json_results.append(data)
-
- if segm_json_results is None:
- continue
-
- # segm results
- masks = result['masks']
- mask_scores = result.get('mask_scores', scores)
- for i, label in enumerate(labels):
- data = dict()
- data['image_id'] = image_id
- data['bbox'] = self.xyxy2xywh(bboxes[i])
- data['score'] = float(mask_scores[i])
- data['category_id'] = self.cat_ids[label]
- if isinstance(masks[i]['counts'], bytes):
- masks[i]['counts'] = masks[i]['counts'].decode()
- data['segmentation'] = masks[i]
- segm_json_results.append(data)
-
- result_files = dict()
- result_files['bbox'] = f'{outfile_prefix}.bbox.json'
- result_files['proposal'] = f'{outfile_prefix}.bbox.json'
- dump(bbox_json_results, result_files['bbox'])
-
- if segm_json_results is not None:
- result_files['segm'] = f'{outfile_prefix}.segm.json'
- dump(segm_json_results, result_files['segm'])
-
- return result_files
-
- def gt_to_coco_json(self, gt_dicts: Sequence[dict],
- outfile_prefix: str) -> str:
- """Convert ground truth to coco format json file.
-
- Args:
- gt_dicts (Sequence[dict]): Ground truth of the dataset.
- outfile_prefix (str): The filename prefix of the json files. If the
- prefix is "somepath/xxx", the json file will be named
- "somepath/xxx.gt.json".
- Returns:
- str: The filename of the json file.
- """
- categories = [
- dict(id=id, name=name)
- for id, name in enumerate(self.dataset_meta['classes'])
- ]
- image_infos = []
- annotations = []
-
- for idx, gt_dict in enumerate(gt_dicts):
- img_id = gt_dict.get('img_id', idx)
- image_info = dict(
- id=img_id,
- width=gt_dict['width'],
- height=gt_dict['height'],
- file_name='')
- image_infos.append(image_info)
- for ann in gt_dict['anns']:
- label = ann['bbox_label']
- bbox = ann['bbox']
- coco_bbox = [
- bbox[0],
- bbox[1],
- bbox[2] - bbox[0],
- bbox[3] - bbox[1],
- ]
-
- annotation = dict(
- id=len(annotations) +
- 1, # coco api requires id starts with 1
- image_id=img_id,
- bbox=coco_bbox,
- iscrowd=ann.get('ignore_flag', 0),
- category_id=int(label),
- area=coco_bbox[2] * coco_bbox[3])
- if ann.get('mask', None):
- mask = ann['mask']
- # area = mask_util.area(mask)
- if isinstance(mask, dict) and isinstance(
- mask['counts'], bytes):
- mask['counts'] = mask['counts'].decode()
- annotation['segmentation'] = mask
- # annotation['area'] = float(area)
- annotations.append(annotation)
-
- info = dict(
- date_created=str(datetime.datetime.now()),
- description='Coco json file converted by mmdet CocoMetric.')
- coco_json = dict(
- info=info,
- images=image_infos,
- categories=categories,
- licenses=None,
- )
- if len(annotations) > 0:
- coco_json['annotations'] = annotations
- converted_json_path = f'{outfile_prefix}.gt.json'
- dump(coco_json, converted_json_path)
- return converted_json_path
-
- # TODO: data_batch is no longer needed, consider adjusting the
- # parameter position
- def update(self, data_batch: dict, data_samples: Sequence[dict]) -> None:
- """Process one batch of data samples and predictions. The processed
- results should be stored in ``self.results``, which will be used to
- compute the metrics when all batches have been processed.
-
- Args:
- data_batch (dict): A batch of data from the dataloader.
- data_samples (Sequence[dict]): A batch of data samples that
- contain annotations and predictions.
- """
- for data_sample in data_samples:
- result = dict()
- pred = data_sample.pred_instances
- result['img_id'] = data_sample.img_id
- result['bboxes'] = pred['bboxes'].cpu().numpy()
- result['scores'] = pred['scores'].cpu().numpy()
- result['labels'] = pred['labels'].cpu().numpy()
- # encode mask to RLE
- if 'masks' in pred:
- result['masks'] = encode_mask_results(
- pred['masks'].detach().cpu().numpy()) if isinstance(
- pred['masks'], torch.Tensor) else pred['masks']
- # some detectors use different scores for bbox and mask
- if 'mask_scores' in pred:
- result['mask_scores'] = pred['mask_scores'].cpu().numpy()
-
- # parse gt
- gt = dict()
- gt['width'] = data_sample.ori_shape[1]
- gt['height'] = data_sample.ori_shape[0]
- gt['img_id'] = data_sample.img_id
- if self._coco_api is None:
- # TODO: Need to refactor to support LoadAnnotations
- assert 'gt_instances' in data_sample, \
- 'ground truth is required for evaluation when ' \
- '`ann_file` is not provided'
- gt['anns'] = []
- for x_data in data_sample.gt_instances:
- mask_ = encode_mask_results(x_data['masks'].masks)
- assert len(mask_) == 1, \
- 'Only support one mask per instance for now'
- gt['anns'].append(
- dict(
- bbox_label=x_data['labels'].item(),
- bbox=x_data['bboxes'].cpu().numpy().reshape(4),
- mask=mask_[0]
- )
- )
- # add converted result to the results list
- self.results.append((gt, result))
-
- def compute(self) -> Dict[str, float]:
- """Compute the metrics from processed results.
-
- Args:
- results (list): The processed results of each batch.
-
- Returns:
- Dict[str, float]: The computed metrics. The keys are the names of
- the metrics, and the values are corresponding results.
- """
- results = self.results
- logger: MMLogger = MMLogger.get_current_instance()
-
- # split gt and prediction list
- gts, preds = zip(*results)
-
- tmp_dir = None
- if self.outfile_prefix is None:
- tmp_dir = tempfile.TemporaryDirectory()
- outfile_prefix = osp.join(tmp_dir.name, 'results')
- else:
- outfile_prefix = self.outfile_prefix
-
- if self._coco_api is None:
- # use converted gt json file to initialize coco api
- logger.info('Converting ground truth to coco format...')
- coco_json_path = self.gt_to_coco_json(
- gt_dicts=gts, outfile_prefix=outfile_prefix)
- self._coco_api = COCO(coco_json_path)
-
- # handle lazy init
- if self.cat_ids is None:
- self.cat_ids = self._coco_api.get_cat_ids(
- cat_names=self.dataset_meta['classes'])
- if self.img_ids is None:
- self.img_ids = self._coco_api.get_img_ids()
-
- # convert predictions to coco format and dump to json file
- result_files = self.results2json(preds, outfile_prefix)
-
- eval_results = OrderedDict()
- if self.format_only:
- logger.info('results are saved in '
- f'{osp.dirname(outfile_prefix)}')
- return eval_results
-
- for metric in self.metrics:
- logger.info(f'Evaluating {metric}...')
-
- # TODO: May refactor fast_eval_recall to an independent metric?
- # fast eval recall
- if metric == 'proposal_fast':
- ar = self.fast_eval_recall(
- preds, self.proposal_nums, self.iou_thrs, logger=logger)
- log_msg = []
- for i, num in enumerate(self.proposal_nums):
- eval_results[f'AR@{num}'] = ar[i]
- log_msg.append(f'\nAR@{num}\t{ar[i]:.4f}')
- log_msg = ''.join(log_msg)
- logger.info(log_msg)
- continue
-
- # evaluate proposal, bbox and segm
- iou_type = 'bbox' if metric == 'proposal' else metric
- if metric not in result_files:
- raise KeyError(f'{metric} is not in results')
- try:
- predictions = load(result_files[metric])
- if iou_type == 'segm':
- # Refer to https://github.com/cocodataset/cocoapi/blob/master/PythonAPI/pycocotools/coco.py#L331 # noqa
- # When evaluating mask AP, if the results contain bbox,
- # cocoapi will use the box area instead of the mask area
- # for calculating the instance area. Though the overall AP
- # is not affected, this leads to different
- # small/medium/large mask AP results.
- for x in predictions:
- x.pop('bbox')
- coco_dt = self._coco_api.loadRes(predictions)
-
- except IndexError:
- # for k, v in eval_results.items():
- # eval_results[k] = torch.tensor(v).to(self.device)
- # self._coco_api = None
- logger.error(
- 'The testing results of the whole dataset is empty.')
- break
-
- coco_eval = COCOeval(self._coco_api, coco_dt, iou_type)
-
- coco_eval.params.catIds = self.cat_ids
- coco_eval.params.imgIds = self.img_ids
- coco_eval.params.maxDets = list(self.proposal_nums)
- coco_eval.params.iouThrs = self.iou_thrs
-
- # mapping of cocoEval.stats
- coco_metric_names = {
- 'mAP': 0,
- 'mAP_50': 1,
- 'mAP_75': 2,
- 'mAP_s': 3,
- 'mAP_m': 4,
- 'mAP_l': 5,
- 'AR@100': 6,
- 'AR@300': 7,
- 'AR@1000': 8,
- 'AR_s@1000': 9,
- 'AR_m@1000': 10,
- 'AR_l@1000': 11
- }
- metric_items = self.metric_items
- if metric_items is not None:
- for metric_item in metric_items:
- if metric_item not in coco_metric_names:
- raise KeyError(
- f'metric item "{metric_item}" is not supported')
-
- if metric == 'proposal':
- coco_eval.params.useCats = 0
- coco_eval.evaluate()
- coco_eval.accumulate()
- coco_eval.summarize()
- if metric_items is None:
- metric_items = [
- 'AR@100', 'AR@300', 'AR@1000', 'AR_s@1000',
- 'AR_m@1000', 'AR_l@1000'
- ]
-
- for item in metric_items:
- val = float(
- f'{coco_eval.stats[coco_metric_names[item]]:.3f}')
- eval_results[item] = val
- else:
- coco_eval.evaluate()
- coco_eval.accumulate()
- coco_eval.summarize()
- if self.classwise: # Compute per-category AP
- # Compute per-category AP
- # from https://github.com/facebookresearch/detectron2/
- precisions = coco_eval.eval['precision']
- # precision: (iou, recall, cls, area range, max dets)
- assert len(self.cat_ids) == precisions.shape[2]
-
- results_per_category = []
- for idx, cat_id in enumerate(self.cat_ids):
- t = []
- # area range index 0: all area ranges
- # max dets index -1: typically 100 per image
- nm = self._coco_api.loadCats(cat_id)[0]
- precision = precisions[:, :, idx, 0, -1]
- precision = precision[precision > -1]
- if precision.size:
- ap = np.mean(precision)
- else:
- ap = float('nan')
- t.append(f'{nm["name"]}')
- t.append(f'{round(ap, 3)}')
- eval_results[f'{nm["name"]}_precision'] = round(ap, 3)
-
- # indexes of IoU @50 and @75
- for iou in [0, 5]:
- precision = precisions[iou, :, idx, 0, -1]
- precision = precision[precision > -1]
- if precision.size:
- ap = np.mean(precision)
- else:
- ap = float('nan')
- t.append(f'{round(ap, 3)}')
-
- # indexes of area of small, median and large
- for area in [1, 2, 3]:
- precision = precisions[:, :, idx, area, -1]
- precision = precision[precision > -1]
- if precision.size:
- ap = np.mean(precision)
- else:
- ap = float('nan')
- t.append(f'{round(ap, 3)}')
- results_per_category.append(tuple(t))
-
- num_columns = len(results_per_category[0])
- results_flatten = list(
- itertools.chain(*results_per_category))
- headers = [
- 'category', 'mAP', 'mAP_50', 'mAP_75', 'mAP_s',
- 'mAP_m', 'mAP_l'
- ]
- results_2d = itertools.zip_longest(*[
- results_flatten[i::num_columns]
- for i in range(num_columns)
- ])
- table_data = [headers]
- table_data += [result for result in results_2d]
- table = AsciiTable(table_data)
- # if mmengine.dist.get_local_rank() == 0:
- rank_zero_info('\n' + table.table)
-
- if metric_items is None:
- metric_items = [
- 'mAP', 'mAP_50', 'mAP_75', 'mAP_s', 'mAP_m', 'mAP_l'
- ]
-
- for metric_item in metric_items:
- key = f'{metric}_{metric_item}'
- val = coco_eval.stats[coco_metric_names[metric_item]]
- eval_results[key] = float(f'{round(val, 3)}')
-
- ap = coco_eval.stats[:6]
- # if mmengine.dist.get_local_rank() == 0:
-
- rank_zero_info(f'{metric}_mAP_copypaste: {ap[0]:.3f} '
- f'{ap[1]:.3f} {ap[2]:.3f} {ap[3]:.3f} '
- f'{ap[4]:.3f} {ap[5]:.3f}')
-
- if tmp_dir is not None:
- tmp_dir.cleanup()
- for k, v in eval_results.items():
- eval_results[k] = torch.tensor(v).to(self.device)
- self._coco_api = None
- return eval_results
diff --git a/spaces/LanguageBind/LanguageBind/open_clip/loss.py b/spaces/LanguageBind/LanguageBind/open_clip/loss.py
deleted file mode 100644
index 3a8bfb901fe5e4178de983d9ce2bdecc7c27e530..0000000000000000000000000000000000000000
--- a/spaces/LanguageBind/LanguageBind/open_clip/loss.py
+++ /dev/null
@@ -1,216 +0,0 @@
-import torch
-import torch.nn as nn
-from torch.nn import functional as F
-
-try:
- import torch.distributed.nn
- from torch import distributed as dist
-
- has_distributed = True
-except ImportError:
- has_distributed = False
-
-try:
- import horovod.torch as hvd
-except ImportError:
- hvd = None
-
-
-def gather_features(
- image_features,
- text_features,
- local_loss=False,
- gather_with_grad=False,
- rank=0,
- world_size=1,
- use_horovod=False
-):
- assert has_distributed, 'torch.distributed did not import correctly, please use a PyTorch version with support.'
- if use_horovod:
- assert hvd is not None, 'Please install horovod'
- if gather_with_grad:
- all_image_features = hvd.allgather(image_features)
- all_text_features = hvd.allgather(text_features)
- else:
- with torch.no_grad():
- all_image_features = hvd.allgather(image_features)
- all_text_features = hvd.allgather(text_features)
- if not local_loss:
- # ensure grads for local rank when all_* features don't have a gradient
- gathered_image_features = list(all_image_features.chunk(world_size, dim=0))
- gathered_text_features = list(all_text_features.chunk(world_size, dim=0))
- gathered_image_features[rank] = image_features
- gathered_text_features[rank] = text_features
- all_image_features = torch.cat(gathered_image_features, dim=0)
- all_text_features = torch.cat(gathered_text_features, dim=0)
- else:
- # We gather tensors from all gpus
- if gather_with_grad:
- all_image_features = torch.cat(torch.distributed.nn.all_gather(image_features), dim=0)
- all_text_features = torch.cat(torch.distributed.nn.all_gather(text_features), dim=0)
- else:
- gathered_image_features = [torch.zeros_like(image_features) for _ in range(world_size)]
- gathered_text_features = [torch.zeros_like(text_features) for _ in range(world_size)]
- dist.all_gather(gathered_image_features, image_features)
- dist.all_gather(gathered_text_features, text_features)
- if not local_loss:
- # ensure grads for local rank when all_* features don't have a gradient
- gathered_image_features[rank] = image_features
- gathered_text_features[rank] = text_features
- all_image_features = torch.cat(gathered_image_features, dim=0)
- all_text_features = torch.cat(gathered_text_features, dim=0)
-
- return all_image_features, all_text_features
-
-
-class ClipLoss(nn.Module):
-
- def __init__(
- self,
- local_loss=False,
- gather_with_grad=False,
- cache_labels=False,
- rank=0,
- world_size=1,
- use_horovod=False,
- ):
- super().__init__()
- self.local_loss = local_loss
- self.gather_with_grad = gather_with_grad
- self.cache_labels = cache_labels
- self.rank = rank
- self.world_size = world_size
- self.use_horovod = use_horovod
-
- # cache state
- self.prev_num_logits = 0
- self.labels = {}
-
- def get_ground_truth(self, device, num_logits) -> torch.Tensor:
- # calculated ground-truth and cache if enabled
- if self.prev_num_logits != num_logits or device not in self.labels:
- labels = torch.arange(num_logits, device=device, dtype=torch.long)
- if self.world_size > 1 and self.local_loss:
- labels = labels + num_logits * self.rank
- if self.cache_labels:
- self.labels[device] = labels
- self.prev_num_logits = num_logits
- else:
- labels = self.labels[device]
- return labels
-
- def get_logits(self, image_features, text_features, logit_scale):
- if self.world_size > 1:
- all_image_features, all_text_features = gather_features(
- image_features, text_features,
- self.local_loss, self.gather_with_grad, self.rank, self.world_size, self.use_horovod)
-
- if self.local_loss:
- logits_per_image = logit_scale * image_features @ all_text_features.T
- logits_per_text = logit_scale * text_features @ all_image_features.T
- else:
- logits_per_image = logit_scale * all_image_features @ all_text_features.T
- logits_per_text = logits_per_image.T
- else:
- logits_per_image = logit_scale * image_features @ text_features.T
- logits_per_text = logit_scale * text_features @ image_features.T
-
- return logits_per_image, logits_per_text
-
- def forward(self, image_features, text_features, logit_scale, output_dict=False):
- device = image_features.device
- logits_per_image, logits_per_text = self.get_logits(image_features, text_features, logit_scale)
-
- labels = self.get_ground_truth(device, logits_per_image.shape[0])
-
- total_loss = (
- F.cross_entropy(logits_per_image, labels) +
- F.cross_entropy(logits_per_text, labels)
- ) / 2
-
- return {"contrastive_loss": total_loss} if output_dict else total_loss
-
-
-class CoCaLoss(ClipLoss):
- def __init__(
- self,
- caption_loss_weight,
- clip_loss_weight,
- pad_id=0, # pad_token for open_clip custom tokenizer
- local_loss=False,
- gather_with_grad=False,
- cache_labels=False,
- rank=0,
- world_size=1,
- use_horovod=False,
- ):
- super().__init__(
- local_loss=local_loss,
- gather_with_grad=gather_with_grad,
- cache_labels=cache_labels,
- rank=rank,
- world_size=world_size,
- use_horovod=use_horovod
- )
-
- self.clip_loss_weight = clip_loss_weight
- self.caption_loss_weight = caption_loss_weight
- self.caption_loss = nn.CrossEntropyLoss(ignore_index=pad_id)
-
- def forward(self, image_features, text_features, logits, labels, logit_scale, output_dict=False):
-
- clip_loss = 0
-
- if self.clip_loss_weight:
- clip_loss = super().forward(image_features, text_features, logit_scale)
- clip_loss = self.clip_loss_weight * clip_loss
-
- caption_loss = self.caption_loss(
- logits.permute(0, 2, 1),
- labels,
- )
- caption_loss = caption_loss * self.caption_loss_weight
-
- if output_dict:
- return {"contrastive_loss": clip_loss, "caption_loss": caption_loss}
-
- return clip_loss, caption_loss
-
-
-class DistillClipLoss(ClipLoss):
-
- def dist_loss(self, teacher_logits, student_logits):
- return -(teacher_logits.softmax(dim=1) * student_logits.log_softmax(dim=1)).sum(dim=1).mean(dim=0)
-
- def forward(
- self,
- image_features,
- text_features,
- logit_scale,
- dist_image_features,
- dist_text_features,
- dist_logit_scale,
- output_dict=False,
- ):
- logits_per_image, logits_per_text = \
- self.get_logits(image_features, text_features, logit_scale)
-
- dist_logits_per_image, dist_logits_per_text = \
- self.get_logits(dist_image_features, dist_text_features, dist_logit_scale)
-
- labels = self.get_ground_truth(image_features.device, logits_per_image.shape[0])
-
- contrastive_loss = (
- F.cross_entropy(logits_per_image, labels) +
- F.cross_entropy(logits_per_text, labels)
- ) / 2
-
- distill_loss = (
- self.dist_loss(dist_logits_per_image, logits_per_image) +
- self.dist_loss(dist_logits_per_text, logits_per_text)
- ) / 2
-
- if output_dict:
- return {"contrastive_loss": contrastive_loss, "distill_loss": distill_loss}
-
- return contrastive_loss, distill_loss
diff --git a/spaces/MathysL/AutoGPT4/autogpt/processing/text.py b/spaces/MathysL/AutoGPT4/autogpt/processing/text.py
deleted file mode 100644
index 52add81401775c1b111512d8149f86a175fd9acb..0000000000000000000000000000000000000000
--- a/spaces/MathysL/AutoGPT4/autogpt/processing/text.py
+++ /dev/null
@@ -1,132 +0,0 @@
-"""Text processing functions"""
-from typing import Dict, Generator, Optional
-
-from selenium.webdriver.remote.webdriver import WebDriver
-
-from autogpt.config import Config
-from autogpt.llm_utils import create_chat_completion
-from autogpt.memory import get_memory
-
-CFG = Config()
-MEMORY = get_memory(CFG)
-
-
-def split_text(text: str, max_length: int = 8192) -> Generator[str, None, None]:
- """Split text into chunks of a maximum length
-
- Args:
- text (str): The text to split
- max_length (int, optional): The maximum length of each chunk. Defaults to 8192.
-
- Yields:
- str: The next chunk of text
-
- Raises:
- ValueError: If the text is longer than the maximum length
- """
- paragraphs = text.split("\n")
- current_length = 0
- current_chunk = []
-
- for paragraph in paragraphs:
- if current_length + len(paragraph) + 1 <= max_length:
- current_chunk.append(paragraph)
- current_length += len(paragraph) + 1
- else:
- yield "\n".join(current_chunk)
- current_chunk = [paragraph]
- current_length = len(paragraph) + 1
-
- if current_chunk:
- yield "\n".join(current_chunk)
-
-
-def summarize_text(
- url: str, text: str, question: str, driver: Optional[WebDriver] = None
-) -> str:
- """Summarize text using the OpenAI API
-
- Args:
- url (str): The url of the text
- text (str): The text to summarize
- question (str): The question to ask the model
- driver (WebDriver): The webdriver to use to scroll the page
-
- Returns:
- str: The summary of the text
- """
- if not text:
- return "Error: No text to summarize"
-
- text_length = len(text)
- print(f"Text length: {text_length} characters")
-
- summaries = []
- chunks = list(split_text(text))
- scroll_ratio = 1 / len(chunks)
-
- for i, chunk in enumerate(chunks):
- if driver:
- scroll_to_percentage(driver, scroll_ratio * i)
- print(f"Adding chunk {i + 1} / {len(chunks)} to memory")
-
- memory_to_add = f"Source: {url}\n" f"Raw content part#{i + 1}: {chunk}"
-
- MEMORY.add(memory_to_add)
-
- print(f"Summarizing chunk {i + 1} / {len(chunks)}")
- messages = [create_message(chunk, question)]
-
- summary = create_chat_completion(
- model=CFG.fast_llm_model,
- messages=messages,
- )
- summaries.append(summary)
- print(f"Added chunk {i + 1} summary to memory")
-
- memory_to_add = f"Source: {url}\n" f"Content summary part#{i + 1}: {summary}"
-
- MEMORY.add(memory_to_add)
-
- print(f"Summarized {len(chunks)} chunks.")
-
- combined_summary = "\n".join(summaries)
- messages = [create_message(combined_summary, question)]
-
- return create_chat_completion(
- model=CFG.fast_llm_model,
- messages=messages,
- )
-
-
-def scroll_to_percentage(driver: WebDriver, ratio: float) -> None:
- """Scroll to a percentage of the page
-
- Args:
- driver (WebDriver): The webdriver to use
- ratio (float): The percentage to scroll to
-
- Raises:
- ValueError: If the ratio is not between 0 and 1
- """
- if ratio < 0 or ratio > 1:
- raise ValueError("Percentage should be between 0 and 1")
- driver.execute_script(f"window.scrollTo(0, document.body.scrollHeight * {ratio});")
-
-
-def create_message(chunk: str, question: str) -> Dict[str, str]:
- """Create a message for the chat completion
-
- Args:
- chunk (str): The chunk of text to summarize
- question (str): The question to answer
-
- Returns:
- Dict[str, str]: The message to send to the chat completion
- """
- return {
- "role": "user",
- "content": f'"""{chunk}""" Using the above text, answer the following'
- f' question: "{question}" -- if the question cannot be answered using the text,'
- " summarize the text.",
- }
diff --git a/spaces/MattyWhite/ChatGPT-ImageCaptioner2/detic/config.py b/spaces/MattyWhite/ChatGPT-ImageCaptioner2/detic/config.py
deleted file mode 100644
index b6132f70116518b55e3b653fc6cd4ec9f61e50b0..0000000000000000000000000000000000000000
--- a/spaces/MattyWhite/ChatGPT-ImageCaptioner2/detic/config.py
+++ /dev/null
@@ -1,131 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-from detectron2.config import CfgNode as CN
-
-def add_detic_config(cfg):
- _C = cfg
-
- _C.WITH_IMAGE_LABELS = False # Turn on co-training with classification data
-
- # Open-vocabulary classifier
- _C.MODEL.ROI_BOX_HEAD.USE_ZEROSHOT_CLS = False # Use fixed classifier for open-vocabulary detection
- _C.MODEL.ROI_BOX_HEAD.ZEROSHOT_WEIGHT_PATH = 'datasets/metadata/lvis_v1_clip_a+cname.npy'
- _C.MODEL.ROI_BOX_HEAD.ZEROSHOT_WEIGHT_DIM = 512
- _C.MODEL.ROI_BOX_HEAD.NORM_WEIGHT = True
- _C.MODEL.ROI_BOX_HEAD.NORM_TEMP = 50.0
- _C.MODEL.ROI_BOX_HEAD.IGNORE_ZERO_CATS = False
- _C.MODEL.ROI_BOX_HEAD.USE_BIAS = 0.0 # >= 0: not use
-
- _C.MODEL.ROI_BOX_HEAD.MULT_PROPOSAL_SCORE = False # CenterNet2
- _C.MODEL.ROI_BOX_HEAD.USE_SIGMOID_CE = False
- _C.MODEL.ROI_BOX_HEAD.PRIOR_PROB = 0.01
- _C.MODEL.ROI_BOX_HEAD.USE_FED_LOSS = False # Federated Loss
- _C.MODEL.ROI_BOX_HEAD.CAT_FREQ_PATH = \
- 'datasets/metadata/lvis_v1_train_cat_info.json'
- _C.MODEL.ROI_BOX_HEAD.FED_LOSS_NUM_CAT = 50
- _C.MODEL.ROI_BOX_HEAD.FED_LOSS_FREQ_WEIGHT = 0.5
-
- # Classification data configs
- _C.MODEL.ROI_BOX_HEAD.IMAGE_LABEL_LOSS = 'max_size' # max, softmax, sum
- _C.MODEL.ROI_BOX_HEAD.IMAGE_LOSS_WEIGHT = 0.1
- _C.MODEL.ROI_BOX_HEAD.IMAGE_BOX_SIZE = 1.0
- _C.MODEL.ROI_BOX_HEAD.ADD_IMAGE_BOX = False # Used for image-box loss and caption loss
- _C.MODEL.ROI_BOX_HEAD.WS_NUM_PROPS = 128 # num proposals for image-labeled data
- _C.MODEL.ROI_BOX_HEAD.WITH_SOFTMAX_PROP = False # Used for WSDDN
- _C.MODEL.ROI_BOX_HEAD.CAPTION_WEIGHT = 1.0 # Caption loss weight
- _C.MODEL.ROI_BOX_HEAD.NEG_CAP_WEIGHT = 0.125 # Caption loss hyper-parameter
- _C.MODEL.ROI_BOX_HEAD.ADD_FEATURE_TO_PROP = False # Used for WSDDN
- _C.MODEL.ROI_BOX_HEAD.SOFTMAX_WEAK_LOSS = False # Used when USE_SIGMOID_CE is False
-
- _C.MODEL.ROI_HEADS.MASK_WEIGHT = 1.0
- _C.MODEL.ROI_HEADS.ONE_CLASS_PER_PROPOSAL = False # For demo only
-
- # Caption losses
- _C.MODEL.CAP_BATCH_RATIO = 4 # Ratio between detection data and caption data
- _C.MODEL.WITH_CAPTION = False
- _C.MODEL.SYNC_CAPTION_BATCH = False # synchronize across GPUs to enlarge # "classes"
-
- # dynamic class sampling when training with 21K classes
- _C.MODEL.DYNAMIC_CLASSIFIER = False
- _C.MODEL.NUM_SAMPLE_CATS = 50
-
- # Different classifiers in testing, used in cross-dataset evaluation
- _C.MODEL.RESET_CLS_TESTS = False
- _C.MODEL.TEST_CLASSIFIERS = []
- _C.MODEL.TEST_NUM_CLASSES = []
-
- # Backbones
- _C.MODEL.SWIN = CN()
- _C.MODEL.SWIN.SIZE = 'T' # 'T', 'S', 'B'
- _C.MODEL.SWIN.USE_CHECKPOINT = False
- _C.MODEL.SWIN.OUT_FEATURES = (1, 2, 3) # FPN stride 8 - 32
-
- _C.MODEL.TIMM = CN()
- _C.MODEL.TIMM.BASE_NAME = 'resnet50'
- _C.MODEL.TIMM.OUT_LEVELS = (3, 4, 5)
- _C.MODEL.TIMM.NORM = 'FrozenBN'
- _C.MODEL.TIMM.FREEZE_AT = 0
- _C.MODEL.DATASET_LOSS_WEIGHT = []
-
- # Multi-dataset dataloader
- _C.DATALOADER.DATASET_RATIO = [1, 1] # sample ratio
- _C.DATALOADER.USE_RFS = [False, False]
- _C.DATALOADER.MULTI_DATASET_GROUPING = False # Always true when multi-dataset is enabled
- _C.DATALOADER.DATASET_ANN = ['box', 'box'] # Annotation type of each dataset
- _C.DATALOADER.USE_DIFF_BS_SIZE = False # Use different batchsize for each dataset
- _C.DATALOADER.DATASET_BS = [8, 32] # Used when USE_DIFF_BS_SIZE is on
- _C.DATALOADER.DATASET_INPUT_SIZE = [896, 384] # Used when USE_DIFF_BS_SIZE is on
- _C.DATALOADER.DATASET_INPUT_SCALE = [(0.1, 2.0), (0.5, 1.5)] # Used when USE_DIFF_BS_SIZE is on
- _C.DATALOADER.DATASET_MIN_SIZES = [(640, 800), (320, 400)] # Used when USE_DIFF_BS_SIZE is on
- _C.DATALOADER.DATASET_MAX_SIZES = [1333, 667] # Used when USE_DIFF_BS_SIZE is on
- _C.DATALOADER.USE_TAR_DATASET = False # for ImageNet-21K, directly reading from unziped files
- _C.DATALOADER.TARFILE_PATH = 'datasets/imagenet/metadata-22k/tar_files.npy'
- _C.DATALOADER.TAR_INDEX_DIR = 'datasets/imagenet/metadata-22k/tarindex_npy'
-
- _C.SOLVER.USE_CUSTOM_SOLVER = False
- _C.SOLVER.OPTIMIZER = 'SGD'
- _C.SOLVER.BACKBONE_MULTIPLIER = 1.0 # Used in DETR
- _C.SOLVER.CUSTOM_MULTIPLIER = 1.0 # Used in DETR
- _C.SOLVER.CUSTOM_MULTIPLIER_NAME = [] # Used in DETR
-
- # Deformable DETR
- _C.MODEL.DETR = CN()
- _C.MODEL.DETR.NUM_CLASSES = 80
- _C.MODEL.DETR.FROZEN_WEIGHTS = '' # For Segmentation
- _C.MODEL.DETR.GIOU_WEIGHT = 2.0
- _C.MODEL.DETR.L1_WEIGHT = 5.0
- _C.MODEL.DETR.DEEP_SUPERVISION = True
- _C.MODEL.DETR.NO_OBJECT_WEIGHT = 0.1
- _C.MODEL.DETR.CLS_WEIGHT = 2.0
- _C.MODEL.DETR.NUM_FEATURE_LEVELS = 4
- _C.MODEL.DETR.TWO_STAGE = False
- _C.MODEL.DETR.WITH_BOX_REFINE = False
- _C.MODEL.DETR.FOCAL_ALPHA = 0.25
- _C.MODEL.DETR.NHEADS = 8
- _C.MODEL.DETR.DROPOUT = 0.1
- _C.MODEL.DETR.DIM_FEEDFORWARD = 2048
- _C.MODEL.DETR.ENC_LAYERS = 6
- _C.MODEL.DETR.DEC_LAYERS = 6
- _C.MODEL.DETR.PRE_NORM = False
- _C.MODEL.DETR.HIDDEN_DIM = 256
- _C.MODEL.DETR.NUM_OBJECT_QUERIES = 100
-
- _C.MODEL.DETR.USE_FED_LOSS = False
- _C.MODEL.DETR.WEAK_WEIGHT = 0.1
-
- _C.INPUT.CUSTOM_AUG = ''
- _C.INPUT.TRAIN_SIZE = 640
- _C.INPUT.TEST_SIZE = 640
- _C.INPUT.SCALE_RANGE = (0.1, 2.)
- # 'default' for fixed short/ long edge, 'square' for max size=INPUT.SIZE
- _C.INPUT.TEST_INPUT_TYPE = 'default'
-
- _C.FIND_UNUSED_PARAM = True
- _C.EVAL_PRED_AR = False
- _C.EVAL_PROPOSAL_AR = False
- _C.EVAL_CAT_SPEC_AR = False
- _C.IS_DEBUG = False
- _C.QUICK_DEBUG = False
- _C.FP16 = False
- _C.EVAL_AP_FIX = False
- _C.GEN_PSEDO_LABELS = False
- _C.SAVE_DEBUG_PATH = 'output/save_debug/'
\ No newline at end of file
diff --git a/spaces/Mellow-ai/PhotoAI_Mellow/annotator/uniformer/mmseg/apis/train.py b/spaces/Mellow-ai/PhotoAI_Mellow/annotator/uniformer/mmseg/apis/train.py
deleted file mode 100644
index 63f319a919ff023931a6a663e668f27dd1a07a2e..0000000000000000000000000000000000000000
--- a/spaces/Mellow-ai/PhotoAI_Mellow/annotator/uniformer/mmseg/apis/train.py
+++ /dev/null
@@ -1,116 +0,0 @@
-import random
-import warnings
-
-import numpy as np
-import torch
-from annotator.uniformer.mmcv.parallel import MMDataParallel, MMDistributedDataParallel
-from annotator.uniformer.mmcv.runner import build_optimizer, build_runner
-
-from annotator.uniformer.mmseg.core import DistEvalHook, EvalHook
-from annotator.uniformer.mmseg.datasets import build_dataloader, build_dataset
-from annotator.uniformer.mmseg.utils import get_root_logger
-
-
-def set_random_seed(seed, deterministic=False):
- """Set random seed.
-
- Args:
- seed (int): Seed to be used.
- deterministic (bool): Whether to set the deterministic option for
- CUDNN backend, i.e., set `torch.backends.cudnn.deterministic`
- to True and `torch.backends.cudnn.benchmark` to False.
- Default: False.
- """
- random.seed(seed)
- np.random.seed(seed)
- torch.manual_seed(seed)
- torch.cuda.manual_seed_all(seed)
- if deterministic:
- torch.backends.cudnn.deterministic = True
- torch.backends.cudnn.benchmark = False
-
-
-def train_segmentor(model,
- dataset,
- cfg,
- distributed=False,
- validate=False,
- timestamp=None,
- meta=None):
- """Launch segmentor training."""
- logger = get_root_logger(cfg.log_level)
-
- # prepare data loaders
- dataset = dataset if isinstance(dataset, (list, tuple)) else [dataset]
- data_loaders = [
- build_dataloader(
- ds,
- cfg.data.samples_per_gpu,
- cfg.data.workers_per_gpu,
- # cfg.gpus will be ignored if distributed
- len(cfg.gpu_ids),
- dist=distributed,
- seed=cfg.seed,
- drop_last=True) for ds in dataset
- ]
-
- # put model on gpus
- if distributed:
- find_unused_parameters = cfg.get('find_unused_parameters', False)
- # Sets the `find_unused_parameters` parameter in
- # torch.nn.parallel.DistributedDataParallel
- model = MMDistributedDataParallel(
- model.cuda(),
- device_ids=[torch.cuda.current_device()],
- broadcast_buffers=False,
- find_unused_parameters=find_unused_parameters)
- else:
- model = MMDataParallel(
- model.cuda(cfg.gpu_ids[0]), device_ids=cfg.gpu_ids)
-
- # build runner
- optimizer = build_optimizer(model, cfg.optimizer)
-
- if cfg.get('runner') is None:
- cfg.runner = {'type': 'IterBasedRunner', 'max_iters': cfg.total_iters}
- warnings.warn(
- 'config is now expected to have a `runner` section, '
- 'please set `runner` in your config.', UserWarning)
-
- runner = build_runner(
- cfg.runner,
- default_args=dict(
- model=model,
- batch_processor=None,
- optimizer=optimizer,
- work_dir=cfg.work_dir,
- logger=logger,
- meta=meta))
-
- # register hooks
- runner.register_training_hooks(cfg.lr_config, cfg.optimizer_config,
- cfg.checkpoint_config, cfg.log_config,
- cfg.get('momentum_config', None))
-
- # an ugly walkaround to make the .log and .log.json filenames the same
- runner.timestamp = timestamp
-
- # register eval hooks
- if validate:
- val_dataset = build_dataset(cfg.data.val, dict(test_mode=True))
- val_dataloader = build_dataloader(
- val_dataset,
- samples_per_gpu=1,
- workers_per_gpu=cfg.data.workers_per_gpu,
- dist=distributed,
- shuffle=False)
- eval_cfg = cfg.get('evaluation', {})
- eval_cfg['by_epoch'] = cfg.runner['type'] != 'IterBasedRunner'
- eval_hook = DistEvalHook if distributed else EvalHook
- runner.register_hook(eval_hook(val_dataloader, **eval_cfg), priority='LOW')
-
- if cfg.resume_from:
- runner.resume(cfg.resume_from)
- elif cfg.load_from:
- runner.load_checkpoint(cfg.load_from)
- runner.run(data_loaders, cfg.workflow)
diff --git a/spaces/Mellow-ai/PhotoAI_Mellow/annotator/uniformer/mmseg/models/decode_heads/nl_head.py b/spaces/Mellow-ai/PhotoAI_Mellow/annotator/uniformer/mmseg/models/decode_heads/nl_head.py
deleted file mode 100644
index 3eee424199e6aa363b564e2a3340a070db04db86..0000000000000000000000000000000000000000
--- a/spaces/Mellow-ai/PhotoAI_Mellow/annotator/uniformer/mmseg/models/decode_heads/nl_head.py
+++ /dev/null
@@ -1,49 +0,0 @@
-import torch
-from annotator.uniformer.mmcv.cnn import NonLocal2d
-
-from ..builder import HEADS
-from .fcn_head import FCNHead
-
-
-@HEADS.register_module()
-class NLHead(FCNHead):
- """Non-local Neural Networks.
-
- This head is the implementation of `NLNet
- `_.
-
- Args:
- reduction (int): Reduction factor of projection transform. Default: 2.
- use_scale (bool): Whether to scale pairwise_weight by
- sqrt(1/inter_channels). Default: True.
- mode (str): The nonlocal mode. Options are 'embedded_gaussian',
- 'dot_product'. Default: 'embedded_gaussian.'.
- """
-
- def __init__(self,
- reduction=2,
- use_scale=True,
- mode='embedded_gaussian',
- **kwargs):
- super(NLHead, self).__init__(num_convs=2, **kwargs)
- self.reduction = reduction
- self.use_scale = use_scale
- self.mode = mode
- self.nl_block = NonLocal2d(
- in_channels=self.channels,
- reduction=self.reduction,
- use_scale=self.use_scale,
- conv_cfg=self.conv_cfg,
- norm_cfg=self.norm_cfg,
- mode=self.mode)
-
- def forward(self, inputs):
- """Forward function."""
- x = self._transform_inputs(inputs)
- output = self.convs[0](x)
- output = self.nl_block(output)
- output = self.convs[1](output)
- if self.concat_input:
- output = self.conv_cat(torch.cat([x, output], dim=1))
- output = self.cls_seg(output)
- return output
diff --git a/spaces/MetaWabbit/Auto-GPT/tests/browse_tests.py b/spaces/MetaWabbit/Auto-GPT/tests/browse_tests.py
deleted file mode 100644
index f896e7dd751b1b661d5e989909448b7e182eab69..0000000000000000000000000000000000000000
--- a/spaces/MetaWabbit/Auto-GPT/tests/browse_tests.py
+++ /dev/null
@@ -1,26 +0,0 @@
-import os
-import sys
-import unittest
-
-from bs4 import BeautifulSoup
-
-sys.path.append(os.path.abspath("../scripts"))
-
-from browse import extract_hyperlinks
-
-
-class TestBrowseLinks(unittest.TestCase):
- def test_extract_hyperlinks(self):
- body = """
-
- Google
- Foo
-
Some other crap
-
- """
- soup = BeautifulSoup(body, "html.parser")
- links = extract_hyperlinks(soup, "http://example.com")
- self.assertEqual(
- links,
- [("Google", "https://google.com"), ("Foo", "http://example.com/foo.html")],
- )
diff --git a/spaces/MindSyncAI/Plant_Classification/README.md b/spaces/MindSyncAI/Plant_Classification/README.md
deleted file mode 100644
index 6d61072735ba64539d2fdc5e75b27e156a33eb14..0000000000000000000000000000000000000000
--- a/spaces/MindSyncAI/Plant_Classification/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Plant Classification
-emoji: 👀
-colorFrom: yellow
-colorTo: pink
-sdk: streamlit
-sdk_version: 1.26.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/Mountchicken/MAERec-Gradio/configs/textdet/dbnetpp/dbnetpp_resnet50-oclip_fpnc_1200e_icdar2015.py b/spaces/Mountchicken/MAERec-Gradio/configs/textdet/dbnetpp/dbnetpp_resnet50-oclip_fpnc_1200e_icdar2015.py
deleted file mode 100644
index 737985241484fa1d2649d4da698a3bcf0e83321b..0000000000000000000000000000000000000000
--- a/spaces/Mountchicken/MAERec-Gradio/configs/textdet/dbnetpp/dbnetpp_resnet50-oclip_fpnc_1200e_icdar2015.py
+++ /dev/null
@@ -1,20 +0,0 @@
-_base_ = [
- 'dbnetpp_resnet50-dcnv2_fpnc_1200e_icdar2015.py',
-]
-
-load_from = None
-
-_base_.model.backbone = dict(
- type='CLIPResNet',
- init_cfg=dict(
- type='Pretrained',
- checkpoint='https://download.openmmlab.com/'
- 'mmocr/backbone/resnet50-oclip-7ba0c533.pth'))
-
-_base_.train_dataloader.num_workers = 24
-_base_.optim_wrapper.optimizer.lr = 0.002
-
-param_scheduler = [
- dict(type='LinearLR', end=200, start_factor=0.001),
- dict(type='PolyLR', power=0.9, eta_min=1e-7, begin=200, end=1200),
-]
diff --git a/spaces/MrBodean/VoiceClone/synthesizer/inference.py b/spaces/MrBodean/VoiceClone/synthesizer/inference.py
deleted file mode 100644
index af7bf083ffc9bed33ea6e2c77cb7f69e6b5c0475..0000000000000000000000000000000000000000
--- a/spaces/MrBodean/VoiceClone/synthesizer/inference.py
+++ /dev/null
@@ -1,171 +0,0 @@
-import torch
-from synthesizer import audio
-from synthesizer.hparams import hparams
-from synthesizer.models.tacotron import Tacotron
-from synthesizer.utils.symbols import symbols
-from synthesizer.utils.text import text_to_sequence
-from vocoder.display import simple_table
-from pathlib import Path
-from typing import Union, List
-import numpy as np
-import librosa
-
-
-class Synthesizer:
- sample_rate = hparams.sample_rate
- hparams = hparams
-
- def __init__(self, model_fpath: Path, verbose=True):
- """
- The model isn't instantiated and loaded in memory until needed or until load() is called.
-
- :param model_fpath: path to the trained model file
- :param verbose: if False, prints less information when using the model
- """
- self.model_fpath = model_fpath
- self.verbose = verbose
-
- # Check for GPU
- if torch.cuda.is_available():
- self.device = torch.device("cuda")
- else:
- self.device = torch.device("cpu")
- if self.verbose:
- print("Synthesizer using device:", self.device)
-
- # Tacotron model will be instantiated later on first use.
- self._model = None
-
- def is_loaded(self):
- """
- Whether the model is loaded in memory.
- """
- return self._model is not None
-
- def load(self):
- """
- Instantiates and loads the model given the weights file that was passed in the constructor.
- """
- self._model = Tacotron(embed_dims=hparams.tts_embed_dims,
- num_chars=len(symbols),
- encoder_dims=hparams.tts_encoder_dims,
- decoder_dims=hparams.tts_decoder_dims,
- n_mels=hparams.num_mels,
- fft_bins=hparams.num_mels,
- postnet_dims=hparams.tts_postnet_dims,
- encoder_K=hparams.tts_encoder_K,
- lstm_dims=hparams.tts_lstm_dims,
- postnet_K=hparams.tts_postnet_K,
- num_highways=hparams.tts_num_highways,
- dropout=hparams.tts_dropout,
- stop_threshold=hparams.tts_stop_threshold,
- speaker_embedding_size=hparams.speaker_embedding_size).to(self.device)
-
- self._model.load(self.model_fpath)
- self._model.eval()
-
- if self.verbose:
- print("Loaded synthesizer \"%s\" trained to step %d" % (self.model_fpath.name, self._model.state_dict()["step"]))
-
- def synthesize_spectrograms(self, texts: List[str],
- embeddings: Union[np.ndarray, List[np.ndarray]],
- return_alignments=False):
- """
- Synthesizes mel spectrograms from texts and speaker embeddings.
-
- :param texts: a list of N text prompts to be synthesized
- :param embeddings: a numpy array or list of speaker embeddings of shape (N, 256)
- :param return_alignments: if True, a matrix representing the alignments between the
- characters
- and each decoder output step will be returned for each spectrogram
- :return: a list of N melspectrograms as numpy arrays of shape (80, Mi), where Mi is the
- sequence length of spectrogram i, and possibly the alignments.
- """
- # Load the model on the first request.
- if not self.is_loaded():
- self.load()
-
- # Print some info about the model when it is loaded
- tts_k = self._model.get_step() // 1000
-
- simple_table([("Tacotron", str(tts_k) + "k"),
- ("r", self._model.r)])
-
- # Preprocess text inputs
- inputs = [text_to_sequence(text.strip(), hparams.tts_cleaner_names) for text in texts]
- if not isinstance(embeddings, list):
- embeddings = [embeddings]
-
- # Batch inputs
- batched_inputs = [inputs[i:i+hparams.synthesis_batch_size]
- for i in range(0, len(inputs), hparams.synthesis_batch_size)]
- batched_embeds = [embeddings[i:i+hparams.synthesis_batch_size]
- for i in range(0, len(embeddings), hparams.synthesis_batch_size)]
-
- specs = []
- for i, batch in enumerate(batched_inputs, 1):
- if self.verbose:
- print(f"\n| Generating {i}/{len(batched_inputs)}")
-
- # Pad texts so they are all the same length
- text_lens = [len(text) for text in batch]
- max_text_len = max(text_lens)
- chars = [pad1d(text, max_text_len) for text in batch]
- chars = np.stack(chars)
-
- # Stack speaker embeddings into 2D array for batch processing
- speaker_embeds = np.stack(batched_embeds[i-1])
-
- # Convert to tensor
- chars = torch.tensor(chars).long().to(self.device)
- speaker_embeddings = torch.tensor(speaker_embeds).float().to(self.device)
-
- # Inference
- _, mels, alignments = self._model.generate(chars, speaker_embeddings)
- mels = mels.detach().cpu().numpy()
- for m in mels:
- # Trim silence from end of each spectrogram
- while np.max(m[:, -1]) < hparams.tts_stop_threshold:
- m = m[:, :-1]
- specs.append(m)
-
- if self.verbose:
- print("\n\nDone.\n")
- return (specs, alignments) if return_alignments else specs
-
- @staticmethod
- def load_preprocess_wav(fpath):
- """
- Loads and preprocesses an audio file under the same conditions the audio files were used to
- train the synthesizer.
- """
- wav = librosa.load(str(fpath), hparams.sample_rate)[0]
- if hparams.rescale:
- wav = wav / np.abs(wav).max() * hparams.rescaling_max
- return wav
-
- @staticmethod
- def make_spectrogram(fpath_or_wav: Union[str, Path, np.ndarray]):
- """
- Creates a mel spectrogram from an audio file in the same manner as the mel spectrograms that
- were fed to the synthesizer when training.
- """
- if isinstance(fpath_or_wav, str) or isinstance(fpath_or_wav, Path):
- wav = Synthesizer.load_preprocess_wav(fpath_or_wav)
- else:
- wav = fpath_or_wav
-
- mel_spectrogram = audio.melspectrogram(wav, hparams).astype(np.float32)
- return mel_spectrogram
-
- @staticmethod
- def griffin_lim(mel):
- """
- Inverts a mel spectrogram using Griffin-Lim. The mel spectrogram is expected to have been built
- with the same parameters present in hparams.py.
- """
- return audio.inv_mel_spectrogram(mel, hparams)
-
-
-def pad1d(x, max_len, pad_value=0):
- return np.pad(x, (0, max_len - len(x)), mode="constant", constant_values=pad_value)
diff --git a/spaces/NCTCMumbai/NCTC/models/official/benchmark/resnet_ctl_imagenet_benchmark.py b/spaces/NCTCMumbai/NCTC/models/official/benchmark/resnet_ctl_imagenet_benchmark.py
deleted file mode 100644
index 0e70e8da969ec9b02a2de00d1973bdd2aa5f2b51..0000000000000000000000000000000000000000
--- a/spaces/NCTCMumbai/NCTC/models/official/benchmark/resnet_ctl_imagenet_benchmark.py
+++ /dev/null
@@ -1,452 +0,0 @@
-# Copyright 2019 The TensorFlow Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ==============================================================================
-"""Executes CTL benchmarks and accuracy tests."""
-# pylint: disable=line-too-long,g-bad-import-order
-from __future__ import print_function
-
-import os
-import time
-
-from absl import flags
-import tensorflow as tf
-
-from official.benchmark import owner_utils
-from official.vision.image_classification.resnet import common
-from official.vision.image_classification.resnet import resnet_ctl_imagenet_main
-from official.benchmark.perfzero_benchmark import PerfZeroBenchmark
-from official.benchmark import benchmark_wrappers
-from official.utils.flags import core as flags_core
-
-MIN_TOP_1_ACCURACY = 0.76
-MAX_TOP_1_ACCURACY = 0.77
-
-FLAGS = flags.FLAGS
-
-
-class CtlBenchmark(PerfZeroBenchmark):
- """Base benchmark class with methods to simplify testing."""
-
- def __init__(self, output_dir=None, default_flags=None, flag_methods=None):
- self.default_flags = default_flags or {}
- self.flag_methods = flag_methods or {}
- super(CtlBenchmark, self).__init__(
- output_dir=output_dir,
- default_flags=self.default_flags,
- flag_methods=self.flag_methods)
-
- def _report_benchmark(self,
- stats,
- wall_time_sec,
- top_1_max=None,
- top_1_min=None,
- total_batch_size=None,
- log_steps=None,
- warmup=1,
- start_time_sec=None):
- """Report benchmark results by writing to local protobuf file.
-
- Args:
- stats: dict returned from keras models with known entries.
- wall_time_sec: the during of the benchmark execution in seconds
- top_1_max: highest passing level for top_1 accuracy.
- top_1_min: lowest passing level for top_1 accuracy.
- total_batch_size: Global batch-size.
- log_steps: How often the log was created for stats['step_timestamp_log'].
- warmup: number of entries in stats['step_timestamp_log'] to ignore.
- start_time_sec: the start time of the program in seconds since epoch.
- """
-
- metrics = []
- if 'eval_acc' in stats:
- metrics.append({
- 'name': 'accuracy_top_1',
- 'value': stats['eval_acc'],
- 'min_value': top_1_min,
- 'max_value': top_1_max
- })
- metrics.append({'name': 'eval_loss', 'value': stats['eval_loss']})
-
- metrics.append({
- 'name': 'top_1_train_accuracy',
- 'value': stats['train_acc']
- })
- metrics.append({'name': 'train_loss', 'value': stats['train_loss']})
-
- if (warmup and 'step_timestamp_log' in stats and
- len(stats['step_timestamp_log']) > warmup + 1):
- # first entry in the time_log is start of step 0. The rest of the
- # entries are the end of each step recorded
- time_log = stats['step_timestamp_log']
- steps_elapsed = time_log[-1].batch_index - time_log[warmup].batch_index
- time_elapsed = time_log[-1].timestamp - time_log[warmup].timestamp
- examples_per_sec = total_batch_size * (steps_elapsed / time_elapsed)
- metrics.append({'name': 'exp_per_second', 'value': examples_per_sec})
-
- if 'avg_exp_per_second' in stats:
- metrics.append({
- 'name': 'avg_exp_per_second',
- 'value': stats['avg_exp_per_second']
- })
-
- if start_time_sec and 'step_timestamp_log' in stats:
- time_log = stats['step_timestamp_log']
- # time_log[0] is recorded at the beginning of the first step.
- startup_time = time_log[0].timestamp - start_time_sec
- metrics.append({'name': 'startup_time', 'value': startup_time})
-
- flags_str = flags_core.get_nondefault_flags_as_str()
- self.report_benchmark(
- iters=-1,
- wall_time=wall_time_sec,
- metrics=metrics,
- extras={'flags': flags_str})
-
-
-class Resnet50CtlAccuracy(CtlBenchmark):
- """Benchmark accuracy tests for ResNet50 in CTL."""
-
- def __init__(self, output_dir=None, root_data_dir=None, **kwargs):
- """A benchmark class.
-
- Args:
- output_dir: directory where to output e.g. log files
- root_data_dir: directory under which to look for dataset
- **kwargs: arbitrary named arguments. This is needed to make the
- constructor forward compatible in case PerfZero provides more named
- arguments before updating the constructor.
- """
-
- flag_methods = [common.define_keras_flags]
-
- self.data_dir = os.path.join(root_data_dir, 'imagenet')
- super(Resnet50CtlAccuracy, self).__init__(
- output_dir=output_dir, flag_methods=flag_methods)
-
- def benchmark_8_gpu(self):
- """Test Keras model with eager, dist_strat and 8 GPUs."""
- self._setup()
- FLAGS.num_gpus = 8
- FLAGS.data_dir = self.data_dir
- FLAGS.batch_size = 128 * 8
- FLAGS.train_epochs = 90
- FLAGS.epochs_between_evals = 10
- FLAGS.model_dir = self._get_model_dir('benchmark_8_gpu')
- FLAGS.dtype = 'fp32'
- self._run_and_report_benchmark()
-
- def benchmark_8_gpu_fp16(self):
- """Test Keras model with eager, 8 GPUs with tf.keras mixed precision."""
- self._setup()
- FLAGS.num_gpus = 8
- FLAGS.data_dir = self.data_dir
- FLAGS.batch_size = 256 * 8
- FLAGS.train_epochs = 90
- FLAGS.epochs_between_evals = 10
- FLAGS.model_dir = self._get_model_dir('benchmark_8_gpu_fp16')
- FLAGS.dtype = 'fp16'
- self._run_and_report_benchmark()
-
- def benchmark_8_gpu_amp(self):
- """Test Keras model with 8 GPUs and mixed precision via graph rewrite."""
- self._setup()
- FLAGS.num_gpus = 8
- FLAGS.data_dir = self.data_dir
- FLAGS.batch_size = 256 * 8
- FLAGS.train_epochs = 90
- FLAGS.epochs_between_evals = 10
- FLAGS.model_dir = self._get_model_dir('benchmark_8_gpu_amp')
- FLAGS.dtype = 'fp16'
- FLAGS.fp16_implementation = 'graph_rewrite'
- self._run_and_report_benchmark()
-
- @benchmark_wrappers.enable_runtime_flags
- def _run_and_report_benchmark(self):
- start_time_sec = time.time()
- stats = resnet_ctl_imagenet_main.run(flags.FLAGS)
- wall_time_sec = time.time() - start_time_sec
-
- super(Resnet50CtlAccuracy, self)._report_benchmark(
- stats,
- wall_time_sec,
- top_1_min=MIN_TOP_1_ACCURACY,
- top_1_max=MAX_TOP_1_ACCURACY,
- total_batch_size=FLAGS.batch_size,
- log_steps=100,
- start_time_sec=start_time_sec)
-
-
-class Resnet50CtlBenchmarkBase(CtlBenchmark):
- """Resnet50 benchmarks."""
-
- def __init__(self, output_dir=None, default_flags=None):
- flag_methods = [common.define_keras_flags]
-
- super(Resnet50CtlBenchmarkBase, self).__init__(
- output_dir=output_dir,
- flag_methods=flag_methods,
- default_flags=default_flags)
-
- @benchmark_wrappers.enable_runtime_flags
- def _run_and_report_benchmark(self):
- start_time_sec = time.time()
- stats = resnet_ctl_imagenet_main.run(FLAGS)
- wall_time_sec = time.time() - start_time_sec
-
- # Warmup means the number of logged step time entries that are excluded in
- # performance report. Default to exclude 1 FLAGS.log_steps time.
- super(Resnet50CtlBenchmarkBase, self)._report_benchmark(
- stats,
- wall_time_sec,
- total_batch_size=FLAGS.batch_size,
- log_steps=FLAGS.log_steps,
- warmup=1,
- start_time_sec=start_time_sec)
-
- def benchmark_1_gpu_no_dist_strat(self):
- """Test Keras model with 1 GPU, no distribution strategy."""
- self._setup()
-
- FLAGS.num_gpus = 1
- FLAGS.distribution_strategy = 'off'
- FLAGS.model_dir = self._get_model_dir('benchmark_1_gpu_no_dist_strat')
- FLAGS.batch_size = 128
- self._run_and_report_benchmark()
-
- def benchmark_1_gpu(self):
- """Test Keras model with 1 GPU."""
- self._setup()
-
- FLAGS.num_gpus = 1
- FLAGS.distribution_strategy = 'one_device'
- FLAGS.model_dir = self._get_model_dir('benchmark_1_gpu')
- FLAGS.batch_size = 128
- self._run_and_report_benchmark()
-
- def benchmark_1_gpu_fp16(self):
- """Test Keras model with 1 GPU with tf.keras mixed precision."""
- self._setup()
-
- FLAGS.num_gpus = 1
- FLAGS.distribution_strategy = 'one_device'
- FLAGS.model_dir = self._get_model_dir('benchmark_1_gpu_fp16')
- FLAGS.batch_size = 256
- FLAGS.dtype = 'fp16'
- self._run_and_report_benchmark()
-
- def benchmark_1_gpu_amp(self):
- """Test Keras model with 1 GPU with automatic mixed precision."""
- self._setup()
-
- FLAGS.num_gpus = 1
- FLAGS.distribution_strategy = 'one_device'
- FLAGS.model_dir = self._get_model_dir('benchmark_1_gpu_amp')
- FLAGS.batch_size = 256
- FLAGS.dtype = 'fp16'
- FLAGS.fp16_implementation = 'graph_rewrite'
- self._run_and_report_benchmark()
-
- def benchmark_xla_1_gpu_amp(self):
- """Test Keras model with XLA and 1 GPU with automatic mixed precision."""
- self._setup()
-
- FLAGS.num_gpus = 1
- FLAGS.distribution_strategy = 'one_device'
- FLAGS.model_dir = self._get_model_dir('benchmark_xla_1_gpu_amp')
- FLAGS.batch_size = 256
- FLAGS.dtype = 'fp16'
- FLAGS.fp16_implementation = 'graph_rewrite'
- FLAGS.enable_xla = True
- self._run_and_report_benchmark()
-
- def benchmark_1_gpu_eager(self):
- """Test Keras model with 1 GPU in pure eager mode."""
- self._setup()
-
- FLAGS.num_gpus = 1
- FLAGS.distribution_strategy = 'one_device'
- FLAGS.model_dir = self._get_model_dir('benchmark_1_gpu_eager')
- FLAGS.batch_size = 120
- FLAGS.use_tf_function = False
- FLAGS.use_tf_while_loop = False
- FLAGS.single_l2_loss_op = True
- self._run_and_report_benchmark()
-
- def benchmark_1_gpu_fp16_eager(self):
- """Test Keras model with 1 GPU with fp16 and pure eager mode."""
- self._setup()
-
- FLAGS.num_gpus = 1
- FLAGS.distribution_strategy = 'one_device'
- FLAGS.model_dir = self._get_model_dir('benchmark_1_gpu_fp16_eager')
- FLAGS.batch_size = 240
- FLAGS.dtype = 'fp16'
- FLAGS.use_tf_function = False
- FLAGS.use_tf_while_loop = False
- FLAGS.single_l2_loss_op = True
- self._run_and_report_benchmark()
-
- def benchmark_8_gpu(self):
- """Test Keras model with 8 GPUs."""
- self._setup()
-
- FLAGS.num_gpus = 8
- FLAGS.distribution_strategy = 'mirrored'
- FLAGS.model_dir = self._get_model_dir('benchmark_8_gpu')
- FLAGS.batch_size = 128 * 8 # 8 GPUs
- self._run_and_report_benchmark()
-
- def benchmark_8_gpu_fp16(self):
- """Test Keras model with 8 GPUs with tf.keras mixed precision."""
- self._setup()
-
- FLAGS.num_gpus = 8
- FLAGS.distribution_strategy = 'mirrored'
- FLAGS.model_dir = self._get_model_dir('benchmark_8_gpu_fp16')
- FLAGS.batch_size = 256 * 8 # 8 GPUs
- FLAGS.dtype = 'fp16'
- self._run_and_report_benchmark()
-
- def benchmark_8_gpu_eager(self):
- """Test Keras model with 8 GPUs, eager, fp32."""
- self._setup()
-
- FLAGS.num_gpus = 8
- FLAGS.use_tf_function = False
- FLAGS.use_tf_while_loop = False
- FLAGS.distribution_strategy = 'mirrored'
- FLAGS.model_dir = self._get_model_dir('benchmark_8_gpu_eager')
- FLAGS.batch_size = 128
- self._run_and_report_benchmark()
-
- def benchmark_8_gpu_eager_fp16(self):
- """Test Keras model with 8 GPUs, eager, fp16."""
- self._setup()
-
- FLAGS.num_gpus = 8
- FLAGS.dtype = 'fp16'
- FLAGS.use_tf_function = False
- FLAGS.use_tf_while_loop = False
- FLAGS.distribution_strategy = 'mirrored'
- FLAGS.model_dir = self._get_model_dir('benchmark_8_gpu_eager_fp16')
- FLAGS.batch_size = 128
- self._run_and_report_benchmark()
-
- def benchmark_8_gpu_amp(self):
- """Test Keras model with 8 GPUs with automatic mixed precision."""
- self._setup()
-
- FLAGS.num_gpus = 8
- FLAGS.distribution_strategy = 'mirrored'
- FLAGS.model_dir = self._get_model_dir('benchmark_8_gpu_amp')
- FLAGS.batch_size = 256 * 8 # 8 GPUs
- FLAGS.dtype = 'fp16'
- FLAGS.fp16_implementation = 'graph_rewrite'
- self._run_and_report_benchmark()
-
- def benchmark_xla_8_gpu_amp(self):
- """Test Keras model with XLA and 8 GPUs with automatic mixed precision."""
- self._setup()
-
- FLAGS.num_gpus = 8
- FLAGS.distribution_strategy = 'mirrored'
- FLAGS.model_dir = self._get_model_dir('benchmark_xla_8_gpu_amp')
- FLAGS.batch_size = 256 * 8 # 8 GPUs
- FLAGS.dtype = 'fp16'
- FLAGS.fp16_implementation = 'graph_rewrite'
- FLAGS.enable_xla = True
- self._run_and_report_benchmark()
-
- def _set_df_common(self):
- FLAGS.steps_per_loop = 500
- FLAGS.train_epochs = 2
- FLAGS.train_steps = None
- FLAGS.skip_eval = True
- FLAGS.enable_eager = True
- FLAGS.enable_tensorboard = False
- FLAGS.distribution_strategy = 'tpu'
- FLAGS.report_accuracy_metrics = False
- FLAGS.log_steps = 50
- FLAGS.single_l2_loss_op = True
- FLAGS.use_tf_function = True
- FLAGS.enable_checkpoint_and_export = False
-
- def benchmark_2x2_tpu_bf16(self):
- self._setup()
- self._set_df_common()
- FLAGS.batch_size = 1024
- FLAGS.dtype = 'bf16'
- self._run_and_report_benchmark()
-
- def benchmark_4x4_tpu_bf16(self):
- self._setup()
- self._set_df_common()
- FLAGS.batch_size = 4096
- FLAGS.dtype = 'bf16'
- self._run_and_report_benchmark()
-
- @owner_utils.Owner('tf-graph-compiler')
- def benchmark_4x4_tpu_bf16_mlir(self):
- """Run resnet model on 4x4 with the MLIR Bridge enabled."""
- self._setup()
- self._set_df_common()
- FLAGS.batch_size = 4096
- FLAGS.dtype = 'bf16'
- tf.config.experimental.enable_mlir_bridge()
- self._run_and_report_benchmark()
-
- def benchmark_8x16_tpu_bf16(self):
- self._setup()
- self._set_df_common()
- FLAGS.batch_size = 8192
- FLAGS.dtype = 'bf16'
- self._run_and_report_benchmark()
-
- def fill_report_object(self, stats):
- super(Resnet50CtlBenchmarkBase, self).fill_report_object(
- stats, total_batch_size=FLAGS.batch_size, log_steps=FLAGS.log_steps)
-
-
-class Resnet50CtlBenchmarkSynth(Resnet50CtlBenchmarkBase):
- """Resnet50 synthetic benchmark tests."""
-
- def __init__(self, output_dir=None, root_data_dir=None, **kwargs):
- def_flags = {}
- def_flags['skip_eval'] = True
- def_flags['use_synthetic_data'] = True
- def_flags['train_steps'] = 110
- def_flags['steps_per_loop'] = 20
- def_flags['log_steps'] = 10
-
- super(Resnet50CtlBenchmarkSynth, self).__init__(
- output_dir=output_dir, default_flags=def_flags)
-
-
-class Resnet50CtlBenchmarkReal(Resnet50CtlBenchmarkBase):
- """Resnet50 real data benchmark tests."""
-
- def __init__(self, output_dir=None, root_data_dir=None, **kwargs):
- def_flags = {}
- def_flags['skip_eval'] = True
- def_flags['data_dir'] = os.path.join(root_data_dir, 'imagenet')
- def_flags['train_steps'] = 110
- def_flags['steps_per_loop'] = 20
- def_flags['log_steps'] = 10
-
- super(Resnet50CtlBenchmarkReal, self).__init__(
- output_dir=output_dir, default_flags=def_flags)
-
-
-if __name__ == '__main__':
- tf.test.main()
diff --git a/spaces/NCTCMumbai/NCTC/models/official/modeling/training/distributed_executor.py b/spaces/NCTCMumbai/NCTC/models/official/modeling/training/distributed_executor.py
deleted file mode 100644
index 11451260cdca52a9c9f4019010123c4d2b40e99e..0000000000000000000000000000000000000000
--- a/spaces/NCTCMumbai/NCTC/models/official/modeling/training/distributed_executor.py
+++ /dev/null
@@ -1,815 +0,0 @@
-# Copyright 2019 The TensorFlow Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ==============================================================================
-"""Custom training loop for running TensorFlow 2.0 models."""
-
-from __future__ import absolute_import
-from __future__ import division
-# from __future__ import google_type_annotations
-from __future__ import print_function
-
-import os
-
-from absl import flags
-from absl import logging
-
-import numpy as np
-import tensorflow as tf
-
-# pylint: disable=unused-import,g-import-not-at-top,redefined-outer-name,reimported
-from typing import Optional, Dict, List, Text, Callable, Union, Iterator, Any
-from official.modeling.hyperparams import params_dict
-from official.utils import hyperparams_flags
-from official.utils.misc import distribution_utils
-from official.utils.misc import keras_utils
-
-FLAGS = flags.FLAGS
-
-strategy_flags_dict = hyperparams_flags.strategy_flags_dict
-hparam_flags_dict = hyperparams_flags.hparam_flags_dict
-
-
-def _save_checkpoint(checkpoint, model_dir, checkpoint_prefix):
- """Saves model to model_dir with provided checkpoint prefix."""
-
- checkpoint_path = os.path.join(model_dir, checkpoint_prefix)
- saved_path = checkpoint.save(checkpoint_path)
- logging.info('Saving model as TF checkpoint: %s', saved_path)
-
-
-def _steps_to_run(current_step, total_steps, steps_per_loop):
- """Calculates steps to run on device."""
- if steps_per_loop <= 0:
- raise ValueError('steps_per_loop should be positive integer.')
- return min(total_steps - current_step, steps_per_loop)
-
-
-def _no_metric():
- return None
-
-
-def metrics_as_dict(metric):
- """Puts input metric(s) into a list.
-
- Args:
- metric: metric(s) to be put into the list. `metric` could be a object, a
- list or a dict of tf.keras.metrics.Metric or has the `required_method`.
-
- Returns:
- A dictionary of valid metrics.
- """
- if isinstance(metric, tf.keras.metrics.Metric):
- metrics = {metric.name: metric}
- elif isinstance(metric, list):
- metrics = {m.name: m for m in metric}
- elif isinstance(metric, dict):
- metrics = metric
- elif not metric:
- return {}
- else:
- metrics = {'metric': metric}
- return metrics
-
-
-def metric_results(metric):
- """Collects results from the given metric(s)."""
- metrics = metrics_as_dict(metric)
- metric_result = {
- name: m.result().numpy().astype(float) for name, m in metrics.items()
- }
- return metric_result
-
-
-def reset_states(metric):
- """Resets states of the given metric(s)."""
- metrics = metrics_as_dict(metric)
- for m in metrics.values():
- m.reset_states()
-
-
-class SummaryWriter(object):
- """Simple SummaryWriter for writing dictionary of metrics.
-
- Attributes:
- writer: The tf.SummaryWriter.
- """
-
- def __init__(self, model_dir: Text, name: Text):
- """Inits SummaryWriter with paths.
-
- Arguments:
- model_dir: the model folder path.
- name: the summary subfolder name.
- """
- self.writer = tf.summary.create_file_writer(os.path.join(model_dir, name))
-
- def __call__(self, metrics: Union[Dict[Text, float], float], step: int):
- """Write metrics to summary with the given writer.
-
- Args:
- metrics: a dictionary of metrics values. Prefer dictionary.
- step: integer. The training step.
- """
- if not isinstance(metrics, dict):
- # Support scalar metric without name.
- logging.warning('Warning: summary writer prefer metrics as dictionary.')
- metrics = {'metric': metrics}
-
- with self.writer.as_default():
- for k, v in metrics.items():
- tf.summary.scalar(k, v, step=step)
- self.writer.flush()
-
-
-class DistributedExecutor(object):
- """Interface to train and eval models with tf.distribute.Strategy.
- """
-
- def __init__(self,
- strategy,
- params,
- model_fn,
- loss_fn,
- is_multi_host=False):
- """Constructor.
-
- Args:
- strategy: an instance of tf.distribute.Strategy.
- params: Model configuration needed to run distribution strategy.
- model_fn: Keras model function. Signature:
- (params: ParamsDict) -> tf.keras.models.Model.
- loss_fn: loss function. Signature:
- (y_true: Tensor, y_pred: Tensor) -> Tensor
- is_multi_host: Set to True when using multi hosts for training, like multi
- worker GPU or TPU pod (slice). Otherwise, False.
- """
-
- self._params = params
- self._model_fn = model_fn
- self._loss_fn = loss_fn
- self._strategy = strategy
- self._checkpoint_name = 'ctl_step_{step}.ckpt'
- self._is_multi_host = is_multi_host
- self.train_summary_writer = None
- self.eval_summary_writer = None
- self.global_train_step = None
-
- @property
- def checkpoint_name(self):
- """Returns default checkpoint name."""
- return self._checkpoint_name
-
- @checkpoint_name.setter
- def checkpoint_name(self, name):
- """Sets default summary writer for the current thread."""
- self._checkpoint_name = name
-
- def loss_fn(self):
- return self._loss_fn()
-
- def model_fn(self, params):
- return self._model_fn(params)
-
- def _save_config(self, model_dir):
- """Save parameters to config files if model_dir is defined."""
-
- logging.info('Save config to model_dir %s.', model_dir)
- if model_dir:
- if not tf.io.gfile.exists(model_dir):
- tf.io.gfile.makedirs(model_dir)
- self._params.lock()
- params_dict.save_params_dict_to_yaml(self._params,
- model_dir + '/params.yaml')
- else:
- logging.warning('model_dir is empty, so skip the save config.')
-
- def _get_input_iterator(
- self, input_fn: Callable[..., tf.data.Dataset],
- strategy: tf.distribute.Strategy) -> Optional[Iterator[Any]]:
- """Returns distributed dataset iterator.
-
- Args:
- input_fn: (params: dict) -> tf.data.Dataset.
- strategy: an instance of tf.distribute.Strategy.
-
- Returns:
- An iterator that yields input tensors.
- """
-
- if input_fn is None:
- return None
- # When training with multiple TPU workers, datasets needs to be cloned
- # across workers. Since Dataset instance cannot be cloned in eager mode,
- # we instead pass callable that returns a dataset.
- if self._is_multi_host:
- return iter(
- strategy.experimental_distribute_datasets_from_function(input_fn))
- else:
- input_data = input_fn()
- return iter(strategy.experimental_distribute_dataset(input_data))
-
- def _create_replicated_step(self,
- strategy,
- model,
- loss_fn,
- optimizer,
- metric=None):
- """Creates a single training step.
-
- Args:
- strategy: an instance of tf.distribute.Strategy.
- model: (Tensor, bool) -> Tensor. model function.
- loss_fn: (y_true: Tensor, y_pred: Tensor) -> Tensor.
- optimizer: tf.keras.optimizers.Optimizer.
- metric: tf.keras.metrics.Metric subclass.
-
- Returns:
- The training step callable.
- """
- metrics = metrics_as_dict(metric)
-
- def _replicated_step(inputs):
- """Replicated training step."""
- inputs, labels = inputs
-
- with tf.GradientTape() as tape:
- outputs = model(inputs, training=True)
- prediction_loss = loss_fn(labels, outputs)
- loss = tf.reduce_mean(prediction_loss)
- loss = loss / strategy.num_replicas_in_sync
- for m in metrics.values():
- m.update_state(labels, outputs)
-
- grads = tape.gradient(loss, model.trainable_variables)
- optimizer.apply_gradients(zip(grads, model.trainable_variables))
- return loss
-
- return _replicated_step
-
- def _create_train_step(self,
- strategy,
- model,
- loss_fn,
- optimizer,
- metric=None):
- """Creates a distributed training step.
-
- Args:
- strategy: an instance of tf.distribute.Strategy.
- model: (Tensor, bool) -> Tensor. model function.
- loss_fn: (y_true: Tensor, y_pred: Tensor) -> Tensor.
- optimizer: tf.keras.optimizers.Optimizer.
- metric: tf.keras.metrics.Metric subclass.
-
- Returns:
- The training step callable.
- """
- replicated_step = self._create_replicated_step(strategy, model, loss_fn,
- optimizer, metric)
-
- @tf.function
- def train_step(iterator, num_steps):
- """Performs a distributed training step.
-
- Args:
- iterator: an iterator that yields input tensors.
- num_steps: the number of steps in the loop.
-
- Returns:
- The loss tensor.
- """
- if not isinstance(num_steps, tf.Tensor):
- raise ValueError('steps should be an Tensor. Python object may cause '
- 'retracing.')
-
- per_replica_losses = strategy.run(
- replicated_step, args=(next(iterator),))
- for _ in tf.range(num_steps - 1):
- per_replica_losses = strategy.run(
- replicated_step, args=(next(iterator),))
-
- # For reporting, we returns the mean of losses.
- losses = tf.nest.map_structure(
- lambda x: strategy.reduce(tf.distribute.ReduceOp.MEAN, x, axis=None),
- per_replica_losses)
- return losses
-
- return train_step
-
- def _create_test_step(self, strategy, model, metric):
- """Creates a distributed test step."""
- metrics = metrics_as_dict(metric)
-
- @tf.function
- def test_step(iterator):
- """Calculates evaluation metrics on distributed devices."""
- if not metric:
- logging.info('Skip test_step because metric is None (%s)', metric)
- return None, None
-
- def _test_step_fn(inputs):
- """Replicated accuracy calculation."""
- inputs, labels = inputs
- model_outputs = model(inputs, training=False)
- for m in metrics.values():
- m.update_state(labels, model_outputs)
- return labels, model_outputs
-
- return strategy.run(_test_step_fn, args=(next(iterator),))
-
- return test_step
-
- def train(self,
- train_input_fn: Callable[[params_dict.ParamsDict], tf.data.Dataset],
- eval_input_fn: Callable[[params_dict.ParamsDict],
- tf.data.Dataset] = None,
- model_dir: Text = None,
- total_steps: int = 1,
- iterations_per_loop: int = 1,
- train_metric_fn: Callable[[], Any] = None,
- eval_metric_fn: Callable[[], Any] = None,
- summary_writer_fn: Callable[[Text, Text],
- SummaryWriter] = SummaryWriter,
- init_checkpoint: Callable[[tf.keras.Model], Any] = None,
- custom_callbacks: List[tf.keras.callbacks.Callback] = None,
- continuous_eval: bool = False,
- save_config: bool = True):
- """Runs distributed training.
-
- Args:
- train_input_fn: (params: dict) -> tf.data.Dataset training data input
- function.
- eval_input_fn: (Optional) same type as train_input_fn. If not None, will
- trigger evaluting metric on eval data. If None, will not run eval step.
- model_dir: the folder path for model checkpoints.
- total_steps: total training steps.
- iterations_per_loop: train steps per loop. After each loop, this job will
- update metrics like loss and save checkpoint.
- train_metric_fn: metric_fn for evaluation in train_step.
- eval_metric_fn: metric_fn for evaluation in test_step.
- summary_writer_fn: function to create summary writer.
- init_checkpoint: function to load checkpoint.
- custom_callbacks: A list of Keras Callbacks objects to run during
- training. More specifically, `on_batch_begin()`, `on_batch_end()`,
- methods are invoked during training.
- continuous_eval: If `True`, will continously run evaluation on every
- available checkpoints. If `False`, will do the evaluation once after the
- final step.
- save_config: bool. Whether to save params to model_dir.
- Returns:
- The training loss and eval metrics.
- """
- assert train_input_fn is not None
- if train_metric_fn and not callable(train_metric_fn):
- raise ValueError('if `train_metric_fn` is specified, '
- 'train_metric_fn must be a callable.')
- if eval_metric_fn and not callable(eval_metric_fn):
- raise ValueError('if `eval_metric_fn` is specified, '
- 'eval_metric_fn must be a callable.')
- train_metric_fn = train_metric_fn or _no_metric
- eval_metric_fn = eval_metric_fn or _no_metric
-
- if custom_callbacks and iterations_per_loop != 1:
- logging.warning(
- 'It is sematically wrong to run callbacks when '
- 'iterations_per_loop is not one (%s)', iterations_per_loop)
-
- custom_callbacks = custom_callbacks or []
-
- def _run_callbacks_on_batch_begin(batch):
- """Runs custom callbacks at the start of every step."""
- if not custom_callbacks:
- return
- for callback in custom_callbacks:
- if callback:
- callback.on_batch_begin(batch)
-
- def _run_callbacks_on_batch_end(batch):
- """Runs custom callbacks at the end of every step."""
- if not custom_callbacks:
- return
- for callback in custom_callbacks:
- if callback:
- callback.on_batch_end(batch)
-
- if save_config:
- self._save_config(model_dir)
-
- if FLAGS.save_checkpoint_freq:
- save_freq = FLAGS.save_checkpoint_freq
- else:
- save_freq = iterations_per_loop
-
- params = self._params
- strategy = self._strategy
- # To reduce unnecessary send/receive input pipeline operation, we place
- # input pipeline ops in worker task.
- train_iterator = self._get_input_iterator(train_input_fn, strategy)
- train_loss = None
- train_metric_result = None
- eval_metric_result = None
- tf.keras.backend.set_learning_phase(1)
- with strategy.scope():
- # To correctly place the model weights on accelerators,
- # model and optimizer should be created in scope.
- model = self.model_fn(params.as_dict())
- if not hasattr(model, 'optimizer'):
- raise ValueError('User should set optimizer attribute to model '
- 'inside `model_fn`.')
- optimizer = model.optimizer
-
- # Training loop starts here.
- checkpoint = tf.train.Checkpoint(model=model, optimizer=optimizer)
- latest_checkpoint_file = tf.train.latest_checkpoint(model_dir)
- initial_step = 0
- if latest_checkpoint_file:
- logging.info(
- 'Checkpoint file %s found and restoring from '
- 'checkpoint', latest_checkpoint_file)
- checkpoint.restore(latest_checkpoint_file)
- initial_step = optimizer.iterations.numpy()
- logging.info('Loading from checkpoint file completed. Init step %d',
- initial_step)
- elif init_checkpoint:
- logging.info('Restoring from init checkpoint function')
- init_checkpoint(model)
- logging.info('Loading from init checkpoint file completed')
-
- current_step = optimizer.iterations.numpy()
- checkpoint_name = self.checkpoint_name
-
- eval_metric = eval_metric_fn()
- train_metric = train_metric_fn()
- train_summary_writer = summary_writer_fn(model_dir, 'eval_train')
- self.train_summary_writer = train_summary_writer.writer
-
- test_summary_writer = summary_writer_fn(model_dir, 'eval_test')
- self.eval_summary_writer = test_summary_writer.writer
-
- # Use training summary writer in TimeHistory if it's in use
- for cb in custom_callbacks:
- if isinstance(cb, keras_utils.TimeHistory):
- cb.summary_writer = self.train_summary_writer
-
- # Continue training loop.
- train_step = self._create_train_step(
- strategy=strategy,
- model=model,
- loss_fn=self.loss_fn(),
- optimizer=optimizer,
- metric=train_metric)
- test_step = None
- if eval_input_fn and eval_metric:
- self.global_train_step = model.optimizer.iterations
- test_step = self._create_test_step(strategy, model, metric=eval_metric)
-
- # Step-0 operations
- if current_step == 0 and not latest_checkpoint_file:
- _save_checkpoint(
- checkpoint, model_dir, checkpoint_name.format(step=current_step))
- if test_step:
- eval_iterator = self._get_input_iterator(eval_input_fn, strategy)
- eval_metric_result = self._run_evaluation(
- test_step, current_step, eval_metric, eval_iterator)
- logging.info(
- 'Step: %s evalation metric = %s.', current_step, eval_metric_result)
- test_summary_writer(
- metrics=eval_metric_result, step=optimizer.iterations)
- reset_states(eval_metric)
-
- logging.info('Training started')
- last_save_checkpoint_step = current_step
- while current_step < total_steps:
-
- num_steps = _steps_to_run(current_step, total_steps, iterations_per_loop)
- _run_callbacks_on_batch_begin(current_step)
- train_loss = train_step(train_iterator,
- tf.convert_to_tensor(num_steps, dtype=tf.int32))
- current_step += num_steps
-
- train_loss = tf.nest.map_structure(lambda x: x.numpy().astype(float),
- train_loss)
-
- _run_callbacks_on_batch_end(current_step - 1)
- if not isinstance(train_loss, dict):
- train_loss = {'total_loss': train_loss}
- if np.isnan(train_loss['total_loss']):
- raise ValueError('total loss is NaN.')
-
- if train_metric:
- train_metric_result = metric_results(train_metric)
- train_metric_result.update(train_loss)
- else:
- train_metric_result = train_loss
- if callable(optimizer.lr):
- train_metric_result.update(
- {'learning_rate': optimizer.lr(current_step).numpy()})
- else:
- train_metric_result.update({'learning_rate': optimizer.lr.numpy()})
- logging.info('Train Step: %d/%d / loss = %s / training metric = %s',
- current_step, total_steps, train_loss,
- train_metric_result)
-
- train_summary_writer(
- metrics=train_metric_result, step=optimizer.iterations)
-
- # Saves model checkpoints and run validation steps at every
- # iterations_per_loop steps.
- # To avoid repeated model saving, we do not save after the last
- # step of training.
- if save_freq > 0 and current_step < total_steps and (
- current_step - last_save_checkpoint_step) >= save_freq:
- _save_checkpoint(checkpoint, model_dir,
- checkpoint_name.format(step=current_step))
- last_save_checkpoint_step = current_step
-
- if continuous_eval and current_step < total_steps and test_step:
- eval_iterator = self._get_input_iterator(eval_input_fn, strategy)
- eval_metric_result = self._run_evaluation(test_step, current_step,
- eval_metric, eval_iterator)
- logging.info('Step: %s evalation metric = %s.', current_step,
- eval_metric_result)
- test_summary_writer(
- metrics=eval_metric_result, step=optimizer.iterations)
-
- # Re-initialize evaluation metric, except the last step.
- if eval_metric and current_step < total_steps:
- reset_states(eval_metric)
- if train_metric and current_step < total_steps:
- reset_states(train_metric)
-
- # Reaches the end of training and saves the last checkpoint.
- if last_save_checkpoint_step < total_steps:
- _save_checkpoint(checkpoint, model_dir,
- checkpoint_name.format(step=current_step))
-
- if test_step:
- logging.info('Running final evaluation after training is complete.')
- eval_iterator = self._get_input_iterator(eval_input_fn, strategy)
- eval_metric_result = self._run_evaluation(test_step, current_step,
- eval_metric, eval_iterator)
- logging.info('Final evaluation metric = %s.', eval_metric_result)
- test_summary_writer(
- metrics=eval_metric_result, step=optimizer.iterations)
-
- self.train_summary_writer.close()
- self.eval_summary_writer.close()
-
- return train_metric_result, eval_metric_result
-
- def _run_evaluation(self, test_step, current_training_step, metric,
- test_iterator):
- """Runs validation steps and aggregate metrics."""
- if not test_iterator or not metric:
- logging.warning(
- 'Both test_iterator (%s) and metrics (%s) must not be None.',
- test_iterator, metric)
- return None
- logging.info('Running evaluation after step: %s.', current_training_step)
- eval_step = 0
- while True:
- try:
- with tf.experimental.async_scope():
- test_step(test_iterator)
- eval_step += 1
- except (StopIteration, tf.errors.OutOfRangeError):
- tf.experimental.async_clear_error()
- break
-
- metric_result = metric_results(metric)
- logging.info('Total eval steps: [%d]', eval_step)
- logging.info('At training step: [%r] Validation metric = %r',
- current_training_step, metric_result)
- return metric_result
-
- def evaluate_from_model_dir(
- self,
- model_dir: Text,
- eval_input_fn: Callable[[params_dict.ParamsDict], tf.data.Dataset],
- eval_metric_fn: Callable[[], Any],
- total_steps: int = -1,
- eval_timeout: int = None,
- min_eval_interval: int = 180,
- summary_writer_fn: Callable[[Text, Text], SummaryWriter] = SummaryWriter):
- """Runs distributed evaluation on model folder.
-
- Args:
- model_dir: the folder for storing model checkpoints.
- eval_input_fn: (Optional) same type as train_input_fn. If not None, will
- trigger evaluting metric on eval data. If None, will not run eval step.
- eval_metric_fn: metric_fn for evaluation in test_step.
- total_steps: total training steps. If the current step reaches the
- total_steps, the evaluation loop will stop.
- eval_timeout: The maximum number of seconds to wait between checkpoints.
- If left as None, then the process will wait indefinitely. Used by
- tf.train.checkpoints_iterator.
- min_eval_interval: The minimum number of seconds between yielding
- checkpoints. Used by tf.train.checkpoints_iterator.
- summary_writer_fn: function to create summary writer.
-
- Returns:
- Eval metrics dictionary of the last checkpoint.
- """
-
- if not model_dir:
- raise ValueError('model_dir must be set.')
-
- def terminate_eval():
- tf.logging.info('Terminating eval after %d seconds of no checkpoints' %
- eval_timeout)
- return True
-
- summary_writer = summary_writer_fn(model_dir, 'eval')
- self.eval_summary_writer = summary_writer.writer
-
- # Read checkpoints from the given model directory
- # until `eval_timeout` seconds elapses.
- for checkpoint_path in tf.train.checkpoints_iterator(
- model_dir,
- min_interval_secs=min_eval_interval,
- timeout=eval_timeout,
- timeout_fn=terminate_eval):
- eval_metric_result, current_step = self.evaluate_checkpoint(
- checkpoint_path=checkpoint_path,
- eval_input_fn=eval_input_fn,
- eval_metric_fn=eval_metric_fn,
- summary_writer=summary_writer)
- if total_steps > 0 and current_step >= total_steps:
- logging.info('Evaluation finished after training step %d', current_step)
- break
- return eval_metric_result
-
- def evaluate_checkpoint(self,
- checkpoint_path: Text,
- eval_input_fn: Callable[[params_dict.ParamsDict],
- tf.data.Dataset],
- eval_metric_fn: Callable[[], Any],
- summary_writer: SummaryWriter = None):
- """Runs distributed evaluation on the one checkpoint.
-
- Args:
- checkpoint_path: the checkpoint to evaluate.
- eval_input_fn: (Optional) same type as train_input_fn. If not None, will
- trigger evaluting metric on eval data. If None, will not run eval step.
- eval_metric_fn: metric_fn for evaluation in test_step.
- summary_writer: function to create summary writer.
-
- Returns:
- Eval metrics dictionary of the last checkpoint.
- """
- if not callable(eval_metric_fn):
- raise ValueError('if `eval_metric_fn` is specified, '
- 'eval_metric_fn must be a callable.')
-
- old_phrase = tf.keras.backend.learning_phase()
- tf.keras.backend.set_learning_phase(0)
- params = self._params
- strategy = self._strategy
- # To reduce unnecessary send/receive input pipeline operation, we place
- # input pipeline ops in worker task.
- with strategy.scope():
-
- # To correctly place the model weights on accelerators,
- # model and optimizer should be created in scope.
- model = self.model_fn(params.as_dict())
- checkpoint = tf.train.Checkpoint(model=model)
-
- eval_metric = eval_metric_fn()
- assert eval_metric, 'eval_metric does not exist'
- test_step = self._create_test_step(strategy, model, metric=eval_metric)
-
- logging.info('Starting to evaluate.')
- if not checkpoint_path:
- raise ValueError('checkpoint path is empty')
- reader = tf.compat.v1.train.NewCheckpointReader(checkpoint_path)
- current_step = reader.get_tensor(
- 'optimizer/iter/.ATTRIBUTES/VARIABLE_VALUE')
- logging.info(
- 'Checkpoint file %s found and restoring from '
- 'checkpoint', checkpoint_path)
- checkpoint.restore(checkpoint_path)
-
- self.global_train_step = model.optimizer.iterations
- eval_iterator = self._get_input_iterator(eval_input_fn, strategy)
- eval_metric_result = self._run_evaluation(test_step, current_step,
- eval_metric, eval_iterator)
- logging.info('Step: %s evalation metric = %s.', current_step,
- eval_metric_result)
- summary_writer(metrics=eval_metric_result, step=current_step)
- reset_states(eval_metric)
-
- tf.keras.backend.set_learning_phase(old_phrase)
- return eval_metric_result, current_step
-
- def predict(self):
- return NotImplementedError('Unimplmented function.')
-
-
-class ExecutorBuilder(object):
- """Builder of DistributedExecutor.
-
- Example 1: Builds an executor with supported Strategy.
- builder = ExecutorBuilder(
- strategy_type='tpu',
- strategy_config={'tpu': '/bns/xxx'})
- dist_executor = builder.build_executor(
- params=params,
- model_fn=my_model_fn,
- loss_fn=my_loss_fn,
- metric_fn=my_metric_fn)
-
- Example 2: Builds an executor with customized Strategy.
- builder = ExecutorBuilder()
- builder.strategy =
- dist_executor = builder.build_executor(
- params=params,
- model_fn=my_model_fn,
- loss_fn=my_loss_fn,
- metric_fn=my_metric_fn)
-
- Example 3: Builds a customized executor with customized Strategy.
- class MyDistributedExecutor(DistributedExecutor):
- # implementation ...
-
- builder = ExecutorBuilder()
- builder.strategy =
- dist_executor = builder.build_executor(
- class_ctor=MyDistributedExecutor,
- params=params,
- model_fn=my_model_fn,
- loss_fn=my_loss_fn,
- metric_fn=my_metric_fn)
- """
-
- def __init__(self, strategy_type=None, strategy_config=None):
- _ = distribution_utils.configure_cluster(
- strategy_config.worker_hosts, strategy_config.task_index)
- """Constructor.
-
- Args:
- strategy_type: string. One of 'tpu', 'mirrored', 'multi_worker_mirrored'.
- If None. User is responsible to set the strategy before calling
- build_executor(...).
- strategy_config: necessary config for constructing the proper Strategy.
- Check strategy_flags_dict() for examples of the structure.
- """
- self._strategy = distribution_utils.get_distribution_strategy(
- distribution_strategy=strategy_type,
- num_gpus=strategy_config.num_gpus,
- all_reduce_alg=strategy_config.all_reduce_alg,
- num_packs=strategy_config.num_packs,
- tpu_address=strategy_config.tpu)
-
- @property
- def strategy(self):
- """Returns default checkpoint name."""
- return self._strategy
-
- @strategy.setter
- def strategy(self, new_strategy):
- """Sets default summary writer for the current thread."""
- self._strategy = new_strategy
-
- def build_executor(self,
- class_ctor=DistributedExecutor,
- params=None,
- model_fn=None,
- loss_fn=None,
- **kwargs):
- """Creates an executor according to strategy type.
-
- See doc string of the DistributedExecutor.__init__ for more information of
- the
- input arguments.
-
- Args:
- class_ctor: A constructor of executor (default: DistributedExecutor).
- params: ParamsDict, all the model parameters and runtime parameters.
- model_fn: Keras model function.
- loss_fn: loss function.
- **kwargs: other arguments to the executor constructor.
-
- Returns:
- An instance of DistributedExecutor or its subclass.
- """
- if self._strategy is None:
- raise ValueError('`strategy` should not be None. You need to specify '
- '`strategy_type` in the builder contructor or directly '
- 'set the `strategy` property of the builder.')
- return class_ctor(
- strategy=self._strategy,
- params=params,
- model_fn=model_fn,
- loss_fn=loss_fn,
- **kwargs)
diff --git a/spaces/NCTCMumbai/NCTC/models/official/nlp/data/squad_lib_sp.py b/spaces/NCTCMumbai/NCTC/models/official/nlp/data/squad_lib_sp.py
deleted file mode 100644
index c65f713fd09bc4858f77f8ce823b17467606271c..0000000000000000000000000000000000000000
--- a/spaces/NCTCMumbai/NCTC/models/official/nlp/data/squad_lib_sp.py
+++ /dev/null
@@ -1,892 +0,0 @@
-# Copyright 2019 The TensorFlow Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ==============================================================================
-"""Run ALBERT on SQuAD 1.1 and SQuAD 2.0 using sentence piece tokenization.
-
-The file is forked from:
-
-https://github.com/google-research/ALBERT/blob/master/run_squad_sp.py
-"""
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import collections
-import copy
-import json
-import math
-import os
-from absl import logging
-import numpy as np
-import tensorflow as tf
-
-from official.nlp.bert import tokenization
-
-
-class SquadExample(object):
- """A single training/test example for simple sequence classification.
-
- For examples without an answer, the start and end position are -1.
- """
-
- def __init__(self,
- qas_id,
- question_text,
- paragraph_text,
- orig_answer_text=None,
- start_position=None,
- end_position=None,
- is_impossible=False):
- self.qas_id = qas_id
- self.question_text = question_text
- self.paragraph_text = paragraph_text
- self.orig_answer_text = orig_answer_text
- self.start_position = start_position
- self.end_position = end_position
- self.is_impossible = is_impossible
-
- def __str__(self):
- return self.__repr__()
-
- def __repr__(self):
- s = ""
- s += "qas_id: %s" % (tokenization.printable_text(self.qas_id))
- s += ", question_text: %s" % (
- tokenization.printable_text(self.question_text))
- s += ", paragraph_text: [%s]" % (" ".join(self.paragraph_text))
- if self.start_position:
- s += ", start_position: %d" % (self.start_position)
- if self.start_position:
- s += ", end_position: %d" % (self.end_position)
- if self.start_position:
- s += ", is_impossible: %r" % (self.is_impossible)
- return s
-
-
-class InputFeatures(object):
- """A single set of features of data."""
-
- def __init__(self,
- unique_id,
- example_index,
- doc_span_index,
- tok_start_to_orig_index,
- tok_end_to_orig_index,
- token_is_max_context,
- tokens,
- input_ids,
- input_mask,
- segment_ids,
- paragraph_len,
- start_position=None,
- end_position=None,
- is_impossible=None):
- self.unique_id = unique_id
- self.example_index = example_index
- self.doc_span_index = doc_span_index
- self.tok_start_to_orig_index = tok_start_to_orig_index
- self.tok_end_to_orig_index = tok_end_to_orig_index
- self.token_is_max_context = token_is_max_context
- self.tokens = tokens
- self.input_ids = input_ids
- self.input_mask = input_mask
- self.segment_ids = segment_ids
- self.paragraph_len = paragraph_len
- self.start_position = start_position
- self.end_position = end_position
- self.is_impossible = is_impossible
-
-
-def read_squad_examples(input_file, is_training, version_2_with_negative):
- """Read a SQuAD json file into a list of SquadExample."""
- del version_2_with_negative
- with tf.io.gfile.GFile(input_file, "r") as reader:
- input_data = json.load(reader)["data"]
-
- examples = []
- for entry in input_data:
- for paragraph in entry["paragraphs"]:
- paragraph_text = paragraph["context"]
-
- for qa in paragraph["qas"]:
- qas_id = qa["id"]
- question_text = qa["question"]
- start_position = None
- orig_answer_text = None
- is_impossible = False
-
- if is_training:
- is_impossible = qa.get("is_impossible", False)
- if (len(qa["answers"]) != 1) and (not is_impossible):
- raise ValueError(
- "For training, each question should have exactly 1 answer.")
- if not is_impossible:
- answer = qa["answers"][0]
- orig_answer_text = answer["text"]
- start_position = answer["answer_start"]
- else:
- start_position = -1
- orig_answer_text = ""
-
- example = SquadExample(
- qas_id=qas_id,
- question_text=question_text,
- paragraph_text=paragraph_text,
- orig_answer_text=orig_answer_text,
- start_position=start_position,
- is_impossible=is_impossible)
- examples.append(example)
-
- return examples
-
-
-def _convert_index(index, pos, m=None, is_start=True):
- """Converts index."""
- if index[pos] is not None:
- return index[pos]
- n = len(index)
- rear = pos
- while rear < n - 1 and index[rear] is None:
- rear += 1
- front = pos
- while front > 0 and index[front] is None:
- front -= 1
- assert index[front] is not None or index[rear] is not None
- if index[front] is None:
- if index[rear] >= 1:
- if is_start:
- return 0
- else:
- return index[rear] - 1
- return index[rear]
- if index[rear] is None:
- if m is not None and index[front] < m - 1:
- if is_start:
- return index[front] + 1
- else:
- return m - 1
- return index[front]
- if is_start:
- if index[rear] > index[front] + 1:
- return index[front] + 1
- else:
- return index[rear]
- else:
- if index[rear] > index[front] + 1:
- return index[rear] - 1
- else:
- return index[front]
-
-
-def convert_examples_to_features(examples,
- tokenizer,
- max_seq_length,
- doc_stride,
- max_query_length,
- is_training,
- output_fn,
- do_lower_case,
- batch_size=None):
- """Loads a data file into a list of `InputBatch`s."""
- cnt_pos, cnt_neg = 0, 0
- base_id = 1000000000
- unique_id = base_id
- max_n, max_m = 1024, 1024
- f = np.zeros((max_n, max_m), dtype=np.float32)
-
- for (example_index, example) in enumerate(examples):
-
- if example_index % 100 == 0:
- logging.info("Converting %d/%d pos %d neg %d", example_index,
- len(examples), cnt_pos, cnt_neg)
-
- query_tokens = tokenization.encode_ids(
- tokenizer.sp_model,
- tokenization.preprocess_text(
- example.question_text, lower=do_lower_case))
-
- if len(query_tokens) > max_query_length:
- query_tokens = query_tokens[0:max_query_length]
-
- paragraph_text = example.paragraph_text
- para_tokens = tokenization.encode_pieces(
- tokenizer.sp_model,
- tokenization.preprocess_text(
- example.paragraph_text, lower=do_lower_case))
-
- chartok_to_tok_index = []
- tok_start_to_chartok_index = []
- tok_end_to_chartok_index = []
- char_cnt = 0
- for i, token in enumerate(para_tokens):
- new_token = token.replace(tokenization.SPIECE_UNDERLINE, " ")
- chartok_to_tok_index.extend([i] * len(new_token))
- tok_start_to_chartok_index.append(char_cnt)
- char_cnt += len(new_token)
- tok_end_to_chartok_index.append(char_cnt - 1)
-
- tok_cat_text = "".join(para_tokens).replace(tokenization.SPIECE_UNDERLINE,
- " ")
- n, m = len(paragraph_text), len(tok_cat_text)
-
- if n > max_n or m > max_m:
- max_n = max(n, max_n)
- max_m = max(m, max_m)
- f = np.zeros((max_n, max_m), dtype=np.float32)
-
- g = {}
- # pylint: disable=cell-var-from-loop
- def _lcs_match(max_dist, n=n, m=m):
- """Longest-common-substring algorithm."""
- f.fill(0)
- g.clear()
-
- ### longest common sub sequence
- # f[i, j] = max(f[i - 1, j], f[i, j - 1], f[i - 1, j - 1] + match(i, j))
- for i in range(n):
-
- # unlike standard LCS, this is specifically optimized for the setting
- # because the mismatch between sentence pieces and original text will
- # be small
- for j in range(i - max_dist, i + max_dist):
- if j >= m or j < 0:
- continue
-
- if i > 0:
- g[(i, j)] = 0
- f[i, j] = f[i - 1, j]
-
- if j > 0 and f[i, j - 1] > f[i, j]:
- g[(i, j)] = 1
- f[i, j] = f[i, j - 1]
-
- f_prev = f[i - 1, j - 1] if i > 0 and j > 0 else 0
- if (tokenization.preprocess_text(
- paragraph_text[i], lower=do_lower_case,
- remove_space=False) == tok_cat_text[j] and f_prev + 1 > f[i, j]):
- g[(i, j)] = 2
- f[i, j] = f_prev + 1
- # pylint: enable=cell-var-from-loop
-
- max_dist = abs(n - m) + 5
- for _ in range(2):
- _lcs_match(max_dist)
- if f[n - 1, m - 1] > 0.8 * n:
- break
- max_dist *= 2
-
- orig_to_chartok_index = [None] * n
- chartok_to_orig_index = [None] * m
- i, j = n - 1, m - 1
- while i >= 0 and j >= 0:
- if (i, j) not in g:
- break
- if g[(i, j)] == 2:
- orig_to_chartok_index[i] = j
- chartok_to_orig_index[j] = i
- i, j = i - 1, j - 1
- elif g[(i, j)] == 1:
- j = j - 1
- else:
- i = i - 1
-
- if (all(v is None for v in orig_to_chartok_index) or
- f[n - 1, m - 1] < 0.8 * n):
- logging.info("MISMATCH DETECTED!")
- continue
-
- tok_start_to_orig_index = []
- tok_end_to_orig_index = []
- for i in range(len(para_tokens)):
- start_chartok_pos = tok_start_to_chartok_index[i]
- end_chartok_pos = tok_end_to_chartok_index[i]
- start_orig_pos = _convert_index(
- chartok_to_orig_index, start_chartok_pos, n, is_start=True)
- end_orig_pos = _convert_index(
- chartok_to_orig_index, end_chartok_pos, n, is_start=False)
-
- tok_start_to_orig_index.append(start_orig_pos)
- tok_end_to_orig_index.append(end_orig_pos)
-
- if not is_training:
- tok_start_position = tok_end_position = None
-
- if is_training and example.is_impossible:
- tok_start_position = 0
- tok_end_position = 0
-
- if is_training and not example.is_impossible:
- start_position = example.start_position
- end_position = start_position + len(example.orig_answer_text) - 1
-
- start_chartok_pos = _convert_index(
- orig_to_chartok_index, start_position, is_start=True)
- tok_start_position = chartok_to_tok_index[start_chartok_pos]
-
- end_chartok_pos = _convert_index(
- orig_to_chartok_index, end_position, is_start=False)
- tok_end_position = chartok_to_tok_index[end_chartok_pos]
- assert tok_start_position <= tok_end_position
-
- def _piece_to_id(x):
- return tokenizer.sp_model.PieceToId(x)
-
- all_doc_tokens = list(map(_piece_to_id, para_tokens))
-
- # The -3 accounts for [CLS], [SEP] and [SEP]
- max_tokens_for_doc = max_seq_length - len(query_tokens) - 3
-
- # We can have documents that are longer than the maximum sequence length.
- # To deal with this we do a sliding window approach, where we take chunks
- # of the up to our max length with a stride of `doc_stride`.
- _DocSpan = collections.namedtuple( # pylint: disable=invalid-name
- "DocSpan", ["start", "length"])
- doc_spans = []
- start_offset = 0
- while start_offset < len(all_doc_tokens):
- length = len(all_doc_tokens) - start_offset
- if length > max_tokens_for_doc:
- length = max_tokens_for_doc
- doc_spans.append(_DocSpan(start=start_offset, length=length))
- if start_offset + length == len(all_doc_tokens):
- break
- start_offset += min(length, doc_stride)
-
- for (doc_span_index, doc_span) in enumerate(doc_spans):
- tokens = []
- token_is_max_context = {}
- segment_ids = []
-
- cur_tok_start_to_orig_index = []
- cur_tok_end_to_orig_index = []
-
- tokens.append(tokenizer.sp_model.PieceToId("[CLS]"))
- segment_ids.append(0)
- for token in query_tokens:
- tokens.append(token)
- segment_ids.append(0)
- tokens.append(tokenizer.sp_model.PieceToId("[SEP]"))
- segment_ids.append(0)
-
- for i in range(doc_span.length):
- split_token_index = doc_span.start + i
-
- cur_tok_start_to_orig_index.append(
- tok_start_to_orig_index[split_token_index])
- cur_tok_end_to_orig_index.append(
- tok_end_to_orig_index[split_token_index])
-
- is_max_context = _check_is_max_context(doc_spans, doc_span_index,
- split_token_index)
- token_is_max_context[len(tokens)] = is_max_context
- tokens.append(all_doc_tokens[split_token_index])
- segment_ids.append(1)
- tokens.append(tokenizer.sp_model.PieceToId("[SEP]"))
- segment_ids.append(1)
-
- paragraph_len = len(tokens)
- input_ids = tokens
-
- # The mask has 1 for real tokens and 0 for padding tokens. Only real
- # tokens are attended to.
- input_mask = [1] * len(input_ids)
-
- # Zero-pad up to the sequence length.
- while len(input_ids) < max_seq_length:
- input_ids.append(0)
- input_mask.append(0)
- segment_ids.append(0)
-
- assert len(input_ids) == max_seq_length
- assert len(input_mask) == max_seq_length
- assert len(segment_ids) == max_seq_length
-
- span_is_impossible = example.is_impossible
- start_position = None
- end_position = None
- if is_training and not span_is_impossible:
- # For training, if our document chunk does not contain an annotation
- # we throw it out, since there is nothing to predict.
- doc_start = doc_span.start
- doc_end = doc_span.start + doc_span.length - 1
- out_of_span = False
- if not (tok_start_position >= doc_start and
- tok_end_position <= doc_end):
- out_of_span = True
- if out_of_span:
- # continue
- start_position = 0
- end_position = 0
- span_is_impossible = True
- else:
- doc_offset = len(query_tokens) + 2
- start_position = tok_start_position - doc_start + doc_offset
- end_position = tok_end_position - doc_start + doc_offset
-
- if is_training and span_is_impossible:
- start_position = 0
- end_position = 0
-
- if example_index < 20:
- logging.info("*** Example ***")
- logging.info("unique_id: %s", (unique_id))
- logging.info("example_index: %s", (example_index))
- logging.info("doc_span_index: %s", (doc_span_index))
- logging.info("tok_start_to_orig_index: %s",
- " ".join([str(x) for x in cur_tok_start_to_orig_index]))
- logging.info("tok_end_to_orig_index: %s",
- " ".join([str(x) for x in cur_tok_end_to_orig_index]))
- logging.info(
- "token_is_max_context: %s", " ".join(
- ["%d:%s" % (x, y) for (x, y) in token_is_max_context.items()]))
- logging.info(
- "input_pieces: %s",
- " ".join([tokenizer.sp_model.IdToPiece(x) for x in tokens]))
- logging.info("input_ids: %s", " ".join([str(x) for x in input_ids]))
- logging.info("input_mask: %s", " ".join([str(x) for x in input_mask]))
- logging.info("segment_ids: %s", " ".join([str(x) for x in segment_ids]))
-
- if is_training and span_is_impossible:
- logging.info("impossible example span")
-
- if is_training and not span_is_impossible:
- pieces = [
- tokenizer.sp_model.IdToPiece(token)
- for token in tokens[start_position:(end_position + 1)]
- ]
- answer_text = tokenizer.sp_model.DecodePieces(pieces)
- logging.info("start_position: %d", (start_position))
- logging.info("end_position: %d", (end_position))
- logging.info("answer: %s", (tokenization.printable_text(answer_text)))
-
- # With multi processing, the example_index is actually the index
- # within the current process therefore we use example_index=None
- # to avoid being used in the future.
- # The current code does not use example_index of training data.
- if is_training:
- feat_example_index = None
- else:
- feat_example_index = example_index
-
- feature = InputFeatures(
- unique_id=unique_id,
- example_index=feat_example_index,
- doc_span_index=doc_span_index,
- tok_start_to_orig_index=cur_tok_start_to_orig_index,
- tok_end_to_orig_index=cur_tok_end_to_orig_index,
- token_is_max_context=token_is_max_context,
- tokens=[tokenizer.sp_model.IdToPiece(x) for x in tokens],
- input_ids=input_ids,
- input_mask=input_mask,
- segment_ids=segment_ids,
- paragraph_len=paragraph_len,
- start_position=start_position,
- end_position=end_position,
- is_impossible=span_is_impossible)
-
- # Run callback
- if is_training:
- output_fn(feature)
- else:
- output_fn(feature, is_padding=False)
-
- unique_id += 1
- if span_is_impossible:
- cnt_neg += 1
- else:
- cnt_pos += 1
-
- if not is_training and feature:
- assert batch_size
- num_padding = 0
- num_examples = unique_id - base_id
- if unique_id % batch_size != 0:
- num_padding = batch_size - (num_examples % batch_size)
- dummy_feature = copy.deepcopy(feature)
- for _ in range(num_padding):
- dummy_feature.unique_id = unique_id
-
- # Run callback
- output_fn(feature, is_padding=True)
- unique_id += 1
-
- logging.info("Total number of instances: %d = pos %d neg %d",
- cnt_pos + cnt_neg, cnt_pos, cnt_neg)
- return unique_id - base_id
-
-
-def _check_is_max_context(doc_spans, cur_span_index, position):
- """Check if this is the 'max context' doc span for the token."""
-
- # Because of the sliding window approach taken to scoring documents, a single
- # token can appear in multiple documents. E.g.
- # Doc: the man went to the store and bought a gallon of milk
- # Span A: the man went to the
- # Span B: to the store and bought
- # Span C: and bought a gallon of
- # ...
- #
- # Now the word 'bought' will have two scores from spans B and C. We only
- # want to consider the score with "maximum context", which we define as
- # the *minimum* of its left and right context (the *sum* of left and
- # right context will always be the same, of course).
- #
- # In the example the maximum context for 'bought' would be span C since
- # it has 1 left context and 3 right context, while span B has 4 left context
- # and 0 right context.
- best_score = None
- best_span_index = None
- for (span_index, doc_span) in enumerate(doc_spans):
- end = doc_span.start + doc_span.length - 1
- if position < doc_span.start:
- continue
- if position > end:
- continue
- num_left_context = position - doc_span.start
- num_right_context = end - position
- score = min(num_left_context, num_right_context) + 0.01 * doc_span.length
- if best_score is None or score > best_score:
- best_score = score
- best_span_index = span_index
-
- return cur_span_index == best_span_index
-
-
-def write_predictions(all_examples,
- all_features,
- all_results,
- n_best_size,
- max_answer_length,
- do_lower_case,
- output_prediction_file,
- output_nbest_file,
- output_null_log_odds_file,
- version_2_with_negative=False,
- null_score_diff_threshold=0.0,
- verbose=False):
- """Write final predictions to the json file and log-odds of null if needed."""
- logging.info("Writing predictions to: %s", (output_prediction_file))
- logging.info("Writing nbest to: %s", (output_nbest_file))
-
- all_predictions, all_nbest_json, scores_diff_json = (
- postprocess_output(all_examples=all_examples,
- all_features=all_features,
- all_results=all_results,
- n_best_size=n_best_size,
- max_answer_length=max_answer_length,
- do_lower_case=do_lower_case,
- version_2_with_negative=version_2_with_negative,
- null_score_diff_threshold=null_score_diff_threshold,
- verbose=verbose))
-
- write_to_json_files(all_predictions, output_prediction_file)
- write_to_json_files(all_nbest_json, output_nbest_file)
- if version_2_with_negative:
- write_to_json_files(scores_diff_json, output_null_log_odds_file)
-
-
-def postprocess_output(all_examples,
- all_features,
- all_results,
- n_best_size,
- max_answer_length,
- do_lower_case,
- version_2_with_negative=False,
- null_score_diff_threshold=0.0,
- verbose=False):
- """Postprocess model output, to form predicton results."""
-
- del do_lower_case, verbose
-
- example_index_to_features = collections.defaultdict(list)
- for feature in all_features:
- example_index_to_features[feature.example_index].append(feature)
-
- unique_id_to_result = {}
- for result in all_results:
- unique_id_to_result[result.unique_id] = result
-
- _PrelimPrediction = collections.namedtuple( # pylint: disable=invalid-name
- "PrelimPrediction",
- ["feature_index", "start_index", "end_index", "start_logit", "end_logit"])
-
- all_predictions = collections.OrderedDict()
- all_nbest_json = collections.OrderedDict()
- scores_diff_json = collections.OrderedDict()
-
- for (example_index, example) in enumerate(all_examples):
- features = example_index_to_features[example_index]
-
- prelim_predictions = []
- # keep track of the minimum score of null start+end of position 0
- score_null = 1000000 # large and positive
- min_null_feature_index = 0 # the paragraph slice with min mull score
- null_start_logit = 0 # the start logit at the slice with min null score
- null_end_logit = 0 # the end logit at the slice with min null score
- for (feature_index, feature) in enumerate(features):
- result = unique_id_to_result[feature.unique_id]
- start_indexes = _get_best_indexes(result.start_logits, n_best_size)
- end_indexes = _get_best_indexes(result.end_logits, n_best_size)
- # if we could have irrelevant answers, get the min score of irrelevant
- if version_2_with_negative:
- feature_null_score = result.start_logits[0] + result.end_logits[0]
- if feature_null_score < score_null:
- score_null = feature_null_score
- min_null_feature_index = feature_index
- null_start_logit = result.start_logits[0]
- null_end_logit = result.end_logits[0]
- for start_index in start_indexes:
- for end_index in end_indexes:
- doc_offset = feature.tokens.index("[SEP]") + 1
- # We could hypothetically create invalid predictions, e.g., predict
- # that the start of the span is in the question. We throw out all
- # invalid predictions.
- if start_index - doc_offset >= len(feature.tok_start_to_orig_index):
- continue
- if end_index - doc_offset >= len(feature.tok_end_to_orig_index):
- continue
- # if start_index not in feature.tok_start_to_orig_index:
- # continue
- # if end_index not in feature.tok_end_to_orig_index:
- # continue
- if not feature.token_is_max_context.get(start_index, False):
- continue
- if end_index < start_index:
- continue
- length = end_index - start_index + 1
- if length > max_answer_length:
- continue
- prelim_predictions.append(
- _PrelimPrediction(
- feature_index=feature_index,
- start_index=start_index - doc_offset,
- end_index=end_index - doc_offset,
- start_logit=result.start_logits[start_index],
- end_logit=result.end_logits[end_index]))
-
- if version_2_with_negative:
- prelim_predictions.append(
- _PrelimPrediction(
- feature_index=min_null_feature_index,
- start_index=-1,
- end_index=-1,
- start_logit=null_start_logit,
- end_logit=null_end_logit))
- prelim_predictions = sorted(
- prelim_predictions,
- key=lambda x: (x.start_logit + x.end_logit),
- reverse=True)
-
- _NbestPrediction = collections.namedtuple( # pylint: disable=invalid-name
- "NbestPrediction", ["text", "start_logit", "end_logit"])
-
- seen_predictions = {}
- nbest = []
- for pred in prelim_predictions:
- if len(nbest) >= n_best_size:
- break
- feature = features[pred.feature_index]
- if pred.start_index >= 0: # this is a non-null prediction
- tok_start_to_orig_index = feature.tok_start_to_orig_index
- tok_end_to_orig_index = feature.tok_end_to_orig_index
- start_orig_pos = tok_start_to_orig_index[pred.start_index]
- end_orig_pos = tok_end_to_orig_index[pred.end_index]
-
- paragraph_text = example.paragraph_text
- final_text = paragraph_text[start_orig_pos:end_orig_pos + 1].strip()
- if final_text in seen_predictions:
- continue
-
- seen_predictions[final_text] = True
- else:
- final_text = ""
- seen_predictions[final_text] = True
-
- nbest.append(
- _NbestPrediction(
- text=final_text,
- start_logit=pred.start_logit,
- end_logit=pred.end_logit))
-
- # if we didn't inlude the empty option in the n-best, inlcude it
- if version_2_with_negative:
- if "" not in seen_predictions:
- nbest.append(
- _NbestPrediction(
- text="", start_logit=null_start_logit,
- end_logit=null_end_logit))
- # In very rare edge cases we could have no valid predictions. So we
- # just create a nonce prediction in this case to avoid failure.
- if not nbest:
- nbest.append(
- _NbestPrediction(text="empty", start_logit=0.0, end_logit=0.0))
-
- assert len(nbest) >= 1
-
- total_scores = []
- best_non_null_entry = None
- for entry in nbest:
- total_scores.append(entry.start_logit + entry.end_logit)
- if not best_non_null_entry:
- if entry.text:
- best_non_null_entry = entry
-
- probs = _compute_softmax(total_scores)
-
- nbest_json = []
- for (i, entry) in enumerate(nbest):
- output = collections.OrderedDict()
- output["text"] = entry.text
- output["probability"] = probs[i]
- output["start_logit"] = entry.start_logit
- output["end_logit"] = entry.end_logit
- nbest_json.append(output)
-
- assert len(nbest_json) >= 1
-
- if not version_2_with_negative:
- all_predictions[example.qas_id] = nbest_json[0]["text"]
- else:
- assert best_non_null_entry is not None
- # predict "" iff the null score - the score of best non-null > threshold
- score_diff = score_null - best_non_null_entry.start_logit - (
- best_non_null_entry.end_logit)
- scores_diff_json[example.qas_id] = score_diff
- if score_diff > null_score_diff_threshold:
- all_predictions[example.qas_id] = ""
- else:
- all_predictions[example.qas_id] = best_non_null_entry.text
-
- all_nbest_json[example.qas_id] = nbest_json
-
- return all_predictions, all_nbest_json, scores_diff_json
-
-
-def write_to_json_files(json_records, json_file):
- with tf.io.gfile.GFile(json_file, "w") as writer:
- writer.write(json.dumps(json_records, indent=4) + "\n")
-
-
-def _get_best_indexes(logits, n_best_size):
- """Get the n-best logits from a list."""
- index_and_score = sorted(enumerate(logits), key=lambda x: x[1], reverse=True)
-
- best_indexes = []
- for i in range(len(index_and_score)):
- if i >= n_best_size:
- break
- best_indexes.append(index_and_score[i][0])
- return best_indexes
-
-
-def _compute_softmax(scores):
- """Compute softmax probability over raw logits."""
- if not scores:
- return []
-
- max_score = None
- for score in scores:
- if max_score is None or score > max_score:
- max_score = score
-
- exp_scores = []
- total_sum = 0.0
- for score in scores:
- x = math.exp(score - max_score)
- exp_scores.append(x)
- total_sum += x
-
- probs = []
- for score in exp_scores:
- probs.append(score / total_sum)
- return probs
-
-
-class FeatureWriter(object):
- """Writes InputFeature to TF example file."""
-
- def __init__(self, filename, is_training):
- self.filename = filename
- self.is_training = is_training
- self.num_features = 0
- tf.io.gfile.makedirs(os.path.dirname(filename))
- self._writer = tf.io.TFRecordWriter(filename)
-
- def process_feature(self, feature):
- """Write a InputFeature to the TFRecordWriter as a tf.train.Example."""
- self.num_features += 1
-
- def create_int_feature(values):
- feature = tf.train.Feature(
- int64_list=tf.train.Int64List(value=list(values)))
- return feature
-
- features = collections.OrderedDict()
- features["unique_ids"] = create_int_feature([feature.unique_id])
- features["input_ids"] = create_int_feature(feature.input_ids)
- features["input_mask"] = create_int_feature(feature.input_mask)
- features["segment_ids"] = create_int_feature(feature.segment_ids)
-
- if self.is_training:
- features["start_positions"] = create_int_feature([feature.start_position])
- features["end_positions"] = create_int_feature([feature.end_position])
- impossible = 0
- if feature.is_impossible:
- impossible = 1
- features["is_impossible"] = create_int_feature([impossible])
-
- tf_example = tf.train.Example(features=tf.train.Features(feature=features))
- self._writer.write(tf_example.SerializeToString())
-
- def close(self):
- self._writer.close()
-
-
-def generate_tf_record_from_json_file(input_file_path,
- sp_model_file,
- output_path,
- max_seq_length=384,
- do_lower_case=True,
- max_query_length=64,
- doc_stride=128,
- version_2_with_negative=False):
- """Generates and saves training data into a tf record file."""
- train_examples = read_squad_examples(
- input_file=input_file_path,
- is_training=True,
- version_2_with_negative=version_2_with_negative)
- tokenizer = tokenization.FullSentencePieceTokenizer(
- sp_model_file=sp_model_file)
- train_writer = FeatureWriter(filename=output_path, is_training=True)
- number_of_examples = convert_examples_to_features(
- examples=train_examples,
- tokenizer=tokenizer,
- max_seq_length=max_seq_length,
- doc_stride=doc_stride,
- max_query_length=max_query_length,
- is_training=True,
- output_fn=train_writer.process_feature,
- do_lower_case=do_lower_case)
- train_writer.close()
-
- meta_data = {
- "task_type": "bert_squad",
- "train_data_size": number_of_examples,
- "max_seq_length": max_seq_length,
- "max_query_length": max_query_length,
- "doc_stride": doc_stride,
- "version_2_with_negative": version_2_with_negative,
- }
-
- return meta_data
diff --git a/spaces/NCTCMumbai/NCTC/models/official/vision/detection/evaluation/factory.py b/spaces/NCTCMumbai/NCTC/models/official/vision/detection/evaluation/factory.py
deleted file mode 100644
index 4d44bf177071a97b663b41410a05d59d59f04456..0000000000000000000000000000000000000000
--- a/spaces/NCTCMumbai/NCTC/models/official/vision/detection/evaluation/factory.py
+++ /dev/null
@@ -1,40 +0,0 @@
-# Copyright 2019 The TensorFlow Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ==============================================================================
-"""Evaluator factory."""
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-from official.vision.detection.evaluation import coco_evaluator
-
-
-def evaluator_generator(params):
- """Generator function for various evaluators."""
- if params.type == 'box':
- evaluator = coco_evaluator.COCOEvaluator(
- annotation_file=params.val_json_file, include_mask=False)
- elif params.type == 'box_and_mask':
- evaluator = coco_evaluator.COCOEvaluator(
- annotation_file=params.val_json_file, include_mask=True)
- elif params.type == 'shapemask_box_and_mask':
- evaluator = coco_evaluator.ShapeMaskCOCOEvaluator(
- mask_eval_class=params.mask_eval_class,
- annotation_file=params.val_json_file, include_mask=True)
-
- else:
- raise ValueError('Evaluator %s is not supported.' % params.type)
-
- return coco_evaluator.MetricWrapper(evaluator)
diff --git a/spaces/Nee001/bing0/src/components/learn-more.tsx b/spaces/Nee001/bing0/src/components/learn-more.tsx
deleted file mode 100644
index a64459ee7900a612292e117a6bda96ee9260990f..0000000000000000000000000000000000000000
--- a/spaces/Nee001/bing0/src/components/learn-more.tsx
+++ /dev/null
@@ -1,39 +0,0 @@
-import React from 'react'
-import { SourceAttribution } from '@/lib/bots/bing/types'
-
-export interface LearnMoreProps {
- sourceAttributions?: SourceAttribution[]
-}
-
-export function LearnMore({ sourceAttributions }: LearnMoreProps) {
- if (!sourceAttributions?.length) {
- return null
- }
-
- return (
-
- )
-}
diff --git a/spaces/NeuralInternet/ChatLLMs/README.md b/spaces/NeuralInternet/ChatLLMs/README.md
deleted file mode 100644
index cf3e82ee1bc7b2bcb723a51a79d3f886431df910..0000000000000000000000000000000000000000
--- a/spaces/NeuralInternet/ChatLLMs/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: ChatLLMs
-emoji: 📊
-colorFrom: blue
-colorTo: gray
-sdk: gradio
-sdk_version: 3.20.1
-app_file: app.py
-pinned: false
-duplicated_from: olivierdehaene/chat-llm-streaming
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/examples/byte_level_bpe/get_bitext.py b/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/examples/byte_level_bpe/get_bitext.py
deleted file mode 100644
index 6ac1eeec1e6167ec6bafd76b37173ee6987cae7e..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/examples/byte_level_bpe/get_bitext.py
+++ /dev/null
@@ -1,254 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-
-import argparse
-import os
-import os.path as op
-from collections import namedtuple
-from multiprocessing import cpu_count
-from typing import List, Optional
-
-import sentencepiece as sp
-from fairseq.data.encoders.byte_bpe import ByteBPE
-from fairseq.data.encoders.byte_utils import byte_encode
-from fairseq.data.encoders.bytes import Bytes
-from fairseq.data.encoders.characters import Characters
-from fairseq.data.encoders.moses_tokenizer import MosesTokenizer
-from fairseq.data.encoders.sentencepiece_bpe import SentencepieceBPE
-
-
-SPLITS = ["train", "valid", "test"]
-
-
-def _convert_xml(in_path: str, out_path: str):
- with open(in_path) as f, open(out_path, "w") as f_o:
- for s in f:
- ss = s.strip()
- if not ss.startswith("", "").split('">')
- assert len(ss) == 2
- f_o.write(ss[1].strip() + "\n")
-
-
-def _convert_train(in_path: str, out_path: str):
- with open(in_path) as f, open(out_path, "w") as f_o:
- for s in f:
- ss = s.strip()
- if ss.startswith("<"):
- continue
- f_o.write(ss.strip() + "\n")
-
-
-def _get_bytes(in_path: str, out_path: str):
- with open(in_path) as f, open(out_path, "w") as f_o:
- for s in f:
- f_o.write(Bytes.encode(s.strip()) + "\n")
-
-
-def _get_chars(in_path: str, out_path: str):
- with open(in_path) as f, open(out_path, "w") as f_o:
- for s in f:
- f_o.write(Characters.encode(s.strip()) + "\n")
-
-
-def pretokenize(in_path: str, out_path: str, src: str, tgt: str):
- Args = namedtuple(
- "Args",
- [
- "moses_source_lang",
- "moses_target_lang",
- "moses_no_dash_splits",
- "moses_no_escape",
- ],
- )
- args = Args(
- moses_source_lang=src,
- moses_target_lang=tgt,
- moses_no_dash_splits=False,
- moses_no_escape=False,
- )
- pretokenizer = MosesTokenizer(args)
- with open(in_path) as f, open(out_path, "w") as f_o:
- for s in f:
- f_o.write(pretokenizer.encode(s.strip()) + "\n")
-
-
-def _convert_to_bchar(in_path_prefix: str, src: str, tgt: str, out_path: str):
- with open(out_path, "w") as f_o:
- for lang in [src, tgt]:
- with open(f"{in_path_prefix}.{lang}") as f:
- for s in f:
- f_o.write(byte_encode(s.strip()) + "\n")
-
-
-def _get_bpe(in_path: str, model_prefix: str, vocab_size: int):
- arguments = [
- f"--input={in_path}",
- f"--model_prefix={model_prefix}",
- f"--model_type=bpe",
- f"--vocab_size={vocab_size}",
- "--character_coverage=1.0",
- "--normalization_rule_name=identity",
- f"--num_threads={cpu_count()}",
- ]
- sp.SentencePieceTrainer.Train(" ".join(arguments))
-
-
-def _apply_bbpe(model_path: str, in_path: str, out_path: str):
- Args = namedtuple("Args", ["sentencepiece_model_path"])
- args = Args(sentencepiece_model_path=model_path)
- tokenizer = ByteBPE(args)
- with open(in_path) as f, open(out_path, "w") as f_o:
- for s in f:
- f_o.write(tokenizer.encode(s.strip()) + "\n")
-
-
-def _apply_bpe(model_path: str, in_path: str, out_path: str):
- Args = namedtuple("Args", ["sentencepiece_model"])
- args = Args(sentencepiece_model=model_path)
- tokenizer = SentencepieceBPE(args)
- with open(in_path) as f, open(out_path, "w") as f_o:
- for s in f:
- f_o.write(tokenizer.encode(s.strip()) + "\n")
-
-
-def _concat_files(in_paths: List[str], out_path: str):
- with open(out_path, "w") as f_o:
- for p in in_paths:
- with open(p) as f:
- for r in f:
- f_o.write(r)
-
-
-def preprocess_iwslt17(
- root: str,
- src: str,
- tgt: str,
- bpe_size: Optional[int],
- need_chars: bool,
- bbpe_size: Optional[int],
- need_bytes: bool,
-):
- # extract bitext
- in_root = op.join(root, f"{src}-{tgt}")
- for lang in [src, tgt]:
- _convert_train(
- op.join(in_root, f"train.tags.{src}-{tgt}.{lang}"),
- op.join(root, f"train.{lang}"),
- )
- _convert_xml(
- op.join(in_root, f"IWSLT17.TED.dev2010.{src}-{tgt}.{lang}.xml"),
- op.join(root, f"valid.{lang}"),
- )
- _convert_xml(
- op.join(in_root, f"IWSLT17.TED.tst2015.{src}-{tgt}.{lang}.xml"),
- op.join(root, f"test.{lang}"),
- )
- # pre-tokenize
- for lang in [src, tgt]:
- for split in SPLITS:
- pretokenize(
- op.join(root, f"{split}.{lang}"),
- op.join(root, f"{split}.moses.{lang}"),
- src,
- tgt,
- )
- # tokenize with BPE vocabulary
- if bpe_size is not None:
- # learn vocabulary
- concated_train_path = op.join(root, "train.all")
- _concat_files(
- [op.join(root, "train.moses.fr"), op.join(root, "train.moses.en")],
- concated_train_path,
- )
- bpe_model_prefix = op.join(root, f"spm_bpe{bpe_size}")
- _get_bpe(concated_train_path, bpe_model_prefix, bpe_size)
- os.remove(concated_train_path)
- # apply
- for lang in [src, tgt]:
- for split in SPLITS:
- _apply_bpe(
- bpe_model_prefix + ".model",
- op.join(root, f"{split}.moses.{lang}"),
- op.join(root, f"{split}.moses.bpe{bpe_size}.{lang}"),
- )
- # tokenize with bytes vocabulary
- if need_bytes:
- for lang in [src, tgt]:
- for split in SPLITS:
- _get_bytes(
- op.join(root, f"{split}.moses.{lang}"),
- op.join(root, f"{split}.moses.bytes.{lang}"),
- )
- # tokenize with characters vocabulary
- if need_chars:
- for lang in [src, tgt]:
- for split in SPLITS:
- _get_chars(
- op.join(root, f"{split}.moses.{lang}"),
- op.join(root, f"{split}.moses.chars.{lang}"),
- )
- # tokenize with byte-level BPE vocabulary
- if bbpe_size is not None:
- # learn vocabulary
- bchar_path = op.join(root, "train.bchar")
- _convert_to_bchar(op.join(root, "train.moses"), src, tgt, bchar_path)
- bbpe_model_prefix = op.join(root, f"spm_bbpe{bbpe_size}")
- _get_bpe(bchar_path, bbpe_model_prefix, bbpe_size)
- os.remove(bchar_path)
- # apply
- for lang in [src, tgt]:
- for split in SPLITS:
- _apply_bbpe(
- bbpe_model_prefix + ".model",
- op.join(root, f"{split}.moses.{lang}"),
- op.join(root, f"{split}.moses.bbpe{bbpe_size}.{lang}"),
- )
-
-
-def main():
- parser = argparse.ArgumentParser()
- parser.add_argument("--root", type=str, default="data")
- parser.add_argument(
- "--bpe-vocab",
- default=None,
- type=int,
- help="Generate tokenized bitext with BPE of size K."
- "Default to None (disabled).",
- )
- parser.add_argument(
- "--bbpe-vocab",
- default=None,
- type=int,
- help="Generate tokenized bitext with BBPE of size K."
- "Default to None (disabled).",
- )
- parser.add_argument(
- "--byte-vocab",
- action="store_true",
- help="Generate tokenized bitext with bytes vocabulary",
- )
- parser.add_argument(
- "--char-vocab",
- action="store_true",
- help="Generate tokenized bitext with chars vocabulary",
- )
- args = parser.parse_args()
-
- preprocess_iwslt17(
- args.root,
- "fr",
- "en",
- args.bpe_vocab,
- args.char_vocab,
- args.bbpe_vocab,
- args.byte_vocab,
- )
-
-
-if __name__ == "__main__":
- main()
diff --git a/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/examples/m2m_100/tokenizers/tokenize_zh.py b/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/examples/m2m_100/tokenizers/tokenize_zh.py
deleted file mode 100644
index 674b5849cba829cf4f07a69369e9cc6eed376d4c..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/examples/m2m_100/tokenizers/tokenize_zh.py
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-
-import fileinput
-
-import sacrebleu
-
-
-for line in fileinput.input():
- print(sacrebleu.tokenize_zh(line))
diff --git a/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/examples/roberta/preprocess_RACE.py b/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/examples/roberta/preprocess_RACE.py
deleted file mode 100644
index cdd66072718ccb6033304c97926271909a17f9d6..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/examples/roberta/preprocess_RACE.py
+++ /dev/null
@@ -1,102 +0,0 @@
-#!/usr/bin/env python
-# Copyright (c) Facebook, Inc. and its affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-import argparse
-import json
-import os
-import re
-
-
-class InputExample:
- def __init__(self, paragraph, qa_list, label):
- self.paragraph = paragraph
- self.qa_list = qa_list
- self.label = label
-
-
-def get_examples(data_dir, set_type):
- """
- Extract paragraph and question-answer list from each json file
- """
- examples = []
-
- levels = ["middle", "high"]
- set_type_c = set_type.split("-")
- if len(set_type_c) == 2:
- levels = [set_type_c[1]]
- set_type = set_type_c[0]
- for level in levels:
- cur_dir = os.path.join(data_dir, set_type, level)
- for filename in os.listdir(cur_dir):
- cur_path = os.path.join(cur_dir, filename)
- with open(cur_path, "r") as f:
- cur_data = json.load(f)
- answers = cur_data["answers"]
- options = cur_data["options"]
- questions = cur_data["questions"]
- context = cur_data["article"].replace("\n", " ")
- context = re.sub(r"\s+", " ", context)
- for i in range(len(answers)):
- label = ord(answers[i]) - ord("A")
- qa_list = []
- question = questions[i]
- for j in range(4):
- option = options[i][j]
- if "_" in question:
- qa_cat = question.replace("_", option)
- else:
- qa_cat = " ".join([question, option])
- qa_cat = re.sub(r"\s+", " ", qa_cat)
- qa_list.append(qa_cat)
- examples.append(InputExample(context, qa_list, label))
-
- return examples
-
-
-def main():
- """
- Helper script to extract paragraphs questions and answers from RACE datasets.
- """
- parser = argparse.ArgumentParser()
- parser.add_argument(
- "--input-dir",
- help="input directory for downloaded RACE dataset",
- )
- parser.add_argument(
- "--output-dir",
- help="output directory for extracted data",
- )
- args = parser.parse_args()
-
- if not os.path.exists(args.output_dir):
- os.makedirs(args.output_dir, exist_ok=True)
-
- for set_type in ["train", "dev", "test-middle", "test-high"]:
- examples = get_examples(args.input_dir, set_type)
- qa_file_paths = [
- os.path.join(args.output_dir, set_type + ".input" + str(i + 1))
- for i in range(4)
- ]
- qa_files = [open(qa_file_path, "w") for qa_file_path in qa_file_paths]
- outf_context_path = os.path.join(args.output_dir, set_type + ".input0")
- outf_label_path = os.path.join(args.output_dir, set_type + ".label")
- outf_context = open(outf_context_path, "w")
- outf_label = open(outf_label_path, "w")
- for example in examples:
- outf_context.write(example.paragraph + "\n")
- for i in range(4):
- qa_files[i].write(example.qa_list[i] + "\n")
- outf_label.write(str(example.label) + "\n")
-
- for f in qa_files:
- f.close()
- outf_label.close()
- outf_context.close()
-
-
-if __name__ == "__main__":
- main()
diff --git a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/examples/linformer/linformer_src/modules/multihead_linear_attention.py b/spaces/OFA-Sys/OFA-Image_Caption/fairseq/examples/linformer/linformer_src/modules/multihead_linear_attention.py
deleted file mode 100644
index 6be1007279217c5de644e8b054f5d14a19f06c55..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/examples/linformer/linformer_src/modules/multihead_linear_attention.py
+++ /dev/null
@@ -1,481 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import math
-from typing import Dict, Optional, Tuple
-
-import torch
-import torch.nn.functional as F
-from fairseq import utils
-from fairseq.incremental_decoding_utils import with_incremental_state
-from fairseq.modules.quant_noise import quant_noise
-from torch import Tensor, nn
-from torch.nn import Parameter
-
-
-@with_incremental_state
-class MultiheadLinearAttention(nn.Module):
- """Multi-headed linformer attention.
-
- Projects the key and values down to the compressed dimension, before computing self-attention.
-
- See "Linformer: Self-Attention with Linear Complexity" for more details.
- """
-
- def __init__(
- self,
- embed_dim,
- num_heads,
- kdim=None,
- vdim=None,
- dropout=0.0,
- bias=True,
- add_bias_kv=False,
- add_zero_attn=False,
- self_attention=False,
- encoder_decoder_attention=False,
- q_noise=0.0,
- qn_block_size=8,
- compressed=1,
- max_seq_len=256,
- shared_kv_compressed=0,
- shared_compress_layer=None,
- freeze_compress=0,
- ):
- super().__init__()
- self.embed_dim = embed_dim
- self.kdim = kdim if kdim is not None else embed_dim
- self.vdim = vdim if vdim is not None else embed_dim
- self.qkv_same_dim = self.kdim == embed_dim and self.vdim == embed_dim
-
- self.num_heads = num_heads
- self.dropout = dropout
- self.head_dim = embed_dim // num_heads
- assert (
- self.head_dim * num_heads == self.embed_dim
- ), "embed_dim must be divisible by num_heads"
- self.scaling = self.head_dim ** -0.5
-
- self.self_attention = self_attention
- self.encoder_decoder_attention = encoder_decoder_attention
-
- assert not self.self_attention or self.qkv_same_dim, (
- "Self-attention requires query, key and " "value to be of the same size"
- )
-
- self.k_proj = quant_noise(
- nn.Linear(self.kdim, embed_dim, bias=bias), q_noise, qn_block_size
- )
- self.v_proj = quant_noise(
- nn.Linear(self.vdim, embed_dim, bias=bias), q_noise, qn_block_size
- )
- self.q_proj = quant_noise(
- nn.Linear(embed_dim, embed_dim, bias=bias), q_noise, qn_block_size
- )
-
- # used for compress sequence to subsequence
- if shared_compress_layer is None:
- self.compress_seq_len = max_seq_len // compressed
- self.compress_k = nn.Linear(max_seq_len, self.compress_seq_len, bias=False)
- if shared_kv_compressed == 0:
- self.compress_v = nn.Linear(
- max_seq_len, self.compress_seq_len, bias=False
- )
- self.layerwise_sharing = False
- else:
- self.compress_k = shared_compress_layer
- if shared_kv_compressed == 0:
- self.compress_v = shared_compress_layer
- self.layerwise_sharing = True
- self.shared_kv_compressed = shared_kv_compressed
-
- self.out_proj = quant_noise(
- nn.Linear(embed_dim, embed_dim, bias=bias), q_noise, qn_block_size
- )
-
- if add_bias_kv:
- self.bias_k = Parameter(torch.Tensor(1, 1, embed_dim))
- self.bias_v = Parameter(torch.Tensor(1, 1, embed_dim))
- else:
- self.bias_k = self.bias_v = None
-
- self.add_zero_attn = add_zero_attn
-
- self.reset_parameters()
-
- if freeze_compress == 1:
- self.compress_k.weight.requires_grad = False
- if shared_kv_compressed == 0:
- self.compress_v.weight.requires_grad = False
-
- self.onnx_trace = False
-
- def prepare_for_onnx_export_(self):
- self.onnx_trace = True
-
- def reset_parameters(self):
- if self.qkv_same_dim:
- # Empirically observed the convergence to be much better with
- # the scaled initialization
- nn.init.xavier_uniform_(self.k_proj.weight, gain=1 / math.sqrt(2))
- nn.init.xavier_uniform_(self.v_proj.weight, gain=1 / math.sqrt(2))
- nn.init.xavier_uniform_(self.q_proj.weight, gain=1 / math.sqrt(2))
- if (
- not self.layerwise_sharing
- ): # otherwise, we already initialize the parameters
- nn.init.xavier_uniform_(self.compress_k.weight, gain=1 / math.sqrt(2))
- if self.shared_kv_compressed == 0:
- nn.init.xavier_uniform_(
- self.compress_v.weight, gain=1 / math.sqrt(2)
- )
- else:
- nn.init.xavier_uniform_(self.k_proj.weight)
- nn.init.xavier_uniform_(self.v_proj.weight)
- nn.init.xavier_uniform_(self.q_proj.weight)
- if (
- not self.layerwise_sharing
- ): # otherwise, we already initialize the parameters
- nn.init.xavier_uniform_(self.compress_k.weight)
- if self.shared_kv_compressed == 0:
- nn.init.xavier_uniform_(self.compress_v.weight)
-
- nn.init.xavier_uniform_(self.out_proj.weight)
- if self.out_proj.bias is not None:
- nn.init.constant_(self.out_proj.bias, 0.0)
- if self.bias_k is not None:
- nn.init.xavier_normal_(self.bias_k)
- if self.bias_v is not None:
- nn.init.xavier_normal_(self.bias_v)
-
- def forward(
- self,
- query,
- key: Optional[Tensor],
- value: Optional[Tensor],
- key_padding_mask: Optional[Tensor] = None,
- incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None,
- need_weights: bool = True,
- static_kv: bool = False,
- attn_mask: Optional[Tensor] = None,
- before_softmax: bool = False,
- need_head_weights: bool = False,
- ) -> Tuple[Tensor, Optional[Tensor]]:
- """Input shape: Time x Batch x Channel
-
- Args:
- key_padding_mask (ByteTensor, optional): mask to exclude
- keys that are pads, of shape `(batch, src_len)`, where
- padding elements are indicated by 1s.
- need_weights (bool, optional): return the attention weights,
- averaged over heads (default: False).
- attn_mask (ByteTensor, optional): typically used to
- implement causal attention, where the mask prevents the
- attention from looking forward in time (default: None).
- before_softmax (bool, optional): return the raw attention
- weights and values before the attention softmax.
- need_head_weights (bool, optional): return the attention
- weights for each head. Implies *need_weights*. Default:
- return the average attention weights over all heads.
- """
- if need_head_weights:
- need_weights = True
-
- tgt_len, bsz, embed_dim = query.size()
- assert embed_dim == self.embed_dim
- assert list(query.size()) == [tgt_len, bsz, embed_dim]
-
- if incremental_state is not None:
- saved_state = self._get_input_buffer(incremental_state)
- if saved_state is not None and "prev_key" in saved_state:
- # previous time steps are cached - no need to recompute
- # key and value if they are static
- if static_kv:
- assert self.encoder_decoder_attention and not self.self_attention
- key = value = None
- else:
- saved_state = None
-
- if self.self_attention:
- q = self.q_proj(query)
-
- k_input = query.permute(1, 2, 0).contiguous() # B * C * T
- k_input = (
- F.linear(k_input, self.compress_k.weight[:, 0:tgt_len])
- .permute(2, 0, 1)
- .contiguous()
- )
- k = self.k_proj(k_input)
-
- v_input = query.permute(1, 2, 0).contiguous() # B * C * T
- if self.shared_kv_compressed == 0:
- v_input = (
- F.linear(v_input, self.compress_v.weight[:, 0:tgt_len])
- .permute(2, 0, 1)
- .contiguous()
- )
- if self.shared_kv_compressed == 1: # use shared kv compressed linear layer
- v_input = (
- F.linear(v_input, self.compress_k.weight[:, 0:tgt_len])
- .permute(2, 0, 1)
- .contiguous()
- )
- v = self.v_proj(v_input)
- elif self.encoder_decoder_attention:
- # encoder-decoder attention
- q = self.q_proj(query)
- if key is None:
- assert value is None
- k = v = None
- else:
- k = self.k_proj(key)
- v = self.v_proj(key)
-
- else:
- assert key is not None and value is not None
- q = self.q_proj(query)
- k = self.k_proj(key)
- v = self.v_proj(value)
- q *= self.scaling
-
- if self.bias_k is not None:
- assert self.bias_v is not None
- k = torch.cat([k, self.bias_k.repeat(1, bsz, 1)])
- v = torch.cat([v, self.bias_v.repeat(1, bsz, 1)])
- if attn_mask is not None:
- attn_mask = torch.cat(
- [attn_mask, attn_mask.new_zeros(attn_mask.size(0), 1)], dim=1
- )
- if key_padding_mask is not None:
- key_padding_mask = torch.cat(
- [
- key_padding_mask,
- key_padding_mask.new_zeros(key_padding_mask.size(0), 1),
- ],
- dim=1,
- )
-
- q = (
- q.contiguous()
- .view(tgt_len, bsz * self.num_heads, self.head_dim)
- .transpose(0, 1)
- )
- if k is not None:
- k = (
- k.contiguous()
- .view(-1, bsz * self.num_heads, self.head_dim)
- .transpose(0, 1)
- )
- if v is not None:
- v = (
- v.contiguous()
- .view(-1, bsz * self.num_heads, self.head_dim)
- .transpose(0, 1)
- )
-
- if saved_state is not None:
- # saved states are stored with shape (bsz, num_heads, seq_len, head_dim)
- if "prev_key" in saved_state:
- _prev_key = saved_state["prev_key"]
- assert _prev_key is not None
- prev_key = _prev_key.view(bsz * self.num_heads, -1, self.head_dim)
- if static_kv:
- k = prev_key
- else:
- assert k is not None
- k = torch.cat([prev_key, k], dim=1)
- if "prev_value" in saved_state:
- _prev_value = saved_state["prev_value"]
- assert _prev_value is not None
- prev_value = _prev_value.view(bsz * self.num_heads, -1, self.head_dim)
- if static_kv:
- v = prev_value
- else:
- assert v is not None
- v = torch.cat([prev_value, v], dim=1)
- prev_key_padding_mask: Optional[Tensor] = None
- if "prev_key_padding_mask" in saved_state:
- prev_key_padding_mask = saved_state["prev_key_padding_mask"]
- assert k is not None and v is not None
- key_padding_mask = MultiheadLinearAttention._append_prev_key_padding_mask(
- key_padding_mask=key_padding_mask,
- prev_key_padding_mask=prev_key_padding_mask,
- batch_size=bsz,
- src_len=k.size(1),
- static_kv=static_kv,
- )
-
- saved_state["prev_key"] = k.view(bsz, self.num_heads, -1, self.head_dim)
- saved_state["prev_value"] = v.view(bsz, self.num_heads, -1, self.head_dim)
- saved_state["prev_key_padding_mask"] = key_padding_mask
- # In this branch incremental_state is never None
- assert incremental_state is not None
- incremental_state = self._set_input_buffer(incremental_state, saved_state)
- assert k is not None
- src_len = k.size(1)
-
- if self.add_zero_attn:
- assert v is not None
- src_len += 1
- k = torch.cat([k, k.new_zeros((k.size(0), 1) + k.size()[2:])], dim=1)
- v = torch.cat([v, v.new_zeros((v.size(0), 1) + v.size()[2:])], dim=1)
- if attn_mask is not None:
- attn_mask = torch.cat(
- [attn_mask, attn_mask.new_zeros(attn_mask.size(0), 1)], dim=1
- )
-
- attn_weights = torch.bmm(q, k.transpose(1, 2))
- attn_weights = MultiheadLinearAttention.apply_sparse_mask(
- attn_weights, tgt_len, src_len, bsz
- )
-
- assert list(attn_weights.size()) == [bsz * self.num_heads, tgt_len, src_len]
-
- if attn_mask is not None:
- attn_mask = attn_mask.unsqueeze(0)
- if self.onnx_trace:
- attn_mask = attn_mask.repeat(attn_weights.size(0), 1, 1)
- attn_weights += attn_mask
-
- if before_softmax:
- return attn_weights, v
-
- attn_weights_float = utils.softmax(
- attn_weights, dim=-1, onnx_trace=self.onnx_trace
- )
- attn_weights = attn_weights_float.type_as(attn_weights)
- attn_probs = F.dropout(
- attn_weights,
- p=self.dropout,
- training=self.training,
- )
- assert v is not None
- attn = torch.bmm(attn_probs, v)
- assert list(attn.size()) == [bsz * self.num_heads, tgt_len, self.head_dim]
- if self.onnx_trace and attn.size(1) == 1:
- # when ONNX tracing a single decoder step (sequence length == 1)
- # the transpose is a no-op copy before view, thus unnecessary
- attn = attn.contiguous().view(tgt_len, bsz, embed_dim)
- else:
- attn = attn.transpose(0, 1).contiguous().view(tgt_len, bsz, embed_dim)
- attn = self.out_proj(attn)
- attn_weights: Optional[Tensor] = None
- if need_weights:
- attn_weights = attn_weights_float.view(
- bsz, self.num_heads, tgt_len, src_len
- ).transpose(1, 0)
- if not need_head_weights:
- # average attention weights over heads
- attn_weights = attn_weights.mean(dim=0)
-
- return attn, attn_weights
-
- @staticmethod
- def _append_prev_key_padding_mask(
- key_padding_mask: Optional[Tensor],
- prev_key_padding_mask: Optional[Tensor],
- batch_size: int,
- src_len: int,
- static_kv: bool,
- ) -> Optional[Tensor]:
- # saved key padding masks have shape (bsz, seq_len)
- if prev_key_padding_mask is not None and static_kv:
- new_key_padding_mask = prev_key_padding_mask
- elif prev_key_padding_mask is not None and key_padding_mask is not None:
- new_key_padding_mask = torch.cat(
- [prev_key_padding_mask.float(), key_padding_mask.float()], dim=1
- )
- # During incremental decoding, as the padding token enters and
- # leaves the frame, there will be a time when prev or current
- # is None
- elif prev_key_padding_mask is not None:
- filler = torch.zeros(
- (batch_size, src_len - prev_key_padding_mask.size(1)),
- device=prev_key_padding_mask.device,
- )
- new_key_padding_mask = torch.cat(
- [prev_key_padding_mask.float(), filler.float()], dim=1
- )
- elif key_padding_mask is not None:
- filler = torch.zeros(
- (batch_size, src_len - key_padding_mask.size(1)),
- device=key_padding_mask.device,
- )
- new_key_padding_mask = torch.cat(
- [filler.float(), key_padding_mask.float()], dim=1
- )
- else:
- new_key_padding_mask = prev_key_padding_mask
- return new_key_padding_mask
-
- @torch.jit.export
- def reorder_incremental_state(
- self,
- incremental_state: Dict[str, Dict[str, Optional[Tensor]]],
- new_order: Tensor,
- ):
- """Reorder buffered internal state (for incremental generation)."""
- input_buffer = self._get_input_buffer(incremental_state)
- if input_buffer is not None:
- for k in input_buffer.keys():
- input_buffer_k = input_buffer[k]
- if input_buffer_k is not None:
- if self.encoder_decoder_attention and input_buffer_k.size(
- 0
- ) == new_order.size(0):
- break
- input_buffer[k] = input_buffer_k.index_select(0, new_order)
- incremental_state = self._set_input_buffer(incremental_state, input_buffer)
- return incremental_state
-
- def _get_input_buffer(
- self, incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]]
- ) -> Dict[str, Optional[Tensor]]:
- result = self.get_incremental_state(incremental_state, "attn_state")
- if result is not None:
- return result
- else:
- empty_result: Dict[str, Optional[Tensor]] = {}
- return empty_result
-
- def _set_input_buffer(
- self,
- incremental_state: Dict[str, Dict[str, Optional[Tensor]]],
- buffer: Dict[str, Optional[Tensor]],
- ):
- return self.set_incremental_state(incremental_state, "attn_state", buffer)
-
- def apply_sparse_mask(attn_weights, tgt_len: int, src_len: int, bsz: int):
- return attn_weights
-
- def upgrade_state_dict_named(self, state_dict, name):
- prefix = name + "." if name != "" else ""
- items_to_add = {}
- keys_to_remove = []
- for k in state_dict.keys():
- if k.endswith(prefix + "in_proj_weight"):
- # in_proj_weight used to be q + k + v with same dimensions
- dim = int(state_dict[k].shape[0] / 3)
- items_to_add[prefix + "q_proj.weight"] = state_dict[k][:dim]
- items_to_add[prefix + "k_proj.weight"] = state_dict[k][dim : 2 * dim]
- items_to_add[prefix + "v_proj.weight"] = state_dict[k][2 * dim :]
-
- keys_to_remove.append(k)
-
- k_bias = prefix + "in_proj_bias"
- if k_bias in state_dict.keys():
- dim = int(state_dict[k].shape[0] / 3)
- items_to_add[prefix + "q_proj.bias"] = state_dict[k_bias][:dim]
- items_to_add[prefix + "k_proj.bias"] = state_dict[k_bias][
- dim : 2 * dim
- ]
- items_to_add[prefix + "v_proj.bias"] = state_dict[k_bias][2 * dim :]
-
- keys_to_remove.append(prefix + "in_proj_bias")
-
- for k in keys_to_remove:
- del state_dict[k]
-
- for key, value in items_to_add.items():
- state_dict[key] = value
diff --git a/spaces/OFA-Sys/OFA-Visual_Grounding/fairseq/examples/discriminative_reranking_nmt/criterions/__init__.py b/spaces/OFA-Sys/OFA-Visual_Grounding/fairseq/examples/discriminative_reranking_nmt/criterions/__init__.py
deleted file mode 100644
index 7c257c2700f015cb123a976584aef72f0429eb0c..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Visual_Grounding/fairseq/examples/discriminative_reranking_nmt/criterions/__init__.py
+++ /dev/null
@@ -1,6 +0,0 @@
-from .discriminative_reranking_criterion import KLDivergenceRerankingCriterion
-
-
-__all__ = [
- "KLDivergenceRerankingCriterion",
-]
diff --git a/spaces/OFA-Sys/OFA-vqa/fairseq/examples/joint_alignment_translation/prepare-wmt18en2de_no_norm_no_escape_no_agressive.sh b/spaces/OFA-Sys/OFA-vqa/fairseq/examples/joint_alignment_translation/prepare-wmt18en2de_no_norm_no_escape_no_agressive.sh
deleted file mode 100644
index e3efeb21d302ef8d9eae8f1d4b06434c593705f6..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-vqa/fairseq/examples/joint_alignment_translation/prepare-wmt18en2de_no_norm_no_escape_no_agressive.sh
+++ /dev/null
@@ -1,118 +0,0 @@
-#!/bin/bash
-
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-echo 'Cloning Moses github repository (for tokenization scripts)...'
-git clone https://github.com/moses-smt/mosesdecoder.git
-
-SCRIPTS=mosesdecoder/scripts
-TOKENIZER=$SCRIPTS/tokenizer/tokenizer.perl
-CLEAN=$SCRIPTS/training/clean-corpus-n.perl
-REM_NON_PRINT_CHAR=$SCRIPTS/tokenizer/remove-non-printing-char.perl
-
-URLS=(
- "http://statmt.org/wmt13/training-parallel-europarl-v7.tgz"
- "http://statmt.org/wmt13/training-parallel-commoncrawl.tgz"
- "http://data.statmt.org/wmt18/translation-task/training-parallel-nc-v13.tgz"
- "http://data.statmt.org/wmt18/translation-task/rapid2016.tgz"
- "http://data.statmt.org/wmt17/translation-task/dev.tgz"
- "http://statmt.org/wmt14/test-full.tgz"
-)
-CORPORA=(
- "training/europarl-v7.de-en"
- "commoncrawl.de-en"
- "training-parallel-nc-v13/news-commentary-v13.de-en"
- "rapid2016.de-en"
-)
-
-if [ ! -d "$SCRIPTS" ]; then
- echo "Please set SCRIPTS variable correctly to point to Moses scripts."
- exit
-fi
-
-src=en
-tgt=de
-lang=en-de
-prep=wmt18_en_de
-tmp=$prep/tmp
-orig=orig
-dev=dev/newstest2012
-codes=32000
-bpe=bpe.32k
-
-mkdir -p $orig $tmp $prep $bpe
-
-cd $orig
-
-for ((i=0;i<${#URLS[@]};++i)); do
- url=${URLS[i]}
- file=$(basename $url)
- if [ -f $file ]; then
- echo "$file already exists, skipping download"
- else
- wget "$url"
- if [ -f $file ]; then
- echo "$url successfully downloaded."
- else
- echo "$url not successfully downloaded."
- exit 1
- fi
- if [ ${file: -4} == ".tgz" ]; then
- tar zxvf $file
- elif [ ${file: -4} == ".tar" ]; then
- tar xvf $file
- fi
- fi
-done
-cd ..
-
-echo "pre-processing train data..."
-for l in $src $tgt; do
- rm -rf $tmp/train.tags.$lang.tok.$l
- for f in "${CORPORA[@]}"; do
- cat $orig/$f.$l | \
- perl $REM_NON_PRINT_CHAR | \
- perl $TOKENIZER -threads 8 -l $l -no-escape >> $tmp/train.tags.$lang.tok.$l
- done
-done
-
-echo "pre-processing test data..."
-for l in $src $tgt; do
- if [ "$l" == "$src" ]; then
- t="src"
- else
- t="ref"
- fi
- grep '\s*//g' | \
- sed -e 's/\s*<\/seg>\s*//g' | \
- sed -e "s/\’/\'/g" | \
- perl $TOKENIZER -threads 8 -l $l -no-escape > $tmp/test.$l
- echo ""
-done
-
-# apply length filtering before BPE
-perl $CLEAN -ratio 1.5 $tmp/train.tags.$lang.tok $src $tgt $tmp/train 1 100
-
-# use newstest2012 for valid
-echo "pre-processing valid data..."
-for l in $src $tgt; do
- rm -rf $tmp/valid.$l
- cat $orig/$dev.$l | \
- perl $REM_NON_PRINT_CHAR | \
- perl $TOKENIZER -threads 8 -l $l -no-escape >> $tmp/valid.$l
-done
-
-mkdir output
-mv $tmp/{train,valid,test}.{$src,$tgt} output
-
-#BPE
-git clone https://github.com/glample/fastBPE.git
-pushd fastBPE
-g++ -std=c++11 -pthread -O3 fastBPE/main.cc -IfastBPE -o fast
-popd
-fastBPE/fast learnbpe $codes output/train.$src output/train.$tgt > $bpe/codes
-for split in {train,valid,test}; do for lang in {en,de}; do fastBPE/fast applybpe $bpe/$split.$lang output/$split.$lang $bpe/codes; done; done
diff --git a/spaces/OFA-Sys/OFA-vqa/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/decode_word_step2.sh b/spaces/OFA-Sys/OFA-vqa/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/decode_word_step2.sh
deleted file mode 100644
index 59a6cbb12539cf62658f8344f7be7cecf2e3380f..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-vqa/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/decode_word_step2.sh
+++ /dev/null
@@ -1,30 +0,0 @@
-#!/bin/bash
-
-# prepare a new data directory of HMM word output
-
-. ./path.sh
-
-set -eu
-
-out_dir= # same as in train.sh
-dec_lmparam= # LM hyperparameters (e.g., 7.0.0)
-
-dec_exp=tri3b # what HMM stage to decode (e.g., tri3b)
-dec_suffix=word
-dec_splits="train valid"
-dec_data_dir=$out_dir/dec_data_word # where to write HMM output
-
-data_dir=$out_dir/data
-wrd_data_dir=$out_dir/data_word
-
-for x in $dec_splits; do
- mkdir -p $dec_data_dir/$x
- cp $data_dir/$x/{feats.scp,cmvn.scp,utt2spk,spk2utt} $dec_data_dir/$x/
-
- tra=$out_dir/exp/$dec_exp/decode${dec_suffix}_${x}/scoring/${dec_lmparam}.tra
- cat $tra | utils/int2sym.pl -f 2- $data_dir/lang_word/words.txt | \
- sed 's:::g' | sed 's:::g' > $dec_data_dir/$x/text
- utils/fix_data_dir.sh $dec_data_dir/$x
- echo "WER on $x is" $(compute-wer ark:$wrd_data_dir/${x}_gt/text ark:$dec_data_dir/$x/text | cut -d" " -f2-)
-done
-
diff --git a/spaces/ORI-Muchim/BarKeYaeTTS/transforms.py b/spaces/ORI-Muchim/BarKeYaeTTS/transforms.py
deleted file mode 100644
index 4793d67ca5a5630e0ffe0f9fb29445c949e64dae..0000000000000000000000000000000000000000
--- a/spaces/ORI-Muchim/BarKeYaeTTS/transforms.py
+++ /dev/null
@@ -1,193 +0,0 @@
-import torch
-from torch.nn import functional as F
-
-import numpy as np
-
-
-DEFAULT_MIN_BIN_WIDTH = 1e-3
-DEFAULT_MIN_BIN_HEIGHT = 1e-3
-DEFAULT_MIN_DERIVATIVE = 1e-3
-
-
-def piecewise_rational_quadratic_transform(inputs,
- unnormalized_widths,
- unnormalized_heights,
- unnormalized_derivatives,
- inverse=False,
- tails=None,
- tail_bound=1.,
- min_bin_width=DEFAULT_MIN_BIN_WIDTH,
- min_bin_height=DEFAULT_MIN_BIN_HEIGHT,
- min_derivative=DEFAULT_MIN_DERIVATIVE):
-
- if tails is None:
- spline_fn = rational_quadratic_spline
- spline_kwargs = {}
- else:
- spline_fn = unconstrained_rational_quadratic_spline
- spline_kwargs = {
- 'tails': tails,
- 'tail_bound': tail_bound
- }
-
- outputs, logabsdet = spline_fn(
- inputs=inputs,
- unnormalized_widths=unnormalized_widths,
- unnormalized_heights=unnormalized_heights,
- unnormalized_derivatives=unnormalized_derivatives,
- inverse=inverse,
- min_bin_width=min_bin_width,
- min_bin_height=min_bin_height,
- min_derivative=min_derivative,
- **spline_kwargs
- )
- return outputs, logabsdet
-
-
-def searchsorted(bin_locations, inputs, eps=1e-6):
- bin_locations[..., -1] += eps
- return torch.sum(
- inputs[..., None] >= bin_locations,
- dim=-1
- ) - 1
-
-
-def unconstrained_rational_quadratic_spline(inputs,
- unnormalized_widths,
- unnormalized_heights,
- unnormalized_derivatives,
- inverse=False,
- tails='linear',
- tail_bound=1.,
- min_bin_width=DEFAULT_MIN_BIN_WIDTH,
- min_bin_height=DEFAULT_MIN_BIN_HEIGHT,
- min_derivative=DEFAULT_MIN_DERIVATIVE):
- inside_interval_mask = (inputs >= -tail_bound) & (inputs <= tail_bound)
- outside_interval_mask = ~inside_interval_mask
-
- outputs = torch.zeros_like(inputs)
- logabsdet = torch.zeros_like(inputs)
-
- if tails == 'linear':
- unnormalized_derivatives = F.pad(unnormalized_derivatives, pad=(1, 1))
- constant = np.log(np.exp(1 - min_derivative) - 1)
- unnormalized_derivatives[..., 0] = constant
- unnormalized_derivatives[..., -1] = constant
-
- outputs[outside_interval_mask] = inputs[outside_interval_mask]
- logabsdet[outside_interval_mask] = 0
- else:
- raise RuntimeError('{} tails are not implemented.'.format(tails))
-
- outputs[inside_interval_mask], logabsdet[inside_interval_mask] = rational_quadratic_spline(
- inputs=inputs[inside_interval_mask],
- unnormalized_widths=unnormalized_widths[inside_interval_mask, :],
- unnormalized_heights=unnormalized_heights[inside_interval_mask, :],
- unnormalized_derivatives=unnormalized_derivatives[inside_interval_mask, :],
- inverse=inverse,
- left=-tail_bound, right=tail_bound, bottom=-tail_bound, top=tail_bound,
- min_bin_width=min_bin_width,
- min_bin_height=min_bin_height,
- min_derivative=min_derivative
- )
-
- return outputs, logabsdet
-
-def rational_quadratic_spline(inputs,
- unnormalized_widths,
- unnormalized_heights,
- unnormalized_derivatives,
- inverse=False,
- left=0., right=1., bottom=0., top=1.,
- min_bin_width=DEFAULT_MIN_BIN_WIDTH,
- min_bin_height=DEFAULT_MIN_BIN_HEIGHT,
- min_derivative=DEFAULT_MIN_DERIVATIVE):
- if torch.min(inputs) < left or torch.max(inputs) > right:
- raise ValueError('Input to a transform is not within its domain')
-
- num_bins = unnormalized_widths.shape[-1]
-
- if min_bin_width * num_bins > 1.0:
- raise ValueError('Minimal bin width too large for the number of bins')
- if min_bin_height * num_bins > 1.0:
- raise ValueError('Minimal bin height too large for the number of bins')
-
- widths = F.softmax(unnormalized_widths, dim=-1)
- widths = min_bin_width + (1 - min_bin_width * num_bins) * widths
- cumwidths = torch.cumsum(widths, dim=-1)
- cumwidths = F.pad(cumwidths, pad=(1, 0), mode='constant', value=0.0)
- cumwidths = (right - left) * cumwidths + left
- cumwidths[..., 0] = left
- cumwidths[..., -1] = right
- widths = cumwidths[..., 1:] - cumwidths[..., :-1]
-
- derivatives = min_derivative + F.softplus(unnormalized_derivatives)
-
- heights = F.softmax(unnormalized_heights, dim=-1)
- heights = min_bin_height + (1 - min_bin_height * num_bins) * heights
- cumheights = torch.cumsum(heights, dim=-1)
- cumheights = F.pad(cumheights, pad=(1, 0), mode='constant', value=0.0)
- cumheights = (top - bottom) * cumheights + bottom
- cumheights[..., 0] = bottom
- cumheights[..., -1] = top
- heights = cumheights[..., 1:] - cumheights[..., :-1]
-
- if inverse:
- bin_idx = searchsorted(cumheights, inputs)[..., None]
- else:
- bin_idx = searchsorted(cumwidths, inputs)[..., None]
-
- input_cumwidths = cumwidths.gather(-1, bin_idx)[..., 0]
- input_bin_widths = widths.gather(-1, bin_idx)[..., 0]
-
- input_cumheights = cumheights.gather(-1, bin_idx)[..., 0]
- delta = heights / widths
- input_delta = delta.gather(-1, bin_idx)[..., 0]
-
- input_derivatives = derivatives.gather(-1, bin_idx)[..., 0]
- input_derivatives_plus_one = derivatives[..., 1:].gather(-1, bin_idx)[..., 0]
-
- input_heights = heights.gather(-1, bin_idx)[..., 0]
-
- if inverse:
- a = (((inputs - input_cumheights) * (input_derivatives
- + input_derivatives_plus_one
- - 2 * input_delta)
- + input_heights * (input_delta - input_derivatives)))
- b = (input_heights * input_derivatives
- - (inputs - input_cumheights) * (input_derivatives
- + input_derivatives_plus_one
- - 2 * input_delta))
- c = - input_delta * (inputs - input_cumheights)
-
- discriminant = b.pow(2) - 4 * a * c
- assert (discriminant >= 0).all()
-
- root = (2 * c) / (-b - torch.sqrt(discriminant))
- outputs = root * input_bin_widths + input_cumwidths
-
- theta_one_minus_theta = root * (1 - root)
- denominator = input_delta + ((input_derivatives + input_derivatives_plus_one - 2 * input_delta)
- * theta_one_minus_theta)
- derivative_numerator = input_delta.pow(2) * (input_derivatives_plus_one * root.pow(2)
- + 2 * input_delta * theta_one_minus_theta
- + input_derivatives * (1 - root).pow(2))
- logabsdet = torch.log(derivative_numerator) - 2 * torch.log(denominator)
-
- return outputs, -logabsdet
- else:
- theta = (inputs - input_cumwidths) / input_bin_widths
- theta_one_minus_theta = theta * (1 - theta)
-
- numerator = input_heights * (input_delta * theta.pow(2)
- + input_derivatives * theta_one_minus_theta)
- denominator = input_delta + ((input_derivatives + input_derivatives_plus_one - 2 * input_delta)
- * theta_one_minus_theta)
- outputs = input_cumheights + numerator / denominator
-
- derivative_numerator = input_delta.pow(2) * (input_derivatives_plus_one * theta.pow(2)
- + 2 * input_delta * theta_one_minus_theta
- + input_derivatives * (1 - theta).pow(2))
- logabsdet = torch.log(derivative_numerator) - 2 * torch.log(denominator)
-
- return outputs, logabsdet
diff --git a/spaces/Okkoman/PokeFace/app.py b/spaces/Okkoman/PokeFace/app.py
deleted file mode 100644
index 069e6cea063904d474c6a409e2490e34406e0d8a..0000000000000000000000000000000000000000
--- a/spaces/Okkoman/PokeFace/app.py
+++ /dev/null
@@ -1,66 +0,0 @@
-# AUTOGENERATED! DO NOT EDIT! File to edit: ../app.ipynb.
-
-# %% auto 0
-__all__ = ['modelname', 'pokemon_types', 'pokemon_types_en', 'examplespath', 'learn_inf', 'lang', 'prob_threshold',
- 'classify_image']
-
-# %% ../app.ipynb 3
-import pandas as pd
-
-modelname = f'model_gen0.pkl'
-pokemon_types = pd.read_csv(f'pokemon.csv')
-pokemon_types_en = pokemon_types['en']
-
-examplespath = 'images/'
-
-# %% ../app.ipynb 7
-from huggingface_hub import hf_hub_download
-from fastai.learner import load_learner
-
-learn_inf = load_learner(hf_hub_download("Okkoman/PokeFace", modelname))
-
-# %% ../app.ipynb 9
-import gradio as gr
-
-lang = 'en'
-
-prob_threshold = 0.75
-
-from flask import request
-if request:
- lang = request.headers.get("Accept-Language")
-
-if lang == 'fr':
- title = "# PokeFace - Quel est ce pokemon ?"
- description = "## Un classifieur pour les pokemons de 1ere et 2eme générations (001-251)"
- unknown = 'inconnu'
-else:
- title = "# PokeFace - What is this pokemon ?"
- description = "## An classifier for 1st-2nd generation pokemons (001-251)"
- unknown = 'unknown'
-
-def classify_image(img):
- pred,pred_idx,probs = learn_inf.predict(img)
- index = pokemon_types_en[pokemon_types_en == pred].index[0]
- label = pokemon_types[lang].iloc[index]
- if probs[pred_idx] > prob_threshold:
- return f"{index+1} - {label} ({probs[pred_idx]*100:.0f}%)"
- else:
- return unknown
-
-with gr.Blocks() as demo:
-
- with gr.Row():
- gr.Markdown(title)
- with gr.Row():
- gr.Markdown(description)
- with gr.Row():
- interf = gr.Interface(
- fn=classify_image,
- inputs=gr.inputs.Image(shape=(192,192)),
- outputs=gr.outputs.Label(),
- examples=examplespath,
- allow_flagging='auto')
-
-demo.launch(inline=False)
-
diff --git a/spaces/OlaWod/FreeVC/speaker_encoder/voice_encoder.py b/spaces/OlaWod/FreeVC/speaker_encoder/voice_encoder.py
deleted file mode 100644
index 88cdee2de76b72db58c5dd19a888597e0fe12fbb..0000000000000000000000000000000000000000
--- a/spaces/OlaWod/FreeVC/speaker_encoder/voice_encoder.py
+++ /dev/null
@@ -1,173 +0,0 @@
-from speaker_encoder.hparams import *
-from speaker_encoder import audio
-from pathlib import Path
-from typing import Union, List
-from torch import nn
-from time import perf_counter as timer
-import numpy as np
-import torch
-
-
-class SpeakerEncoder(nn.Module):
- def __init__(self, weights_fpath, device: Union[str, torch.device]=None, verbose=True):
- """
- :param device: either a torch device or the name of a torch device (e.g. "cpu", "cuda").
- If None, defaults to cuda if it is available on your machine, otherwise the model will
- run on cpu. Outputs are always returned on the cpu, as numpy arrays.
- """
- super().__init__()
-
- # Define the network
- 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()
-
- # Get the target device
- if device is None:
- device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
- elif isinstance(device, str):
- device = torch.device(device)
- self.device = device
-
- # Load the pretrained model'speaker weights
- # weights_fpath = Path(__file__).resolve().parent.joinpath("pretrained.pt")
- # if not weights_fpath.exists():
- # raise Exception("Couldn't find the voice encoder pretrained model at %s." %
- # weights_fpath)
-
- start = timer()
- checkpoint = torch.load(weights_fpath, map_location="cpu")
-
- self.load_state_dict(checkpoint["model_state"], strict=False)
- self.to(device)
-
- if verbose:
- print("Loaded the voice encoder model on %s in %.2f seconds." %
- (device.type, timer() - start))
-
- def forward(self, mels: torch.FloatTensor):
- """
- Computes the embeddings of a batch of utterance spectrograms.
- :param mels: a batch of mel spectrograms of same duration as a float32 tensor of shape
- (batch_size, n_frames, n_channels)
- :return: the embeddings as a float 32 tensor of shape (batch_size, embedding_size).
- Embeddings are positive and L2-normed, thus they lay in the range [0, 1].
- """
- # Pass the input through the LSTM layers and retrieve the final hidden state of the last
- # layer. Apply a cutoff to 0 for negative values and L2 normalize the embeddings.
- _, (hidden, _) = self.lstm(mels)
- embeds_raw = self.relu(self.linear(hidden[-1]))
- return embeds_raw / torch.norm(embeds_raw, dim=1, keepdim=True)
-
- @staticmethod
- def compute_partial_slices(n_samples: int, rate, min_coverage):
- """
- Computes where to split an utterance waveform and its corresponding mel spectrogram to
- obtain partial utterances of each. Both the waveform and the
- mel spectrogram slices are returned, so as to make each partial utterance waveform
- correspond to its spectrogram.
-
- The returned ranges may be indexing further than the length of the waveform. It is
- recommended that you pad the waveform with zeros up to wav_slices[-1].stop.
-
- :param n_samples: the number of samples in the waveform
- :param rate: how many partial utterances should occur per second. Partial utterances must
- cover the span of the entire utterance, thus the rate should not be lower than the inverse
- of the duration of a partial utterance. By default, partial utterances are 1.6s long and
- the minimum rate is thus 0.625.
- :param min_coverage: when reaching the last partial utterance, it may or may not have
- enough frames. If at least of are present,
- then the last partial utterance will be considered by zero-padding the audio. Otherwise,
- it will be discarded. If there aren't enough frames for one partial utterance,
- this parameter is ignored so that the function always returns at least one slice.
- :return: the waveform slices and mel spectrogram slices as lists of array slices. Index
- respectively the waveform and the mel spectrogram with these slices to obtain the partial
- utterances.
- """
- assert 0 < min_coverage <= 1
-
- # Compute how many frames separate two partial utterances
- samples_per_frame = int((sampling_rate * mel_window_step / 1000))
- n_frames = int(np.ceil((n_samples + 1) / samples_per_frame))
- frame_step = int(np.round((sampling_rate / rate) / samples_per_frame))
- assert 0 < frame_step, "The rate is too high"
- assert frame_step <= partials_n_frames, "The rate is too low, it should be %f at least" % \
- (sampling_rate / (samples_per_frame * partials_n_frames))
-
- # Compute the slices
- wav_slices, mel_slices = [], []
- steps = max(1, n_frames - partials_n_frames + frame_step + 1)
- for i in range(0, steps, frame_step):
- mel_range = np.array([i, i + partials_n_frames])
- wav_range = mel_range * samples_per_frame
- mel_slices.append(slice(*mel_range))
- wav_slices.append(slice(*wav_range))
-
- # Evaluate whether extra padding is warranted or not
- last_wav_range = wav_slices[-1]
- coverage = (n_samples - last_wav_range.start) / (last_wav_range.stop - last_wav_range.start)
- if coverage < min_coverage and len(mel_slices) > 1:
- mel_slices = mel_slices[:-1]
- wav_slices = wav_slices[:-1]
-
- return wav_slices, mel_slices
-
- def embed_utterance(self, wav: np.ndarray, return_partials=False, rate=1.3, min_coverage=0.75):
- """
- Computes an embedding for a single utterance. The utterance is divided in partial
- utterances and an embedding is computed for each. The complete utterance embedding is the
- L2-normed average embedding of the partial utterances.
-
- TODO: independent batched version of this function
-
- :param wav: a preprocessed utterance waveform as a numpy array of float32
- :param return_partials: if True, the partial embeddings will also be returned along with
- the wav slices corresponding to each partial utterance.
- :param rate: how many partial utterances should occur per second. Partial utterances must
- cover the span of the entire utterance, thus the rate should not be lower than the inverse
- of the duration of a partial utterance. By default, partial utterances are 1.6s long and
- the minimum rate is thus 0.625.
- :param min_coverage: when reaching the last partial utterance, it may or may not have
- enough frames. If at least of are present,
- then the last partial utterance will be considered by zero-padding the audio. Otherwise,
- it will be discarded. If there aren't enough frames for one partial utterance,
- this parameter is ignored so that the function always returns at least one slice.
- :return: the embedding as a numpy array of float32 of shape (model_embedding_size,). If
- is True, the partial utterances as a numpy array of float32 of shape
- (n_partials, model_embedding_size) and the wav partials as a list of slices will also be
- returned.
- """
- # Compute where to split the utterance into partials and pad the waveform with zeros if
- # the partial utterances cover a larger range.
- wav_slices, mel_slices = self.compute_partial_slices(len(wav), rate, min_coverage)
- max_wave_length = wav_slices[-1].stop
- if max_wave_length >= len(wav):
- wav = np.pad(wav, (0, max_wave_length - len(wav)), "constant")
-
- # Split the utterance into partials and forward them through the model
- mel = audio.wav_to_mel_spectrogram(wav)
- mels = np.array([mel[s] for s in mel_slices])
- with torch.no_grad():
- mels = torch.from_numpy(mels).to(self.device)
- partial_embeds = self(mels).cpu().numpy()
-
- # Compute the utterance embedding from the partial embeddings
- raw_embed = np.mean(partial_embeds, axis=0)
- embed = raw_embed / np.linalg.norm(raw_embed, 2)
-
- if return_partials:
- return embed, partial_embeds, wav_slices
- return embed
-
- def embed_speaker(self, wavs: List[np.ndarray], **kwargs):
- """
- Compute the embedding of a collection of wavs (presumably from the same speaker) by
- averaging their embedding and L2-normalizing it.
-
- :param wavs: list of wavs a numpy arrays of float32.
- :param kwargs: extra arguments to embed_utterance()
- :return: the embedding as a numpy array of float32 of shape (model_embedding_size,).
- """
- raw_embed = np.mean([self.embed_utterance(wav, return_partials=False, **kwargs) \
- for wav in wavs], axis=0)
- return raw_embed / np.linalg.norm(raw_embed, 2)
\ No newline at end of file
diff --git a/spaces/OpenGVLab/InternGPT/iGPT/models/grit_src/third_party/CenterNet2/detectron2/structures/masks.py b/spaces/OpenGVLab/InternGPT/iGPT/models/grit_src/third_party/CenterNet2/detectron2/structures/masks.py
deleted file mode 100644
index 8f8e72dd9f953ddd2ac1a8a301b1f990d4dd770a..0000000000000000000000000000000000000000
--- a/spaces/OpenGVLab/InternGPT/iGPT/models/grit_src/third_party/CenterNet2/detectron2/structures/masks.py
+++ /dev/null
@@ -1,532 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import copy
-import itertools
-import numpy as np
-from typing import Any, Iterator, List, Union
-import pycocotools.mask as mask_util
-import torch
-from torch import device
-
-from detectron2.layers.roi_align import ROIAlign
-from detectron2.utils.memory import retry_if_cuda_oom
-
-from .boxes import Boxes
-
-
-def polygon_area(x, y):
- # Using the shoelace formula
- # https://stackoverflow.com/questions/24467972/calculate-area-of-polygon-given-x-y-coordinates
- return 0.5 * np.abs(np.dot(x, np.roll(y, 1)) - np.dot(y, np.roll(x, 1)))
-
-
-def polygons_to_bitmask(polygons: List[np.ndarray], height: int, width: int) -> np.ndarray:
- """
- Args:
- polygons (list[ndarray]): each array has shape (Nx2,)
- height, width (int)
-
- Returns:
- ndarray: a bool mask of shape (height, width)
- """
- if len(polygons) == 0:
- # COCOAPI does not support empty polygons
- return np.zeros((height, width)).astype(np.bool)
- rles = mask_util.frPyObjects(polygons, height, width)
- rle = mask_util.merge(rles)
- return mask_util.decode(rle).astype(np.bool)
-
-
-def rasterize_polygons_within_box(
- polygons: List[np.ndarray], box: np.ndarray, mask_size: int
-) -> torch.Tensor:
- """
- Rasterize the polygons into a mask image and
- crop the mask content in the given box.
- The cropped mask is resized to (mask_size, mask_size).
-
- This function is used when generating training targets for mask head in Mask R-CNN.
- Given original ground-truth masks for an image, new ground-truth mask
- training targets in the size of `mask_size x mask_size`
- must be provided for each predicted box. This function will be called to
- produce such targets.
-
- Args:
- polygons (list[ndarray[float]]): a list of polygons, which represents an instance.
- box: 4-element numpy array
- mask_size (int):
-
- Returns:
- Tensor: BoolTensor of shape (mask_size, mask_size)
- """
- # 1. Shift the polygons w.r.t the boxes
- w, h = box[2] - box[0], box[3] - box[1]
-
- polygons = copy.deepcopy(polygons)
- for p in polygons:
- p[0::2] = p[0::2] - box[0]
- p[1::2] = p[1::2] - box[1]
-
- # 2. Rescale the polygons to the new box size
- # max() to avoid division by small number
- ratio_h = mask_size / max(h, 0.1)
- ratio_w = mask_size / max(w, 0.1)
-
- if ratio_h == ratio_w:
- for p in polygons:
- p *= ratio_h
- else:
- for p in polygons:
- p[0::2] *= ratio_w
- p[1::2] *= ratio_h
-
- # 3. Rasterize the polygons with coco api
- mask = polygons_to_bitmask(polygons, mask_size, mask_size)
- mask = torch.from_numpy(mask)
- return mask
-
-
-class BitMasks:
- """
- This class stores the segmentation masks for all objects in one image, in
- the form of bitmaps.
-
- Attributes:
- tensor: bool Tensor of N,H,W, representing N instances in the image.
- """
-
- def __init__(self, tensor: Union[torch.Tensor, np.ndarray]):
- """
- Args:
- tensor: bool Tensor of N,H,W, representing N instances in the image.
- """
- device = tensor.device if isinstance(tensor, torch.Tensor) else torch.device("cpu")
- tensor = torch.as_tensor(tensor, dtype=torch.bool, device=device)
- assert tensor.dim() == 3, tensor.size()
- self.image_size = tensor.shape[1:]
- self.tensor = tensor
-
- @torch.jit.unused
- def to(self, *args: Any, **kwargs: Any) -> "BitMasks":
- return BitMasks(self.tensor.to(*args, **kwargs))
-
- @property
- def device(self) -> torch.device:
- return self.tensor.device
-
- @torch.jit.unused
- def __getitem__(self, item: Union[int, slice, torch.BoolTensor]) -> "BitMasks":
- """
- Returns:
- BitMasks: Create a new :class:`BitMasks` by indexing.
-
- The following usage are allowed:
-
- 1. `new_masks = masks[3]`: return a `BitMasks` which contains only one mask.
- 2. `new_masks = masks[2:10]`: return a slice of masks.
- 3. `new_masks = masks[vector]`, where vector is a torch.BoolTensor
- with `length = len(masks)`. Nonzero elements in the vector will be selected.
-
- Note that the returned object might share storage with this object,
- subject to Pytorch's indexing semantics.
- """
- if isinstance(item, int):
- return BitMasks(self.tensor[item].unsqueeze(0))
- m = self.tensor[item]
- assert m.dim() == 3, "Indexing on BitMasks with {} returns a tensor with shape {}!".format(
- item, m.shape
- )
- return BitMasks(m)
-
- @torch.jit.unused
- def __iter__(self) -> torch.Tensor:
- yield from self.tensor
-
- @torch.jit.unused
- def __repr__(self) -> str:
- s = self.__class__.__name__ + "("
- s += "num_instances={})".format(len(self.tensor))
- return s
-
- def __len__(self) -> int:
- return self.tensor.shape[0]
-
- def nonempty(self) -> torch.Tensor:
- """
- Find masks that are non-empty.
-
- Returns:
- Tensor: a BoolTensor which represents
- whether each mask is empty (False) or non-empty (True).
- """
- return self.tensor.flatten(1).any(dim=1)
-
- @staticmethod
- def from_polygon_masks(
- polygon_masks: Union["PolygonMasks", List[List[np.ndarray]]], height: int, width: int
- ) -> "BitMasks":
- """
- Args:
- polygon_masks (list[list[ndarray]] or PolygonMasks)
- height, width (int)
- """
- if isinstance(polygon_masks, PolygonMasks):
- polygon_masks = polygon_masks.polygons
- masks = [polygons_to_bitmask(p, height, width) for p in polygon_masks]
- if len(masks):
- return BitMasks(torch.stack([torch.from_numpy(x) for x in masks]))
- else:
- return BitMasks(torch.empty(0, height, width, dtype=torch.bool))
-
- @staticmethod
- def from_roi_masks(roi_masks: "ROIMasks", height: int, width: int) -> "BitMasks":
- """
- Args:
- roi_masks:
- height, width (int):
- """
- return roi_masks.to_bitmasks(height, width)
-
- def crop_and_resize(self, boxes: torch.Tensor, mask_size: int) -> torch.Tensor:
- """
- Crop each bitmask by the given box, and resize results to (mask_size, mask_size).
- This can be used to prepare training targets for Mask R-CNN.
- It has less reconstruction error compared to rasterization with polygons.
- However we observe no difference in accuracy,
- but BitMasks requires more memory to store all the masks.
-
- Args:
- boxes (Tensor): Nx4 tensor storing the boxes for each mask
- mask_size (int): the size of the rasterized mask.
-
- Returns:
- Tensor:
- A bool tensor of shape (N, mask_size, mask_size), where
- N is the number of predicted boxes for this image.
- """
- assert len(boxes) == len(self), "{} != {}".format(len(boxes), len(self))
- device = self.tensor.device
-
- batch_inds = torch.arange(len(boxes), device=device).to(dtype=boxes.dtype)[:, None]
- rois = torch.cat([batch_inds, boxes], dim=1) # Nx5
-
- bit_masks = self.tensor.to(dtype=torch.float32)
- rois = rois.to(device=device)
- output = (
- ROIAlign((mask_size, mask_size), 1.0, 0, aligned=True)
- .forward(bit_masks[:, None, :, :], rois)
- .squeeze(1)
- )
- output = output >= 0.5
- return output
-
- def get_bounding_boxes(self) -> Boxes:
- """
- Returns:
- Boxes: tight bounding boxes around bitmasks.
- If a mask is empty, it's bounding box will be all zero.
- """
- boxes = torch.zeros(self.tensor.shape[0], 4, dtype=torch.float32)
- x_any = torch.any(self.tensor, dim=1)
- y_any = torch.any(self.tensor, dim=2)
- for idx in range(self.tensor.shape[0]):
- x = torch.where(x_any[idx, :])[0]
- y = torch.where(y_any[idx, :])[0]
- if len(x) > 0 and len(y) > 0:
- boxes[idx, :] = torch.as_tensor(
- [x[0], y[0], x[-1] + 1, y[-1] + 1], dtype=torch.float32
- )
- return Boxes(boxes)
-
- @staticmethod
- def cat(bitmasks_list: List["BitMasks"]) -> "BitMasks":
- """
- Concatenates a list of BitMasks into a single BitMasks
-
- Arguments:
- bitmasks_list (list[BitMasks])
-
- Returns:
- BitMasks: the concatenated BitMasks
- """
- assert isinstance(bitmasks_list, (list, tuple))
- assert len(bitmasks_list) > 0
- assert all(isinstance(bitmask, BitMasks) for bitmask in bitmasks_list)
-
- cat_bitmasks = type(bitmasks_list[0])(torch.cat([bm.tensor for bm in bitmasks_list], dim=0))
- return cat_bitmasks
-
-
-class PolygonMasks:
- """
- This class stores the segmentation masks for all objects in one image, in the form of polygons.
-
- Attributes:
- polygons: list[list[ndarray]]. Each ndarray is a float64 vector representing a polygon.
- """
-
- def __init__(self, polygons: List[List[Union[torch.Tensor, np.ndarray]]]):
- """
- Arguments:
- polygons (list[list[np.ndarray]]): The first
- level of the list correspond to individual instances,
- the second level to all the polygons that compose the
- instance, and the third level to the polygon coordinates.
- The third level array should have the format of
- [x0, y0, x1, y1, ..., xn, yn] (n >= 3).
- """
- if not isinstance(polygons, list):
- raise ValueError(
- "Cannot create PolygonMasks: Expect a list of list of polygons per image. "
- "Got '{}' instead.".format(type(polygons))
- )
-
- def _make_array(t: Union[torch.Tensor, np.ndarray]) -> np.ndarray:
- # Use float64 for higher precision, because why not?
- # Always put polygons on CPU (self.to is a no-op) since they
- # are supposed to be small tensors.
- # May need to change this assumption if GPU placement becomes useful
- if isinstance(t, torch.Tensor):
- t = t.cpu().numpy()
- return np.asarray(t).astype("float64")
-
- def process_polygons(
- polygons_per_instance: List[Union[torch.Tensor, np.ndarray]]
- ) -> List[np.ndarray]:
- if not isinstance(polygons_per_instance, list):
- raise ValueError(
- "Cannot create polygons: Expect a list of polygons per instance. "
- "Got '{}' instead.".format(type(polygons_per_instance))
- )
- # transform each polygon to a numpy array
- polygons_per_instance = [_make_array(p) for p in polygons_per_instance]
- for polygon in polygons_per_instance:
- if len(polygon) % 2 != 0 or len(polygon) < 6:
- raise ValueError(f"Cannot create a polygon from {len(polygon)} coordinates.")
- return polygons_per_instance
-
- self.polygons: List[List[np.ndarray]] = [
- process_polygons(polygons_per_instance) for polygons_per_instance in polygons
- ]
-
- def to(self, *args: Any, **kwargs: Any) -> "PolygonMasks":
- return self
-
- @property
- def device(self) -> torch.device:
- return torch.device("cpu")
-
- def get_bounding_boxes(self) -> Boxes:
- """
- Returns:
- Boxes: tight bounding boxes around polygon masks.
- """
- boxes = torch.zeros(len(self.polygons), 4, dtype=torch.float32)
- for idx, polygons_per_instance in enumerate(self.polygons):
- minxy = torch.as_tensor([float("inf"), float("inf")], dtype=torch.float32)
- maxxy = torch.zeros(2, dtype=torch.float32)
- for polygon in polygons_per_instance:
- coords = torch.from_numpy(polygon).view(-1, 2).to(dtype=torch.float32)
- minxy = torch.min(minxy, torch.min(coords, dim=0).values)
- maxxy = torch.max(maxxy, torch.max(coords, dim=0).values)
- boxes[idx, :2] = minxy
- boxes[idx, 2:] = maxxy
- return Boxes(boxes)
-
- def nonempty(self) -> torch.Tensor:
- """
- Find masks that are non-empty.
-
- Returns:
- Tensor:
- a BoolTensor which represents whether each mask is empty (False) or not (True).
- """
- keep = [1 if len(polygon) > 0 else 0 for polygon in self.polygons]
- return torch.from_numpy(np.asarray(keep, dtype=np.bool))
-
- def __getitem__(self, item: Union[int, slice, List[int], torch.BoolTensor]) -> "PolygonMasks":
- """
- Support indexing over the instances and return a `PolygonMasks` object.
- `item` can be:
-
- 1. An integer. It will return an object with only one instance.
- 2. A slice. It will return an object with the selected instances.
- 3. A list[int]. It will return an object with the selected instances,
- correpsonding to the indices in the list.
- 4. A vector mask of type BoolTensor, whose length is num_instances.
- It will return an object with the instances whose mask is nonzero.
- """
- if isinstance(item, int):
- selected_polygons = [self.polygons[item]]
- elif isinstance(item, slice):
- selected_polygons = self.polygons[item]
- elif isinstance(item, list):
- selected_polygons = [self.polygons[i] for i in item]
- elif isinstance(item, torch.Tensor):
- # Polygons is a list, so we have to move the indices back to CPU.
- if item.dtype == torch.bool:
- assert item.dim() == 1, item.shape
- item = item.nonzero().squeeze(1).cpu().numpy().tolist()
- elif item.dtype in [torch.int32, torch.int64]:
- item = item.cpu().numpy().tolist()
- else:
- raise ValueError("Unsupported tensor dtype={} for indexing!".format(item.dtype))
- selected_polygons = [self.polygons[i] for i in item]
- return PolygonMasks(selected_polygons)
-
- def __iter__(self) -> Iterator[List[np.ndarray]]:
- """
- Yields:
- list[ndarray]: the polygons for one instance.
- Each Tensor is a float64 vector representing a polygon.
- """
- return iter(self.polygons)
-
- def __repr__(self) -> str:
- s = self.__class__.__name__ + "("
- s += "num_instances={})".format(len(self.polygons))
- return s
-
- def __len__(self) -> int:
- return len(self.polygons)
-
- def crop_and_resize(self, boxes: torch.Tensor, mask_size: int) -> torch.Tensor:
- """
- Crop each mask by the given box, and resize results to (mask_size, mask_size).
- This can be used to prepare training targets for Mask R-CNN.
-
- Args:
- boxes (Tensor): Nx4 tensor storing the boxes for each mask
- mask_size (int): the size of the rasterized mask.
-
- Returns:
- Tensor: A bool tensor of shape (N, mask_size, mask_size), where
- N is the number of predicted boxes for this image.
- """
- assert len(boxes) == len(self), "{} != {}".format(len(boxes), len(self))
-
- device = boxes.device
- # Put boxes on the CPU, as the polygon representation is not efficient GPU-wise
- # (several small tensors for representing a single instance mask)
- boxes = boxes.to(torch.device("cpu"))
-
- results = [
- rasterize_polygons_within_box(poly, box.numpy(), mask_size)
- for poly, box in zip(self.polygons, boxes)
- ]
- """
- poly: list[list[float]], the polygons for one instance
- box: a tensor of shape (4,)
- """
- if len(results) == 0:
- return torch.empty(0, mask_size, mask_size, dtype=torch.bool, device=device)
- return torch.stack(results, dim=0).to(device=device)
-
- def area(self):
- """
- Computes area of the mask.
- Only works with Polygons, using the shoelace formula:
- https://stackoverflow.com/questions/24467972/calculate-area-of-polygon-given-x-y-coordinates
-
- Returns:
- Tensor: a vector, area for each instance
- """
-
- area = []
- for polygons_per_instance in self.polygons:
- area_per_instance = 0
- for p in polygons_per_instance:
- area_per_instance += polygon_area(p[0::2], p[1::2])
- area.append(area_per_instance)
-
- return torch.tensor(area)
-
- @staticmethod
- def cat(polymasks_list: List["PolygonMasks"]) -> "PolygonMasks":
- """
- Concatenates a list of PolygonMasks into a single PolygonMasks
-
- Arguments:
- polymasks_list (list[PolygonMasks])
-
- Returns:
- PolygonMasks: the concatenated PolygonMasks
- """
- assert isinstance(polymasks_list, (list, tuple))
- assert len(polymasks_list) > 0
- assert all(isinstance(polymask, PolygonMasks) for polymask in polymasks_list)
-
- cat_polymasks = type(polymasks_list[0])(
- list(itertools.chain.from_iterable(pm.polygons for pm in polymasks_list))
- )
- return cat_polymasks
-
-
-class ROIMasks:
- """
- Represent masks by N smaller masks defined in some ROIs. Once ROI boxes are given,
- full-image bitmask can be obtained by "pasting" the mask on the region defined
- by the corresponding ROI box.
- """
-
- def __init__(self, tensor: torch.Tensor):
- """
- Args:
- tensor: (N, M, M) mask tensor that defines the mask within each ROI.
- """
- if tensor.dim() != 3:
- raise ValueError("ROIMasks must take a masks of 3 dimension.")
- self.tensor = tensor
-
- def to(self, device: torch.device) -> "ROIMasks":
- return ROIMasks(self.tensor.to(device))
-
- @property
- def device(self) -> device:
- return self.tensor.device
-
- def __len__(self):
- return self.tensor.shape[0]
-
- def __getitem__(self, item) -> "ROIMasks":
- """
- Returns:
- ROIMasks: Create a new :class:`ROIMasks` by indexing.
-
- The following usage are allowed:
-
- 1. `new_masks = masks[2:10]`: return a slice of masks.
- 2. `new_masks = masks[vector]`, where vector is a torch.BoolTensor
- with `length = len(masks)`. Nonzero elements in the vector will be selected.
-
- Note that the returned object might share storage with this object,
- subject to Pytorch's indexing semantics.
- """
- t = self.tensor[item]
- if t.dim() != 3:
- raise ValueError(
- f"Indexing on ROIMasks with {item} returns a tensor with shape {t.shape}!"
- )
- return ROIMasks(t)
-
- @torch.jit.unused
- def __repr__(self) -> str:
- s = self.__class__.__name__ + "("
- s += "num_instances={})".format(len(self.tensor))
- return s
-
- @torch.jit.unused
- def to_bitmasks(self, boxes: torch.Tensor, height, width, threshold=0.5):
- """
- Args: see documentation of :func:`paste_masks_in_image`.
- """
- from detectron2.layers.mask_ops import paste_masks_in_image, _paste_masks_tensor_shape
-
- if torch.jit.is_tracing():
- if isinstance(height, torch.Tensor):
- paste_func = _paste_masks_tensor_shape
- else:
- paste_func = paste_masks_in_image
- else:
- paste_func = retry_if_cuda_oom(paste_masks_in_image)
- bitmasks = paste_func(self.tensor, boxes.tensor, (height, width), threshold=threshold)
- return BitMasks(bitmasks)
diff --git a/spaces/OpenMotionLab/MotionGPT/mGPT/utils/joints.py b/spaces/OpenMotionLab/MotionGPT/mGPT/utils/joints.py
deleted file mode 100644
index 98199c6831c3416a6be3170b21ae3be119ef8981..0000000000000000000000000000000000000000
--- a/spaces/OpenMotionLab/MotionGPT/mGPT/utils/joints.py
+++ /dev/null
@@ -1,444 +0,0 @@
-mmm_joints = [
- "root",
- "BP",
- "BT",
- "BLN",
- "BUN",
- "LS",
- "LE",
- "LW",
- "RS",
- "RE",
- "RW",
- "LH",
- "LK",
- "LA",
- "LMrot",
- "LF",
- "RH",
- "RK",
- "RA",
- "RMrot",
- "RF",
-]
-
-humanml3d_joints = [
- "root",
- "RH",
- "LH",
- "BP",
- "RK",
- "LK",
- "BT",
- "RMrot",
- "LMrot",
- "BLN",
- "RF",
- "LF",
- "BMN",
- "RSI",
- "LSI",
- "BUN",
- "RS",
- "LS",
- "RE",
- "LE",
- "RW",
- "LW",
-]
-
-smplx_joints = [
- "pelvis",
- "left_hip",
- "right_hip",
- "spine1",
- "left_knee",
- "right_knee",
- "spine2",
- "left_ankle",
- "right_ankle",
- "spine3",
- "left_foot",
- "right_foot",
- "neck",
- "left_collar",
- "right_collar",
- "head",
- "left_shoulder",
- "right_shoulder",
- "left_elbow",
- "right_elbow",
- "left_wrist",
- "right_wrist",
- "jaw",
- "left_eye_smplhf",
- "right_eye_smplhf",
- "left_index1",
- "left_index2",
- "left_index3",
- "left_middle1",
- "left_middle2",
- "left_middle3",
- "left_pinky1",
- "left_pinky2",
- "left_pinky3",
- "left_ring1",
- "left_ring2",
- "left_ring3",
- "left_thumb1",
- "left_thumb2",
- "left_thumb3",
- "right_index1",
- "right_index2",
- "right_index3",
- "right_middle1",
- "right_middle2",
- "right_middle3",
- "right_pinky1",
- "right_pinky2",
- "right_pinky3",
- "right_ring1",
- "right_ring2",
- "right_ring3",
- "right_thumb1",
- "right_thumb2",
- "right_thumb3",
- "nose",
- "right_eye",
- "left_eye",
- "right_ear",
- "left_ear",
- "left_big_toe",
- "left_small_toe",
- "left_heel",
- "right_big_toe",
- "right_small_toe",
- "right_heel",
- "left_thumb",
- "left_index",
- "left_middle",
- "left_ring",
- "left_pinky",
- "right_thumb",
- "right_index",
- "right_middle",
- "right_ring",
- "right_pinky",
- "right_eye_brow1",
- "right_eye_brow2",
- "right_eye_brow3",
- "right_eye_brow4",
- "right_eye_brow5",
- "left_eye_brow5",
- "left_eye_brow4",
- "left_eye_brow3",
- "left_eye_brow2",
- "left_eye_brow1",
- "nose1",
- "nose2",
- "nose3",
- "nose4",
- "right_nose_2",
- "right_nose_1",
- "nose_middle",
- "left_nose_1",
- "left_nose_2",
- "right_eye1",
- "right_eye2",
- "right_eye3",
- "right_eye4",
- "right_eye5",
- "right_eye6",
- "left_eye4",
- "left_eye3",
- "left_eye2",
- "left_eye1",
- "left_eye6",
- "left_eye5",
- "right_mouth_1",
- "right_mouth_2",
- "right_mouth_3",
- "mouth_top",
- "left_mouth_3",
- "left_mouth_2",
- "left_mouth_1",
- "left_mouth_5", # 59 in OpenPose output
- "left_mouth_4", # 58 in OpenPose output
- "mouth_bottom",
- "right_mouth_4",
- "right_mouth_5",
- "right_lip_1",
- "right_lip_2",
- "lip_top",
- "left_lip_2",
- "left_lip_1",
- "left_lip_3",
- "lip_bottom",
- "right_lip_3",
- # Face contour
- "right_contour_1",
- "right_contour_2",
- "right_contour_3",
- "right_contour_4",
- "right_contour_5",
- "right_contour_6",
- "right_contour_7",
- "right_contour_8",
- "contour_middle",
- "left_contour_8",
- "left_contour_7",
- "left_contour_6",
- "left_contour_5",
- "left_contour_4",
- "left_contour_3",
- "left_contour_2",
- "left_contour_1",
-]
-
-smplxnh_joints = [
- "pelvis",
- "left_hip",
- "right_hip",
- "spine1",
- "left_knee",
- "right_knee",
- "spine2",
- "left_ankle",
- "right_ankle",
- "spine3",
- "left_foot",
- "right_foot",
- "neck",
- "left_collar",
- "right_collar",
- "head",
- "left_shoulder",
- "right_shoulder",
- "left_elbow",
- "right_elbow",
- "left_wrist",
- "right_wrist",
-]
-
-smplh_joints = [
- "pelvis",
- "left_hip",
- "right_hip",
- "spine1",
- "left_knee",
- "right_knee",
- "spine2",
- "left_ankle",
- "right_ankle",
- "spine3",
- "left_foot",
- "right_foot",
- "neck",
- "left_collar",
- "right_collar",
- "head",
- "left_shoulder",
- "right_shoulder",
- "left_elbow",
- "right_elbow",
- "left_wrist",
- "right_wrist",
- "left_index1",
- "left_index2",
- "left_index3",
- "left_middle1",
- "left_middle2",
- "left_middle3",
- "left_pinky1",
- "left_pinky2",
- "left_pinky3",
- "left_ring1",
- "left_ring2",
- "left_ring3",
- "left_thumb1",
- "left_thumb2",
- "left_thumb3",
- "right_index1",
- "right_index2",
- "right_index3",
- "right_middle1",
- "right_middle2",
- "right_middle3",
- "right_pinky1",
- "right_pinky2",
- "right_pinky3",
- "right_ring1",
- "right_ring2",
- "right_ring3",
- "right_thumb1",
- "right_thumb2",
- "right_thumb3",
- "nose",
- "right_eye",
- "left_eye",
- "right_ear",
- "left_ear",
- "left_big_toe",
- "left_small_toe",
- "left_heel",
- "right_big_toe",
- "right_small_toe",
- "right_heel",
- "left_thumb",
- "left_index",
- "left_middle",
- "left_ring",
- "left_pinky",
- "right_thumb",
- "right_index",
- "right_middle",
- "right_ring",
- "right_pinky",
-]
-
-smplnh_joints = [
- "pelvis",
- "left_hip",
- "right_hip",
- "spine1",
- "left_knee",
- "right_knee",
- "spine2",
- "left_ankle",
- "right_ankle",
- "spine3",
- "left_foot",
- "right_foot",
- "neck",
- "left_collar",
- "right_collar",
- "head",
- "left_shoulder",
- "right_shoulder",
- "left_elbow",
- "right_elbow",
- "left_wrist",
- "right_wrist",
-]
-
-mmm2smplh_correspondence = {
- "root": "pelvis",
- "BP": "spine1",
- "BT": "spine3",
- "BLN": "neck",
- "BUN": "head",
- "LS": "left_shoulder",
- "LE": "left_elbow",
- "LW": "left_wrist",
- "RS": "right_shoulder",
- "RE": "right_elbow",
- "RW": "right_wrist",
- "LH": "left_hip",
- "LK": "left_knee",
- "LA": "left_ankle",
- "LMrot": "left_heel",
- "LF": "left_foot",
- "RH": "right_hip",
- "RK": "right_knee",
- "RA": "right_ankle",
- "RMrot": "right_heel",
- "RF": "right_foot",
-}
-
-smplh2mmm_correspondence = {
- val: key
- for key, val in mmm2smplh_correspondence.items()
-}
-smplh2mmm_indexes = [
- smplh_joints.index(mmm2smplh_correspondence[x]) for x in mmm_joints
-]
-
-smplnh2smplh_correspondence = {key: key for key in smplnh_joints}
-smplh2smplnh_correspondence = {
- val: key
- for key, val in smplnh2smplh_correspondence.items()
-}
-
-smplh2smplnh_indexes = [
- smplh_joints.index(smplnh2smplh_correspondence[x]) for x in smplnh_joints
-]
-
-mmm_kinematic_tree = [
- [0, 1, 2, 3, 4], # body
- [3, 5, 6, 7], # right arm
- [3, 8, 9, 10], # left arm
- [0, 11, 12, 13, 14, 15], # right leg
- [0, 16, 17, 18, 19, 20],
-] # left leg
-
-humanml3d_kinematic_tree = [
- [0, 3, 6, 9, 12, 15], # body
- [9, 14, 17, 19, 21], # right arm
- [9, 13, 16, 18, 20], # left arm
- [0, 2, 5, 8, 11], # right leg
- [0, 1, 4, 7, 10],
-] # left leg
-
-smplh_to_mmm_scaling_factor = 480 / 0.75
-mmm_to_smplh_scaling_factor = 0.75 / 480
-
-mmm_joints_info = {
- "root":
- mmm_joints.index("root"),
- "feet": [
- mmm_joints.index("LMrot"),
- mmm_joints.index("RMrot"),
- mmm_joints.index("LF"),
- mmm_joints.index("RF"),
- ],
- "shoulders": [mmm_joints.index("LS"),
- mmm_joints.index("RS")],
- "hips": [mmm_joints.index("LH"),
- mmm_joints.index("RH")],
-}
-
-smplnh_joints_info = {
- "root":
- smplnh_joints.index("pelvis"),
- "feet": [
- smplnh_joints.index("left_ankle"),
- smplnh_joints.index("right_ankle"),
- smplnh_joints.index("left_foot"),
- smplnh_joints.index("right_foot"),
- ],
- "shoulders": [
- smplnh_joints.index("left_shoulder"),
- smplnh_joints.index("right_shoulder"),
- ],
- "hips":
- [smplnh_joints.index("left_hip"),
- smplnh_joints.index("right_hip")],
-}
-
-infos = {"mmm": mmm_joints_info, "smplnh": smplnh_joints_info}
-
-smplh_indexes = {"mmm": smplh2mmm_indexes, "smplnh": smplh2smplnh_indexes}
-
-root_joints = {
- "mmm": mmm_joints_info["root"],
- "mmmns": mmm_joints_info["root"],
- "smplmmm": mmm_joints_info["root"],
- "smplnh": smplnh_joints_info["root"],
- "smplh": smplh_joints.index("pelvis"),
-}
-
-
-def get_root_idx(joinstype):
- return root_joints[joinstype]
-
-
-# def mmm2smpl(joints_mmm):
-# mmm2smplnh_indexes = []
-# for x in smplnh_joints:
-# if x in smplh2mmm_correspondence:
-# mmm2smplnh_indexes.append(mmm_joints.index(smplh2mmm_correspondence[x]))
-
-# spine2 = 0.5*(joints[mmm_joints.index("spine1")] + joints[mmm_joints.index("spine3")])
-
-# joints = joints_mmm[indexes]
-# return joints
diff --git a/spaces/Owechada/roopfaceswapr/roop/metadata.py b/spaces/Owechada/roopfaceswapr/roop/metadata.py
deleted file mode 100644
index 35b0f0245a38eb9ec024f2ed2c829044f6051c29..0000000000000000000000000000000000000000
--- a/spaces/Owechada/roopfaceswapr/roop/metadata.py
+++ /dev/null
@@ -1,2 +0,0 @@
-name = 'roop'
-version = '1.1.0'
diff --git a/spaces/PSLD/PSLD/diffusion-posterior-sampling/bkse/generate_blur.py b/spaces/PSLD/PSLD/diffusion-posterior-sampling/bkse/generate_blur.py
deleted file mode 100644
index 5e162bcee94ec049c5303fcabceebef705aacc9b..0000000000000000000000000000000000000000
--- a/spaces/PSLD/PSLD/diffusion-posterior-sampling/bkse/generate_blur.py
+++ /dev/null
@@ -1,53 +0,0 @@
-import argparse
-
-import cv2
-import numpy as np
-import os.path as osp
-import torch
-import utils.util as util
-import yaml
-from models.kernel_encoding.kernel_wizard import KernelWizard
-
-
-def main():
- device = torch.device("cuda")
-
- parser = argparse.ArgumentParser(description="Kernel extractor testing")
-
- parser.add_argument("--image_path", action="store", help="image path", type=str, required=True)
- parser.add_argument("--yml_path", action="store", help="yml path", type=str, required=True)
- parser.add_argument("--save_path", action="store", help="save path", type=str, default=".")
- parser.add_argument("--num_samples", action="store", help="number of samples", type=int, default=1)
-
- args = parser.parse_args()
-
- image_path = args.image_path
- yml_path = args.yml_path
- num_samples = args.num_samples
-
- # Initializing mode
- with open(yml_path, "r") as f:
- opt = yaml.load(f)["KernelWizard"]
- model_path = opt["pretrained"]
- model = KernelWizard(opt)
- model.eval()
- model.load_state_dict(torch.load(model_path))
- model = model.to(device)
-
- HQ = cv2.cvtColor(cv2.imread(image_path), cv2.COLOR_BGR2RGB) / 255.0
- HQ = np.transpose(HQ, (2, 0, 1))
- HQ_tensor = torch.Tensor(HQ).unsqueeze(0).to(device).cuda()
-
- for i in range(num_samples):
- print(f"Sample #{i}/{num_samples}")
- with torch.no_grad():
- kernel = torch.randn((1, 512, 2, 2)).cuda() * 1.2
- LQ_tensor = model.adaptKernel(HQ_tensor, kernel)
-
- dst = osp.join(args.save_path, f"blur{i:03d}.png")
- LQ_img = util.tensor2img(LQ_tensor)
-
- cv2.imwrite(dst, LQ_img)
-
-
-main()
diff --git a/spaces/Pattr/DrumClassification/lilypond-2.24.2/lib/guile/2.2/ccache/ice-9/curried-definitions.go b/spaces/Pattr/DrumClassification/lilypond-2.24.2/lib/guile/2.2/ccache/ice-9/curried-definitions.go
deleted file mode 100644
index d3c95738909f2f5ae484cea994a8dbea92ea7afb..0000000000000000000000000000000000000000
Binary files a/spaces/Pattr/DrumClassification/lilypond-2.24.2/lib/guile/2.2/ccache/ice-9/curried-definitions.go and /dev/null differ
diff --git a/spaces/Pattr/DrumClassification/lilypond-2.24.2/lib/guile/2.2/ccache/srfi/srfi-1.go b/spaces/Pattr/DrumClassification/lilypond-2.24.2/lib/guile/2.2/ccache/srfi/srfi-1.go
deleted file mode 100644
index 8d889580cf6b453c0ddfc58af6bc70bc52ccc516..0000000000000000000000000000000000000000
Binary files a/spaces/Pattr/DrumClassification/lilypond-2.24.2/lib/guile/2.2/ccache/srfi/srfi-1.go and /dev/null differ
diff --git a/spaces/PaulHilders/CLIPGroundingExplainability/clip_grounding/utils/visualize.py b/spaces/PaulHilders/CLIPGroundingExplainability/clip_grounding/utils/visualize.py
deleted file mode 100644
index aaee90b5be63568dbcde91da84e9560a580c7f89..0000000000000000000000000000000000000000
--- a/spaces/PaulHilders/CLIPGroundingExplainability/clip_grounding/utils/visualize.py
+++ /dev/null
@@ -1,183 +0,0 @@
-"""Helpers for visualization"""
-import numpy as np
-import matplotlib
-import matplotlib.pyplot as plt
-import cv2
-from PIL import Image
-
-
-# define predominanat colors
-COLORS = {
- "pink": (242, 116, 223),
- "cyan": (46, 242, 203),
- "red": (255, 0, 0),
- "green": (0, 255, 0),
- "blue": (0, 0, 255),
- "yellow": (255, 255, 0),
-}
-
-
-def show_single_image(image: np.ndarray, figsize: tuple = (8, 8), title: str = None, titlesize=18, cmap: str = None, ticks=False, save=False, save_path=None):
- """Show a single image."""
- fig, ax = plt.subplots(1, 1, figsize=figsize)
-
- if isinstance(image, Image.Image):
- image = np.asarray(image)
-
- ax.set_title(title, fontsize=titlesize)
- ax.imshow(image, cmap=cmap)
-
- if not ticks:
- ax.set_xticks([])
- ax.set_yticks([])
-
- if save:
- plt.savefig(save_path, bbox_inches='tight')
-
- plt.show()
-
-
-def show_grid_of_images(
- images: np.ndarray, n_cols: int = 4, figsize: tuple = (8, 8),
- cmap=None, subtitles=None, title=None, subtitlesize=18,
- save=False, save_path=None, titlesize=20,
- ):
- """Show a grid of images."""
- n_cols = min(n_cols, len(images))
-
- copy_of_images = images.copy()
- for i, image in enumerate(copy_of_images):
- if isinstance(image, Image.Image):
- image = np.asarray(image)
- images[i] = image
-
- if subtitles is None:
- subtitles = [None] * len(images)
-
- n_rows = int(np.ceil(len(images) / n_cols))
- fig, axes = plt.subplots(n_rows, n_cols, figsize=figsize)
- for i, ax in enumerate(axes.flat):
- if i < len(images):
- if len(images[i].shape) == 2 and cmap is None:
- cmap="gray"
- ax.imshow(images[i], cmap=cmap)
- ax.set_title(subtitles[i], fontsize=subtitlesize)
- ax.axis('off')
- fig.set_tight_layout(True)
- plt.suptitle(title, y=0.8, fontsize=titlesize)
-
- if save:
- plt.savefig(save_path, bbox_inches='tight')
- plt.close()
- else:
- plt.show()
-
-
-def show_keypoint_matches(
- img1, kp1, img2, kp2, matches,
- K=10, figsize=(10, 5), drawMatches_args=dict(matchesThickness=3, singlePointColor=(0, 0, 0)),
- choose_matches="random",
- ):
- """Displays matches found in the pair of images"""
- if choose_matches == "random":
- selected_matches = np.random.choice(matches, K)
- elif choose_matches == "all":
- K = len(matches)
- selected_matches = matches
- elif choose_matches == "topk":
- selected_matches = matches[:K]
- else:
- raise ValueError(f"Unknown value for choose_matches: {choose_matches}")
-
- # color each match with a different color
- cmap = matplotlib.cm.get_cmap('gist_rainbow', K)
- colors = [[int(x*255) for x in cmap(i)[:3]] for i in np.arange(0,K)]
- drawMatches_args.update({"matchColor": -1, "singlePointColor": (100, 100, 100)})
-
- img3 = cv2.drawMatches(img1, kp1, img2, kp2, selected_matches, outImg=None, **drawMatches_args)
- show_single_image(
- img3,
- figsize=figsize,
- title=f"[{choose_matches.upper()}] Selected K = {K} matches between the pair of images.",
- )
- return img3
-
-
-def draw_kps_on_image(image: np.ndarray, kps: np.ndarray, color=COLORS["red"], radius=3, thickness=-1, return_as="numpy"):
- """
- Draw keypoints on image.
-
- Args:
- image: Image to draw keypoints on.
- kps: Keypoints to draw. Note these should be in (x, y) format.
- """
- if isinstance(image, Image.Image):
- image = np.asarray(image)
-
- for kp in kps:
- image = cv2.circle(
- image, (int(kp[0]), int(kp[1])), radius=radius, color=color, thickness=thickness)
-
- if return_as == "PIL":
- return Image.fromarray(image)
-
- return image
-
-
-def get_concat_h(im1, im2):
- """Concatenate two images horizontally"""
- dst = Image.new('RGB', (im1.width + im2.width, im1.height))
- dst.paste(im1, (0, 0))
- dst.paste(im2, (im1.width, 0))
- return dst
-
-
-def get_concat_v(im1, im2):
- """Concatenate two images vertically"""
- dst = Image.new('RGB', (im1.width, im1.height + im2.height))
- dst.paste(im1, (0, 0))
- dst.paste(im2, (0, im1.height))
- return dst
-
-
-def show_images_with_keypoints(images: list, kps: list, radius=15, color=(0, 220, 220), figsize=(10, 8), return_images=False, save=False, save_path="sample.png"):
- assert len(images) == len(kps)
-
- # generate
- images_with_kps = []
- for i in range(len(images)):
- img_with_kps = draw_kps_on_image(images[i], kps[i], radius=radius, color=color, return_as="PIL")
- images_with_kps.append(img_with_kps)
-
- # show
- show_grid_of_images(images_with_kps, n_cols=len(images), figsize=figsize, save=save, save_path=save_path)
-
- if return_images:
- return images_with_kps
-
-
-def set_latex_fonts(usetex=True, fontsize=14, show_sample=False, **kwargs):
- try:
- plt.rcParams.update({
- "text.usetex": usetex,
- "font.family": "serif",
- "font.serif": ["Computer Modern Roman"],
- "font.size": fontsize,
- **kwargs,
- })
- if show_sample:
- plt.figure()
- plt.title("Sample $y = x^2$")
- plt.plot(np.arange(0, 10), np.arange(0, 10)**2, "--o")
- plt.grid()
- plt.show()
- except:
- print("Failed to setup LaTeX fonts. Proceeding without.")
- pass
-
-
-def get_colors(num_colors, palette="jet"):
- cmap = plt.get_cmap(palette)
- colors = [cmap(i) for i in np.linspace(0, 1, num_colors)]
- return colors
-
diff --git a/spaces/Pie31415/control-animation/annotator/uniformer/mmcv/parallel/__init__.py b/spaces/Pie31415/control-animation/annotator/uniformer/mmcv/parallel/__init__.py
deleted file mode 100644
index 2ed2c17ad357742e423beeaf4d35db03fe9af469..0000000000000000000000000000000000000000
--- a/spaces/Pie31415/control-animation/annotator/uniformer/mmcv/parallel/__init__.py
+++ /dev/null
@@ -1,13 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from .collate import collate
-from .data_container import DataContainer
-from .data_parallel import MMDataParallel
-from .distributed import MMDistributedDataParallel
-from .registry import MODULE_WRAPPERS
-from .scatter_gather import scatter, scatter_kwargs
-from .utils import is_module_wrapper
-
-__all__ = [
- 'collate', 'DataContainer', 'MMDataParallel', 'MMDistributedDataParallel',
- 'scatter', 'scatter_kwargs', 'is_module_wrapper', 'MODULE_WRAPPERS'
-]
diff --git a/spaces/PineSearch/generatorImage/app.py b/spaces/PineSearch/generatorImage/app.py
deleted file mode 100644
index c85de5d5e577146094ee04a9f0cee0adf8ea4167..0000000000000000000000000000000000000000
--- a/spaces/PineSearch/generatorImage/app.py
+++ /dev/null
@@ -1,140 +0,0 @@
-import gradio as gr
-from gradio.inputs import Textbox
-
-import torch
-from diffusers import StableDiffusionPipeline
-import boto3
-from io import BytesIO
-import os
-import botocore
-from time import sleep
-
-AWS_ACCESS_KEY_ID = os.getenv("AWS_ACCESS_KEY_ID")
-AWS_SECRET_ACCESS_KEY = os.getenv("AWS_SECRET_ACCESS_KEY")
-S3_BUCKET_NAME = 'pineblogs101145-dev'
-
-bucket_name = 'pineblogs101145-dev'
-folder = 'public/mdx/'
-
-model_id = "CompVis/stable-diffusion-v1-4"
-device = "cuda" if torch.cuda.is_available() else "cpu"
-
-pipe = StableDiffusionPipeline.from_pretrained(
- model_id, torch_dtype=torch.float32)
-
-pipe = pipe.to(device)
-
-
-def text_to_image(prompt, save_as, key_id):
-
- if AWS_ACCESS_KEY_ID != key_id:
- return "not permition"
-
- # Create an instance of the S3 client
- s3 = boto3.client('s3',
- aws_access_key_id=AWS_ACCESS_KEY_ID,
- aws_secret_access_key=AWS_SECRET_ACCESS_KEY)
-
- image_name = '-'.join(save_as.split()) + ".webp"
-
- def save_image_to_s3(image):
- # Create a BytesIO object to store the image.
- image_buffer = BytesIO()
- image.save(image_buffer, format='WEBP')
- image_buffer.seek(0)
-
- # Full path of the file in the bucket
- s3_key = "public/" + image_name
- print('Saving image to s3')
-
- # Upload the image to the S3 bucket
- s3.upload_fileobj(image_buffer, S3_BUCKET_NAME, s3_key)
- print('Image %s saved to s3' % s3_key)
-
- def generator_image(prompt):
- prompt = prompt
- print('Starting to generate the image ...')
- try:
- image = pipe(prompt).images[0]
- except Exception as e:
- print('Error: ', e)
-
- print('Image generation completed')
-
- # Save the image in S3
- save_image_to_s3(image)
-
- generator_image(prompt)
- return image_name
-
-
-def check_if_exist(bucket_name, key):
-
- s3 = boto3.resource('s3',
- aws_access_key_id=AWS_ACCESS_KEY_ID,
- aws_secret_access_key=AWS_SECRET_ACCESS_KEY)
-
- try:
- s3.Object(bucket_name, key).load()
- except botocore.exceptions.ClientError as e:
- if e.response['Error']['Code'] == "404":
- # The object does not exist.
- return False
- else:
- # Something else has gone wrong.
- raise
- else:
- return True
-
-
-def list_s3_files():
-
- s3_client = boto3.client('s3',
- aws_access_key_id=AWS_ACCESS_KEY_ID,
- aws_secret_access_key=AWS_SECRET_ACCESS_KEY)
-
-
- s3 = boto3.resource('s3',
- aws_access_key_id=AWS_ACCESS_KEY_ID,
- aws_secret_access_key=AWS_SECRET_ACCESS_KEY)
-
- my_bucket = s3.Bucket(bucket_name)
-
- for objects in my_bucket.objects.filter(Prefix=folder):
- print(objects.key)
-
- filename_ext = '%s' % os.path.basename(objects.key)
- filename = os.path.splitext(filename_ext)[0]
- s3image = 'public/%s.webp' % filename
-
- if check_if_exist(bucket_name, s3image):
- print('Image %s already exists!' % s3image)
- else:
- response = s3_client.head_object(Bucket=bucket_name, Key=objects.key)
- metadata = response['Metadata']
- print(metadata)
- if 'titulo' in metadata:
- print('Has titulo, ready to create image!')
- print('Start creating image.. %s ' % s3image)
- title = metadata['titulo']
- text_to_image(title, filename, AWS_ACCESS_KEY_ID)
- else:
- print('There is NOT resume, skipping..')
-
- sleep(500/1000)
-
-
-demo = gr.Blocks()
-
-with demo:
-
- text = gr.Textbox()
-
- bimage = gr.Button("Generate Blog Images for PineSearch!")
-
- bimage.click(list_s3_files, outputs=text)
-
-demo.launch()
-
-# iface = gr.Interface(fn=list_s3_files, inputs=[Textbox(label="bucket_name"), Textbox(label="folder")], outputs="text")
-# iface.launch()
diff --git a/spaces/Plachta/VALL-E-X/utils/g2p/__init__.py b/spaces/Plachta/VALL-E-X/utils/g2p/__init__.py
deleted file mode 100644
index a6da9152cd58393f39937085139ee36d55ca7367..0000000000000000000000000000000000000000
--- a/spaces/Plachta/VALL-E-X/utils/g2p/__init__.py
+++ /dev/null
@@ -1,72 +0,0 @@
-""" from https://github.com/keithito/tacotron """
-import utils.g2p.cleaners
-from utils.g2p.symbols import symbols
-from tokenizers import Tokenizer
-
-# Mappings from symbol to numeric ID and vice versa:
-_symbol_to_id = {s: i for i, s in enumerate(symbols)}
-_id_to_symbol = {i: s for i, s in enumerate(symbols)}
-
-
-class PhonemeBpeTokenizer:
- def __init__(self, tokenizer_path = "./utils/g2p/bpe_1024.json"):
- self.tokenizer = Tokenizer.from_file(tokenizer_path)
-
- def tokenize(self, text):
- # 1. convert text to phoneme
- phonemes, langs = _clean_text(text, ['cje_cleaners'])
- # 2. replace blank space " " with "_"
- phonemes = phonemes.replace(" ", "_")
- # 3. tokenize phonemes
- phoneme_tokens = self.tokenizer.encode(phonemes).ids
- assert(len(phoneme_tokens) == len(langs))
- if not len(phoneme_tokens):
- raise ValueError("Empty text is given")
- return phoneme_tokens, langs
-
-def text_to_sequence(text, cleaner_names):
- '''Converts a string of text to a sequence of IDs corresponding to the symbols in the text.
- Args:
- text: string to convert to a sequence
- cleaner_names: names of the cleaner functions to run the text through
- Returns:
- List of integers corresponding to the symbols in the text
- '''
- sequence = []
- symbol_to_id = {s: i for i, s in enumerate(symbols)}
- clean_text = _clean_text(text, cleaner_names)
- for symbol in clean_text:
- if symbol not in symbol_to_id.keys():
- continue
- symbol_id = symbol_to_id[symbol]
- sequence += [symbol_id]
- return sequence
-
-
-def cleaned_text_to_sequence(cleaned_text):
- '''Converts a string of text to a sequence of IDs corresponding to the symbols in the text.
- Args:
- text: string to convert to a sequence
- Returns:
- List of integers corresponding to the symbols in the text
- '''
- sequence = [_symbol_to_id[symbol] for symbol in cleaned_text if symbol in _symbol_to_id.keys()]
- return sequence
-
-
-def sequence_to_text(sequence):
- '''Converts a sequence of IDs back to a string'''
- result = ''
- for symbol_id in sequence:
- s = _id_to_symbol[symbol_id]
- result += s
- return result
-
-
-def _clean_text(text, cleaner_names):
- for name in cleaner_names:
- cleaner = getattr(cleaners, name)
- if not cleaner:
- raise Exception('Unknown cleaner: %s' % name)
- text, langs = cleaner(text)
- return text, langs
diff --git a/spaces/PublicPrompts/Pixel_diffusion/app.py b/spaces/PublicPrompts/Pixel_diffusion/app.py
deleted file mode 100644
index 62b00075a6420f966ea00fe58e52387684c0dbca..0000000000000000000000000000000000000000
--- a/spaces/PublicPrompts/Pixel_diffusion/app.py
+++ /dev/null
@@ -1,277 +0,0 @@
-from diffusers import AutoencoderKL, UNet2DConditionModel, StableDiffusionPipeline, StableDiffusionImg2ImgPipeline, DPMSolverMultistepScheduler
-import gradio as gr
-import torch
-from PIL import Image
-import utils
-import datetime
-import time
-import psutil
-
-start_time = time.time()
-is_colab = utils.is_google_colab()
-
-class Model:
- def __init__(self, name, path="", prefix=""):
- self.name = name
- self.path = path
- self.prefix = prefix
- self.pipe_t2i = None
- self.pipe_i2i = None
-
-models = [
- Model("ArtOfMtg+V1", "TopdeckingLands/ArtOfMtg_V1", "mtg art"),
- ]
- # Model("Spider-Verse", "nitrosocke/spider-verse-diffusion", "spiderverse style "),
- # Model("Balloon Art", "Fictiverse/Stable_Diffusion_BalloonArt_Model", "BalloonArt "),
- # Model("Elden Ring", "nitrosocke/elden-ring-diffusion", "elden ring style "),
- # Model("Tron Legacy", "dallinmackay/Tron-Legacy-diffusion", "trnlgcy ")
- #Model("Pokémon", "lambdalabs/sd-pokemon-diffusers", ""),
- #Model("Pony Diffusion", "AstraliteHeart/pony-diffusion", ""),
- #Model("Robo Diffusion", "nousr/robo-diffusion", ""),
-
-scheduler = DPMSolverMultistepScheduler(
- beta_start=0.00085,
- beta_end=0.012,
- beta_schedule="scaled_linear",
- num_train_timesteps=1000,
- trained_betas=None,
- predict_epsilon=True,
- thresholding=False,
- algorithm_type="dpmsolver++",
- solver_type="midpoint",
- lower_order_final=True,
-)
-
-custom_model = None
-if is_colab:
- models.insert(0, Model("Custom model"))
- custom_model = models[0]
-
-last_mode = "txt2img"
-current_model = models[1] if is_colab else models[0]
-current_model_path = current_model.path
-
-if is_colab:
- pipe = StableDiffusionPipeline.from_pretrained(current_model.path, torch_dtype=torch.float16, scheduler=scheduler, safety_checker=lambda images, clip_input: (images, False))
-
-else: # download all models
- print(f"{datetime.datetime.now()} Downloading vae...")
- vae = AutoencoderKL.from_pretrained(current_model.path, subfolder="vae", torch_dtype=torch.float16)
- for model in models:
- try:
- print(f"{datetime.datetime.now()} Downloading {model.name} model...")
- unet = UNet2DConditionModel.from_pretrained(model.path, subfolder="unet", torch_dtype=torch.float16)
- model.pipe_t2i = StableDiffusionPipeline.from_pretrained(model.path, unet=unet, vae=vae, torch_dtype=torch.float16, scheduler=scheduler)
- model.pipe_i2i = StableDiffusionImg2ImgPipeline.from_pretrained(model.path, unet=unet, vae=vae, torch_dtype=torch.float16, scheduler=scheduler)
- except Exception as e:
- print(f"{datetime.datetime.now()} Failed to load model " + model.name + ": " + str(e))
- models.remove(model)
- pipe = models[0].pipe_t2i
-
-if torch.cuda.is_available():
- pipe = pipe.to("cuda")
-
-device = "GPU 🔥" if torch.cuda.is_available() else "CPU 🥶"
-
-def error_str(error, title="Error"):
- return f"""#### {title}
- {error}""" if error else ""
-
-def custom_model_changed(path):
- models[0].path = path
- global current_model
- current_model = models[0]
-
-def on_model_change(model_name):
-
- prefix = "Enter prompt. \"" + next((m.prefix for m in models if m.name == model_name), None) + "\" is prefixed automatically" if model_name != models[0].name else "Don't forget to use the custom model prefix in the prompt!"
-
- return gr.update(visible = model_name == models[0].name), gr.update(placeholder=prefix)
-
-def inference(model_name, prompt, guidance, steps, width=512, height=512, seed=0, img=None, strength=0.5, neg_prompt=""):
-
- print(psutil.virtual_memory()) # print memory usage
-
- global current_model
- for model in models:
- if model.name == model_name:
- current_model = model
- model_path = current_model.path
-
- generator = torch.Generator('cuda').manual_seed(seed) if seed != 0 else None
-
- try:
- if img is not None:
- return img_to_img(model_path, prompt, neg_prompt, img, strength, guidance, steps, width, height, generator), None
- else:
- return txt_to_img(model_path, prompt, neg_prompt, guidance, steps, width, height, generator), None
- except Exception as e:
- return None, error_str(e)
-
-def txt_to_img(model_path, prompt, neg_prompt, guidance, steps, width, height, generator):
-
- print(f"{datetime.datetime.now()} txt_to_img, model: {current_model.name}")
-
- global last_mode
- global pipe
- global current_model_path
- if model_path != current_model_path or last_mode != "txt2img":
- current_model_path = model_path
-
- if is_colab or current_model == custom_model:
- pipe = StableDiffusionPipeline.from_pretrained(current_model_path, torch_dtype=torch.float16, scheduler=scheduler, safety_checker=lambda images, clip_input: (images, False))
- else:
- pipe = pipe.to("cpu")
- pipe = current_model.pipe_t2i
-
- if torch.cuda.is_available():
- pipe = pipe.to("cuda")
- last_mode = "txt2img"
-
- prompt = current_model.prefix + prompt
- result = pipe(
- prompt,
- negative_prompt = neg_prompt,
- # num_images_per_prompt=n_images,
- num_inference_steps = int(steps),
- guidance_scale = guidance,
- width = width,
- height = height,
- generator = generator)
-
- return replace_nsfw_images(result)
-
-def img_to_img(model_path, prompt, neg_prompt, img, strength, guidance, steps, width, height, generator):
-
- print(f"{datetime.datetime.now()} img_to_img, model: {model_path}")
-
- global last_mode
- global pipe
- global current_model_path
- if model_path != current_model_path or last_mode != "img2img":
- current_model_path = model_path
-
- if is_colab or current_model == custom_model:
- pipe = StableDiffusionImg2ImgPipeline.from_pretrained(current_model_path, torch_dtype=torch.float16, scheduler=scheduler, safety_checker=lambda images, clip_input: (images, False))
- else:
- pipe = pipe.to("cpu")
- pipe = current_model.pipe_i2i
-
- if torch.cuda.is_available():
- pipe = pipe.to("cuda")
- last_mode = "img2img"
-
- prompt = current_model.prefix + prompt
- ratio = min(height / img.height, width / img.width)
- img = img.resize((int(img.width * ratio), int(img.height * ratio)), Image.LANCZOS)
- result = pipe(
- prompt,
- negative_prompt = neg_prompt,
- # num_images_per_prompt=n_images,
- init_image = img,
- num_inference_steps = int(steps),
- strength = strength,
- guidance_scale = guidance,
- width = width,
- height = height,
- generator = generator)
-
- return replace_nsfw_images(result)
-
-def replace_nsfw_images(results):
-
- if is_colab:
- return results.images[0]
-
- for i in range(len(results.images)):
- if results.nsfw_content_detected[i]:
- results.images[i] = Image.open("nsfw.png")
- return results.images[0]
-
-css = """.finetuned-diffusion-div div{display:inline-flex;align-items:center;gap:.8rem;font-size:1.75rem}.finetuned-diffusion-div div h1{font-weight:900;margin-bottom:7px}.finetuned-diffusion-div p{margin-bottom:10px;font-size:94%}a{text-decoration:underline}.tabs{margin-top:0;margin-bottom:0}#gallery{min-height:20rem}
-"""
-with gr.Blocks(css=css) as demo:
- gr.HTML(
- f"""
-
-
-
Finetuned Diffusion
-
-
- Demo for ArtOfMtg + in colab notebook you can load any other Diffusers 🧨 SD model hosted on HuggingFace 🤗.
-
-
You can skip the queue and load custom models in the colab:
- Running on {device}{(" in a Google Colab." if is_colab else "")}
-
-
- """
- )
- with gr.Row():
-
- with gr.Column(scale=55):
- with gr.Group():
- model_name = gr.Dropdown(label="Model", choices=[m.name for m in models], value=current_model.name)
- with gr.Box(visible=False) as custom_model_group:
- custom_model_path = gr.Textbox(label="Custom model path", placeholder="Path to model, e.g. nitrosocke/Arcane-Diffusion", interactive=True)
- gr.HTML("
Custom models have to be downloaded first, so give it some time.
-