diff --git a/spaces/101-5/gpt4free/g4f/Provider/Providers/Forefront.py b/spaces/101-5/gpt4free/g4f/Provider/Providers/Forefront.py
deleted file mode 100644
index e7e89831cc4ec6dc37ea094d9828a7582e981ff1..0000000000000000000000000000000000000000
--- a/spaces/101-5/gpt4free/g4f/Provider/Providers/Forefront.py
+++ /dev/null
@@ -1,30 +0,0 @@
-import os
-import json
-import requests
-from ...typing import sha256, Dict, get_type_hints
-
-url = 'https://forefront.com'
-model = ['gpt-3.5-turbo']
-supports_stream = True
-needs_auth = False
-
-def _create_completion(model: str, messages: list, stream: bool, **kwargs):
- json_data = {
- 'text': messages[-1]['content'],
- 'action': 'noauth',
- 'id': '',
- 'parentId': '',
- 'workspaceId': '',
- 'messagePersona': '607e41fe-95be-497e-8e97-010a59b2e2c0',
- 'model': 'gpt-4',
- 'messages': messages[:-1] if len(messages) > 1 else [],
- 'internetMode': 'auto'
- }
- response = requests.post( 'https://streaming.tenant-forefront-default.knative.chi.coreweave.com/free-chat',
- json=json_data, stream=True)
- for token in response.iter_lines():
- if b'delta' in token:
- token = json.loads(token.decode().split('data: ')[1])['delta']
- yield (token)
-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]])
\ No newline at end of file
diff --git a/spaces/1acneusushi/gradio-2dmoleculeeditor/data/Adobephotoshopcs2paradoxkeygenindir12 A Complete Guide to Using Adobe Photoshop CS2 Keygen Paradox.md b/spaces/1acneusushi/gradio-2dmoleculeeditor/data/Adobephotoshopcs2paradoxkeygenindir12 A Complete Guide to Using Adobe Photoshop CS2 Keygen Paradox.md
deleted file mode 100644
index 6aa2469896022a7282d92bb252f8b42d84b39f5e..0000000000000000000000000000000000000000
--- a/spaces/1acneusushi/gradio-2dmoleculeeditor/data/Adobephotoshopcs2paradoxkeygenindir12 A Complete Guide to Using Adobe Photoshop CS2 Keygen Paradox.md
+++ /dev/null
@@ -1,171 +0,0 @@
-
-
How to Download and Activate Adobe Photoshop CS2 for Free
-
Adobe Photoshop CS2 is one of the most popular and powerful photo editing software that can help you create stunning images and graphics. However, this software is not free and you need to pay a license fee to use it legally. But what if you want to use Adobe Photoshop CS2 for free without breaking the law? Is there a way to download and activate this software without paying anything?
-
In this article, we will show you how to download and activate Adobe Photoshop CS2 for free using a keygen. We will also explain what a keygen is, how it works, and what are the risks and disadvantages of using it. But before we get into that, let's first understand what Adobe Photoshop CS2 is and why you might want to use it.
Adobe Photoshop CS2 is the ninth version of Adobe Photoshop, which was released in 2005. It is a software that allows you to edit, enhance, and manipulate digital images and graphics. You can use it for various purposes, such as photo retouching, color correction, cropping, resizing, adding effects, filters, layers, masks, text, shapes, and more.
-
Adobe Photoshop CS2 also has some advanced features that make it stand out from other photo editing software. Some of these features are:
-
-
Camera Raw 3.0: This feature allows you to import and edit raw images from digital cameras without losing any quality or data. You can adjust the exposure, white balance, contrast, saturation, sharpness, noise reduction, and more.
-
Smart Objects: This feature allows you to transform and warp raster and vector objects without losing their original quality or resolution. You can also apply filters and effects to smart objects non-destructively.
-
Image Warp: This feature allows you to distort and reshape any image or layer using customizable warp presets or custom points. You can use it to create realistic or artistic effects.
-
Vanishing Point: This feature allows you to clone, paint, and transform images in perspective using a grid that matches the perspective of your image. You can use it to create realistic scenes or compositions.
-
Spot Healing Brush: This feature allows you to quickly remove blemishes, dust, scratches, and other imperfections from your images with a single click. It automatically samples the surrounding pixels and blends them seamlessly.
-
-
These are just some of the features and benefits of Adobe Photoshop CS2 that make it a powerful and versatile photo editing software. However, as we mentioned earlier, this software is not free and you need to pay a license fee to use it legally.
If you want to use Adobe Photoshop CS2 for free without paying anything, you might be wondering how to download it. The good news is that Adobe has made this software available for free download on its official website. However, there is a catch. This software is only intended for users who have purchased a valid license for Adobe Photoshop CS2 in the past and need to reinstall it on their computers. It is not meant for new users who have never bought this software before.
-
Therefore, if you download Adobe Photoshop CS2 from the official website without having a valid license, you will be violating the terms of service and the copyright laws. You will also need a serial number and an activation code to install and activate this software on your computer. These codes are not provided by Adobe on its website.
-
So how can you get these codes for free? This is where a keygen comes in handy.
-
How to Activate Adobe Photoshop CS2 with a Keygen?
-
What is a Keygen?
-
A keygen is a program that generates serial numbers and activation codes for various software products. It is usually created by hackers or crackers who want to bypass the security measures of the software developers. A keygen can help you activate a software product without paying anything or contacting the customer support.
-
However, using a keygen is illegal and unethical. It is considered as software piracy, which is a serious crime that can result in fines or imprisonment. Moreover, using a keygen can also expose your computer to malware infection and data theft.
-
How to Use a Keygen to Generate a Serial Number and an Activation Code?
-
If you still want to use a keygen to activate Adobe Photoshop CS2 for free despite knowing the risks and consequences, here are the steps you need to follow:
-
-
Download a keygen for Adobe Photoshop CS2: You can find many keygens for this software on various websites that offer cracked software or torrents. However, be careful as these websites may contain viruses or malware that can harm your computer or steal your data.
-
Run the keygen program: After downloading the keygen file, extract it if it is compressed and run it on your computer. You may need to disable your antivirus or firewall temporarily as they may detect the keygen as malicious.
-
Select "Photoshop CS2 9.0" from the application list: The keygen program may have options for different software products from Adobe or other companies. Make sure you select "Photoshop CS2 9.0" from the application list before generating any codes.
-
Click "Generate" to get a serial number: The keygen program will generate a random serial number for Adobe Photoshop CS2 that you can use to install the software on your computer. Copy this serial number by selecting it with your mouse cursor and pressing Ctrl+C on your keyboard.
-
Paste the serial number in the setup window of Adobe Photoshop CS2: Go back to the setup window of Adobe Photoshop CS2 that you downloaded from the official website earlier. Choose "I have a serial number" option and paste the serial number that you copied from the keygen program by pressing Ctrl+V on your keyboard.
-
Complete the installation process: Follow the instructions on the screen to complete the installation process of Adobe Photoshop CS2 on your computer.
-
Select "By telephone via" option when prompted for activation: After installing Adobe Photoshop CS2 on your computer Continuing the article:
Select "By telephone via" option when prompted for activation: After installing Adobe Photoshop CS2 on your computer, you will be asked to activate it within 30 days. To do this, choose "By telephone via" option and click "Next". You will see an activation number on the screen.
-
Copy the activation number and paste it in the keygen program: Go back to the keygen program that you ran earlier and select "Photoshop CS2 9.0" from the application list. Copy the activation number from the Adobe Photoshop CS2 window by selecting it with your mouse cursor and pressing Ctrl+C on your keyboard. Then paste it in the "Request Code" field of the keygen program by pressing Ctrl+V on your keyboard.
-
Click "Generate" to get an authorization code: The keygen program will generate an authorization code for Adobe Photoshop CS2 based on the activation number that you entered. Copy this authorization code by selecting it with your mouse cursor and pressing Ctrl+C on your keyboard.
-
Paste the authorization code in the Adobe Photoshop CS2 window: Go back to the Adobe Photoshop CS2 window and paste the authorization code in the "Authorization Code" field by pressing Ctrl+V on your keyboard. Then click "Activate".
-
Enjoy using Adobe Photoshop CS2 for free: If everything goes well, you will see a message saying "Thank you" and confirming that your product has been activated successfully. You can now use Adobe Photoshop CS2 for free without any limitations.
-
-
Risks and Disadvantages of Using a Keygen for Adobe Photoshop CS2
-
While using a keygen may seem like an easy and convenient way to get Adobe Photoshop CS2 for free, it is not without its drawbacks and dangers. Here are some of the risks and disadvantages of using a keygen for Adobe Photoshop CS2:
-
Legal Issues and Penalties for Software Piracy
-
Using a keygen to activate Adobe Photoshop CS2 is considered as software piracy, which is a form of intellectual property theft. Software piracy is illegal in most countries and can result in serious legal consequences, such as fines, lawsuits, or even imprisonment. According to the Business Software Alliance (BSA), software piracy costs the global economy more than $63 billion annually in lost revenue and damages.
-
Moreover, using a keygen to activate Adobe Photoshop CS2 is also unethical and unfair to the software developers who spend a lot of time, money, and effort to create quality products. By using a keygen, you are depriving them of their rightful income and recognition.
-
Malware Infection and Data Theft from Keygens
-
Another risk of using a keygen to activate Adobe Photoshop CS2 is that you may expose your computer to malware infection and data theft. Keygens are often created by hackers or crackers who may have malicious intentions. They may embed viruses, Trojans, worms, spyware, ransomware, or other malware into the keygen files or programs that can harm your computer or steal your data.
-
Some of the possible effects of malware infection and data theft from keygens are:
-
-
Your computer may slow down or crash frequently: Malware can consume a lot of your system resources or damage your files or programs, causing your computer to perform poorly or become unstable.
-
Your personal information may be compromised: Malware can monitor your online activities or keystrokes, access your webcam or microphone, or scan your hard drive for sensitive information, such as passwords, bank accounts, credit cards, or identity documents. This information can then be sent to remote servers or hackers who can use it for identity theft, fraud, blackmail, or other crimes.
-
Your files may be encrypted or deleted: Malware can encrypt or delete your files or folders, making them inaccessible or unusable. You may then be asked to pay a ransom to get them back or risk losing them forever.
-
-
Poor Performance and Functionality of Cracked Software
-
A final disadvantage of using a keygen to activate Adobe Photoshop CS2 is that you may experience poor performance and functionality of the cracked software. Cracked software is software that has been modified or tampered with to bypass its security features or limitations. However, this may also affect its quality or compatibility with your system or other programs.
-
Some of the possible problems that you may encounter with cracked software are:
-
-
Your software may not work properly or at all: Cracked software may have bugs, errors, glitches, or missing features that can prevent it from working properly or at all. You may also not be able to update it to fix these issues or get new features.
-
Your software may be incompatible with your system or other programs: Cracked software may not be compatible with your operating system or hardware specifications. It may also conflict with other programs that you have installed on your computer, causing them to malfunction or crash.
-
Your software may be detected as illegal by the software developer: Cracked software may be detected as illegal by the software developer through online verification or registration processes. You may then be blocked from using it or reported to the authorities.
-
-
Conclusion
-
In conclusion, using a keygen to download and activate Adobe Photoshop CS2 for free is not a good idea. It is illegal, unethical, risky, and disadvantageous. You may face legal issues and penalties for software piracy, malware infection and data theft from keygens, and poor performance and functionality of cracked software.
-
If you want to use Adobe Photoshop CS2 legally and safely, you should buy a valid license from Adobe or use its free alternatives. Some of the free alternatives to Adobe Photoshop CS2 are GIMP, Paint.NET Continuing the article:
Free Alternatives to Adobe Photoshop CS2
-
If you don't want to use a keygen to download and activate Adobe Photoshop CS2 for free, but you also don't want to pay for a license, you may consider using some of the free alternatives to this software. There are many free photo editing software that can offer similar or even better features and functionality than Adobe Photoshop CS2. Some of the best free alternatives to Adobe Photoshop CS2 are:
-
GIMP
-
GIMP (GNU Image Manipulation Program) is one of the most popular and powerful free photo editing software that can help you create stunning images and graphics. It has a very similar interface and features to Adobe Photoshop CS2, such as layers, masks, filters, effects, brushes, tools, and more. You can also import and edit PSD files with GIMP, although some advanced features may not be supported.
-
GIMP is also highly customizable and extensible, as you can add plugins and scripts to enhance its functionality further. GIMP is available for Windows, Mac, and Linux platforms, and supports a wide range of file formats.
-
Pixlr Editor
-
Pixlr Editor is a web-based photo editing software that can run on any browser that supports Flash. It has a very similar interface and features to Adobe Photoshop CS2, such as layers, blending modes, filters, adjustments, tools, and more. You can also import and edit PSD files with Pixlr Editor, although some advanced features may not be supported.
-
Pixlr Editor is very easy to use and convenient, as you don't need to download or install anything on your computer. You can also save your work online or export it to your local drive. Pixlr Editor is available for free for personal use.
-
Paint.NET
-
Paint.NET is a free photo editing software that was originally designed as a more advanced version of Microsoft Paint. It has a simple and intuitive interface that offers basic and advanced features, such as layers, effects, adjustments, tools, and more. You can also import and edit PSD files with Paint.NET, although some advanced features may not be supported.
-
Paint.NET is also very fast and lightweight, as it runs on the .NET Framework. You can also add plugins and extensions to enhance its functionality further. Paint.NET is available for Windows platforms only.
-
Krita
-
Krita is a free and open-source photo editing software that is mainly focused on digital painting and drawing. It has a rich set of features that can help you create amazing artworks, such as brushes, textures, patterns, gradients, tools, filters, effects, layers, masks, and more. You can also import and edit PSD files with Krita, although some advanced features may not be supported.
-
Krita is also very user-friendly and customizable, as you can adjust the interface and settings to suit your preferences and workflow. You can also add plugins and scripts to enhance its functionality further. Krita is available for Windows Continuing the article:
Krita
-
Krita is a free and open-source photo editing software that is mainly focused on digital painting and drawing. It has a rich set of features that can help you create amazing artworks, such as brushes, textures, patterns, gradients, tools, filters, effects, layers, masks, and more. You can also import and edit PSD files with Krita, although some advanced features may not be supported.
-
Krita is also very user-friendly and customizable, as you can adjust the interface and settings to suit your preferences and workflow. You can also add plugins and scripts to enhance its functionality further. Krita is available for Windows, Mac, Linux, Android, and ChromeOS platforms.
-
Conclusion
-
In conclusion, Adobe Photoshop CS2 is a powerful and versatile photo editing software that can help you create stunning images and graphics. However, it is not free and you need to pay a license fee to use it legally. If you want to use it for free without paying anything, you may consider using a keygen to download and activate it. However, this is illegal, unethical, risky, and disadvantageous. You may face legal issues and penalties for software piracy, malware infection and data theft from keygens, and poor performance and functionality of cracked software.
-
If you want to use a free photo editing software that can offer similar or even better features and functionality than Adobe Photoshop CS2, you may consider using some of the free alternatives to this software. Some of the best free alternatives to Adobe Photoshop CS2 are GIMP, Pixlr Editor, Paint.NET Continuing the article:
Paint.NET
-
Paint.NET is a free photo editing software that was originally designed as a more advanced version of Microsoft Paint. It has a simple and intuitive interface that offers basic and advanced features, such as layers, effects, adjustments, tools, and more. You can also import and edit PSD files with Paint.NET, although some advanced features may not be supported.
-
Paint.NET is also very fast and lightweight, as it runs on the .NET Framework. You can also add plugins and extensions to enhance its functionality further. Paint.NET is available for Windows platforms only.
-
Krita
-
Krita is a free and open-source photo editing software that is mainly focused on digital painting and drawing. It has a rich set of features that can help you create amazing artworks, such as brushes, textures, patterns, gradients, tools, filters, effects, layers, masks, and more. You can also import and edit PSD files with Krita, although some advanced features may not be supported.
-
Krita is also very user-friendly and customizable, as you can adjust the interface and settings to suit your preferences and workflow. You can also add plugins and scripts to enhance its functionality further. Krita is available for Windows, Mac, Linux, Android, and ChromeOS platforms.
-
Photopea
-
Photopea is a web-based photo editing software that can run on any browser that supports HTML5. It has a very similar interface and features to Adobe Photoshop CS2, such as layers, blending modes, filters, adjustments, tools, and more. You can also import and edit PSD files with Photopea, as well as other file formats such as Sketch or XCF.
-
Photopea is very easy to use and convenient, as you don't need to download or install anything on your computer. You can also save your work online or export it to your local drive. Photopea is available for free for personal use.
-
Conclusion
-
In conclusion, Adobe Photoshop CS2 is a powerful and versatile photo editing software that can help you create stunning images and graphics. However, it is not free and you need to pay a license fee to use it legally. If you want to use it for free without paying anything, you may consider using a keygen to download and activate it. However, this is illegal, unethical, risky, and disadvantageous. You may face legal issues and penalties for software piracy, malware infection and data theft from keygens, and poor performance and functionality of cracked software.
-
If you want to use a free photo editing software that can offer similar or even better features and functionality than Adobe Photoshop CS2 Continuing the article:
If you want to use a free photo editing software that can offer similar or even better features and functionality than Adobe Photoshop CS2, you may consider using some of the free alternatives to this software. Some of the best free alternatives to Adobe Photoshop CS2 are GIMP, Pixlr Editor, Paint.NET, Krita, and Photopea. These software are free, legal, safe, and effective. You can use them to edit, enhance, and manipulate your images and graphics without any limitations or risks.
-
FAQs
-
Here are some of the frequently asked questions about Adobe Photoshop CS2 and its free alternatives:
-
Q: Is Adobe Photoshop CS2 still available?
-
A: Adobe Photoshop CS2 is no longer available for purchase or download from Adobe. The only way to get it is to have a valid license from the past and download it from the official website. However, this is only intended for users who need to reinstall it on their computers. It is not meant for new users who have never bought this software before.
-
Q: Is Adobe Photoshop CS2 compatible with Windows 10?
-
A: Adobe Photoshop CS2 is not officially compatible with Windows 10. It may work on some systems, but it may also cause errors or crashes on others. It is recommended to use a newer version of Adobe Photoshop or a free alternative that is compatible with Windows 10.
-
Q: What are the system requirements for Adobe Photoshop CS2?
-
A: The minimum system requirements for Adobe Photoshop CS2 are:
-
-
Intel Pentium III or 4 processor
-
Windows 2000/XP
-
320 MB of RAM (384 MB recommended)
-
650 MB of available hard-disk space
-
1024 x 768 monitor resolution with 16-bit video card
-
CD-ROM drive
-
Internet or phone connection required for product activation
-
-
Q: What are the advantages of using a keygen for Adobe Photoshop CS2?
-
A: The only advantage of using a keygen for Adobe Photoshop CS2 is that you can download and activate this software for free without paying anything. However, this is illegal, unethical, risky, and disadvantageous. You may face legal issues and penalties for software piracy, malware infection and data theft from keygens, and poor performance and functionality of cracked software.
-
Q: What are the disadvantages of using a keygen for Adobe Photoshop CS2?
-
A: The disadvantages of using a keygen for Adobe Photoshop CS2 are:
-
-
You will be violating the terms of service and the copyright laws of Adobe and the software developers.
-
You will be depriving the software developers of their rightful income and recognition.
-
You will be exposing your computer to malware infection and data theft from keygens.
-
You will be experiencing poor performance and functionality of cracked software.
-
You will not be able to update or get support for your software.
-
- 0a6ba089eb
-
-
\ No newline at end of file
diff --git a/spaces/1acneusushi/gradio-2dmoleculeeditor/data/Download Photoshop CS6 Nesabamedia A Risky and Illegal Way to Get Photoshop for Free.md b/spaces/1acneusushi/gradio-2dmoleculeeditor/data/Download Photoshop CS6 Nesabamedia A Risky and Illegal Way to Get Photoshop for Free.md
deleted file mode 100644
index ed282135fdb73f1541ee720ec0a91f11217cb4c3..0000000000000000000000000000000000000000
--- a/spaces/1acneusushi/gradio-2dmoleculeeditor/data/Download Photoshop CS6 Nesabamedia A Risky and Illegal Way to Get Photoshop for Free.md
+++ /dev/null
@@ -1,38 +0,0 @@
-
-
Download Photoshop CS6 Nesabamedia: A Guide for Beginners
-
Photoshop CS6 is one of the most popular and powerful photo editing software in the world. It offers a range of features and tools that can help you create stunning images and graphics. However, Photoshop CS6 is not free and requires a license to use. If you want to download Photoshop CS6 Nesabamedia, a cracked version of the software, you need to be careful and follow some steps.
In this article, we will show you how to download Photoshop CS6 Nesabamedia safely and legally. We will also explain the risks and disadvantages of using a cracked version of Photoshop CS6. Finally, we will suggest some alternatives to Photoshop CS6 that are free and easy to use.
-
-
How to Download Photoshop CS6 Nesabamedia Safely and Legally
-
Photoshop CS6 Nesabamedia is a modified version of Photoshop CS6 that bypasses the activation process and allows you to use the software without a license. However, downloading and using Photoshop CS6 Nesabamedia is illegal and can expose you to various risks. For example, you may encounter malware, viruses, spyware, or ransomware that can harm your computer or steal your personal information. You may also face legal consequences such as fines or lawsuits from Adobe, the owner of Photoshop CS6.
-
Therefore, we do not recommend downloading or using Photoshop CS6 Nesabamedia. Instead, we suggest you download Photoshop CS6 legally from Adobe's official website. You can get a free trial of Photoshop CS6 for 7 days and then decide whether you want to buy a subscription or not. You can also get a discounted price if you are a student or a teacher.
-
To download Photoshop CS6 legally from Adobe's website, follow these steps:
Sign in with your Adobe ID or create one if you don't have one.
-
Choose your operating system (Windows or Mac) and language.
-
Follow the instructions on the screen to install Photoshop CS6 on your computer.
-
Launch Photoshop CS6 and enjoy your free trial for 7 days.
-
-
-
The Risks and Disadvantages of Using Photoshop CS6 Nesabamedia
-
As we mentioned earlier, using Photoshop CS6 Nesabamedia is illegal and risky. Here are some of the main drawbacks of using a cracked version of Photoshop CS6:
-
-
-
You may get infected with malware, viruses, spyware, or ransomware that can damage your computer or compromise your security.
-
You may not be able to access all the features and updates of Photoshop CS6 as Adobe may block or disable them.
-
You may experience bugs, errors, crashes, or poor performance as Photoshop CS6 Nesabamedia may not be compatible with your system or other software.
-
You may lose your work or data as Photoshop CS6 Nesabamedia may not have a reliable backup or recovery system.
-
You may violate the intellectual property rights of Adobe and face legal actions such as fines or lawsuits.
-
You may miss out on the benefits of being an Adobe customer such as customer support, tutorials, community forums, cloud storage, etc.
-
-
-
The Alternatives to Photoshop CS6 That Are Free and Easy to Use
-
If you don't want to pay for Photoshop CS6 or use a cracked version of it, you can try some alternatives that are free and easy to use. Here are some of the best ones:
-
-
GIMP: GIMP is an open-source image editor that offers many features similar to Photoshop such as layers, masks, filters, brushes, etc. It is compatible with Windows, Mac, and Linux.
-
Pixlr: Pixlr is an online photo editor that allows you to edit your images in your browser without downloading anything. It has a simple interface and a variety of tools such as crop, resize, rotate, adjust colors, add effects, etc.
In this article, we will show you how to download Virtual DJ 7 cracked version for free and how to install it on your computer. We will also explain some of the advantages and disadvantages of using a cracked version of Virtual DJ 7, as well as some tips and tricks to make the most out of it. But before we get into that, let's see what Virtual DJ 7 can do for you.
-
What is Virtual DJ 7?
-
Virtual DJ 7 is a software developed by Atomix Productions that allows you to mix music from your computer using various effects, filters, loops, samples, and more. You can use it with or without any hardware connected to your computer, such as a DJ controller, a mixer, or a turntable. You can also use it to create visuals that match with the beats that you are dropping, as well as stream your mixes live to various platforms like Facebook and YouTube.
-
Virtual DJ 7 has been around for over 20 years and has been updated regularly with new features and improvements. Some of the features that Virtual DJ 7 offers are:
-
-
-
Standard sound music control
-
Selective control (from -34 to +34%)
-
Three-band equalizer with gain + kill
-
One click for beat new fame algorithm
-
Automatic beating machine
-
On-the-fly technology without the need to save or any formatting
-
Automatic counting and leveling
-
Stomp and throw beat
-
Real Search Simulator
-
Automatic rotation of the beats
-
12 point sync
-
Applying the actual sound algorithm
-
Fast performance with optimized
-
Simplified interface and user friendly
-
-
Virtual DJ 7 is compatible with Windows XP, Vista, 7, 8, and 10. It also supports over 300 DJ controllers from various brands like Pioneer, Numark, Reloop, Denon, Hercules, Rane, and more. You can also sync it with your Android or IOS devices using the VirtualDJ Remote app.
-
How to Download Virtual DJ 7 Cracked Version for Free?
-
If you want to download Virtual DJ 7 cracked version for free, you will need to follow these steps:
-
-
Go to this link and click on the download button.
-
You will be redirected to a safe and fast downloader that will help you get the file.
-
Once the download is complete, extract the file using WinRAR or any other software that can handle ZIP files.
-
Turn off your internet connection and disable any antivirus or windows defender that might interfere with the installation.
-
Run the installation file and follow the instructions on the screen.
-
Open the block_host.cmd file as administrator and run it. This will prevent Virtual DJ 7 from connecting to the internet and verifying your license.
-
Run the VDJ 7 application and open keygen.exe.
-
Click on generate and copy the serial number that appears.
-
Paste the serial number in the registration window of Virtual DJ 7 and click on OK.
-
Congratulations! You have successfully installed Virtual DJ 7 cracked version for free.
-
-
-
What are the Pros and Cons of Using Virtual DJ 7 Cracked Version?
-
-
While using Virtual DJ 7 cracked version for free might seem like a great deal, there are some advantages and disadvantages that
ddb901b051
-
-
\ No newline at end of file
diff --git a/spaces/1acneusushi/gradio-2dmoleculeeditor/data/HACK Camtasia Studio 7 Serial Tips and Tricks to Make the Most of the Software.md b/spaces/1acneusushi/gradio-2dmoleculeeditor/data/HACK Camtasia Studio 7 Serial Tips and Tricks to Make the Most of the Software.md
deleted file mode 100644
index cccb79ea1ae8da35c220c7ee5e1fac8294424017..0000000000000000000000000000000000000000
--- a/spaces/1acneusushi/gradio-2dmoleculeeditor/data/HACK Camtasia Studio 7 Serial Tips and Tricks to Make the Most of the Software.md
+++ /dev/null
@@ -1,196 +0,0 @@
-
-
HACK Camtasia Studio 7 Serial: How to Get It for Free
-
Camtasia Studio 7 is one of the most popular and powerful screen recording and video editing software in the market. It allows you to create stunning videos for various purposes, such as tutorials, presentations, demos, and more. But how can you get it for free without paying the hefty price tag? In this article, we will show you how to hack Camtasia Studio 7 serial key and enjoy all its features without spending a dime.
Camtasia Studio 7 is a software product developed by TechSmith, a global leader in screen recording and screen capture. It was released in October 2010 and has since been updated with new features and improvements. Camtasia Studio 7 is compatible with Windows and Mac operating systems.
-
Features and benefits of Camtasia Studio 7
-
Camtasia Studio 7 has many features and benefits that make it stand out from other screen recording and video editing software. Some of them are:
-
-
It can record anything on your computer screen, including your webcam, microphone, system audio, cursor movements, keystrokes, and more.
-
It has a built-in video editor that lets you trim, cut, split, crop, rotate, zoom, pan, add transitions, effects, annotations, captions, quizzes, and more.
-
It can export your videos in various formats and resolutions, such as MP4, WMV, AVI, MOV, GIF, etc.
-
It can upload your videos directly to YouTube, Vimeo, Screencast.com, Google Drive, Dropbox, etc.
-
It can create interactive videos with clickable links, buttons, hotspots, etc.
-
It can import media files from your computer or other sources, such as PowerPoint slides, images, audio files, etc.
-
It has a library of royalty-free music tracks and sound effects that you can use in your videos.
-
It has a smart focus feature that automatically zooms in on the important parts of your screen recording.
-
It has a speech-to-text feature that automatically generates captions from your narration.
-
It has a green screen feature that lets you change the background of your video with any image or video.
-
-
How much does Camtasia Studio 7 cost?
-
The official price of Camtasia Studio 7 is $299 for a single-user license. This license allows you to install the software on up to two computers. You can also get a volume discount if you buy multiple licenses at once. For example, if you buy 5 licenses, you can save $50 per license. If you buy 10 licenses, you can save $100 per license.
-
However, if you are an educator or a student, you can get a special academic discount of $179 for a single-user license. This license allows you to install the software on up to two computers as well. You just need to provide proof of your academic status when purchasing the software.
-
Why do you need a serial key for Camtasia Studio 7?
-
Activation and registration process
-
A serial key is a unique code that is required to activate and register your copy of Camtasia Studio 7. Without a valid serial key, you cannot use the software beyond the 30-day trial period. The trial version has all the features of the full version except for the ability to produce videos without a watermark.
-
How to hack Camtasia Studio 7 with serial key
-Camtasia Studio 7 crack download free
-Camtasia Studio 7 serial number generator online
-Hack Camtasia Studio 7 activation code
-Camtasia Studio 7 license key hack
-Camtasia Studio 7 full version crack
-Camtasia Studio 7 keygen hack
-Camtasia Studio 7 patch hack
-Camtasia Studio 7 registration code hack
-Camtasia Studio 7 product key hack
-Hack Camtasia Studio 7 for free
-Camtasia Studio 7 hacked version download
-Camtasia Studio 7 crack file download
-Hack Camtasia Studio 7 without survey
-Camtasia Studio 7 serial key hack tool
-Camtasia Studio 7 crack software download
-Hack Camtasia Studio 7 offline activation
-Camtasia Studio 7 hack no virus
-Camtasia Studio 7 crack tutorial
-Hack Camtasia Studio 7 latest version
-Camtasia Studio 7 crack windows 10
-Hack Camtasia Studio 7 mac os
-Camtasia Studio 7 crack reddit
-Hack Camtasia Studio 7 youtube
-Camtasia Studio 7 crack blogspot
-Hack Camtasia Studio 7 quora
-Camtasia Studio 7 crack forum
-Hack Camtasia Studio 7 facebook
-Camtasia Studio 7 crack twitter
-Hack Camtasia Studio 7 instagram
-Camtasia Studio 7 crack pinterest
-Hack Camtasia Studio 7 telegram
-Camtasia Studio 7 crack whatsapp
-Hack Camtasia Studio 7 discord
-Camtasia Studio 7 crack email
-Hack Camtasia Studio 7 phone number
-Camtasia Studio 7 crack sms
-Hack Camtasia Studio 7 voice call
-Camtasia Studio 7 crack video call
-Hack Camtasia Studio 7 webcam
-Camtasia Studio 7 crack screen recorder
-Hack Camtasia Studio 7 screen capture
-Camtasia Studio 7 crack video editor
-Hack Camtasia Studio 7 video maker
-Camtasia Studio 7 crack audio editor
-Hack Camtasia Studio 7 audio recorder
-Camtasia Studio 7 crack animation maker
-Hack Camtasia Studio 7 animation editor
-Camtasia Studio 7 crack gif maker
-
To activate and register your copy of Camtasia Studio 7, you need to follow these steps:
-
-
Download and install the software from the official website or from a CD/DVD.
-
Launch the software and enter your name and email address.
-
Enter your serial key when prompted. You can find your serial key in your order confirmation email or on the back of your CD/DVD case.
-
Click on Activate.
-
You will receive a confirmation message that your software has been activated and registered successfully.
-
-
Benefits of having a valid serial key
-
Having a valid serial key for Camtasia Studio 7 has many benefits. Some of them are:
-
-
You can use the software without any limitations or restrictions.
-
You can get free updates and bug fixes for the software.
-
You can get technical support from TechSmith via phone or email.
-
You can access online resources such as tutorials, forums, blogs, etc.
-
You can join the TechSmith community and share your feedback and ideas with other users.
-
-
Risks of using a hacked serial key
-
Using a hacked serial key for Camtasia Studio 7 may seem tempting but it also comes with many risks. Some of them are:
-
-
You may violate the terms and conditions of TechSmith and face legal consequences.
-
You may expose your computer to viruses, malware, spyware, etc. that may harm your system or steal your personal information.
-
You may experience errors, crashes, glitches, or poor performance with the software.
-
You may not be able to update or upgrade the software or access its online features.
-
You may not be able to get technical support or customer service from TechSmith.
-
You may lose your credibility and reputation as a professional or an educator.
-
-
How to hack Camtasia Studio 7 serial key?
-
If you still want to hack Camtasia Studio 7 serial key despite knowing the risks involved, there are two common methods that people use: using a keygen program or using a crack file. However, we do not recommend or endorse these methods as they are illegal, unethical, and unsafe. Use them at your own risk!
-
Method 1: Use a keygen program
-
A keygen program is a software tool that generates random serial keys for various software products, including Camtasia Studio 7. You can download such programs from various websites, but be careful as they may contain viruses or malware. Also, make sure that you disable your antivirus or firewall before running them as they may be detected as threats by your security software.
-
Steps to use a keygen program
-
-
Download and install Camtasia Studio 7 from the official website or from a CD/DVD.
-
Download and run a keygen program for Camtasia Studio 7 from any website.
-
Select Camtasia Studio 7 from the list of products.
-
Click on Generate.
-
A random serial key will be displayed. Copy it.
-
Launch Camtasia Studio 7 and enter your name and email address.
-
Paste the serial key when prompted. Click on Activate.
-
If the activation is successful, you will see a confirmation message. If not, try another serial key until you find one that works.
-
-
Pros and cons of using a keygen program
-
The pros of using a keygen program are:
-
-
You can get unlimited serial keys for free.
-
You can activate the software without any limitations or restrictions.
-
You can bypass the activation and registration process.
-
-
The cons of using a keygen program are:
-
-
You may violate the terms and conditions of TechSmith and face legal consequences.
-
You may expose your computer to viruses, malware, spyware, etc. that may harm your system or steal your personal information.
-
You may experience errors, crashes, glitches, or poor performance with the software.
-
You may not be able to update or upgrade the software or access its online features.
-
You may not be able to get technical support or customer service from TechSmith.
-
You may lose your credibility and reputation as a professional or an educator.
-
-
Method 2: Use a crack file
-
A crack file is a modified version of the original executable file of Camtasia Studio 7. It is designed to bypass the activation and registration process and make the software think that it is already registered. You can download such files from various websites, but be careful as they may contain viruses or malware. Also, make sure that you backup your original executable file before replacing it with the crack file.
-
Steps to use a crack file
-
-
Download and install Camtasia Studio 7 from the official website or from a CD/DVD.
-
Download and extract a crack file for Camtasia Studio 7 from any website.
-
Locate the original executable file of Camtasia Studio 7 on your computer. It is usually found in C:\Program Files\TechSmith\Camtasia Studio 7\ folder.
-
Rename the original executable file to something else, such as Camtasia.exe.bak.
-
Copy and paste the crack file to the same folder where the original executable file is located. Make sure that the crack file has the same name as the original executable file, such as Camtasia.exe.
-
Launch Camtasia Studio 7 and enjoy using it without any activation or registration.
-
-
Pros and cons of using a crack file
-
The pros of using a crack file are:
-
-
You can use the software without any limitations or restrictions.
-
You can bypass the activation and registration process.
-
-
The cons of using a crack file are:
-
-
You may violate the terms and conditions of TechSmith and face legal consequences.
-
You may expose your computer to viruses, malware, spyware, etc. that may harm your system or steal your personal information.
-
You may experience errors, crashes, glitches, or poor performance with the software.
-
You may not be able to update or upgrade the software or access its online features.
-
You may not be able to get technical support or customer service from TechSmith.
-
You may lose your credibility and reputation as a professional or an educator.
-
-
Conclusion
-
In this article, we have shown you how to hack Camtasia Studio 7 serial key and get it for free. We have explained what Camtasia Studio 7 is, what its features and benefits are, how much it costs, why you need a serial key for it, and how to hack it using two methods: using a keygen program or using a crack file. However, we have also warned you about the risks and consequences of using these methods as they are illegal, unethical, and unsafe. Therefore, we do not recommend or endorse these methods at all. Use them at your own risk!
-
If you want to use Camtasia Studio 7 legally and safely, we suggest that you buy a valid serial key from TechSmith's official website or from an authorized reseller. You can also get a special academic discount if you are an educator or a student. By doing so, you will not only support the developers of this amazing software but also enjoy its full features and benefits without any hassle or worry. You will also get free updates, technical support, online resources, and access to the TechSmith community. You will also enhance your credibility and reputation as a professional or an educator.
-
So what are you waiting for? Get your serial key for Camtasia Studio 7 today and start creating amazing videos with ease!
-
Summary of the main points
-
-
Camtasia Studio 7 is a powerful screen recording and video editing software that allows you to create stunning videos for various purposes.
-
The official price of Camtasia Studio 7 is $299 for a single-user license. Educators and students can get a special academic discount of $179 for a single-user license.
-
A serial key is required to activate and register Camtasia Studio 7. Without a valid serial key, you cannot use the software beyond the 30-day trial period.
-
There are two common methods to hack Camtasia Studio 7 serial key: using a keygen program or using a crack file. However, these methods are illegal, unethical, and unsafe. They may expose your computer to viruses or malware, violate TechSmith's terms and conditions, cause errors or crashes with the software, prevent you from updating or upgrading the software or accessing its online features, deprive you of technical support or customer service from TechSmith, and damage your credibility and reputation as a professional or an educator.
-
-
Call to action
-
If you want to use Camtasia Studio 7 legally and safely, we urge you to buy a valid serial key from TechSmith's official website or from an authorized reseller. You can also get a special academic discount if you are an educator or a student. By doing so, you will support the developers of this amazing software and enjoy its full features and benefits without any hassle or worry. You will also get free updates, technical support, online resources, and access to the TechSmith community. You will also enhance your credibility and reputation as a professional or an educator. So what are you waiting for? Get your serial key for Camtasia Studio 7 today and start creating amazing videos with ease!
-
Frequently Asked Questions
-
-
What is the difference between Camtasia Studio 7 and Camtasia 2023?
-
Camtasia Studio 7 is an older version of Camtasia that was released in 2010. Camtasia 2023 is the latest version of Camtasia that was released in 2023. Camtasia 2023 has more features and improvements than Camtasia Studio 7, such as new templates, themes, assets, tracks, animations, behaviors, transitions, effects, etc. Camtasia 2023 also has better performance and compatibility than Camtasia Studio 7. However, Camtasia Studio 7 still works well and has many loyal users who prefer its simplicity and familiarity.
-
Can I use both Camtasia Studio 7 and Camtasia 2023 on the same computer?
-
Yes, you can use both Camtasia Studio 7 and Camtasia 2023 on the same computer. They are separate products and do not interfere with each other. However, you cannot open or edit projects created in one version with another version. You need to convert them first using TechSmith's conversion tool.
-
How can I get technical support or customer service for Camtasia Studio 7?
-
If you have bought a valid serial key for Camtasia Studio 7 from TechSmith's official website or from an authorized reseller, you can get technical support or customer service from TechSmith via phone or email. You can also access online resources such as tutorials, forums, blogs, etc.. However, if you have hacked Camtasia Studio 7 serial key using a keygen program or a crack file, you will not be able to get any support or service from TechSmith. You will also risk losing your license or facing legal action from TechSmith.
-
Is there any alternative to hacking Camtasia Studio 7 serial key?
-
If you do not want to pay for Camtasia Studio 7 but still want to use it legally and safely, there are some alternatives that you can try. One alternative is to use TechSmith's free trial offer. You can download and install Camtasia Studio 7 for free and use it for up to 30 days without any limitations or restrictions. However, after the trial period expires, you will need to buy a valid serial key to continue using it. Another alternative is to use TechSmith's academic discount offer. If you are an educator or a student, you can buy a single-user license for Camtasia Studio 7 for only $ 179 for Camtasia Studio 7. You just need to provide proof of your academic status when purchasing the software. This license allows you to install the software on up to two computers as well. However, you will need to renew your license every year to keep using it.
-
What are some tips and tricks to create amazing videos with Camtasia Studio 7?
-
Camtasia Studio 7 is a powerful and versatile software that allows you to create amazing videos with ease. However, to make the most out of it, you need to know some tips and tricks that can enhance your video creation process. Here are some of them:
-
-
Plan your video before you start recording. Think about the purpose, audience, message, and structure of your video. Write a script or an outline that covers the main points and details of your video. This will help you stay focused and organized while recording and editing.
-
Use a good microphone and a quiet environment for recording your narration. Make sure that your voice is clear, loud, and confident. Avoid background noises, echoes, or interruptions that may distract or annoy your viewers. You can also use a pop filter or a windscreen to reduce unwanted sounds.
-
Use the smart focus feature to automatically zoom in on the important parts of your screen recording. This will help you highlight the key information and actions that you want your viewers to see and follow. You can also adjust the smart focus settings or manually add or edit zoom points in the timeline.
-
Use transitions, effects, annotations, captions, quizzes, etc. to add interest and interactivity to your video. These elements can help you emphasize, explain, clarify, or reinforce your message. They can also make your video more engaging and interactive for your viewers. However, do not overuse them as they may clutter or distract from your content.
-
Use the library of royalty-free music tracks and sound effects to add mood and emotion to your video. These elements can help you create a professional and polished sound for your video. They can also make your video more appealing and memorable for your viewers. However, do not use music or sound effects that are too loud, repetitive, or irrelevant to your content.
-
Use the green screen feature to change the background of your video with any image or video. This feature can help you create a more realistic and immersive environment for your video. It can also make your video more creative and fun for your viewers. However, do not use a background that is too busy, distracting, or inappropriate for your content.
-
-
- 0a6ba089eb
-
-
\ No newline at end of file
diff --git a/spaces/1acneusushi/gradio-2dmoleculeeditor/data/HD Online Player (ice age scrat no time for nuts 1080p) - See Scrat travel through time in search of his nut.md b/spaces/1acneusushi/gradio-2dmoleculeeditor/data/HD Online Player (ice age scrat no time for nuts 1080p) - See Scrat travel through time in search of his nut.md
deleted file mode 100644
index 0b14439b351a3425ff83a89655952ea003e54d9c..0000000000000000000000000000000000000000
--- a/spaces/1acneusushi/gradio-2dmoleculeeditor/data/HD Online Player (ice age scrat no time for nuts 1080p) - See Scrat travel through time in search of his nut.md
+++ /dev/null
@@ -1,132 +0,0 @@
-
-
HD Online Player (Ice Age Scrat No Time for Nuts 1080p)
-
If you are looking for a fun and hilarious way to spend seven minutes of your time, you should definitely watch Ice Age Scrat No Time for Nuts, a computer-animated short film from Blue Sky Studios, starring Scrat, the lovable squirrel from Ice Age. In this short film, Scrat accidentally travels through time in pursuit of his beloved acorn, causing chaos and comedy along the way.
-
HD Online Player (ice age scrat no time for nuts 1080p)
In this article, we will tell you everything you need to know about this short film, why it is worth watching, and how you can watch it online in HD quality. So sit back, relax, and get ready to laugh out loud with Scrat.
-
What is Ice Age Scrat No Time for Nuts?
-
Ice Age Scrat No Time for Nuts is a short film that was released on November 21, 2006, on the DVD and Blu-ray release of Ice Age: The Meltdown, the second movie in the Ice Age franchise. It was directed by Chris Renaud and Mike Thurmeier, and features Chris Wedge as the voice of Scrat.
-
The short film follows Scrat on a chase after his nut, which has been accidentally sent forward in time by a frozen time machine that he dug up over an ice-encased skeletal body of a human time traveler. Scrat travels to various times and places in history, such as the Middle Ages, Ancient Rome, Titanic's sinking, World War I trench warfare, prehistoric Earth's asteroid impact event etc., trying to get back his nut while avoiding danger and disaster.
-
The short film was nominated for an Academy Award for Best Animated Short Film in 2007 (but lost to The Danish Poet), and also won an Annie Award for Best Animated Short Subject.
-
Why is it worth watching?
-
There are many reasons why Ice Age Scrat No Time for Nuts is a must-watch for anyone who loves animation, comedy, or Ice Age. Here are some of them:
-
-
The hilarious adventures of Scrat: Scrat is one of the most popular and beloved characters from Ice Age, thanks to his adorable appearance, expressive sounds, and relentless pursuit of his acorn. In this short film, he gets into even more trouble than usual as he travels through time and faces various challenges and enemies. Some of the scenes are so funny that you will laugh until you cry.
-
The amazing animation and sound effects: The animation quality of this short film is superb, with smooth movements, realistic textures, vivid colors, and stunning details. The sound effects are also impressive, with crisp noises, clear voices (mostly Scrat's), and fitting music. You will feel like you are watching a mini-movie rather than a short film.
-
The clever references and homages: The short film is full of references and homages to various historical and cultural events, such as King Arthur's sword Excalibur (which Scrat uses to free his acorn), Robin Hood's archers (who shoot at Scrat), Gladiator's Coliseum (where Scrat faces a lion), Titanic's iceberg (which Scrat causes), Charlie Chaplin's The Great Dictator (where Scrat mimics Hitler's speech), etc. These references add more humor and creativity to the short film.
-
-
How to watch Ice Age Scrat No Time for Nuts online?
-
If you want to watch Ice Age Scrat No Time for Nuts online in HD quality, you have several options to choose from. Here are some of them:
-
Watch ice age scrat no time for nuts online in HD
-Ice age scrat no time for nuts 1080p streaming free
-How to download ice age scrat no time for nuts HD video
-Ice age scrat no time for nuts full movie online HD
-Best HD online player for ice age scrat no time for nuts
-Ice age scrat no time for nuts HD online player review
-Ice age scrat no time for nuts 1080p download link
-Where to watch ice age scrat no time for nuts online in HD
-Ice age scrat no time for nuts HD online player features
-Ice age scrat no time for nuts 1080p torrent magnet
-Ice age scrat no time for nuts online HD quality comparison
-Ice age scrat no time for nuts HD online player installation guide
-Ice age scrat no time for nuts 1080p subtitles download
-Ice age scrat no time for nuts online HD playback speed
-Ice age scrat no time for nuts HD online player troubleshooting
-Ice age scrat no time for nuts 1080p trailer watch online
-Ice age scrat no time for nuts online HD sound quality
-Ice age scrat no time for nuts HD online player compatibility
-Ice age scrat no time for nuts 1080p cast and crew
-Ice age scrat no time for nuts online HD screen size adjustment
-Ice age scrat no time for nuts HD online player update
-Ice age scrat no time for nuts 1080p behind the scenes
-Ice age scrat no time for nuts online HD buffering issues
-Ice age scrat no time for nuts HD online player alternatives
-Ice age scrat no time for nuts 1080p bonus features
-Ice age scrat no time for nuts online HD parental control
-Ice age scrat no time for nuts HD online player feedback
-Ice age scrat no time for nuts 1080p trivia and facts
-Ice age scrat no time for nuts online HD language options
-Ice age scrat no time for nuts HD online player ratings
-Ice age scrat no time for nuts 1080p awards and nominations
-Ice age scrat no time for nuts online HD genre and theme
-Ice age scrat no time for nuts HD online player security and privacy
-Ice age scrat no time for nuts 1080p release date and box office
-Ice age scrat no time for nuts online HD recommendations and suggestions
-Ice age scrat no time for nuts HD online player customer service and support
-Ice age scrat no time for nuts 1080p fan art and merchandise
-Ice age scrat no time for nuts online HD comments and reviews
-Ice age scrat no time for nuts HD online player FAQs and tips
-Ice age scrat no time for nuts 1080p soundtrack and score
-Ice age scrat no time for nuts online HD coupons and discounts
-Ice age scrat no time for nuts HD online player testimonials and success stories
-Ice age scrat no time for nuts 1080p making of and documentary
-Ice age scrat no time for nuts online HD blog and newsletter
-Ice age scrat no time for nuts HD online player affiliate program and commission
-Ice age scrat no time for nuts 1080p sequel and spin-off
-
The official sources
-
The easiest way to watch this short film online is to use one of the official sources where it is available. These include:
-
-
DVD or Blu-ray: You can buy or rent the DVD or Blu-ray release of Ice Age: The Meltdown, which includes this short film as a bonus feature. You can then play it on your DVD or Blu-ray player or computer.
-
Streaming platforms: You can also stream this short film online on some streaming platforms that offer Ice Age: The Meltdown, such as Amazon Prime Video or iTunes. You will need to pay a fee or have a subscription to access these platforms.
-
-
The alternative sources
-
If you don't want to use any of the official sources or pay any money to watch this short film online, you can also try some alternative sources that offer it for free or with ads. These include:
-
-
YouTube: You can find this short film on YouTube uploaded by various users or channels. However, be aware that some of these uploads may have low quality, incomplete content, or copyright issues.
-
Dailymotion: You can also find this short film on Dailymotion uploaded by various users or channels. However, be aware that some of these uploads may have similar problems as YouTube.
-
-
The tips and tricks
-
To enhance your online viewing experience of this short film, you can also use some tips and tricks that will help you avoid any issues or enjoy it more. These include:
-
-
Using a VPN: If you want to access any of the official or alternative sources that are not available in your region or country due to geo-restrictions or censorship laws (such as Netflix), you can use a VPN (virtual private network) service that will mask your IP address and location and allow you to bypass these barriers.
-
Adjusting the settings: If you want to watch this short film in HD quality without any buffering or lagging issues due to your internet speed or connection stability (especially if you are using a free or ad-supported source), you can adjust the settings on your device or browser (such as resolution, quality level etc.) according to your preferences.
-
Using headphones: If you want to enjoy this short film more fully without any distractions or noises from your surroundings (such as other people talking etc.), you can use headphones that will isolate you from external sounds and immerse you in the animation and sound effects.
-
- from Ice Age?
-
If you enjoyed watching Ice Age Scrat No Time for Nuts, you might also like some other related content from Ice Age that you can watch online. These include:
-
The Ice Age movies
-
The Ice Age movies are a series of five computer-animated comedy adventure films that follow the adventures of a group of prehistoric animals as they face various challenges and dangers in their changing world. The main characters are Manny, a woolly mammoth; Sid, a sloth; Diego, a saber-toothed tiger; and Scrat, a squirrel. The movies are:
-
-
Ice Age (2002): The first movie introduces the main characters and their journey to return a human baby to his tribe.
-
Ice Age: The Meltdown (2006): The second movie shows the main characters escaping from a melting ice valley and meeting new friends and foes.
-
Ice Age: Dawn of the Dinosaurs (2009): The third movie takes the main characters to a hidden world of dinosaurs and reveals Scrat's love interest, Scratte.
-
Ice Age: Continental Drift (2012): The fourth movie separates the main characters on different continents due to the continental drift and introduces new characters such as pirates and sirens.
-
Ice Age: Collision Course (2016): The fifth and final movie reunites the main characters as they try to stop a meteor from destroying the world and features Scrat's journey to outer space.
-
-
The Ice Age shorts
-
The Ice Age shorts are a series of computer-animated short films that feature the characters from Ice Age in various scenarios and situations. Some of them are related to the movies, while others are standalone stories. The shorts are:
-
-
Gone Nutty (2002): The first short shows Scrat's attempt to store his acorn collection in a tree, which causes a chain reaction of disasters.
-
No Time for Nuts (2006): The second short shows Scrat's accidental time travel in pursuit of his acorn, which causes chaos and comedy along the way.
-
Surviving Sid (2008): The third short shows Sid's attempt to lead a group of young animals on a camping trip, which goes horribly wrong.
-
Scrat's Continental Crack-Up (2010-2011): The fourth and fifth shorts show Scrat's role in causing the continental drift and his encounter with a female saber-toothed squirrel named Scratazon.
-
Cosmic Scrat-tastrophe (2015): The sixth short shows Scrat's adventure in outer space and his impact on the solar system.
-
Scrat: Spaced Out (2016): The seventh short combines scenes from Collision Course and Cosmic Scrat-tastrophe and shows Scrat's battle with Scratazon over his acorn.
-
Ice Age: A Mammoth Christmas (2011): The eighth short is a Christmas special that shows Manny's attempt to save Christmas after he accidentally destroys Santa's workshop.
-
Ice Age: The Great Egg-Scapade (2016): The ninth short is an Easter special that shows Sid's attempt to run an egg-sitting service, which leads to a kidnapping plot by an evil pirate bunny.
-
-
The Ice Age games
-
The Ice Age games are a series of video games that are based on or inspired by the Ice Age movies and shorts. Some of them are adaptations of the movies, while others are original stories or spin-offs. The games are available to play online or on various platforms such as PC, console, or mobile devices. Some of the games are:
-
-
Ice Age Village: A simulation game where you can create your own village of prehistoric animals and interact with them.
-
Ice Age Adventures: An adventure game where you can explore different islands, rescue your friends, and collect items.
-
Ice Age Avalanche: A puzzle game where you can match fruits and nuts to clear levels and unlock new characters and locations.
-
Ice Age Arctic Blast: A puzzle game where you can blast ice cubes and create combos to clear levels and unlock new characters and locations.
-
Ice Age Scrats Nutty Adventure: An action-adventure game where you can control Scrat and help him find his acorn in various environments.
-
-
Conclusion
-
In conclusion, Ice Age Scrat No Time for Nuts is a hilarious and entertaining short film that you should not miss if you love animation, comedy, or Ice Age. It features Scrat, the lovable squirrel from Ice Age, who travels through time in pursuit of his acorn, causing chaos and comedy along the way. You can watch this short film online in HD quality using one of the official or alternative sources that we have listed above. You can also enjoy some other related content from Ice Age that we have recommended above. So what are you waiting for? Go ahead and watch No Time for Nuts, and have fun with Scrat!
-
Frequently Asked Questions (FAQs)
-
-
Q: How long is Ice Age Scrat No Time for Nuts?
-
A: The original version of this short film is 7 minutes long, while the 4-D version is 12 minutes long.
-
Q: Who directed Ice Age Scrat No Time for Nuts?
-
A: This short film was directed by Chris Renaud and Mike Thurmeier.
-
Q: Who voiced Scrat in Ice Age Scrat No Time for Nuts?
-
A: Scrat was voiced by Chris Wedge, who is also one of the co-founders of Blue Sky Studios.
-
Q: What awards did Ice Age Scrat No Time for Nuts win?
-
A: This short film won an Annie Award for Best Animated Short Subject in 2007.
-
Q: Where can I find more information about Ice Age Scrat No Time for Nuts?
-
A: You can find more information about this short film on Wikipedia, IMDb, or Ice Age Wiki.
- 0a6ba089eb
-
-
\ No newline at end of file
diff --git a/spaces/1gistliPinn/ChatGPT4/Examples/Dos Vidas En Un Instante Descargar Espa Ol.md b/spaces/1gistliPinn/ChatGPT4/Examples/Dos Vidas En Un Instante Descargar Espa Ol.md
deleted file mode 100644
index 0914114c65b61e11b2185fcacb33495956ff11cd..0000000000000000000000000000000000000000
--- a/spaces/1gistliPinn/ChatGPT4/Examples/Dos Vidas En Un Instante Descargar Espa Ol.md
+++ /dev/null
@@ -1,15 +0,0 @@
-
-
Dos vidas en un instante: una comedia romántica sobre el azar y el destino
-
Dos vidas en un instante es una pelÃcula de 1998 dirigida por Peter Howitt y protagonizada por Gwyneth Paltrow y John Hannah. La pelÃcula explora dos posibles escenarios de la vida de Helen Quilley, una ejecutiva de publicidad de Londres, que dependen de si pierde o no el metro el dÃa que es despedida de su trabajo y descubre la infidelidad de su novio.
En la primera versión, Helen deja a Gerry, conoce a un hombre encantador llamado James (John Hannah) y mejora su situación laboral y personal. En la segunda, Helen sigue con Gerry, sospecha de su fidelidad y se vuelve más infeliz. La pelÃcula juega con el humor, la fantasÃa y el romance para reflexionar sobre el papel del azar y la fuerza del destino en nuestras vidas.
Si te ha gustado Dos vidas en un instante, quizás te interesen otras pelÃculas que exploran el tema de las realidades alternativas, como El efecto mariposa, El show de Truman o Matrix. Estas pelÃculas te harán cuestionar tu percepción de la realidad y te mostrarán cómo nuestras elecciones tienen consecuencias imprevisibles.
d5da3c52bf
-
-
\ No newline at end of file
diff --git a/spaces/1phancelerku/anime-remove-background/Download WhatsApp Business for Windows 10 (64-bit) and Boost Your Sales and Customer Satisfaction.md b/spaces/1phancelerku/anime-remove-background/Download WhatsApp Business for Windows 10 (64-bit) and Boost Your Sales and Customer Satisfaction.md
deleted file mode 100644
index 494206fa80c072d98786b7586d209bb891cd6c48..0000000000000000000000000000000000000000
--- a/spaces/1phancelerku/anime-remove-background/Download WhatsApp Business for Windows 10 (64-bit) and Boost Your Sales and Customer Satisfaction.md
+++ /dev/null
@@ -1,196 +0,0 @@
-
-
How to Download WhatsApp Business for Windows 10 64 Bits
-
WhatsApp is one of the most popular messaging apps in the world, with more than 2 billion users. But did you know that there is also a version of WhatsApp designed specifically for businesses? It's called WhatsApp Business, and it can help you connect with your customers, showcase your products, and grow your business.
-
In this article, we will show you how to download WhatsApp Business for Windows 10 64 bits, how to set it up and use it on your PC, and how to make the most of its features. Whether you have a small or a large business, WhatsApp Business can help you reach your goals.
WhatsApp Business is a free-to-download app that allows you to create a business profile, communicate with your customers, and manage your business operations on WhatsApp. You can use it as a standalone app or as a complement to your existing WhatsApp Messenger account.
-
WhatsApp Business is ideal for businesses of any size, as it offers different solutions depending on your needs. Here are some of the benefits and features of WhatsApp Business for small and large businesses.
-
Benefits of WhatsApp Business for Small Businesses
-
If you have a small business, you can use the WhatsApp Business app to:
-
How to install whatsapp business app on windows 10 64 bit
-Whatsapp business for windows 10 64 bit free download
-Whatsapp business desktop app for windows 10 64 bit
-Whatsapp business app download for pc windows 10 64 bit
-Download whatsapp business for laptop windows 10 64 bit
-Whatsapp business for windows 10 pro 64 bit download
-Whatsapp business apk download for windows 10 64 bit
-Whatsapp business app for windows 10 home 64 bit download
-Download whatsapp business for windows 10 enterprise 64 bit
-Whatsapp business web download for windows 10 64 bit
-Whatsapp business app for pc windows 10 64 bit offline installer
-Download whatsapp business for windows 10 education 64 bit
-Whatsapp business setup download for windows 10 64 bit
-Whatsapp business app for windows 10 professional 64 bit download
-Download whatsapp business for windows 10 home premium 64 bit
-Whatsapp business software download for windows 10 64 bit
-Whatsapp business app for windows 10 ultimate 64 bit download
-Download whatsapp business for windows 10 single language 64 bit
-Whatsapp business messenger download for windows 10 64 bit
-Whatsapp business app for windows 10 starter edition 64 bit download
-Download whatsapp business for windows server 2019 standard edition (x64)
-Whatsapp business application download for windows server core (x64)
-Download whatsapp business for windows server essentials (x64)
-Whatsapp business client download for windows server datacenter (x64)
-Download whatsapp business for hyper-v server (x64)
-Whatsapp business exe download for windows server foundation (x64)
-Download whatsapp business for azure stack hub (x64)
-Whatsapp business file download for azure stack edge (x64)
-Download whatsapp business for azure stack hci (x64)
-Whatsapp business installer download for azure sphere os (x64)
-Download whatsapp business for linux subsystem on windows (wsl) (x64)
-Whatsapp business latest version download for docker desktop on windows (x64)
-Download whatsapp business for kubernetes on windows (x64)
-Whatsapp business new version download for virtualbox on windows (x64)
-Download whatsapp business for vmware workstation on windows (x64)
-Whatsapp business old version download for parallels desktop on windows (x64)
-Download whatsapp business for microsoft edge on chromium (x64)
-Whatsapp business update download for google chrome on windows (x64)
-Download whatsapp business for mozilla firefox on windows (x64)
-Whatsapp business beta version download for opera browser on windows (x64)
-Download whatsapp business for safari browser on windows (x64)
-Whatsapp business cracked version download for tor browser on windows (x64)
-Download whatsapp business for brave browser on windows (x64)
-Whatsapp business modded version download for vivaldi browser on windows (x64)
-Download whatsapp business for microsoft office outlook on windows (x64)
-Whatsapp business premium version download for microsoft office teams on windows (x64)
-Download whatsapp business for microsoft office skype on windows (x64)
-Whatsapp business full version download for zoom cloud meetings on windows (x64)
-Download whatsapp business for slack desktop app on windows (x64)
-
-
Create a professional and personalized business profile with your logo, description, contact details, website, and catalog.
-
Showcase your products or services in an easy-to-browse catalog that customers can access from your profile or chat.
-
Send and receive messages, calls, photos, videos, documents, and voice notes with your customers using end-to-end encryption.
-
Use labels, quick replies, and automated messages to organize your chats, save time, and provide better customer service.
-
Get insights into your messaging activity, such as the number of messages sent, delivered, read, and received.
-
Use the same phone number as your personal WhatsApp account or a different one.
-
-
Features of WhatsApp Business for Large Businesses
-
If you have a large business or an enterprise, you can use the WhatsApp Business API to:
-
-
Integrate WhatsApp with your existing systems, such as CRM, ERP, or e-commerce platforms.
-
Scale your communication with customers using chatbots, live agents, or a combination of both.
-
Send notifications, confirmations, reminders, updates, and other relevant information to your customers.
-
Provide customer support and feedback through rich media messages, such as images, videos, audio files, or PDFs.
-
Analyze your performance and customer satisfaction using metrics and reports.
-
Use a verified business account with a green checkmark badge next to your name.
-
-
How to Download and Install WhatsApp Business on Your PC
-
If you want to use WhatsApp Business on your PC running Windows 10 64 bits, you have two options: you can download it from the official website or from the Microsoft Store. Here are the steps for both methods.
-
Requirements for WhatsApp Business on PC
-
Before you download and install WhatsApp Business on your PC, make sure you meet the following requirements:
-
-
You have a Windows 10 PC with a 64-bit processor and at least 4 GB of RAM.
-
You have an active internet connection on your PC and your phone.
-
You have a phone number that you can use to verify your WhatsApp Business account.
-
You have a backup of your WhatsApp Messenger chats if you want to migrate them to WhatsApp Business.
-
-
Steps to Download WhatsApp Business from the Official Website
-
To download WhatsApp Business from the official website, follow these steps:
Click on the Get button and sign in with your Microsoft account if prompted.
-
Wait for the app to download and install on your PC.
-
Launch WhatsApp Business and scan the QR code with your phone to link your account.
-
-
How to Set Up and Use WhatsApp Business on Your PC
-
Once you have downloaded and installed WhatsApp Business on your PC, you can start setting it up and using it. Here are some of the things you can do with WhatsApp Business on your PC.
-
How to Migrate Your Existing WhatsApp Account to WhatsApp Business
-
If you already have a WhatsApp Messenger account and you want to migrate it to WhatsApp Business, you can do so by following these steps:
-
-
Create a backup of your WhatsApp Messenger chats on your phone by going to Settings > Chats > Chat backup > Back up.
-
Open WhatsApp Business on your phone and verify your phone number. Make sure it's the same number as your WhatsApp Messenger account.
-
Restore your chat backup when prompted. You will see a message saying that your chat history will be transferred from WhatsApp Messenger to WhatsApp Business.
-
Open WhatsApp Messenger on your phone and tap Agree & Continue. You will see a message saying that your phone number is no longer registered with WhatsApp Messenger and that you can use it with WhatsApp Business instead.
-
Open WhatsApp Business on your PC and scan the QR code with your phone. You will see your chats and contacts synced with your PC.
-
-
Note that you can't use both WhatsApp Messenger and WhatsApp Business with the same phone number. If you want to use both apps, you need to have two different phone numbers.
-
How to Create Your Business Profile and Catalog
-
To create your business profile and catalog on WhatsApp Business, follow these steps:
-
-
Open WhatsApp Business on your PC and click on the Menu icon (three dots) at the top right corner.
-
Select Settings > Business tools > Business profile.
-
Fill in the details of your business, such as name, category, description, location, hours, email, website, etc. You can also upload a logo or a cover photo for your profile.
-
Click on Save.
-
To create a catalog, go back to Business tools > Catalog.
-
Select Add product or service.
-
Add an image, name, price, description, link, and code for each product or service you want to showcase. You can add up to 500 items in your catalog.
-
Select Add to catalog.
-
-
Your business profile and catalog will be visible to anyone who views or chats with you on WhatsApp. You can also share them with your customers by clicking on the Catalog icon at the bottom of the chat window.
-
How to Send and Receive Messages and Calls with WhatsApp Business
-
To send and receive messages and calls with WhatsApp Business, follow these steps:
-
-
Open WhatsApp Business on your PC and select a contact or a chat from the left panel.
-
Type your message in the text box at the bottom of the chat window. You can also attach files, photos, videos, documents, contacts, or locations by clicking on the Attach icon (paperclip).
-
To send a voice note, click on the Microphone icon and hold it while you record your message. Release it when you are done.
-
To make a voice or video call, click on the Voice call or Video call icon at the top of the chat window. You can also make group calls by adding more participants from the call screen.
-
To receive a message or a call, you will see a notification on your PC. You can reply to the message or answer the call from the notification or from the app.
-
-
All your messages and calls are end-to-end encrypted, which means that only you and the person you are communicating with can read or listen to them.
-
How to Use WhatsApp Web or Desktop with WhatsApp Business
-
If you don't want to download WhatsApp Business on your PC, you can also use WhatsApp Web or Desktop with your WhatsApp Business account. WhatsApp Web is a browser-based version of WhatsApp, while WhatsApp Desktop is an app that you can download from the Microsoft Store. Both versions allow you to access your WhatsApp Business account from your PC.
-
To use WhatsApp Web or Desktop with WhatsApp Business, follow these steps:
-
-
Open WhatsApp Business on your phone and tap on the Menu icon (three dots) at the top right corner.
Scan the QR code on your PC screen with your phone.
-
You will see your WhatsApp Business account synced with your PC. You can use it as you would use the app.
-
-
Note that you need to have your phone connected to the internet and close to your PC for WhatsApp Web or Desktop to work.
-
Tips and Tricks for Using WhatsApp Business Effectively
-
Now that you know how to download, install, set up, and use WhatsApp Business on your PC, here are some tips and tricks to help you use it effectively for your business.
-
How to Use Labels, Quick Replies, and Automated Messages
-
Labels, quick replies, and automated messages are some of the features that can help you organize your chats, save time, and provide better customer service with WhatsApp Business. Here's how to use them:
-
-
Labels: Labels are color-coded tags that you can assign to your chats or contacts to categorize them. For example, you can use labels such as new customer, pending payment, order complete, etc. To create and assign labels, go to Menu > Settings > Business tools > Labels.
-
Quick replies: Quick replies are predefined messages that you can send with a shortcut. For example, you can create a quick reply for greeting your customers, thanking them for their purchase, answering frequently asked questions, etc. To create and use quick replies, go to Menu > Settings > Business tools > Quick replies.
-
Automated messages: Automated messages are messages that are sent automatically when certain conditions are met. For example, you can create an automated message for greeting new customers, sending away messages when you are offline, sending greeting messages when you are online, etc. To create and enable automated messages, go to Menu > Settings > Business tools > Away message / Greeting message.
-
-
How to Use Chatbots and APIs with WhatsApp Business
-
If you have a large business or an enterprise, you may want to use chatbots and APIs with WhatsApp Business to scale your communication with customers and integrate it with your existing systems. Here's how to do it:
-
-
Chatbots: Chatbots are software applications that can simulate human conversations and provide automated responses to customer queries. You can use chatbots with WhatsApp Business to handle common requests, provide information, collect feedback, etc. To create and use chatbots with WhatsApp Business, you need to use a third-party service or platform that supports WhatsApp Business API, such as Twilio, Dialogflow, Chatfuel, etc. You can find a list of official partners here: https://www.whatsapp.com/business/api/partners.
-
APIs: APIs are application programming interfaces that allow you to connect WhatsApp Business with your existing systems, such as CRM, ERP, or e-commerce platforms. You can use APIs with WhatsApp Business to send and receive messages, notifications, media files, etc. To use APIs with WhatsApp Business, you need to register for the WhatsApp Business API and follow the documentation here: https://developers.facebook.com/docs/whatsapp.
-
-
How to Analyze Your Performance and Feedback with WhatsApp Business
-
To measure your success and improve your customer satisfaction with WhatsApp Business, you can use the following features:
-
-
Statistics: Statistics are metrics that show you how your messages are performing, such as the number of messages sent, delivered, read, and received. You can access your statistics by going to Menu > Settings > Business tools > Statistics.
-
Reports: Reports are detailed analyses that show you how your customers are interacting with your business, such as the number of chats, calls, messages, media files, etc. You can access your reports by using a third-party service or platform that supports WhatsApp Business API, such as Twilio, Dialogflow, Chatfuel, etc.
-
Feedback: Feedback is the opinion or rating that your customers give you about your products or services. You can collect feedback from your customers by using surveys, polls, ratings, reviews, etc. You can create and send feedback forms by using a third-party service or platform that supports WhatsApp Business API, such as Twilio, Dialogflow, Chatfuel, etc.
-
-
Conclusion
-
WhatsApp Business is a powerful tool that can help you connect with your customers, showcase your products, and grow your business. In this article, we showed you how to download WhatsApp Business for Windows 10 64 bits, how to set it up and use it on your PC, and how to make the most of its features. Whether you have a small or a large business, WhatsApp Business can help you reach your goals.
-
We hope you found this article helpful and informative. If you have any questions or comments, feel free to leave them below. Thank you for reading!
-
FAQs
-
Here are some of the frequently asked questions about WhatsApp Business:
-
-
Is WhatsApp Business free?
-Yes, WhatsApp Business is free to download and use for both small and large businesses. However, if you use the WhatsApp Business API or a third-party service or platform that supports it, you may incur some costs depending on the provider.
-
Can I use WhatsApp Business and WhatsApp Messenger on the same phone?
-Yes, you can use both apps on the same phone as long as you use different phone numbers for each account. You can also link both accounts and switch between them easily.
-
Can I use WhatsApp Business on multiple devices?
-Yes, you can use WhatsApp Business on multiple devices by using WhatsApp Web or Desktop on your PC or tablet. However, you can only have one active session at a time. If you log in on another device, the previous session will be closed.
-
How can I get verified on WhatsApp Business?
-To get verified on WhatsApp Business and get a green checkmark badge next to your name, you need to use the WhatsApp Business API and follow the verification process here: https://developers.facebook.com/docs/whatsapp/business-verification. Verification is not guaranteed and depends on several factors.
-
How can I delete my WhatsApp Business account?
-To delete your WhatsApp Business account and erase all your data from WhatsApp servers, follow these steps:
-
-
Open WhatsApp Business on your phone and tap on the Menu icon (three dots) at the top right corner.
-
Select Settings > Account > Delete my account.
-
Enter your phone number and tap Delete my account.
-
Confirm your decision by tapping Delete my account again.
-
401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/1phancelerku/anime-remove-background/Download and Listen to Woodys Pull String Phrases The Best Toy Story Sound Effects.md b/spaces/1phancelerku/anime-remove-background/Download and Listen to Woodys Pull String Phrases The Best Toy Story Sound Effects.md
deleted file mode 100644
index 7ecbcd19967f56727e984e487159b78f4700f842..0000000000000000000000000000000000000000
--- a/spaces/1phancelerku/anime-remove-background/Download and Listen to Woodys Pull String Phrases The Best Toy Story Sound Effects.md
+++ /dev/null
@@ -1,153 +0,0 @@
-
-
Woody Pull String Phrases Download: How to Get the Voice of Your Favorite Toy Story Character
-
Introduction
-
If you are a fan of Toy Story, you probably know who Woody is. He is the main protagonist of the animated movie series, and one of the most beloved characters in Disney history. He is a cowboy doll with a pull-string that makes him say various catchphrases when pulled.
-
But did you know that you can download woody pull string phrases for your own toy or project? Whether you want to recreate your childhood memories, make a gift for someone special, or create something fun and creative, you can find and use woody pull string phrases for your own purposes.
In this article, we will tell you everything you need to know about woody pull string phrases download. We will explain what Woody is and why he is popular, what are pull string phrases and how they work, and how to download woody pull string phrases for your own toy or project. Let's get started!
-
What is Woody and Why is He Popular
-
Woody is a fictional character created by Pixar Animation Studios and Walt Disney Pictures. He first appeared in the 1995 film Toy Story, and has since starred in three sequels: Toy Story 2 (1999), Toy Story 3 (2010), and Toy Story 4 (2019). He is also featured in various spin-offs, shorts, video games, and merchandise.
-
woody doll voice box phrases mp3
-toy story woody pull string instructions pdf
-how to make a custom woody voice box
-toy story sound effects collection download
-woody's pull string sound wiki
-toy story sheriff woody voice box youtube
-woody action figure with guitar and hat
-tom hanks woody sound effects creator
-toy story pull string woody hasbro manual
-woody's voice box phrases list
-toy story woody sound clips download free
-how to edit woody's voice in adobe audition
-toy story woody pull string repair guide
-woody's voice box sound effects fandom
-toy story 1 4 woody voice box phrases
-toy story woody pull string replacement parts
-how to record your own woody voice box
-toy story woody soundboard online
-woody's pull string sound effects history
-toy story sheriff woody pull string rules
-toy story woody voice box phrases generator
-how to clean and restore a woody doll
-toy story woody pull string batteries size
-woody's voice box sound effects collection
-toy story 4 woody voice box scene youtube
-toy story pull string woody instructions video
-how to make a woody doll costume with voice box
-toy story sound effects download zip file
-woody's pull string sound wiki trivia
-toy story sheriff woody voice box tutorial
-toy story pull string woody hasbro reviews
-woody's voice box phrases quiz online
-toy story woody sound clips download mp3
-how to fix a broken woody voice box
-toy story woody pull string dimensions and weight
-woody's voice box sound effects origin and owner
-toy story 4 woody voice box quotes and meaning
-toy story pull string woody instructions printable version
-how to change the language of a woody voice box
-toy story sound effects collection list and description
-woody's pull string sound wiki categories and pages
-toy story sheriff woody voice box phrases transcript
-toy story pull string woody hasbro product info and faqs
-woody's voice box phrases fun facts and trivia
-toy story sound clips download for free online
-
Woody's Origin and Appearance
-
Woody was originally conceived as a ventriloquist dummy, but was later changed to a pull-string cowboy doll to make him more appealing and relatable. He is based on the generic western heroes of the 1950s and 1960s, such as Roy Rogers and The Lone Ranger. He wears a yellow plaid shirt, a red bandana, blue jeans, brown boots, a brown cowboy hat, and a sheriff badge. He has brown hair, blue eyes, a big nose, and a friendly smile.
-
Woody's Personality and Role in Toy Story
-
Woody is the leader of the toys that belong to a boy named Andy. He is loyal, brave, smart, kind, and optimistic. He cares deeply for his friends and his owner, and will do anything to protect them. He is also very proud of being Andy's favorite toy, and sometimes gets jealous or insecure when he feels threatened by other toys. He often clashes with Buzz Lightyear, a space ranger action figure who becomes his rival and later his best friend.
-
In the Toy Story series, Woody goes through many adventures and challenges with his fellow toys. He faces villains such as Sid, Lotso, Gabby Gabby, and Stinky Pete. He also meets new friends such as Bo Peep, Jessie, Bullseye, Forky, and Duke Caboom. He learns valuable lessons about friendship, loyalty, courage, sacrifice, and identity.
-
Woody's Catchphrases and Voice Actor
-
Woody is known for his iconic catchphrases that he says when his pull string is pulled. Some of them are:
-
-
"There's a snake in my boot!"
-
"You're my favorite deputy!"
-
"Reach for the sky!"
-
"Howdy, partner!"
-
"Somebody's poisoned the waterhole!"
-
"This town ain't big enough for the two of us!"
-
"Yee-haw! Giddyup, partner! We gotta get this wagon train a-movin'!"
-
-
Woody's voice actor is Tom Hanks, a famous Hollywood star who has won two Academy Awards for Best Actor. Tom Hanks has voiced Woody in all four Toy Story films, as well as in other media. He has said that Woody is one of his favorite characters to play, and that he feels a special connection with him.
-
What are Pull String Phrases and How Do They Work
-
Pull string phrases are pre-recorded messages that are played when a toy or doll's pull string is pulled. They are also known as pull string talkers or pull string voice boxes. They are a type of sound-producing device that can be found in many toys or dolls.
-
The History of Pull String Toys and Dolls
-
The first pull string toy was invented by Thomas Edison in 1890. It was called the Phonograph Doll, and it used a miniature phonograph inside its body to play nursery rhymes when its string was pulled. However, it was not very successful due to its high cost and poor sound quality.
-
The first successful pull string toy was Chatty Cathy, a doll that was introduced by Mattel in 1960. It used a vinyl record inside its chest to play 11 phrases when its ring was pulled. It was very popular among children, especially girls, and sold millions of units. It also inspired many other pull string toys and dolls in the following years.
-
The Mechanism and Technology of Pull String Voice Boxes
-
A pull string voice box consists of four main parts: a record or chip that stores the sound data, a needle or sensor that reads the sound data, a speaker that amplifies the sound data, and a spring that rewinds the record or chip when the string is released.
-
When the string is pulled, it rotates the record or chip inside the voice box. The needle or sensor then picks up the sound data from the record or chip and converts it into an electrical signal. The electrical signal is then sent to the speaker that amplifies the sound data and produces the sound. The spring then pulls back the record or chip to its original position when the string is released.
-
The technology of pull string voice boxes has evolved over time. The earliest models used vinyl records that had limited storage capacity and sound quality. Later models used magnetic tapes that had more storage capacity and sound quality, but were prone to wear and tear. Modern models use digital chips that have high storage capacity and sound quality, and are more durable and reliable.
-
The Advantages and Disadvantages of Pull String Phrases
-
Pull string phrases have some advantages and disadvantages as a sound-producing device. Some of the advantages are:
-
-
They are simple and easy to use. Anyone can pull the string and hear the sound.
-
They are fun and interactive. They can make the toy or doll more lively and engaging.
-
They are nostalgic and classic. They can remind people of their childhood memories and favorite characters.
-
-
Some of the disadvantages are:
-
-
They are limited and repetitive. They can only play a fixed number of phrases that may get boring or annoying over time.
-
They are fragile and sensitive. They can break or malfunction if handled roughly or exposed to moisture or dust.
-
They are noisy and intrusive. They can disturb other people or interfere with other sounds in the environment.
-
-
How to Download Woody Pull String Phrases for Your Own Toy or Project
-
If you want to download woody pull string phrases for your own toy or project, you will need to follow some steps and use some tools. Here is a guide on how to do it:
-
The Sources and Formats of Woody Pull String Phrases Online
-
The first step is to find and download woody pull string phrases from the internet. There are many websites and platforms that offer woody pull string phrases for free or for a fee. Some of them are:
A website that hosts thousands of sound clips from various movies, TV shows, games, etc. You can find woody pull string phrases under the Toy Story category.
A video-sharing platform that hosts millions of videos from various genres and topics. You can find woody pull string phrases by searching for keywords such as "woody pull string", "woody voice", "woody quotes", etc.
An online marketplace that sells various products and services. You can find woody pull string phrases by buying a digital album or a CD that contains them.
-
-
-
The formats of woody pull string phrases online may vary depending on the source. Some of the common formats are MP3, WAV, OGG, etc. You will need to choose a format that is compatible with your device or software.
-
The Steps and Tools to Download and Edit Woody Pull String Phrases
-
The second step is to download and edit woody pull string phrases according to your needs and preferences. You will need some tools to do this, such as a computer, a smartphone, a microphone, a software, etc. Here are some steps to follow:
-
-
Download the woody pull string phrases from the source of your choice. Save them in a folder on your device.
-
Open the software of your choice that can play and edit audio files. Some examples are Audacity, VLC Media Player, Windows Media Player, etc.
-
Import the woody pull string phrases into the software. You can drag and drop them or use the file menu.
-
Edit the woody pull string phrases as you wish. You can cut, copy, paste, trim, crop, fade, amplify, normalize, equalize, etc.
-
Save the edited woody pull string phrases in a format of your choice. You can use the same format as the original or convert it to another format.
-
Export the edited woody pull string phrases to your device or upload them to your online storage or platform.
-
-
The Tips and Tricks to Make Your Own Woody Pull String Toy or Project
-
The third step is to make your own woody pull string toy or project using the downloaded and edited woody pull string phrases. You will need some materials and tools to do this, such as a wooden figure, a voice box, a speaker, a battery, a pull string, some paint, some glue, etc. Here are some tips and tricks to follow:
-
-
Choose a wooden figure that resembles Woody or make your own from scratch. You can use a wooden block, a wooden spoon, a wooden peg, etc. You can also carve or sculpt the figure using a knife or a chisel.
-
Paint and decorate the wooden figure to look like Woody. You can use acrylic paint, markers, stickers, fabric, etc. You can also add some details such as hair, eyes, mouth, hat, badge, etc.
-
Make a hole in the back of the wooden figure and insert the voice box inside. You can use a drill, a saw, a knife, etc. You can also glue or tape the voice box to the back of the figure.
-
Attach the speaker to the voice box and make sure it is loud and clear enough. You can use wires, soldering, clips, etc. You can also hide the speaker behind the figure or inside the hat.
-
Connect the battery to the voice box and make sure it has enough power and life span. You can use wires, soldering, clips, etc. You can also hide the battery behind the figure or inside the hat.
-
Attach the pull string to the voice box and make sure it is long and strong enough. You can use a cord, a rope, a ribbon, etc. You can also decorate the pull string with beads, charms, etc.
-
Test your woody pull string toy or project and enjoy it. You can pull the string and hear Woody say his phrases. You can also play with it or display it as you wish.
-
-
Conclusion
-
In conclusion, woody pull string phrases download is a fun and easy way to get the voice of your favorite Toy Story character. You can find and download woody pull string phrases from various sources online, edit them according to your needs and preferences, and use them for your own toy or project. You can also make your own woody pull string toy or project using some materials and tools, and following some tips and tricks. We hope this article has helped you learn more about woody pull string phrases download and inspired you to try it yourself.
-
FAQs
-
Here are some frequently asked questions about woody pull string phrases download:
-
Q1: Where can I buy a woody pull string toy or doll?
-
A1: You can buy a woody pull string toy or doll from various online or physical stores, such as Amazon, eBay, Walmart, Target, etc. You can also check out some vintage or collectible shops for older models of woody pull string toys or dolls.
-
Q2: How many phrases does woody say when you pull his string?
-
A2: Depending on the model and version of the woody pull string toy or doll, he can say anywhere from 11 to 18 phrases when you pull his string. Some of the most common phrases are "There's a snake in my boot!", "You're my favorite deputy!", "Reach for the sky!", "Howdy, partner!", "Somebody's poisoned the waterhole!", etc.
-
Q3: How can I change the voice or language of woody pull string phrases?
-
A3: If you want to change the voice or language of woody pull string phrases, you will need to download a different set of phrases from the internet, or record your own voice using a microphone and a software. Then, you will need to replace the original record inside the voice box of the toy or doll with the new one, using a screwdriver and some wires. Be careful not to damage the toy or doll while doing this.
-
Q4: How can I make my own woody pull string toy or project?
-
A4: If you want to make your own woody pull string toy or project, you will need some materials and tools such as a wooden figure, a voice box, a speaker, a battery, a pull string, some paint, some glue, etc. You can follow some online tutorials or guides on how to assemble and decorate your own woody pull string toy or project. You can also use your creativity and imagination to make it unique and personalized.
-
Q5: What are some other characters or toys that have pull string phrases?
-
A5: Some other characters or toys that have pull string phrases are Chatty Cathy, Buzz Lightyear, Jessie, Mr. Potato Head, Barbie, Mickey Mouse, Elmo, etc. You can also download their phrases from the internet or make your own.
401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/1phancelerku/anime-remove-background/Download the Thrilling Nollywood Tv Series - Jagaban ft. Selina Tested (Episode 6).md b/spaces/1phancelerku/anime-remove-background/Download the Thrilling Nollywood Tv Series - Jagaban ft. Selina Tested (Episode 6).md
deleted file mode 100644
index 1b23be683f8b97077fad909e9e8a1dbcecb0c02b..0000000000000000000000000000000000000000
--- a/spaces/1phancelerku/anime-remove-background/Download the Thrilling Nollywood Tv Series - Jagaban ft. Selina Tested (Episode 6).md
+++ /dev/null
@@ -1,187 +0,0 @@
-
-
How to Download Jagaban Episode 6 Online
-
If you are a fan of Nigerian action drama series, you might have heard of Jagaban, a popular YouTube series that features Selina Tested, another hit series. Jagaban is a thrilling story of revenge, betrayal, and survival in the streets of Lagos. In this article, we will show you how to download Jagaban episode 6 online, so you can watch it anytime and anywhere you want.
-
What is Jagaban Series?
-
A brief introduction to the plot and characters of Jagaban series
-
Jagaban is a YouTube series created by Holy Ghost Concept, a Nigerian production company that specializes in action and comedy videos. The series follows the life of Jagaban, a young man who was betrayed by his friends and left for dead. He survives and vows to take revenge on those who wronged him. Along the way, he meets Selina, a smart and fearless girl who is also on a mission to avenge her brother's death. Together, they face many enemies and challenges in their quest for justice.
Jagaban series is not just an ordinary action drama series. It is a captivating and realistic portrayal of the struggles and joys of living in Lagos, Nigeria's largest city. The series showcases the culture, language, music, and humor of the Nigerian people. It also features talented actors and actresses who deliver impressive performances and stunts. The series has a loyal fan base that eagerly awaits each new episode. If you are looking for an exciting and entertaining series that will keep you on the edge of your seat, you should definitely watch Jagaban series.
-
Where to Watch Jagaban Episode 6 Online
-
The official YouTube channel of Holy Ghost Concept
-
How to access and subscribe to the channel
-
The best and easiest way to watch Jagaban episode 6 online is to visit the official YouTube channel of Holy Ghost Concept. This is where they upload all their videos, including Jagaban series, Selina Tested series, Lightweight series, and more. You can access their channel by clicking [here](^1^) or by searching "Holy Ghost Concept" on YouTube. You can also subscribe to their channel by clicking the red "Subscribe" button below their banner. This way, you will get notified whenever they upload new videos.
-
How to watch and download the video from YouTube
-
Once you are on their channel, you can scroll down until you find Jagaban episode 6. You can also use the search bar on their channel page and type "Jagaban episode 6". Then, click on the video thumbnail to start watching it. You can adjust the quality and speed of the video according to your preference. You can also like, comment, share, or save the video for later viewing.
-
If you want to download the video from YouTube, you will need a third-party tool or app that can extract videos from YouTube. There are many options available online, but some may not work well or may contain viruses or malware. Therefore, you should be careful when choosing a video downloader tool or app. We
We recommend using one of the following video downloader tools or apps that are compatible with Windows 10 and YouTube:
-
-
4K Video Downloader: This is a low-priced tool that allows you to download videos from YouTube and other sites in various resolutions, formats, and qualities. You can also download playlists, channels, subtitles, and 3D and 360-degree videos. It has a simple and user-friendly interface and supports batch downloading. You can try it for free with some limitations or buy the premium version for $15.
-
By Click Downloader: This is a well-priced software that enables you to download videos from YouTube and more than 40 other sites with one click. You can choose the quality, format, and name of the video, and also download subtitles, playlists, and live videos. It has a modern and intuitive interface and supports batch downloading. You can use it for free with some restrictions or upgrade to the premium version for $5.
-
HitPaw Video Downloader and Converter: This is a freemium tool that works on Windows and MacOS and allows you to download videos from YouTube and other popular sites. You can also convert the videos to different formats and devices, and edit them with basic features. It has a sleek and easy-to-use interface and supports multiple downloads. You can use it for free with some limitations or buy the full version for $9.99.
-
-
Once you have chosen your preferred video downloader tool or app, you can follow these general steps to download Jagaban episode 6 from YouTube:
-
-
Install and launch the video downloader tool or app on your computer.
-
Go to the YouTube video of Jagaban episode 6 that you want to download. You can find it by clicking [here] or by searching "Jagaban episode 6" on YouTube.
-
Copy the URL of the video from the address bar of your browser.
-
Paste the URL into the video downloader tool or app and click the "Download" or "Analyze" button.
-
Select the resolution, format, quality, and location of the video that you want to download.
-
Click the "Download" or "Start" button to begin the downloading process.
-
Wait for the video to be downloaded to your computer.
-
Other video download websites that support Jagaban episode 6
-
A list of some popular and reliable video download websites
-
If you don't want to use a video downloader tool or app, you can also use some online video download websites that support Jagaban episode 6. These websites allow you to download videos from YouTube and other sites without installing any software. However, they may have some drawbacks, such as limited options, slow speed, ads, pop-ups, or malware. Therefore, you should be careful when using these websites and only choose the ones that are trustworthy and secure.
-
Here are some of the popular and reliable video download websites that you can use to download Jagaban episode 6:
-
-
Y2mate: This is a free and fast website that lets you download videos from YouTube and other sites in various formats and qualities. You can also convert videos to audio files, edit videos online, and cut videos to your desired length. It has a simple and clean interface and supports multiple languages. You can access it by clicking [here] or by searching "Y2mate" on Google.
-
SaveFrom.net: This is another free and easy website that enables you to download videos from YouTube and more than 40 other sites with one click. You can choose the quality and format of the video, and also download subtitles, playlists, and channels. It has a modern and user-friendly interface and supports multiple languages. You can visit it by clicking [here] or by searching "SaveFrom.net" on Google.
-
BitDownloader: This is a free and powerful website that allows you to download videos from YouTube and hundreds of other sites in high quality and speed. You can also download videos in bulk, extract audio from videos, and download private videos. It has a sleek and easy-to-use interface and supports multiple languages. You can reach it by clicking [here] or by searching "BitDownloader" on Google.
-
-
How to use these websites to download the video
-
Once you have chosen your preferred video download website, you can follow these general steps to download Jagaban episode 6 from YouTube:
-
* download jagaban episode 6 youtube
-* download jagaban episode 6 facebook
-* download jagaban episode 6 mp4
-* download jagaban episode 6 hd
-* download jagaban episode 6 free
-* download jagaban episode 6 online
-* download jagaban episode 6 full movie
-* download jagaban episode 6 english subtitles
-* download jagaban episode 6 selina tested
-* download jagaban episode 6 lightweight
-* download jagaban episode 6 revenge
-* download jagaban episode 6 anmctv
-* download jagaban episode 6 holy ghost concept
-* download jagaban episode 6 latest
-* download jagaban episode 6 nigerian movie
-* download jagaban episode 6 action movie
-* download jagaban episode 6 thriller movie
-* download jagaban episode 6 drama movie
-* download jagaban episode 6 comedy movie
-* download jagaban episode 6 crime movie
-* download jagaban episode 6 part 1
-* download jagaban episode 6 part 2
-* download jagaban episode 6 part 3
-* download jagaban episode 6 part 4
-* download jagaban episode 6 part 5
-* download jagaban episode 7 preview
-* download jagaban season 1 episode 6
-* download jagaban season 2 episode 6
-* download jagaban season 3 episode 6
-* download jagaban season finale episode 6
-* how to download jagaban episode 6
-* where to download jagaban episode 6
-* best site to download jagaban episode 6
-* fastest way to download jagaban episode 6
-* easiest way to download jagaban episode 6
-* watch and download jagaban episode 6
-* stream and download jagaban episode 6
-* torrent and download jagaban episode 6
-* magnet and download jagaban episode 6
-* direct link and download jagaban episode 6
-
-
Go to the YouTube video of Jagaban episode 6 that you want to download. You can find it by clicking [here] or by searching "Jagaban episode 6" on YouTube.
-
Copy the URL of the video from the address bar of your browser.
-
Open a new tab on your browser and go to the video download website that you have selected.
-
Paste the URL of the video into the search box or input field of the website and click the "Download" or "Go" button.
-
Select the resolution, format, quality, and location of the video that you want to download.
-
Click the "Download" or "Save" button to start the downloading process.
-
Wait for the video to be downloaded to your computer.
-
How to Enjoy Jagaban Episode 6 Offline
-
How to transfer the downloaded video to your device
-
How to use a USB cable or a cloud service to transfer the video
-
After you have downloaded Jagaban episode 6 to your computer, you may want to transfer it to your device, such as your smartphone, tablet, or laptop, so you can watch it offline. There are two common ways to do this: using a USB cable or a cloud service.
-
If you want to use a USB cable, you will need a compatible cable that can connect your computer and your device. You will also need to enable the file transfer mode on your device and grant permission to access the device storage on your computer. Then, you can follow these general steps to transfer the video:
-
-
Connect your device and your computer with the USB cable.
-
On your device, swipe down from the top of the screen and tap the notification that says "USB charging this device".
-
Select "File Transfer" or "Media Transfer Protocol (MTP)" from the options.
-
On your computer, open the File Explorer or Finder and locate your device name under "This PC" or "Devices".
-
Double-click on your device name and open the folder where you want to save the video, such as "Movies" or "Downloads".
-
Drag and drop the video file from your computer to the folder on your device.
-
Wait for the transfer to complete and then safely eject your device from your computer.
-
-
If you want to use a cloud service, you will need an account and an app of a cloud service provider, such as Google Drive, Dropbox, or OneDrive. You will also need an internet connection on both your computer and your device. Then, you can follow these general steps to transfer the video:
-
-
On your computer, open the app or website of the cloud service provider and sign in with your account.
-
Upload the video file from your computer to the cloud service.
-
On your device, open the app or website of the cloud service provider and sign in with the same account.
-
Download the video file from the cloud service to your device.
-
Wait for the download to finish and then open the video file on your device.
-
-
How to play the video on your device using a media player app
-
Once you have transferred Jagaban episode 6 to your device, you can play it offline using a media player app. There are many media player apps available for different devices and platforms, but some may not support all video formats or qualities. Therefore, you should choose a media player app that is compatible with the video file that you have downloaded.
-
Here are some of the popular and reliable media player apps that you can use to play Jagaban episode 6 on your device:
-
-
VLC Media Player: This is a free and open-source app that can play almost any video format and quality. It also has many features and settings that allow you to customize your viewing experience. It is available for Windows, MacOS, Linux, Android, iOS, and more. You can download it by clicking [here] or by searching "VLC Media Player" on Google.
-
MX Player: This is a powerful and versatile app that can play various video formats and qualities. It also supports subtitles, gestures, zooming, playback speed, and more. It is mainly designed for Android devices, but it also has versions for Windows and iOS. You can get it by clicking [here] or by searching "MX Player" on Google.
-
KMPlayer: This is another free and feature-rich app that can play different video formats and qualities. It also supports subtitles, playlists, screen capture, editing, and more. It is compatible with Windows, MacOS, Android, iOS, and more. You can install it by clicking [here] or by searching "KMPlayer" on Google.
-
-
Once you have chosen your preferred media player app, you can follow these general steps to play Jagaban episode 6 on your device:
-
-
Install and launch the media player app on your device.
-
Browse or search for the video file that you have transferred to your device.
-
Tap or click on the video file to start playing it.
-
Adjust the volume, brightness, subtitles, playback speed, and other settings according to your preference.
-
Enjoy watching Jagaban episode 6 offline!
-
-
How to Share
How to Share Your Thoughts and Feedback on Jagaban Episode 6
-
How to leave a comment or a review on the YouTube channel or the video download website
-
After you have watched Jagaban episode 6 offline, you may want to share your thoughts and feedback on the episode with the creators and other viewers. You can do this by leaving a comment or a review on the YouTube channel or the video download website that you have used to download the episode.
-
If you want to leave a comment or a review on the YouTube channel, you will need a Google account and an internet connection. You will also need to visit the YouTube video of Jagaban episode 6 again. Then, you can follow these general steps to leave a comment or a review:
-
-
Sign in to your Google account on YouTube.
-
Go to the YouTube video of Jagaban episode 6 that you have watched offline. You can find it by clicking [here] or by searching "Jagaban episode 6" on YouTube.
-
Scroll down to the bottom of the video page and find the comment section.
-
Type your comment or review in the text box and click the "Comment" button.
-
Wait for your comment or review to be posted and visible to others.
-
-
If you want to leave a comment or a review on the video download website, you may or may not need an account and an internet connection. You will also need to visit the video download website that you have used to download the episode again. Then, you can follow these general steps to leave a comment or a review:
-
-
Go to the video download website that you have used to download Jagaban episode 6. You can find it by clicking [here] or by searching "video download website" on Google.
-
Find the page or section where you can leave a comment or a review on the website. It may be under the video title, description, rating, or feedback.
-
Type your comment or review in the text box and click the "Submit" or "Post" button.
-
Wait for your comment or review to be published and visible to others.
-
-
How to join the online community of Jagaban fans on social media
-
How to find and follow the official social media accounts of Holy Ghost Concept and Jagaban series
-
Another way to share your thoughts and feedback on Jagaban episode 6 is to join the online community of Jagaban fans on social media. You can interact with the creators and other fans of Jagaban series, get updates and news about the series, participate in polls and contests, and more. You can also show your support and appreciation for Holy Ghost Concept and Jagaban series by following their official social media accounts.
-
Here are some of the official social media accounts of Holy Ghost Concept and Jagaban series that you can find and follow:
-
-
Facebook: This is where they post their videos, photos, announcements, events, and more. You can like, comment, share, and react to their posts, as well as send them messages. You can access their Facebook page by clicking [here] or by searching "Holy Ghost Concept" on Facebook.
-
Instagram: This is where they share their behind-the-scenes pictures, stories, reels, and more. You can like, comment, share, and save their posts, as well as send them direct messages. You can visit their Instagram profile by clicking [here] or by searching "@holyghostconcept" on Instagram.
-
Twitter: This is where they tweet their updates, news, opinions, and more. You can like, retweet, reply, and quote their tweets, as well as send them direct messages. You can reach their Twitter account by clicking [here] or by searching "@holyghostconcept" on Twitter.
-
-
How to use hashtags and tags to join the conversation about Jagaban episode 6
-
Besides following the official social media accounts of Holy Ghost Concept and Jagaban series, you can also use hashtags and tags to join the conversation about Jagaban episode 6. Hashtags are words or phrases that start with a # symbol and are used to categorize posts on social media. Tags are words or phrases that start with an @ symbol and are used to mention or notify someone on social media.
-
By using hashtags and tags related to Jagaban episode 6, you can make your posts more visible and relevant to other users who are interested in the same topic. You can also see what other users are saying about Jagaban episode 6 by searching for these hashtags and tags on social media. You can also tag or mention the official accounts of Holy Ghost Concept and Jagaban series, as well as the actors and actresses who star in the series, to show your appreciation and feedback.
-
Here are some of the hashtags and tags that you can use to join the conversation about Jagaban episode 6:
-
-
#JagabanEpisode6: This is the main hashtag that is used to talk about Jagaban episode 6. You can use it to share your thoughts, opinions, questions, and reactions about the episode. You can also search for it to see what other users are saying about the episode.
-
#JagabanSeries: This is the general hashtag that is used to talk about Jagaban series as a whole. You can use it to express your love, support, and admiration for the series. You can also search for it to see what other users are saying about the series.
-
#HolyGhostConcept: This is the hashtag that is used to talk about Holy Ghost Concept, the production company behind Jagaban series and other popular videos. You can use it to show your gratitude, respect, and feedback for their work. You can also search for it to see what other users are saying about Holy Ghost Concept.
-
@holyghostconcept: This is the tag that you can use to mention or notify Holy Ghost Concept on social media. You can use it to ask them questions, give them suggestions, or request for more videos. You can also follow them to get updates and news from them.
-
@selinatested: This is the tag that you can use to mention or notify Selina Tested, the hit series that features Selina, one of the main characters of Jagaban series. You can use it to show your appreciation, curiosity, and excitement for Selina Tested. You can also follow them to get more videos from them.
-
@jagabanofficial: This is the tag that you can use to mention or notify Jagaban Official, the official account of Jagaban series on Instagram. You can use it to show your support, admiration, and feedback for Jagaban series. You can also follow them to get more pictures, stories, reels, and more from them.
-
@davidjonesdavid: This is the tag that you can use to mention or notify David Jones David, the actor who plays Jagaban in Jagaban series. You can use it to show your respect, praise, and criticism for his performance. You can also follow him to get more updates and news from him.
-
@princesssalt2: This is the tag that you can use to mention or notify Princess Salt, the actress who plays Selina in Jagaban series and Selina Tested. You can use it to show your respect, praise, and criticism for her performance. You can also follow her to get more updates and news from her.
-
-
Conclusion
-
Jagaban episode 6 is a thrilling and entertaining episode of Jagaban series that you don't want to miss. It is available online on YouTube and other video download websites that you can use to watch it anytime and anywhere you want. You can also transfer it to your device and play it offline using a media player app. Moreover, you can share your thoughts and feedback on Jagaban episode 6 by joining the online community of Jagaban fans on social media using hashtags and tags.
-
We hope this article has helped you learn how to download Jagaban episode 6 online and enjoy it offline. If you have any questions or suggestions, please feel free to leave a comment below or contact us through our social media accounts. Thank you for reading and happy watching!
-
FAQs
-
Here are some of the frequently asked questions about Jagaban episode 6:
-
-
When was Jagaban episode 6 released?
-
Jagaban episode 6 was released on June 18, 2023 on YouTube by Holy Ghost Concept.
-
How long is Jagaban episode 6?
-
Jagaban episode 6 is about 30 minutes long.
-
What happens in Jagaban episode 6?
-
Jagaban episode 6 continues the story of Jagaban and Selina as they face more enemies and challenges in their quest for revenge. In this episode, they encounter a new rival gang led by a mysterious leader who wants to take over their territory. They also have to deal with some internal conflicts and betrayals within their own gang. Meanwhile, they also discover some shocking secrets and revelations about their pasts.
-
Where can I watch the previous episodes of Jagaban series?
-
You can watch the previous episodes of Jagaban series on the official YouTube channel of Holy Ghost Concept. You can access their channel by clicking [here] or by searching "Holy Ghost Concept" on YouTube. You can also use the video download websites or tools that we have mentioned in this article to download the previous episodes and watch them offline.
-
Will there be more episodes of Jagaban series?
-
Yes, there will be more episodes of Jagaban series coming soon. Holy Ghost Concept has confirmed that they are working on the next episodes and they will release them as soon as possible. You can follow their social media accounts to get the latest updates and news about Jagaban series.
- 401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/1phancelerku/anime-remove-background/Free Fire Advance Server on iPhone How to Get Activation Code and Play.md b/spaces/1phancelerku/anime-remove-background/Free Fire Advance Server on iPhone How to Get Activation Code and Play.md
deleted file mode 100644
index 80582442e993d469aa924ac88aa9594445219f01..0000000000000000000000000000000000000000
--- a/spaces/1phancelerku/anime-remove-background/Free Fire Advance Server on iPhone How to Get Activation Code and Play.md
+++ /dev/null
@@ -1,136 +0,0 @@
-
-
How to Download and Access Free Fire Advance Server on iPhone?
-
Free Fire is one of the most popular mobile games in the world, with millions of players enjoying its thrilling battle royale mode. But did you know that there is a way to experience the new features and updates of Free Fire before they are officially released? Yes, you heard it right. There is a special server called Free Fire Advance Server where you can test the latest content and give feedback to the developers.
-
However, accessing the Advance Server is not as easy as it sounds. You need to register on the official website and get an activation code to join the server. The server is also only available for a limited time and for Android devices only. So, if you want to try out the latest Free Fire content, you need to hurry and sign up for the Advance Server.
In this article, I will guide you through the steps of registering, downloading, installing, and accessing the Free Fire Advance Server. I will also tell you about some of the benefits, features, and problems of the Advance Server. Let's get started!
-
How to register for Free Fire Advance Server?
-
The first step to access the Free Fire Advance Server is to register on the official website. Here are the steps you need to follow:
On the homepage, you will see two options to log in: Facebook and Google. Choose the one that is linked to your Free Fire account.
-
After logging in, you will see a registration form where you need to enter your name, email address, and phone number.
-
Click on "Join Now" to submit your registration.
-
Wait for Garena to review your application and send you an activation code via email.
-
-
Note: Not everyone who registers will receive an activation code. Garena will only select a limited number of users based on their criteria. So, make sure you register as soon as possible to increase your chances of getting selected.
-
How to download and install Free Fire Advance Server APK?
-
The next step is to download and install the Free Fire Advance Server APK file on your Android device. Here are the steps you need to follow:
-
-
Once you receive an activation code via email, go back to https://ff-advance.ff.garena.com/ and log in with your Facebook or Google account.
-
You will see a "Download APK" button on the website. Click on it to download the APK file.
-
The APK file size is around 700 MB, so make sure you have enough storage space on your device.
-
After downloading the APK file, locate it in your file manager and tap on it to install it.
-
You may need to enable "Install from unknown sources" in your device settings to allow the installation of the APK file.
-
Follow the on-screen instructions to complete the installation.
-
-
Note: You need to have at least 2 GB of RAM and Android 4.4 or higher to run the Free Fire Advance Server APK.
-
How to get free fire advance server on iphone
-Free fire advance server ios download link
-Free fire advance server registration for iphone users
-Free fire advance server iphone app
-Free fire advance server download in ios 2022
-Free fire advance server iphone mai kaise download kare
-Free fire advance server ios release date
-Free fire advance server iphone gameplay
-Free fire advance server download for iphone 6
-Free fire advance server ios apk
-Free fire advance server iphone 7 download
-Free fire advance server ios beta
-Free fire advance server download for iphone x
-Free fire advance server ios update
-Free fire advance server iphone 8 plus
-Free fire advance server ios ob35
-Free fire advance server download for iphone 11
-Free fire advance server ios version
-Free fire advance server iphone xr
-Free fire advance server ios ob36
-Free fire advance server download for iphone 12
-Free fire advance server ios requirements
-Free fire advance server iphone xs max
-Free fire advance server ios ob37
-Free fire advance server download for iphone se
-Free fire advance server ios review
-Free fire advance server iphone 6s plus
-Free fire advance server ios ob38
-Free fire advance server download for iphone 13
-Free fire advance server ios features
-Free fire advance server iphone 7 plus download
-Free fire advance server ios ob39
-Free fire advance server download for iphone 5s
-Free fire advance server ios tips and tricks
-Free fire advance server iphone x download
-Free fire advance server ios ob40
-Free fire advance server download for iphone 4s
-Free fire advance server ios gameplay video
-Free fire advance server iphone 8 download
-Free fire advance server ios ob41
-Free fire advance server download for iphone xr max
-Free fire advance server ios bug report
-Free fire advance server iphone se 2020
-Free fire advance server ios ob42
-Free fire advance server download for iphone 12 pro max
-Free fire advance server ios rewards
-Free fire advance server iphone xs
-Free fire advance server ios ob43
-
How to access Free Fire Advance Server?
-
The final step is to access the Free Fire Advance Server and enjoy the new features and updates. Here are the steps you need to follow:
-
-
Open the Free Fire Advance Server app on your device. You will see a different icon and name than the regular Free Fire app.
-
Enter your activation code that you received via email and tap on "Confirm".
-
You will be taken to the main menu of the game, where you can choose your game mode and start playing.
-
You can also access the "Report" button on the top right corner of the screen, where you can report any bugs or glitches you encounter in the game.
-
You can also access the "Feedback" button on the bottom right corner of the screen, where you can give your suggestions and opinions about the new features and updates.
-
-
Note: You can only access the Free Fire Advance Server during the testing period, which is usually a few days before the official update. After that, the server will be closed and you will have to wait for the next testing period.
-
What are the benefits of Free Fire Advance Server?
-
There are many benefits of joining the Free Fire Advance Server, such as:
-
-
You can experience the new features and updates of Free Fire before anyone else.
-
You can help the developers improve the game by reporting bugs and giving feedback.
-
You can earn free diamonds as a reward for your participation and contribution. The more bugs you report and feedback you give, the more diamonds you get.
-
You can have fun and challenge yourself with new content and gameplay.
-
-
What are the features of Free Fire Advance Server?
-
The features of Free Fire Advance Server vary depending on the testing period and the upcoming update. However, some of the common features that you can expect to see are:
-
-
New characters, pets, weapons, skins, emotes, and items.
-
New game modes, maps, events, and missions.
-
New graphics, animations, sounds, and effects.
-
New balance changes, bug fixes, and optimizations.
-
-
For example, in the latest testing period of June 2023, some of the new features that were introduced in the Advance Server were:
-
-
A new character named Remy, who has a passive skill called "Quick Reload" that reduces his reload time by 10%.
-
A new pet named Fifi, who has a passive skill called "Furry Friend" that increases his owner's movement speed by 5% when they are near him.
-
A new weapon called M82B Sniper Rifle, which has a special ability called "Armor Penetration" that ignores 30% of the enemy's armor when shooting.
-
A new game mode called "Bomb Squad", where two teams have to plant or defuse bombs in different locations within a time limit.
-
A new map called "Bermuda Remastered", which is a revamped version of the classic Bermuda map with new locations, structures, and details.
-
-
What are the problems of Free Fire Advance Server?
-
While joining the Free Fire Advance Server can be exciting and rewarding, it also comes with some problems that you need to be aware of, such as:
-
-
The server is only available for Android devices. If you have an iPhone or any other device, you cannot access the Advance Server.
-
The server is only open for a limited time. You cannot play on the Advance Server whenever you want. You have to wait for Garena to announce the testing period and open the server.
-
The server is not stable. Since it is a testing server, you may encounter many bugs, glitches, crashes, and errors in the game. The game may also lag or freeze at times.
-
The server is not compatible with your regular Free Fire account. You cannot use your existing account to play on the Advance Server. You have to create a new account and start from scratch. You also cannot transfer your progress or items from one server to another.
-
-
Conclusion
-
Free Fire Advance Server is a great way to enjoy the new features and updates of Free Fire before they are officially released. You can also help the developers improve the game by reporting bugs and giving feedback. You can also earn free diamonds as a reward for your participation and contribution.
-
However, accessing the Advance Server is not as easy as it sounds. You need to register on the official website and get an activation code to join the server. The server is also only available for a limited time and for Android devices only. So, if you want to try out the latest Free Fire content, you need to hurry and sign up for the Advance Server.
-
In this article, I have guided you through the steps of registering, downloading, installing, and accessing the Free Fire Advance Server. I have also told you about some of the benefits, features, and problems of the Advance Server. I hope you found this article helpful and informative.
-
If you have any questions or comments, feel free to leave them below. I would love to hear from you. And if you liked this article, please share it with your friends and fellow Free Fire fans. Thank you for reading!
-
FAQs
-
Here are some of the frequently asked questions about Free Fire Advance Server:
-
Q: How can I get an activation code for Free Fire Advance Server?
-
A: You can get an activation code for Free Fire Advance Server by registering on the official website and waiting for Garena to send you an email with the code. However, not everyone who registers will receive an activation code. Garena will only select a limited number of users based on their criteria.
-
Q: How can I earn free diamonds on Free Fire Advance Server?
-
A: You can earn free diamonds on Free Fire Advance Server by reporting bugs and giving feedback to the developers. The more bugs you report and feedback you give, the more diamonds you get. You can also earn diamonds by completing certain tasks and missions on the server.
-
Q: How can I update Free Fire Advance Server?
-
A: You can update Free Fire Advance Server by downloading and installing the latest APK file from the official website. You will also receive a notification on the app when there is a new update available.
-
Q: How can I delete Free Fire Advance Server?
-
A: You can delete Free Fire Advance Server by uninstalling the app from your device. You can also remove your account from the server by logging out from the app and deleting your data from the website.
-
Q: How can I contact Free Fire Advance Server support?
-
-### 2. Click 'Edit this file'
-
-Button is in top-right corner.
-
-
-### 3. Make Changes
-
-Change `matplotlib` version from `3.2.2` to `3.3`.
-
-
-### 4. Preview Changes and Submit PR
-
-Click on the **Preview changes** tab to verify your updates. At the bottom of the screen select 'Create a **new branch**
-for this commit', assign your branch a descriptive name such as `fix/matplotlib_version` and click the green **Propose
-changes** button. All done, your PR is now submitted to YOLOv5 for review and approval 😃!
-
-
-### PR recommendations
-
-To allow your work to be integrated as seamlessly as possible, we advise you to:
-
-- ✅ Verify your PR is **up-to-date with origin/master.** If your PR is behind origin/master an
- automatic [GitHub actions](https://github.com/ultralytics/yolov5/blob/master/.github/workflows/rebase.yml) rebase may
- be attempted by including the /rebase command in a comment body, or by running the following code, replacing 'feature'
- with the name of your local branch:
-
-```bash
-git remote add upstream https://github.com/ultralytics/yolov5.git
-git fetch upstream
-git checkout feature # <----- replace 'feature' with local branch name
-git merge upstream/master
-git push -u origin -f
-```
-
-- ✅ Verify all Continuous Integration (CI) **checks are passing**.
-- ✅ Reduce changes to the absolute **minimum** required for your bug fix or feature addition. _"It is not daily increase
- but daily decrease, hack away the unessential. The closer to the source, the less wastage there is."_ -Bruce Lee
-
-## Submitting a Bug Report 🐛
-
-If you spot a problem with YOLOv5 please submit a Bug Report!
-
-For us to start investigating a possibel problem we need to be able to reproduce it ourselves first. We've created a few
-short guidelines below to help users provide what we need in order to get started.
-
-When asking a question, people will be better able to provide help if you provide **code** that they can easily
-understand and use to **reproduce** the problem. This is referred to by community members as creating
-a [minimum reproducible example](https://stackoverflow.com/help/minimal-reproducible-example). Your code that reproduces
-the problem should be:
-
-* ✅ **Minimal** – Use as little code as possible that still produces the same problem
-* ✅ **Complete** – Provide **all** parts someone else needs to reproduce your problem in the question itself
-* ✅ **Reproducible** – Test the code you're about to provide to make sure it reproduces the problem
-
-In addition to the above requirements, for [Ultralytics](https://ultralytics.com/) to provide assistance your code
-should be:
-
-* ✅ **Current** – Verify that your code is up-to-date with current
- GitHub [master](https://github.com/ultralytics/yolov5/tree/master), and if necessary `git pull` or `git clone` a new
- copy to ensure your problem has not already been resolved by previous commits.
-* ✅ **Unmodified** – Your problem must be reproducible without any modifications to the codebase in this
- repository. [Ultralytics](https://ultralytics.com/) does not provide support for custom code ⚠️.
-
-If you believe your problem meets all of the above criteria, please close this issue and raise a new one using the 🐛 **
-Bug Report** [template](https://github.com/ultralytics/yolov5/issues/new/choose) and providing
-a [minimum reproducible example](https://stackoverflow.com/help/minimal-reproducible-example) to help us better
-understand and diagnose your problem.
-
-## License
-
-By contributing, you agree that your contributions will be licensed under
-the [GPL-3.0 license](https://choosealicense.com/licenses/gpl-3.0/)
diff --git a/spaces/AgentVerse/agentVerse/agentverse/environments/tasksolving_env/rules/base.py b/spaces/AgentVerse/agentVerse/agentverse/environments/tasksolving_env/rules/base.py
deleted file mode 100644
index 2e25c017c09df0d3ee7f9592897461274e0eba1b..0000000000000000000000000000000000000000
--- a/spaces/AgentVerse/agentVerse/agentverse/environments/tasksolving_env/rules/base.py
+++ /dev/null
@@ -1,181 +0,0 @@
-from __future__ import annotations
-from typing import TYPE_CHECKING, Any, Dict, List, Tuple, Union, Optional
-
-from agentverse.agents.base import BaseAgent
-from agentverse.utils import AGENT_TYPES
-from agentverse.environments.tasksolving_env.rules.decision_maker import (
- BaseDecisionMaker,
- decision_maker_registry,
-)
-from agentverse.environments.tasksolving_env.rules.evaluator import (
- BaseEvaluator,
- evaluator_registry,
-)
-from agentverse.environments.tasksolving_env.rules.executor import (
- BaseExecutor,
- executor_registry,
-)
-from agentverse.environments.tasksolving_env.rules.role_assigner import (
- BaseRoleAssigner,
- role_assigner_registry,
-)
-from agentverse.environments import BaseRule
-
-if TYPE_CHECKING:
- from agentverse.message import SolverMessage, ExecutorMessage
-
-
-class TasksolvingRule(BaseRule):
- role_assigner: BaseRoleAssigner
- decision_maker: BaseDecisionMaker
- executor: BaseExecutor
- evaluator: BaseEvaluator
-
- role_assign_only_once: bool = False
- add_execution_result_to_critic: bool = False
- add_execution_result_to_solver: bool = False
-
- def __init__(
- self,
- role_assigner_config,
- decision_maker_config,
- executor_config,
- evaluator_config,
- *args,
- **kwargs,
- ):
- def build_components(config: Dict, registry):
- component_type = config.pop("type")
- component = registry.build(component_type, **config)
- return component
-
- role_assigner = build_components(
- role_assigner_config,
- role_assigner_registry,
- )
- decision_maker = build_components(
- decision_maker_config,
- decision_maker_registry,
- )
- executor = build_components(executor_config, executor_registry)
- evaluator = build_components(evaluator_config, evaluator_registry)
- super().__init__(
- role_assigner=role_assigner,
- decision_maker=decision_maker,
- executor=executor,
- evaluator=evaluator,
- *args,
- **kwargs,
- )
-
- def role_assign(
- self,
- task_description: str,
- agents: List[BaseAgent],
- cnt_turn: int,
- advice: str = "",
- ) -> List[BaseAgent]:
- """Assign roles to agents"""
- if self.role_assign_only_once and cnt_turn > 0:
- agents = [agents[AGENT_TYPES.SOLVER]] + agents[AGENT_TYPES.CRITIC]
- else:
- agents = self.role_assigner.step(
- role_assigner=agents[AGENT_TYPES.ROLE_ASSIGNMENT],
- group_members=[agents[AGENT_TYPES.SOLVER]] + agents[AGENT_TYPES.CRITIC],
- advice=advice,
- task_description=task_description,
- )
- if self.role_assign_only_once and cnt_turn == 0:
- agents[AGENT_TYPES.SOLVER] = agents[0]
- agents[AGENT_TYPES.CRITIC] = agents[1:]
- return agents
-
- async def decision_making(
- self,
- task_description: str,
- agents: List[BaseAgent],
- previous_plan: str,
- advice: str = "No advice yet.",
- ) -> List[SolverMessage]:
- # TODO: plan should be string or a special type of object?
-
- # dynamic
- if "dynamic" in self.decision_maker.name:
- plan = await self.decision_maker.astep(
- agents=[agents[AGENT_TYPES.SOLVER], *agents[AGENT_TYPES.CRITIC]],
- manager=agents[AGENT_TYPES.MANAGER],
- task_description=task_description,
- previous_plan=previous_plan,
- advice=advice,
- )
- else:
- plan = await self.decision_maker.astep(
- agents=[agents[AGENT_TYPES.SOLVER], *agents[AGENT_TYPES.CRITIC]],
- task_description=task_description,
- previous_plan=previous_plan,
- advice=advice,
- )
- return plan
-
- async def execute(
- self,
- task_description: str,
- agents: List[BaseAgent],
- final_solution: List[SolverMessage],
- ) -> Any:
- """execution stage.
- Use the executor to finish the task.
- """
-
- results = await self.executor.astep(
- agents[AGENT_TYPES.EXECUTION], task_description, final_solution
- )
- if self.add_execution_result_to_critic:
- for agent in agents[AGENT_TYPES.CRITIC]:
- agent.add_message_to_memory(results)
- if self.add_execution_result_to_solver:
- agents[AGENT_TYPES.SOLVER].add_message_to_memory(results)
- return results
-
- def evaluate(
- self,
- task_description: str,
- agents: List[BaseAgent],
- solution: List[SolverMessage],
- result: List[ExecutorMessage],
- ) -> Tuple[List[int], str]:
- """evaluation stage."""
- # if self.human_eval:
- # print("This round, LLM gave the following result:")
- # print(result)
- # comprehensiveness = input("Please evaluate the comprehensiveness>> ")
- # detailedness = input("Please evaluate the detailedness>> ")
- # feasibility = input("Please evaluate the feasibility>> ")
- # novelty = input("Please evaluate the novelty>> ")
- # advice = input("Please give some advice>>")
- # try:
- # comprehensiveness = int(comprehensiveness)
- # detailedness = int(detailedness)
- # feasibility = int(feasibility)
- # novelty = int(novelty)
- # except ValueError:
- # logger.error("Bad response from human evaluator!")
- # return ([comprehensiveness, detailedness, feasibility, novelty], advice)
- # else:
- evaluation = self.evaluator.step(
- agent=agents[AGENT_TYPES.EVALUATION],
- solution=solution,
- result=result,
- task_description=task_description,
- all_role_description=[
- agents[AGENT_TYPES.SOLVER].role_description,
- *[agent.role_description for agent in agents[AGENT_TYPES.CRITIC]],
- ],
- )
- return evaluation.score, evaluation.advice
-
- def reset(self) -> None:
- self.role_assigner.reset()
- self.decision_maker.reset()
- self.executor.reset()
- self.evaluator.reset()
diff --git a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/spinner/audio/Factory.d.ts b/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/spinner/audio/Factory.d.ts
deleted file mode 100644
index 2d960987c303d916cb55d0c261ddaef5af2777d9..0000000000000000000000000000000000000000
--- a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/spinner/audio/Factory.d.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-import Audio from './Audio';
-import Base from '../base/Base';
-
-export default function Factory(
- config?: Base.IConfig
-): Audio;
\ No newline at end of file
diff --git a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/fixwidthbuttons/AddChildMethods.js b/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/fixwidthbuttons/AddChildMethods.js
deleted file mode 100644
index e06abf1b9af212df7db2577de650d5475a7fc69b..0000000000000000000000000000000000000000
--- a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/fixwidthbuttons/AddChildMethods.js
+++ /dev/null
@@ -1,46 +0,0 @@
-import FixWidthSizer from '../fixwidthsizer/FixWidthSizer.js';
-import IsArray from '../../../plugins/utils/object/IsArray.js';
-
-const SizerAdd = FixWidthSizer.prototype.add;
-
-var Add = function (gameObject) {
- SizerAdd.call(this, gameObject);
- this.buttonGroup.add(gameObject);
- return this;
-};
-
-export default {
- addButton(gameObject) {
- if (IsArray(gameObject)) {
- var gameObjects = gameObject;
- for (var i = 0, cnt = gameObjects.length; i < cnt; i++) {
- Add.call(this, gameObjects[i]);
- }
- } else {
- Add.call(this, gameObject);
- }
- return this;
- },
-
- addButtons(gameObjects) {
- if (IsArray(gameObjects[0])) {
- // 2d array
- var lines = gameObjects, line;
- for (var lineIdx = 0, lastLineIdx = (lines.length - 1); lineIdx <= lastLineIdx; lineIdx++) {
- line = lines[lineIdx];
- for (var i = 0, cnt = line.length; i < cnt; i++) {
- Add.call(this, line[i]);
- }
- if (lineIdx > lastLineIdx) {
- SizerAdd.addNewLine(this);
- }
- }
- } else {
- // 1d array
- for (var i = 0, cnt = gameObjects.length; i < cnt; i++) {
- Add.call(this, gameObjects[i]);
- }
- }
- return this;
- }
-}
\ No newline at end of file
diff --git a/spaces/Amrrs/DragGan-Inversion/stylegan_human/dnnlib/tflib/ops/__init__.py b/spaces/Amrrs/DragGan-Inversion/stylegan_human/dnnlib/tflib/ops/__init__.py
deleted file mode 100644
index 4ee9b7dd51bb69639724580f167b2eac39666266..0000000000000000000000000000000000000000
--- a/spaces/Amrrs/DragGan-Inversion/stylegan_human/dnnlib/tflib/ops/__init__.py
+++ /dev/null
@@ -1,9 +0,0 @@
-# Copyright (c) SenseTime Research. All rights reserved.
-
-# Copyright (c) 2019, NVIDIA Corporation. All rights reserved.
-#
-# This work is made available under the Nvidia Source Code License-NC.
-# To view a copy of this license, visit
-# https://nvlabs.github.io/stylegan2/license.html
-
-# empty
diff --git a/spaces/AnTo2209/3D_Zeroshot_Neural_Style_Transfer/src/style_module/style_module.py b/spaces/AnTo2209/3D_Zeroshot_Neural_Style_Transfer/src/style_module/style_module.py
deleted file mode 100644
index 58309e043e4aa96f2da90f81fbf5df96bc1a1824..0000000000000000000000000000000000000000
--- a/spaces/AnTo2209/3D_Zeroshot_Neural_Style_Transfer/src/style_module/style_module.py
+++ /dev/null
@@ -1,300 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import random
-
-
-def calc_mean_std(x, eps=1e-8):
- """
- calculating channel-wise instance mean and standard variance
- x: shape of (N,C,*)
- """
- mean = torch.mean(x.flatten(2), dim=-1, keepdim=True) # size of (N, C, 1)
- std = torch.std(x.flatten(2), dim=-1, keepdim=True) + eps # size of (N, C, 1)
-
- return mean, std
-
-
-def cal_adain_style_loss(x, y):
- """
- style loss in one layer
-
- Args:
- x, y: feature maps of size [N, C, H, W]
- """
- x_mean, x_std = calc_mean_std(x)
- y_mean, y_std = calc_mean_std(y)
-
- return nn.functional.mse_loss(x_mean, y_mean) \
- + nn.functional.mse_loss(x_std, y_std)
-
-
-def cal_mse_content_loss(x, y):
- return nn.functional.mse_loss(x, y)
-
-
-class LearnableIN(nn.Module):
- '''
- Input: (N, C, L) or (C, L)
- '''
-
- def __init__(self, dim=256):
- super().__init__()
- self.IN = torch.nn.InstanceNorm1d(dim, momentum=1e-4, track_running_stats=True)
-
- def forward(self, x):
- if x.size()[-1] <= 1:
- return x
- return self.IN(x)
-
-
-class SimpleLinearStylizer(nn.Module):
- def __init__(self, input_dim=256, embed_dim=32, n_layers=3) -> None:
- super().__init__()
- self.input_dim = input_dim
- self.embed_dim = embed_dim
-
- self.IN = LearnableIN(input_dim)
-
- self.q_embed = nn.Conv1d(input_dim, embed_dim, 1)
- self.k_embed = nn.Conv1d(input_dim, embed_dim, 1)
- self.v_embed = nn.Conv1d(input_dim, embed_dim, 1)
-
- self.unzipper = nn.Conv1d(embed_dim, input_dim, 1, bias=0)
-
- s_net = []
- for i in range(n_layers - 1):
- out_dim = max(embed_dim, input_dim // 2)
- s_net.append(
- nn.Sequential(
- nn.Conv1d(input_dim, out_dim, 1),
- nn.ReLU(inplace=True),
- )
- )
- input_dim = out_dim
- s_net.append(nn.Conv1d(input_dim, embed_dim, 1))
- self.s_net = nn.Sequential(*s_net)
-
- self.s_fc = nn.Linear(embed_dim ** 2, embed_dim ** 2)
-
- def _vectorized_covariance(self, x):
- cov = torch.bmm(x, x.transpose(2, 1)) / x.size(-1)
- cov = cov.flatten(1)
- return cov
-
- def get_content_matrix(self, c):
- '''
- Args:
- c: content feature [N,input_dim,S]
- Return:
- mat: [N,S,embed_dim,embed_dim]
- '''
- normalized_c = self.IN(c)
- # normalized_c = torch.nn.functional.instance_norm(c)
- q_embed = self.q_embed(normalized_c)
- k_embed = self.k_embed(normalized_c)
-
- c_cov = q_embed.transpose(1, 2).unsqueeze(3) * k_embed.transpose(1, 2).unsqueeze(2) # [N,S,embed_dim,embed_dim]
- attn = torch.softmax(c_cov, -1) # [N,S,embed_dim,embed_dim]
-
- return attn, normalized_c
-
- def get_style_mean_std_matrix(self, s):
- '''
- Args:
- s: style feature [N,input_dim,S]
-
- Return:
- mat: [N,embed_dim,embed_dim]
- '''
- s_mean = s.mean(-1, keepdim=True)
- s_std = s.std(-1, keepdim=True)
- s = s - s_mean
-
- s_embed = self.s_net(s)
- s_cov = self._vectorized_covariance(s_embed)
- s_mat = self.s_fc(s_cov)
- s_mat = s_mat.reshape(-1, self.embed_dim, self.embed_dim)
-
- return s_mean, s_std, s_mat
-
- def transform_content_3D(self, c):
- '''
- Args:
- c: content feature [N,input_dim,S]
- Return:
- transformed_c: [N,embed_dim,S]
- '''
- attn, normalized_c = self.get_content_matrix(c) # [N,S,embed_dim,embed_dim]
- c = self.v_embed(normalized_c) # [N,embed_dim,S]
- c = c.transpose(1, 2).unsqueeze(3) # [N,S,embed_dim,1]
- c = torch.matmul(attn, c).squeeze(3) # [N,S,embed_dim]
-
- return c.transpose(1, 2)
-
- def transfer_style_2D(self, s_mean_std_mat, c, acc_map):
- '''
- Agrs:
- c: content feature map after volume rendering [N,embed_dim,S]
- s_mat: style matrix [N,embed_dim,embed_dim]
- acc_map: [S]
-
- s_mean = [N,input_dim,1]
- s_std = [N,input_dim,1]
- '''
- s_mean, s_std, s_mat = s_mean_std_mat
-
- cs = torch.bmm(s_mat, c) # [N,embed_dim,S]
- cs = self.unzipper(cs) # [N,input_dim,S]
-
- cs = cs * s_std + s_mean * acc_map[None, None, ...]
-
- return cs
-
-
-class AdaAttN(nn.Module):
- """ Attention-weighted AdaIN (Liu et al., ICCV 21) """
-
- def __init__(self, qk_dim, v_dim):
- """
- Args:
- qk_dim (int): query and key size.
- v_dim (int): value size.
- """
- super(AdaAttN, self).__init__()
-
- self.q_embed = nn.Conv1d(qk_dim, qk_dim, 1)
- self.k_embed = nn.Conv1d(qk_dim, qk_dim, 1)
- self.s_embed = nn.Conv1d(v_dim, v_dim, 1)
-
- def forward(self, q, k):
- """
- Args:
- q (float tensor, (bs, qk, *)): query (content) features.
- k (float tensor, (bs, qk, *)): key (style) features.
- c (float tensor, (bs, v, *)): content value features.
- s (float tensor, (bs, v, *)): style value features.
-
- Returns:
- cs (float tensor, (bs, v, *)): stylized content features.
- """
- c, s = q, k
-
- shape = c.shape
- q, k = q.flatten(2), k.flatten(2)
- c, s = c.flatten(2), s.flatten(2)
-
- # QKV attention with projected content and style features
- q = self.q_embed(F.instance_norm(q)).transpose(2, 1) # (bs, n, qk)
- k = self.k_embed(F.instance_norm(k)) # (bs, qk, m)
- s = self.s_embed(s).transpose(2, 1) # (bs, m, v)
- attn = F.softmax(torch.bmm(q, k), -1) # (bs, n, m)
-
- # attention-weighted channel-wise statistics
- mean = torch.bmm(attn, s) # (bs, n, v)
- var = F.relu(torch.bmm(attn, s ** 2) - mean ** 2) # (bs, n, v)
- mean = mean.transpose(2, 1) # (bs, v, n)
- std = torch.sqrt(var).transpose(2, 1) # (bs, v, n)
-
- cs = F.instance_norm(c) * std + mean # (bs, v, n)
- cs = cs.reshape(shape)
- return cs
-
-
-class AdaAttN_new_IN(nn.Module):
- """ Attention-weighted AdaIN (Liu et al., ICCV 21) """
-
- def __init__(self, qk_dim, v_dim):
- """
- Args:
- qk_dim (int): query and key size.
- v_dim (int): value size.
- """
- super(AdaAttN_new_IN, self).__init__()
-
- self.q_embed = nn.Conv1d(qk_dim, qk_dim, 1)
- self.k_embed = nn.Conv1d(qk_dim, qk_dim, 1)
- self.s_embed = nn.Conv1d(v_dim, v_dim, 1)
- self.IN = LearnableIN(qk_dim)
-
- def forward(self, q, k):
- """
- Args:
- q (float tensor, (bs, qk, *)): query (content) features.
- k (float tensor, (bs, qk, *)): key (style) features.
- c (float tensor, (bs, v, *)): content value features.
- s (float tensor, (bs, v, *)): style value features.
-
- Returns:
- cs (float tensor, (bs, v, *)): stylized content features.
- """
- c, s = q, k
-
- shape = c.shape
- q, k = q.flatten(2), k.flatten(2)
- c, s = c.flatten(2), s.flatten(2)
-
- # QKV attention with projected content and style features
- q = self.q_embed(self.IN(q)).transpose(2, 1) # (bs, n, qk)
- k = self.k_embed(F.instance_norm(k)) # (bs, qk, m)
- s = self.s_embed(s).transpose(2, 1) # (bs, m, v)
- attn = F.softmax(torch.bmm(q, k), -1) # (bs, n, m)
-
- # attention-weighted channel-wise statistics
- mean = torch.bmm(attn, s) # (bs, n, v)
- var = F.relu(torch.bmm(attn, s ** 2) - mean ** 2) # (bs, n, v)
- mean = mean.transpose(2, 1) # (bs, v, n)
- std = torch.sqrt(var).transpose(2, 1) # (bs, v, n)
-
- cs = self.IN(c) * std + mean # (bs, v, n)
- cs = cs.reshape(shape)
- return cs
-
-
-class AdaAttN_woin(nn.Module):
- """ Attention-weighted AdaIN (Liu et al., ICCV 21) """
-
- def __init__(self, qk_dim, v_dim):
- """
- Args:
- qk_dim (int): query and key size.
- v_dim (int): value size.
- """
- super().__init__()
-
- self.q_embed = nn.Conv1d(qk_dim, qk_dim, 1)
- self.k_embed = nn.Conv1d(qk_dim, qk_dim, 1)
- self.s_embed = nn.Conv1d(v_dim, v_dim, 1)
-
- def forward(self, q, k):
- """
- Args:
- q (float tensor, (bs, qk, *)): query (content) features.
- k (float tensor, (bs, qk, *)): key (style) features.
- c (float tensor, (bs, v, *)): content value features.
- s (float tensor, (bs, v, *)): style value features.
-
- Returns:
- cs (float tensor, (bs, v, *)): stylized content features.
- """
- c, s = q, k
-
- shape = c.shape
- q, k = q.flatten(2), k.flatten(2)
- c, s = c.flatten(2), s.flatten(2)
-
- # QKV attention with projected content and style features
- q = self.q_embed(q).transpose(2, 1) # (bs, n, qk)
- k = self.k_embed(k) # (bs, qk, m)
- s = self.s_embed(s).transpose(2, 1) # (bs, m, v)
- attn = F.softmax(torch.bmm(q, k), -1) # (bs, n, m)
-
- # attention-weighted channel-wise statistics
- mean = torch.bmm(attn, s) # (bs, n, v)
- var = F.relu(torch.bmm(attn, s ** 2) - mean ** 2) # (bs, n, v)
- mean = mean.transpose(2, 1) # (bs, v, n)
- std = torch.sqrt(var).transpose(2, 1) # (bs, v, n)
-
- cs = c * std + mean # (bs, v, n)
- cs = cs.reshape(shape)
- return cs
\ No newline at end of file
diff --git a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/docs/source/en/api/models/asymmetricautoencoderkl.md b/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/docs/source/en/api/models/asymmetricautoencoderkl.md
deleted file mode 100644
index c7b3ee9b5155914240ce865c309b05bcf5206a30..0000000000000000000000000000000000000000
--- a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/docs/source/en/api/models/asymmetricautoencoderkl.md
+++ /dev/null
@@ -1,55 +0,0 @@
-# AsymmetricAutoencoderKL
-
-Improved larger variational autoencoder (VAE) model with KL loss for inpainting task: [Designing a Better Asymmetric VQGAN for StableDiffusion](https://arxiv.org/abs/2306.04632) by Zixin Zhu, Xuelu Feng, Dongdong Chen, Jianmin Bao, Le Wang, Yinpeng Chen, Lu Yuan, Gang Hua.
-
-The abstract from the paper is:
-
-*StableDiffusion is a revolutionary text-to-image generator that is causing a stir in the world of image generation and editing. Unlike traditional methods that learn a diffusion model in pixel space, StableDiffusion learns a diffusion model in the latent space via a VQGAN, ensuring both efficiency and quality. It not only supports image generation tasks, but also enables image editing for real images, such as image inpainting and local editing. However, we have observed that the vanilla VQGAN used in StableDiffusion leads to significant information loss, causing distortion artifacts even in non-edited image regions. To this end, we propose a new asymmetric VQGAN with two simple designs. Firstly, in addition to the input from the encoder, the decoder contains a conditional branch that incorporates information from task-specific priors, such as the unmasked image region in inpainting. Secondly, the decoder is much heavier than the encoder, allowing for more detailed recovery while only slightly increasing the total inference cost. The training cost of our asymmetric VQGAN is cheap, and we only need to retrain a new asymmetric decoder while keeping the vanilla VQGAN encoder and StableDiffusion unchanged. Our asymmetric VQGAN can be widely used in StableDiffusion-based inpainting and local editing methods. Extensive experiments demonstrate that it can significantly improve the inpainting and editing performance, while maintaining the original text-to-image capability. The code is available at https://github.com/buxiangzhiren/Asymmetric_VQGAN*
-
-Evaluation results can be found in section 4.1 of the original paper.
-
-## Available checkpoints
-
-* [https://huggingface.co/cross-attention/asymmetric-autoencoder-kl-x-1-5](https://huggingface.co/cross-attention/asymmetric-autoencoder-kl-x-1-5)
-* [https://huggingface.co/cross-attention/asymmetric-autoencoder-kl-x-2](https://huggingface.co/cross-attention/asymmetric-autoencoder-kl-x-2)
-
-## Example Usage
-
-```python
-from io import BytesIO
-from PIL import Image
-import requests
-from diffusers import AsymmetricAutoencoderKL, StableDiffusionInpaintPipeline
-
-
-def download_image(url: str) -> Image.Image:
- response = requests.get(url)
- return Image.open(BytesIO(response.content)).convert("RGB")
-
-
-prompt = "a photo of a person"
-img_url = "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/repaint/celeba_hq_256.png"
-mask_url = "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/repaint/mask_256.png"
-
-image = download_image(img_url).resize((256, 256))
-mask_image = download_image(mask_url).resize((256, 256))
-
-pipe = StableDiffusionInpaintPipeline.from_pretrained("runwayml/stable-diffusion-inpainting")
-pipe.vae = AsymmetricAutoencoderKL.from_pretrained("cross-attention/asymmetric-autoencoder-kl-x-1-5")
-pipe.to("cuda")
-
-image = pipe(prompt=prompt, image=image, mask_image=mask_image).images[0]
-image.save("image.jpeg")
-```
-
-## AsymmetricAutoencoderKL
-
-[[autodoc]] models.autoencoder_asym_kl.AsymmetricAutoencoderKL
-
-## AutoencoderKLOutput
-
-[[autodoc]] models.autoencoder_kl.AutoencoderKLOutput
-
-## DecoderOutput
-
-[[autodoc]] models.vae.DecoderOutput
diff --git a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/pipelines/shap_e/pipeline_shap_e_img2img.py b/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/pipelines/shap_e/pipeline_shap_e_img2img.py
deleted file mode 100644
index cf40839ab195dde57f533a72fcdf6f71787a80b4..0000000000000000000000000000000000000000
--- a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/pipelines/shap_e/pipeline_shap_e_img2img.py
+++ /dev/null
@@ -1,319 +0,0 @@
-# Copyright 2023 Open AI 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.
-
-from dataclasses import dataclass
-from typing import List, Optional, Union
-
-import numpy as np
-import PIL
-import torch
-from transformers import CLIPImageProcessor, CLIPVisionModel
-
-from ...models import PriorTransformer
-from ...schedulers import HeunDiscreteScheduler
-from ...utils import (
- BaseOutput,
- logging,
- randn_tensor,
- replace_example_docstring,
-)
-from ..pipeline_utils import DiffusionPipeline
-from .renderer import ShapERenderer
-
-
-logger = logging.get_logger(__name__) # pylint: disable=invalid-name
-
-EXAMPLE_DOC_STRING = """
- Examples:
- ```py
- >>> from PIL import Image
- >>> import torch
- >>> from diffusers import DiffusionPipeline
- >>> from diffusers.utils import export_to_gif, load_image
-
- >>> device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-
- >>> repo = "openai/shap-e-img2img"
- >>> pipe = DiffusionPipeline.from_pretrained(repo, torch_dtype=torch.float16)
- >>> pipe = pipe.to(device)
-
- >>> guidance_scale = 3.0
- >>> image_url = "https://hf.co/datasets/diffusers/docs-images/resolve/main/shap-e/corgi.png"
- >>> image = load_image(image_url).convert("RGB")
-
- >>> images = pipe(
- ... image,
- ... guidance_scale=guidance_scale,
- ... num_inference_steps=64,
- ... frame_size=256,
- ... ).images
-
- >>> gif_path = export_to_gif(images[0], "corgi_3d.gif")
- ```
-"""
-
-
-@dataclass
-class ShapEPipelineOutput(BaseOutput):
- """
- Output class for [`ShapEPipeline`] and [`ShapEImg2ImgPipeline`].
-
- Args:
- images (`torch.FloatTensor`)
- A list of images for 3D rendering.
- """
-
- images: Union[PIL.Image.Image, np.ndarray]
-
-
-class ShapEImg2ImgPipeline(DiffusionPipeline):
- """
- Pipeline for generating latent representation of a 3D asset and rendering with NeRF method with Shap-E from an
- image.
-
- This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods
- implemented for all pipelines (downloading, saving, running on a particular device, etc.).
-
- Args:
- prior ([`PriorTransformer`]):
- The canonincal unCLIP prior to approximate the image embedding from the text embedding.
- image_encoder ([`CLIPVisionModel`]):
- Frozen image-encoder.
- image_processor (`CLIPImageProcessor`):
- A [`~transformers.CLIPImageProcessor`] to process images.
- scheduler ([`HeunDiscreteScheduler`]):
- A scheduler to be used in combination with `prior` to generate image embedding.
- shap_e_renderer ([`ShapERenderer`]):
- Shap-E renderer projects the generated latents into parameters of a MLP that's used to create 3D objects
- with the NeRF rendering method.
- """
-
- def __init__(
- self,
- prior: PriorTransformer,
- image_encoder: CLIPVisionModel,
- image_processor: CLIPImageProcessor,
- scheduler: HeunDiscreteScheduler,
- shap_e_renderer: ShapERenderer,
- ):
- super().__init__()
-
- self.register_modules(
- prior=prior,
- image_encoder=image_encoder,
- image_processor=image_processor,
- scheduler=scheduler,
- shap_e_renderer=shap_e_renderer,
- )
-
- # Copied from diffusers.pipelines.unclip.pipeline_unclip.UnCLIPPipeline.prepare_latents
- def prepare_latents(self, shape, dtype, device, generator, latents, scheduler):
- if latents is None:
- latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
- else:
- if latents.shape != shape:
- raise ValueError(f"Unexpected latents shape, got {latents.shape}, expected {shape}")
- latents = latents.to(device)
-
- latents = latents * scheduler.init_noise_sigma
- return latents
-
- def _encode_image(
- self,
- image,
- device,
- num_images_per_prompt,
- do_classifier_free_guidance,
- ):
- if isinstance(image, List) and isinstance(image[0], torch.Tensor):
- image = torch.cat(image, axis=0) if image[0].ndim == 4 else torch.stack(image, axis=0)
-
- if not isinstance(image, torch.Tensor):
- image = self.image_processor(image, return_tensors="pt").pixel_values[0].unsqueeze(0)
-
- image = image.to(dtype=self.image_encoder.dtype, device=device)
-
- image_embeds = self.image_encoder(image)["last_hidden_state"]
- image_embeds = image_embeds[:, 1:, :].contiguous() # batch_size, dim, 256
-
- image_embeds = image_embeds.repeat_interleave(num_images_per_prompt, dim=0)
-
- if do_classifier_free_guidance:
- negative_image_embeds = torch.zeros_like(image_embeds)
-
- # 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
- image_embeds = torch.cat([negative_image_embeds, image_embeds])
-
- return image_embeds
-
- @torch.no_grad()
- @replace_example_docstring(EXAMPLE_DOC_STRING)
- def __call__(
- self,
- image: Union[PIL.Image.Image, List[PIL.Image.Image]],
- num_images_per_prompt: int = 1,
- num_inference_steps: int = 25,
- generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
- latents: Optional[torch.FloatTensor] = None,
- guidance_scale: float = 4.0,
- frame_size: int = 64,
- output_type: Optional[str] = "pil", # pil, np, latent, mesh
- return_dict: bool = True,
- ):
- """
- The call function to the pipeline for generation.
-
- Args:
- image (`torch.FloatTensor`, `PIL.Image.Image`, `np.ndarray`, `List[torch.FloatTensor]`, `List[PIL.Image.Image]`, or `List[np.ndarray]`):
- `Image` or tensor representing an image batch to be used as the starting point. Can also accept image
- latents as `image`, if passing latents directly, it will not be encoded again.
- num_images_per_prompt (`int`, *optional*, defaults to 1):
- The number of images to generate per prompt.
- num_inference_steps (`int`, *optional*, defaults to 100):
- The number of denoising steps. More denoising steps usually lead to a higher quality image at the
- expense of slower inference.
- 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`.
- guidance_scale (`float`, *optional*, defaults to 4.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`.
- frame_size (`int`, *optional*, default to 64):
- The width and height of each image frame of the generated 3D output.
- output_type (`str`, *optional*, defaults to `"pt"`):
- (`np.array`),`"latent"` (`torch.Tensor`), mesh ([`MeshDecoderOutput`]).
- return_dict (`bool`, *optional*, defaults to `True`):
- Whether or not to return a [`~pipelines.shap_e.pipeline_shap_e.ShapEPipelineOutput`] instead of a plain
- tuple.
-
- Examples:
-
- Returns:
- [`~pipelines.shap_e.pipeline_shap_e.ShapEPipelineOutput`] or `tuple`:
- If `return_dict` is `True`, [`~pipelines.shap_e.pipeline_shap_e.ShapEPipelineOutput`] is returned,
- otherwise a `tuple` is returned where the first element is a list with the generated images.
- """
-
- if isinstance(image, PIL.Image.Image):
- batch_size = 1
- elif isinstance(image, torch.Tensor):
- batch_size = image.shape[0]
- elif isinstance(image, list) and isinstance(image[0], (torch.Tensor, PIL.Image.Image)):
- batch_size = len(image)
- else:
- raise ValueError(
- f"`image` has to be of type `PIL.Image.Image`, `torch.Tensor`, `List[PIL.Image.Image]` or `List[torch.Tensor]` but is {type(image)}"
- )
-
- device = self._execution_device
-
- batch_size = batch_size * num_images_per_prompt
-
- do_classifier_free_guidance = guidance_scale > 1.0
- image_embeds = self._encode_image(image, device, num_images_per_prompt, do_classifier_free_guidance)
-
- # prior
-
- self.scheduler.set_timesteps(num_inference_steps, device=device)
- timesteps = self.scheduler.timesteps
-
- num_embeddings = self.prior.config.num_embeddings
- embedding_dim = self.prior.config.embedding_dim
-
- latents = self.prepare_latents(
- (batch_size, num_embeddings * embedding_dim),
- image_embeds.dtype,
- device,
- generator,
- latents,
- self.scheduler,
- )
-
- # YiYi notes: for testing only to match ldm, we can directly create a latents with desired shape: batch_size, num_embeddings, embedding_dim
- latents = latents.reshape(latents.shape[0], num_embeddings, embedding_dim)
-
- for i, t in enumerate(self.progress_bar(timesteps)):
- # expand the latents if we are doing classifier free guidance
- latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents
- scaled_model_input = self.scheduler.scale_model_input(latent_model_input, t)
-
- noise_pred = self.prior(
- scaled_model_input,
- timestep=t,
- proj_embedding=image_embeds,
- ).predicted_image_embedding
-
- # remove the variance
- noise_pred, _ = noise_pred.split(
- scaled_model_input.shape[2], dim=2
- ) # batch_size, num_embeddings, embedding_dim
-
- if do_classifier_free_guidance:
- noise_pred_uncond, noise_pred = noise_pred.chunk(2)
- noise_pred = noise_pred_uncond + guidance_scale * (noise_pred - noise_pred_uncond)
-
- latents = self.scheduler.step(
- noise_pred,
- timestep=t,
- sample=latents,
- ).prev_sample
-
- if output_type not in ["np", "pil", "latent", "mesh"]:
- raise ValueError(
- f"Only the output types `pil`, `np`, `latent` and `mesh` are supported not output_type={output_type}"
- )
-
- if output_type == "latent":
- return ShapEPipelineOutput(images=latents)
-
- images = []
- if output_type == "mesh":
- for i, latent in enumerate(latents):
- mesh = self.shap_e_renderer.decode_to_mesh(
- latent[None, :],
- device,
- )
- images.append(mesh)
-
- else:
- # np, pil
- for i, latent in enumerate(latents):
- image = self.shap_e_renderer.decode_to_image(
- latent[None, :],
- device,
- size=frame_size,
- )
- images.append(image)
-
- images = torch.stack(images)
-
- images = images.cpu().numpy()
-
- if output_type == "pil":
- images = [self.numpy_to_pil(image) for image in images]
-
- # 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 (images,)
-
- return ShapEPipelineOutput(images=images)
diff --git a/spaces/Andy1621/uniformer_image_detection/configs/cascade_rcnn/cascade_mask_rcnn_r50_fpn_20e_coco.py b/spaces/Andy1621/uniformer_image_detection/configs/cascade_rcnn/cascade_mask_rcnn_r50_fpn_20e_coco.py
deleted file mode 100644
index 1296dc45dd89da9c0801e1242080c67957cace74..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_detection/configs/cascade_rcnn/cascade_mask_rcnn_r50_fpn_20e_coco.py
+++ /dev/null
@@ -1,5 +0,0 @@
-_base_ = [
- '../_base_/models/cascade_mask_rcnn_r50_fpn.py',
- '../_base_/datasets/coco_instance.py',
- '../_base_/schedules/schedule_20e.py', '../_base_/default_runtime.py'
-]
diff --git a/spaces/Andy1621/uniformer_image_detection/configs/gn/mask_rcnn_r50_fpn_gn-all_contrib_3x_coco.py b/spaces/Andy1621/uniformer_image_detection/configs/gn/mask_rcnn_r50_fpn_gn-all_contrib_3x_coco.py
deleted file mode 100644
index 66834f08ba398e7621aa8c5a3bfe12a646aecde2..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_detection/configs/gn/mask_rcnn_r50_fpn_gn-all_contrib_3x_coco.py
+++ /dev/null
@@ -1,5 +0,0 @@
-_base_ = './mask_rcnn_r50_fpn_gn-all_contrib_2x_coco.py'
-
-# learning policy
-lr_config = dict(step=[28, 34])
-runner = dict(type='EpochBasedRunner', max_epochs=36)
diff --git a/spaces/Andy1621/uniformer_image_detection/mmdet/models/roi_heads/base_roi_head.py b/spaces/Andy1621/uniformer_image_detection/mmdet/models/roi_heads/base_roi_head.py
deleted file mode 100644
index 2d61cc08007924c61b4a53d7fbc6e6fedfd68f08..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_detection/mmdet/models/roi_heads/base_roi_head.py
+++ /dev/null
@@ -1,103 +0,0 @@
-from abc import ABCMeta, abstractmethod
-
-import torch.nn as nn
-
-from ..builder import build_shared_head
-
-
-class BaseRoIHead(nn.Module, metaclass=ABCMeta):
- """Base class for RoIHeads."""
-
- def __init__(self,
- bbox_roi_extractor=None,
- bbox_head=None,
- mask_roi_extractor=None,
- mask_head=None,
- shared_head=None,
- train_cfg=None,
- test_cfg=None):
- super(BaseRoIHead, self).__init__()
- self.train_cfg = train_cfg
- self.test_cfg = test_cfg
- if shared_head is not None:
- self.shared_head = build_shared_head(shared_head)
-
- if bbox_head is not None:
- self.init_bbox_head(bbox_roi_extractor, bbox_head)
-
- if mask_head is not None:
- self.init_mask_head(mask_roi_extractor, mask_head)
-
- self.init_assigner_sampler()
-
- @property
- def with_bbox(self):
- """bool: whether the RoI head contains a `bbox_head`"""
- return hasattr(self, 'bbox_head') and self.bbox_head is not None
-
- @property
- def with_mask(self):
- """bool: whether the RoI head contains a `mask_head`"""
- return hasattr(self, 'mask_head') and self.mask_head is not None
-
- @property
- def with_shared_head(self):
- """bool: whether the RoI head contains a `shared_head`"""
- return hasattr(self, 'shared_head') and self.shared_head is not None
-
- @abstractmethod
- def init_weights(self, pretrained):
- """Initialize the weights in head.
-
- Args:
- pretrained (str, optional): Path to pre-trained weights.
- Defaults to None.
- """
- pass
-
- @abstractmethod
- def init_bbox_head(self):
- """Initialize ``bbox_head``"""
- pass
-
- @abstractmethod
- def init_mask_head(self):
- """Initialize ``mask_head``"""
- pass
-
- @abstractmethod
- def init_assigner_sampler(self):
- """Initialize assigner and sampler."""
- pass
-
- @abstractmethod
- def forward_train(self,
- x,
- img_meta,
- proposal_list,
- gt_bboxes,
- gt_labels,
- gt_bboxes_ignore=None,
- gt_masks=None,
- **kwargs):
- """Forward function during training."""
-
- async def async_simple_test(self, x, img_meta, **kwargs):
- """Asynchronized test function."""
- raise NotImplementedError
-
- def simple_test(self,
- x,
- proposal_list,
- img_meta,
- proposals=None,
- rescale=False,
- **kwargs):
- """Test without augmentation."""
-
- def aug_test(self, x, proposal_list, img_metas, rescale=False, **kwargs):
- """Test with augmentations.
-
- If rescale is False, then returned bboxes and masks will fit the scale
- of imgs[0].
- """
diff --git a/spaces/Andy1621/uniformer_image_segmentation/configs/encnet/encnet_r50-d8_769x769_80k_cityscapes.py b/spaces/Andy1621/uniformer_image_segmentation/configs/encnet/encnet_r50-d8_769x769_80k_cityscapes.py
deleted file mode 100644
index 7b535f3c80818ce6b692b66f18ceee8e7b181fdc..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_segmentation/configs/encnet/encnet_r50-d8_769x769_80k_cityscapes.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = [
- '../_base_/models/encnet_r50-d8.py',
- '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
- '../_base_/schedules/schedule_80k.py'
-]
-model = dict(
- decode_head=dict(align_corners=True),
- auxiliary_head=dict(align_corners=True),
- test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/spaces/Andy1621/uniformer_image_segmentation/configs/mobilenet_v2/deeplabv3plus_m-v2-d8_512x1024_80k_cityscapes.py b/spaces/Andy1621/uniformer_image_segmentation/configs/mobilenet_v2/deeplabv3plus_m-v2-d8_512x1024_80k_cityscapes.py
deleted file mode 100644
index d4533d79a25771905d7f1900bf7b34037885a77a..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_segmentation/configs/mobilenet_v2/deeplabv3plus_m-v2-d8_512x1024_80k_cityscapes.py
+++ /dev/null
@@ -1,12 +0,0 @@
-_base_ = '../deeplabv3plus/deeplabv3plus_r101-d8_512x1024_80k_cityscapes.py'
-model = dict(
- pretrained='mmcls://mobilenet_v2',
- backbone=dict(
- _delete_=True,
- type='MobileNetV2',
- widen_factor=1.,
- strides=(1, 2, 2, 1, 1, 1, 1),
- dilations=(1, 1, 1, 2, 2, 4, 4),
- out_indices=(1, 2, 4, 6)),
- decode_head=dict(in_channels=320, c1_in_channels=24),
- auxiliary_head=dict(in_channels=96))
diff --git a/spaces/AnishKumbhar/ChatBot/text-generation-webui-main/modules/prompts.py b/spaces/AnishKumbhar/ChatBot/text-generation-webui-main/modules/prompts.py
deleted file mode 100644
index ce652defbeba437b0c7e620ccb140237cefd4d30..0000000000000000000000000000000000000000
--- a/spaces/AnishKumbhar/ChatBot/text-generation-webui-main/modules/prompts.py
+++ /dev/null
@@ -1,51 +0,0 @@
-from pathlib import Path
-
-import yaml
-
-from modules import utils
-from modules.text_generation import get_encoded_length
-
-
-def load_prompt(fname):
- if fname in ['None', '']:
- return ''
- else:
- file_path = Path(f'prompts/{fname}.txt')
- if not file_path.exists():
- return ''
-
- with open(file_path, 'r', encoding='utf-8') as f:
- text = f.read()
- if text[-1] == '\n':
- text = text[:-1]
-
- return text
-
-
-def load_instruction_prompt_simple(fname):
- file_path = Path(f'instruction-templates/{fname}.yaml')
- if not file_path.exists():
- return ''
-
- with open(file_path, 'r', encoding='utf-8') as f:
- data = yaml.safe_load(f)
- output = ''
- if 'context' in data:
- output += data['context']
-
- replacements = {
- '<|user|>': data['user'],
- '<|bot|>': data['bot'],
- '<|user-message|>': 'Input',
- }
-
- output += utils.replace_all(data['turn_template'].split('<|bot-message|>')[0], replacements)
- return output.rstrip(' ')
-
-
-def count_tokens(text):
- try:
- tokens = get_encoded_length(text)
- return str(tokens)
- except:
- return '0'
diff --git a/spaces/Anonymous-sub/Rerender/ControlNet/annotator/uniformer/mmcv/ops/corner_pool.py b/spaces/Anonymous-sub/Rerender/ControlNet/annotator/uniformer/mmcv/ops/corner_pool.py
deleted file mode 100644
index a33d798b43d405e4c86bee4cd6389be21ca9c637..0000000000000000000000000000000000000000
--- a/spaces/Anonymous-sub/Rerender/ControlNet/annotator/uniformer/mmcv/ops/corner_pool.py
+++ /dev/null
@@ -1,161 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-from torch import nn
-from torch.autograd import Function
-
-from ..utils import ext_loader
-
-ext_module = ext_loader.load_ext('_ext', [
- 'top_pool_forward', 'top_pool_backward', 'bottom_pool_forward',
- 'bottom_pool_backward', 'left_pool_forward', 'left_pool_backward',
- 'right_pool_forward', 'right_pool_backward'
-])
-
-_mode_dict = {'top': 0, 'bottom': 1, 'left': 2, 'right': 3}
-
-
-class TopPoolFunction(Function):
-
- @staticmethod
- def symbolic(g, input):
- output = g.op(
- 'mmcv::MMCVCornerPool', input, mode_i=int(_mode_dict['top']))
- return output
-
- @staticmethod
- def forward(ctx, input):
- output = ext_module.top_pool_forward(input)
- ctx.save_for_backward(input)
- return output
-
- @staticmethod
- def backward(ctx, grad_output):
- input, = ctx.saved_tensors
- output = ext_module.top_pool_backward(input, grad_output)
- return output
-
-
-class BottomPoolFunction(Function):
-
- @staticmethod
- def symbolic(g, input):
- output = g.op(
- 'mmcv::MMCVCornerPool', input, mode_i=int(_mode_dict['bottom']))
- return output
-
- @staticmethod
- def forward(ctx, input):
- output = ext_module.bottom_pool_forward(input)
- ctx.save_for_backward(input)
- return output
-
- @staticmethod
- def backward(ctx, grad_output):
- input, = ctx.saved_tensors
- output = ext_module.bottom_pool_backward(input, grad_output)
- return output
-
-
-class LeftPoolFunction(Function):
-
- @staticmethod
- def symbolic(g, input):
- output = g.op(
- 'mmcv::MMCVCornerPool', input, mode_i=int(_mode_dict['left']))
- return output
-
- @staticmethod
- def forward(ctx, input):
- output = ext_module.left_pool_forward(input)
- ctx.save_for_backward(input)
- return output
-
- @staticmethod
- def backward(ctx, grad_output):
- input, = ctx.saved_tensors
- output = ext_module.left_pool_backward(input, grad_output)
- return output
-
-
-class RightPoolFunction(Function):
-
- @staticmethod
- def symbolic(g, input):
- output = g.op(
- 'mmcv::MMCVCornerPool', input, mode_i=int(_mode_dict['right']))
- return output
-
- @staticmethod
- def forward(ctx, input):
- output = ext_module.right_pool_forward(input)
- ctx.save_for_backward(input)
- return output
-
- @staticmethod
- def backward(ctx, grad_output):
- input, = ctx.saved_tensors
- output = ext_module.right_pool_backward(input, grad_output)
- return output
-
-
-class CornerPool(nn.Module):
- """Corner Pooling.
-
- Corner Pooling is a new type of pooling layer that helps a
- convolutional network better localize corners of bounding boxes.
-
- Please refer to https://arxiv.org/abs/1808.01244 for more details.
- Code is modified from https://github.com/princeton-vl/CornerNet-Lite.
-
- Args:
- mode(str): Pooling orientation for the pooling layer
-
- - 'bottom': Bottom Pooling
- - 'left': Left Pooling
- - 'right': Right Pooling
- - 'top': Top Pooling
-
- Returns:
- Feature map after pooling.
- """
-
- pool_functions = {
- 'bottom': BottomPoolFunction,
- 'left': LeftPoolFunction,
- 'right': RightPoolFunction,
- 'top': TopPoolFunction,
- }
-
- cummax_dim_flip = {
- 'bottom': (2, False),
- 'left': (3, True),
- 'right': (3, False),
- 'top': (2, True),
- }
-
- def __init__(self, mode):
- super(CornerPool, self).__init__()
- assert mode in self.pool_functions
- self.mode = mode
- self.corner_pool = self.pool_functions[mode]
-
- def forward(self, x):
- if torch.__version__ != 'parrots' and torch.__version__ >= '1.5.0':
- if torch.onnx.is_in_onnx_export():
- assert torch.__version__ >= '1.7.0', \
- 'When `cummax` serves as an intermediate component whose '\
- 'outputs is used as inputs for another modules, it\'s '\
- 'expected that pytorch version must be >= 1.7.0, '\
- 'otherwise Error appears like: `RuntimeError: tuple '\
- 'appears in op that does not forward tuples, unsupported '\
- 'kind: prim::PythonOp`.'
-
- dim, flip = self.cummax_dim_flip[self.mode]
- if flip:
- x = x.flip(dim)
- pool_tensor, _ = torch.cummax(x, dim=dim)
- if flip:
- pool_tensor = pool_tensor.flip(dim)
- return pool_tensor
- else:
- return self.corner_pool.apply(x)
diff --git a/spaces/AppleQAQ/anime-remove-background/app.py b/spaces/AppleQAQ/anime-remove-background/app.py
deleted file mode 100644
index 230a0d5f8a3da6ab18ecb8db1cd90016a489b96a..0000000000000000000000000000000000000000
--- a/spaces/AppleQAQ/anime-remove-background/app.py
+++ /dev/null
@@ -1,52 +0,0 @@
-import gradio as gr
-import huggingface_hub
-import onnxruntime as rt
-import numpy as np
-import cv2
-
-
-def get_mask(img, s=1024):
- img = (img / 255).astype(np.float32)
- h, w = h0, w0 = img.shape[:-1]
- h, w = (s, int(s * w / h)) if h > w else (int(s * h / w), s)
- ph, pw = s - h, s - w
- img_input = np.zeros([s, s, 3], dtype=np.float32)
- img_input[ph // 2:ph // 2 + h, pw // 2:pw // 2 + w] = cv2.resize(img, (w, h))
- img_input = np.transpose(img_input, (2, 0, 1))
- img_input = img_input[np.newaxis, :]
- mask = rmbg_model.run(None, {'img': img_input})[0][0]
- mask = np.transpose(mask, (1, 2, 0))
- mask = mask[ph // 2:ph // 2 + h, pw // 2:pw // 2 + w]
- mask = cv2.resize(mask, (w0, h0))[:, :, np.newaxis]
- return mask
-
-
-def rmbg_fn(img):
- mask = get_mask(img)
- img = (mask * img + 255 * (1 - mask)).astype(np.uint8)
- mask = (mask * 255).astype(np.uint8)
- img = np.concatenate([img, mask], axis=2, dtype=np.uint8)
- mask = mask.repeat(3, axis=2)
- return mask, img
-
-
-if __name__ == "__main__":
- providers = ['CUDAExecutionProvider', 'CPUExecutionProvider']
- model_path = huggingface_hub.hf_hub_download("skytnt/anime-seg", "isnetis.onnx")
- rmbg_model = rt.InferenceSession(model_path, providers=providers)
- app = gr.Blocks()
- with app:
- gr.Markdown("# Anime Remove Background\n\n"
- "\n\n"
- "demo for [https://github.com/SkyTNT/anime-segmentation/](https://github.com/SkyTNT/anime-segmentation/)")
- with gr.Row():
- with gr.Column():
- input_img = gr.Image(label="input image")
- examples_data = [[f"examples/{x:02d}.jpg"] for x in range(1, 4)]
- examples = gr.Dataset(components=[input_img], samples=examples_data)
- run_btn = gr.Button(variant="primary")
- output_mask = gr.Image(label="mask")
- output_img = gr.Image(label="result", image_mode="RGBA")
- examples.click(lambda x: x[0], [examples], [input_img])
- run_btn.click(rmbg_fn, [input_img], [output_mask, output_img])
- app.launch()
diff --git a/spaces/Ariharasudhan/XAI_Class-Activation-Maps/README.md b/spaces/Ariharasudhan/XAI_Class-Activation-Maps/README.md
deleted file mode 100644
index 576b63eecf47ba83a8a53d910f5eb569b15c87aa..0000000000000000000000000000000000000000
--- a/spaces/Ariharasudhan/XAI_Class-Activation-Maps/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Class Activation Maps
-emoji: 🚀
-colorFrom: yellow
-colorTo: red
-sdk: gradio
-sdk_version: 3.14.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/Artples/llama-2-7b-chat/run-app.sh b/spaces/Artples/llama-2-7b-chat/run-app.sh
deleted file mode 100644
index a63a8e06f941fc702fd223ea3d4de2e28692824e..0000000000000000000000000000000000000000
--- a/spaces/Artples/llama-2-7b-chat/run-app.sh
+++ /dev/null
@@ -1 +0,0 @@
-nodemon -w app.py -x python app.py
diff --git a/spaces/Arulkumar03/GroundingDINO_SOTA_Zero_Shot_Model/groundingdino/util/__init__.py b/spaces/Arulkumar03/GroundingDINO_SOTA_Zero_Shot_Model/groundingdino/util/__init__.py
deleted file mode 100644
index 168f9979a4623806934b0ff1102ac166704e7dec..0000000000000000000000000000000000000000
--- a/spaces/Arulkumar03/GroundingDINO_SOTA_Zero_Shot_Model/groundingdino/util/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
diff --git a/spaces/AxelBell/EasyOCR_text_recognition/data.py b/spaces/AxelBell/EasyOCR_text_recognition/data.py
deleted file mode 100644
index 377bdaecb37de9561ceaa5ed2a17081f7b4b226f..0000000000000000000000000000000000000000
--- a/spaces/AxelBell/EasyOCR_text_recognition/data.py
+++ /dev/null
@@ -1,110 +0,0 @@
-import cv2
-import gradio as gr
-import easyocr
-import numpy as np
-import json
-from collections import OrderedDict
-from pprint import pformat
-
-try:
- import tomllib
-except ModuleNotFoundError:
- import tomli as tomllib
-
-
-def read_file(path: str) -> str:
- with open(path, "rb") as f:
- return f.read().decode("utf-8")
-
-
-def draw_label(
- image,
- center,
- text,
- font=cv2.FONT_HERSHEY_SIMPLEX,
- font_scale=1,
- text_color=(255, 0, 0),
- text_thickness=2,
- circle_color=(0, 0, 0),
- circle_thickness=-1,
-):
- (text_width, text_height), _ = cv2.getTextSize(
- str(text), font, font_scale, text_thickness
- )
- text_x = center[0] - text_width // 2
- text_y = center[1] + text_height // 2
- radius = (text_width + 8) // 2
- cv2.circle(image, center, radius, circle_color, circle_thickness)
- cv2.putText(
- image, str(text), (text_x, text_y), font, font_scale, text_color, text_thickness
- )
- cv2.circle(image, center, radius + 1, text_color, 1)
-
-
-class Data:
- @staticmethod
- def block_factory(block_metadata: list[dict]):
- _block_list = [
- (bm["name"], getattr(gr, bm["type"])(render=False, **bm["param"]))
- for bm in block_metadata
- ]
- return OrderedDict(_block_list)
-
- def __init__(
- self, toml_file: str, batch_size: int = 1, workers: int = 0, canvas_size=2560
- ):
- with open(toml_file, "rb") as f:
- _data = tomllib.load(f, parse_float=float)
- self.assets = {k: read_file(v) for k, v in _data["assets"]}
- self.inputs = Data.block_factory(_data["blocklist"]["inputs"])
- self.default = [getattr(b, "value", None) for b in self.inputs.values()]
- self.outputs = Data.block_factory(_data["blocklist"]["outputs"])
- self.examples = _data["examples"]
- self.batch_size = batch_size
- self.workers = workers
- self.canvas_size = canvas_size
-
- def render(self, *args):
- for bn in args:
- block = self.inputs.get(bn, self.outputs.get(bn))
- if block:
- block.render()
-
- @property
- def inputs_list(self):
- return list(self.inputs.values())
-
- @property
- def outputs_list(self):
- return list(self.outputs.values())
-
- def process_image(self, lang: list[str], *args):
- reader = easyocr.Reader(lang, False)
- kwargs = dict(zip(list(self.inputs.keys())[1:], args))
- kwargs.update(
- {
- "batch_size": self.batch_size,
- "workers": self.workers,
- "canvas_size": self.canvas_size,
- }
- )
- raw = reader.readtext(**kwargs)
- result = raw.copy()
- raw = pformat(raw)
- if not kwargs["detail"]:
- return kwargs["image"], [[idx, i, ""] for idx, i in enumerate(result)], raw
-
- if kwargs["paragraph"]:
- result = [[i[0], i[1], 0] for i in result]
- if kwargs["output_format"] == "json":
- result = [json.loads(i, parse_float=float, parse_int=int) for i in result]
- if kwargs["output_format"] == "dict" or kwargs["output_format"] == "json":
- result = [[i["boxes"], i["text"], i["confident"]] for i in result]
-
- cnt = [np.array(i[0]).astype(int) for i in result]
- cv2.drawContours(kwargs["image"], cnt, -1, (0, 255, 0), 3, cv2.LINE_AA)
- for count, c in enumerate(cnt):
- draw_label(kwargs["image"], c[0], count)
- data = [[idx, i[1], f"{int(i[2]*100)}%"] for idx, i in enumerate(result)]
-
- return kwargs["image"], data, raw
diff --git a/spaces/Axolotlily/TextGen/app.py b/spaces/Axolotlily/TextGen/app.py
deleted file mode 100644
index 565c842df566235fc34e84b14e0cfc2ad92d2172..0000000000000000000000000000000000000000
--- a/spaces/Axolotlily/TextGen/app.py
+++ /dev/null
@@ -1,25 +0,0 @@
-from transformers import AutoTokenizer, AutoModelForCausalLM
-import torch
-import gradio as gr
-
-tokenizer = AutoTokenizer.from_pretrained("gpt2")
-model = AutoModelForCausalLM.from_pretrained("gpt2")
-
-def text_generation(input_text, seed):
- input_ids = tokenizer(input_text, return_tensors="pt").input_ids
- torch.manual_seed(seed) # Max value: 18446744073709551615
- outputs = model.generate(input_ids, do_sample=True, max_length=500)
- generated_text = tokenizer.batch_decode(outputs, skip_special_tokens=True)
- return generated_text
-
-title = "Text Generator Demo GPT2"
-description = "Text Generator Application by ecarbo"
-
-gr.Interface(
- text_generation,
- [gr.inputs.Textbox(lines=2, label="Enter input text"), gr.inputs.Number(default=10, label="Enter seed number")],
- [gr.outputs.Textbox(type="auto", label="Text Generated")],
- title=title,
- description=description,
- theme="huggingface"
-).launch()
\ No newline at end of file
diff --git a/spaces/Bart92/RVC_HF/demucs/pretrained.py b/spaces/Bart92/RVC_HF/demucs/pretrained.py
deleted file mode 100644
index 6aac5db100cc7a9084af96d2cd083f0c8fac473c..0000000000000000000000000000000000000000
--- a/spaces/Bart92/RVC_HF/demucs/pretrained.py
+++ /dev/null
@@ -1,107 +0,0 @@
-# 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.
-# author: adefossez
-
-import logging
-
-from diffq import DiffQuantizer
-import torch.hub
-
-from .model import Demucs
-from .tasnet import ConvTasNet
-from .utils import set_state
-
-logger = logging.getLogger(__name__)
-ROOT = "https://dl.fbaipublicfiles.com/demucs/v3.0/"
-
-PRETRAINED_MODELS = {
- 'demucs': 'e07c671f',
- 'demucs48_hq': '28a1282c',
- 'demucs_extra': '3646af93',
- 'demucs_quantized': '07afea75',
- 'tasnet': 'beb46fac',
- 'tasnet_extra': 'df3777b2',
- 'demucs_unittest': '09ebc15f',
-}
-
-SOURCES = ["drums", "bass", "other", "vocals"]
-
-
-def get_url(name):
- sig = PRETRAINED_MODELS[name]
- return ROOT + name + "-" + sig[:8] + ".th"
-
-
-def is_pretrained(name):
- return name in PRETRAINED_MODELS
-
-
-def load_pretrained(name):
- if name == "demucs":
- return demucs(pretrained=True)
- elif name == "demucs48_hq":
- return demucs(pretrained=True, hq=True, channels=48)
- elif name == "demucs_extra":
- return demucs(pretrained=True, extra=True)
- elif name == "demucs_quantized":
- return demucs(pretrained=True, quantized=True)
- elif name == "demucs_unittest":
- return demucs_unittest(pretrained=True)
- elif name == "tasnet":
- return tasnet(pretrained=True)
- elif name == "tasnet_extra":
- return tasnet(pretrained=True, extra=True)
- else:
- raise ValueError(f"Invalid pretrained name {name}")
-
-
-def _load_state(name, model, quantizer=None):
- url = get_url(name)
- state = torch.hub.load_state_dict_from_url(url, map_location='cpu', check_hash=True)
- set_state(model, quantizer, state)
- if quantizer:
- quantizer.detach()
-
-
-def demucs_unittest(pretrained=True):
- model = Demucs(channels=4, sources=SOURCES)
- if pretrained:
- _load_state('demucs_unittest', model)
- return model
-
-
-def demucs(pretrained=True, extra=False, quantized=False, hq=False, channels=64):
- if not pretrained and (extra or quantized or hq):
- raise ValueError("if extra or quantized is True, pretrained must be True.")
- model = Demucs(sources=SOURCES, channels=channels)
- if pretrained:
- name = 'demucs'
- if channels != 64:
- name += str(channels)
- quantizer = None
- if sum([extra, quantized, hq]) > 1:
- raise ValueError("Only one of extra, quantized, hq, can be True.")
- if quantized:
- quantizer = DiffQuantizer(model, group_size=8, min_size=1)
- name += '_quantized'
- if extra:
- name += '_extra'
- if hq:
- name += '_hq'
- _load_state(name, model, quantizer)
- return model
-
-
-def tasnet(pretrained=True, extra=False):
- if not pretrained and extra:
- raise ValueError("if extra is True, pretrained must be True.")
- model = ConvTasNet(X=10, sources=SOURCES)
- if pretrained:
- name = 'tasnet'
- if extra:
- name = 'tasnet_extra'
- _load_state(name, model)
- return model
diff --git a/spaces/Bart92/RVC_HF/lib/uvr5_pack/lib_v5/spec_utils.py b/spaces/Bart92/RVC_HF/lib/uvr5_pack/lib_v5/spec_utils.py
deleted file mode 100644
index a3fd46d333da7becc7f09f42c084ac7cde661035..0000000000000000000000000000000000000000
--- a/spaces/Bart92/RVC_HF/lib/uvr5_pack/lib_v5/spec_utils.py
+++ /dev/null
@@ -1,667 +0,0 @@
-import os, librosa
-import numpy as np
-import soundfile as sf
-from tqdm import tqdm
-import json, math, hashlib
-
-
-def crop_center(h1, h2):
- h1_shape = h1.size()
- h2_shape = h2.size()
-
- if h1_shape[3] == h2_shape[3]:
- return h1
- elif h1_shape[3] < h2_shape[3]:
- raise ValueError("h1_shape[3] must be greater than h2_shape[3]")
-
- # s_freq = (h2_shape[2] - h1_shape[2]) // 2
- # e_freq = s_freq + h1_shape[2]
- s_time = (h1_shape[3] - h2_shape[3]) // 2
- e_time = s_time + h2_shape[3]
- h1 = h1[:, :, :, s_time:e_time]
-
- return h1
-
-
-def wave_to_spectrogram(
- wave, hop_length, n_fft, mid_side=False, mid_side_b2=False, reverse=False
-):
- if reverse:
- wave_left = np.flip(np.asfortranarray(wave[0]))
- wave_right = np.flip(np.asfortranarray(wave[1]))
- elif mid_side:
- wave_left = np.asfortranarray(np.add(wave[0], wave[1]) / 2)
- wave_right = np.asfortranarray(np.subtract(wave[0], wave[1]))
- elif mid_side_b2:
- wave_left = np.asfortranarray(np.add(wave[1], wave[0] * 0.5))
- wave_right = np.asfortranarray(np.subtract(wave[0], wave[1] * 0.5))
- else:
- wave_left = np.asfortranarray(wave[0])
- wave_right = np.asfortranarray(wave[1])
-
- spec_left = librosa.stft(wave_left, n_fft, hop_length=hop_length)
- spec_right = librosa.stft(wave_right, n_fft, hop_length=hop_length)
-
- spec = np.asfortranarray([spec_left, spec_right])
-
- return spec
-
-
-def wave_to_spectrogram_mt(
- wave, hop_length, n_fft, mid_side=False, mid_side_b2=False, reverse=False
-):
- import threading
-
- if reverse:
- wave_left = np.flip(np.asfortranarray(wave[0]))
- wave_right = np.flip(np.asfortranarray(wave[1]))
- elif mid_side:
- wave_left = np.asfortranarray(np.add(wave[0], wave[1]) / 2)
- wave_right = np.asfortranarray(np.subtract(wave[0], wave[1]))
- elif mid_side_b2:
- wave_left = np.asfortranarray(np.add(wave[1], wave[0] * 0.5))
- wave_right = np.asfortranarray(np.subtract(wave[0], wave[1] * 0.5))
- else:
- wave_left = np.asfortranarray(wave[0])
- wave_right = np.asfortranarray(wave[1])
-
- def run_thread(**kwargs):
- global spec_left
- spec_left = librosa.stft(**kwargs)
-
- thread = threading.Thread(
- target=run_thread,
- kwargs={"y": wave_left, "n_fft": n_fft, "hop_length": hop_length},
- )
- thread.start()
- spec_right = librosa.stft(wave_right, n_fft, hop_length=hop_length)
- thread.join()
-
- spec = np.asfortranarray([spec_left, spec_right])
-
- return spec
-
-
-def combine_spectrograms(specs, mp):
- l = min([specs[i].shape[2] for i in specs])
- spec_c = np.zeros(shape=(2, mp.param["bins"] + 1, l), dtype=np.complex64)
- offset = 0
- bands_n = len(mp.param["band"])
-
- for d in range(1, bands_n + 1):
- h = mp.param["band"][d]["crop_stop"] - mp.param["band"][d]["crop_start"]
- spec_c[:, offset : offset + h, :l] = specs[d][
- :, mp.param["band"][d]["crop_start"] : mp.param["band"][d]["crop_stop"], :l
- ]
- offset += h
-
- if offset > mp.param["bins"]:
- raise ValueError("Too much bins")
-
- # lowpass fiter
- if (
- mp.param["pre_filter_start"] > 0
- ): # and mp.param['band'][bands_n]['res_type'] in ['scipy', 'polyphase']:
- if bands_n == 1:
- spec_c = fft_lp_filter(
- spec_c, mp.param["pre_filter_start"], mp.param["pre_filter_stop"]
- )
- else:
- gp = 1
- for b in range(
- mp.param["pre_filter_start"] + 1, mp.param["pre_filter_stop"]
- ):
- g = math.pow(
- 10, -(b - mp.param["pre_filter_start"]) * (3.5 - gp) / 20.0
- )
- gp = g
- spec_c[:, b, :] *= g
-
- return np.asfortranarray(spec_c)
-
-
-def spectrogram_to_image(spec, mode="magnitude"):
- if mode == "magnitude":
- if np.iscomplexobj(spec):
- y = np.abs(spec)
- else:
- y = spec
- y = np.log10(y**2 + 1e-8)
- elif mode == "phase":
- if np.iscomplexobj(spec):
- y = np.angle(spec)
- else:
- y = spec
-
- y -= y.min()
- y *= 255 / y.max()
- img = np.uint8(y)
-
- if y.ndim == 3:
- img = img.transpose(1, 2, 0)
- img = np.concatenate([np.max(img, axis=2, keepdims=True), img], axis=2)
-
- return img
-
-
-def reduce_vocal_aggressively(X, y, softmask):
- v = X - y
- y_mag_tmp = np.abs(y)
- v_mag_tmp = np.abs(v)
-
- v_mask = v_mag_tmp > y_mag_tmp
- y_mag = np.clip(y_mag_tmp - v_mag_tmp * v_mask * softmask, 0, np.inf)
-
- return y_mag * np.exp(1.0j * np.angle(y))
-
-
-def mask_silence(mag, ref, thres=0.2, min_range=64, fade_size=32):
- if min_range < fade_size * 2:
- raise ValueError("min_range must be >= fade_area * 2")
-
- mag = mag.copy()
-
- idx = np.where(ref.mean(axis=(0, 1)) < thres)[0]
- starts = np.insert(idx[np.where(np.diff(idx) != 1)[0] + 1], 0, idx[0])
- ends = np.append(idx[np.where(np.diff(idx) != 1)[0]], idx[-1])
- uninformative = np.where(ends - starts > min_range)[0]
- if len(uninformative) > 0:
- starts = starts[uninformative]
- ends = ends[uninformative]
- old_e = None
- for s, e in zip(starts, ends):
- if old_e is not None and s - old_e < fade_size:
- s = old_e - fade_size * 2
-
- if s != 0:
- weight = np.linspace(0, 1, fade_size)
- mag[:, :, s : s + fade_size] += weight * ref[:, :, s : s + fade_size]
- else:
- s -= fade_size
-
- if e != mag.shape[2]:
- weight = np.linspace(1, 0, fade_size)
- mag[:, :, e - fade_size : e] += weight * ref[:, :, e - fade_size : e]
- else:
- e += fade_size
-
- mag[:, :, s + fade_size : e - fade_size] += ref[
- :, :, s + fade_size : e - fade_size
- ]
- old_e = e
-
- return mag
-
-
-def align_wave_head_and_tail(a, b):
- l = min([a[0].size, b[0].size])
-
- return a[:l, :l], b[:l, :l]
-
-
-def cache_or_load(mix_path, inst_path, mp):
- mix_basename = os.path.splitext(os.path.basename(mix_path))[0]
- inst_basename = os.path.splitext(os.path.basename(inst_path))[0]
-
- cache_dir = "mph{}".format(
- hashlib.sha1(json.dumps(mp.param, sort_keys=True).encode("utf-8")).hexdigest()
- )
- mix_cache_dir = os.path.join("cache", cache_dir)
- inst_cache_dir = os.path.join("cache", cache_dir)
-
- os.makedirs(mix_cache_dir, exist_ok=True)
- os.makedirs(inst_cache_dir, exist_ok=True)
-
- mix_cache_path = os.path.join(mix_cache_dir, mix_basename + ".npy")
- inst_cache_path = os.path.join(inst_cache_dir, inst_basename + ".npy")
-
- if os.path.exists(mix_cache_path) and os.path.exists(inst_cache_path):
- X_spec_m = np.load(mix_cache_path)
- y_spec_m = np.load(inst_cache_path)
- else:
- X_wave, y_wave, X_spec_s, y_spec_s = {}, {}, {}, {}
-
- for d in range(len(mp.param["band"]), 0, -1):
- bp = mp.param["band"][d]
-
- if d == len(mp.param["band"]): # high-end band
- X_wave[d], _ = librosa.load(
- mix_path, bp["sr"], False, dtype=np.float32, res_type=bp["res_type"]
- )
- y_wave[d], _ = librosa.load(
- inst_path,
- bp["sr"],
- False,
- dtype=np.float32,
- res_type=bp["res_type"],
- )
- else: # lower bands
- X_wave[d] = librosa.resample(
- X_wave[d + 1],
- mp.param["band"][d + 1]["sr"],
- bp["sr"],
- res_type=bp["res_type"],
- )
- y_wave[d] = librosa.resample(
- y_wave[d + 1],
- mp.param["band"][d + 1]["sr"],
- bp["sr"],
- res_type=bp["res_type"],
- )
-
- X_wave[d], y_wave[d] = align_wave_head_and_tail(X_wave[d], y_wave[d])
-
- X_spec_s[d] = wave_to_spectrogram(
- X_wave[d],
- bp["hl"],
- bp["n_fft"],
- mp.param["mid_side"],
- mp.param["mid_side_b2"],
- mp.param["reverse"],
- )
- y_spec_s[d] = wave_to_spectrogram(
- y_wave[d],
- bp["hl"],
- bp["n_fft"],
- mp.param["mid_side"],
- mp.param["mid_side_b2"],
- mp.param["reverse"],
- )
-
- del X_wave, y_wave
-
- X_spec_m = combine_spectrograms(X_spec_s, mp)
- y_spec_m = combine_spectrograms(y_spec_s, mp)
-
- if X_spec_m.shape != y_spec_m.shape:
- raise ValueError("The combined spectrograms are different: " + mix_path)
-
- _, ext = os.path.splitext(mix_path)
-
- np.save(mix_cache_path, X_spec_m)
- np.save(inst_cache_path, y_spec_m)
-
- return X_spec_m, y_spec_m
-
-
-def spectrogram_to_wave(spec, hop_length, mid_side, mid_side_b2, reverse):
- spec_left = np.asfortranarray(spec[0])
- spec_right = np.asfortranarray(spec[1])
-
- wave_left = librosa.istft(spec_left, hop_length=hop_length)
- wave_right = librosa.istft(spec_right, hop_length=hop_length)
-
- if reverse:
- return np.asfortranarray([np.flip(wave_left), np.flip(wave_right)])
- elif mid_side:
- return np.asfortranarray(
- [np.add(wave_left, wave_right / 2), np.subtract(wave_left, wave_right / 2)]
- )
- elif mid_side_b2:
- return np.asfortranarray(
- [
- np.add(wave_right / 1.25, 0.4 * wave_left),
- np.subtract(wave_left / 1.25, 0.4 * wave_right),
- ]
- )
- else:
- return np.asfortranarray([wave_left, wave_right])
-
-
-def spectrogram_to_wave_mt(spec, hop_length, mid_side, reverse, mid_side_b2):
- import threading
-
- spec_left = np.asfortranarray(spec[0])
- spec_right = np.asfortranarray(spec[1])
-
- def run_thread(**kwargs):
- global wave_left
- wave_left = librosa.istft(**kwargs)
-
- thread = threading.Thread(
- target=run_thread, kwargs={"stft_matrix": spec_left, "hop_length": hop_length}
- )
- thread.start()
- wave_right = librosa.istft(spec_right, hop_length=hop_length)
- thread.join()
-
- if reverse:
- return np.asfortranarray([np.flip(wave_left), np.flip(wave_right)])
- elif mid_side:
- return np.asfortranarray(
- [np.add(wave_left, wave_right / 2), np.subtract(wave_left, wave_right / 2)]
- )
- elif mid_side_b2:
- return np.asfortranarray(
- [
- np.add(wave_right / 1.25, 0.4 * wave_left),
- np.subtract(wave_left / 1.25, 0.4 * wave_right),
- ]
- )
- else:
- return np.asfortranarray([wave_left, wave_right])
-
-
-def cmb_spectrogram_to_wave(spec_m, mp, extra_bins_h=None, extra_bins=None):
- wave_band = {}
- bands_n = len(mp.param["band"])
- offset = 0
-
- for d in range(1, bands_n + 1):
- bp = mp.param["band"][d]
- spec_s = np.ndarray(
- shape=(2, bp["n_fft"] // 2 + 1, spec_m.shape[2]), dtype=complex
- )
- h = bp["crop_stop"] - bp["crop_start"]
- spec_s[:, bp["crop_start"] : bp["crop_stop"], :] = spec_m[
- :, offset : offset + h, :
- ]
-
- offset += h
- if d == bands_n: # higher
- if extra_bins_h: # if --high_end_process bypass
- max_bin = bp["n_fft"] // 2
- spec_s[:, max_bin - extra_bins_h : max_bin, :] = extra_bins[
- :, :extra_bins_h, :
- ]
- if bp["hpf_start"] > 0:
- spec_s = fft_hp_filter(spec_s, bp["hpf_start"], bp["hpf_stop"] - 1)
- if bands_n == 1:
- wave = spectrogram_to_wave(
- spec_s,
- bp["hl"],
- mp.param["mid_side"],
- mp.param["mid_side_b2"],
- mp.param["reverse"],
- )
- else:
- wave = np.add(
- wave,
- spectrogram_to_wave(
- spec_s,
- bp["hl"],
- mp.param["mid_side"],
- mp.param["mid_side_b2"],
- mp.param["reverse"],
- ),
- )
- else:
- sr = mp.param["band"][d + 1]["sr"]
- if d == 1: # lower
- spec_s = fft_lp_filter(spec_s, bp["lpf_start"], bp["lpf_stop"])
- wave = librosa.resample(
- spectrogram_to_wave(
- spec_s,
- bp["hl"],
- mp.param["mid_side"],
- mp.param["mid_side_b2"],
- mp.param["reverse"],
- ),
- bp["sr"],
- sr,
- res_type="sinc_fastest",
- )
- else: # mid
- spec_s = fft_hp_filter(spec_s, bp["hpf_start"], bp["hpf_stop"] - 1)
- spec_s = fft_lp_filter(spec_s, bp["lpf_start"], bp["lpf_stop"])
- wave2 = np.add(
- wave,
- spectrogram_to_wave(
- spec_s,
- bp["hl"],
- mp.param["mid_side"],
- mp.param["mid_side_b2"],
- mp.param["reverse"],
- ),
- )
- # wave = librosa.core.resample(wave2, bp['sr'], sr, res_type="sinc_fastest")
- wave = librosa.core.resample(wave2, bp["sr"], sr, res_type="scipy")
-
- return wave.T
-
-
-def fft_lp_filter(spec, bin_start, bin_stop):
- g = 1.0
- for b in range(bin_start, bin_stop):
- g -= 1 / (bin_stop - bin_start)
- spec[:, b, :] = g * spec[:, b, :]
-
- spec[:, bin_stop:, :] *= 0
-
- return spec
-
-
-def fft_hp_filter(spec, bin_start, bin_stop):
- g = 1.0
- for b in range(bin_start, bin_stop, -1):
- g -= 1 / (bin_start - bin_stop)
- spec[:, b, :] = g * spec[:, b, :]
-
- spec[:, 0 : bin_stop + 1, :] *= 0
-
- return spec
-
-
-def mirroring(a, spec_m, input_high_end, mp):
- if "mirroring" == a:
- mirror = np.flip(
- np.abs(
- spec_m[
- :,
- mp.param["pre_filter_start"]
- - 10
- - input_high_end.shape[1] : mp.param["pre_filter_start"]
- - 10,
- :,
- ]
- ),
- 1,
- )
- mirror = mirror * np.exp(1.0j * np.angle(input_high_end))
-
- return np.where(
- np.abs(input_high_end) <= np.abs(mirror), input_high_end, mirror
- )
-
- if "mirroring2" == a:
- mirror = np.flip(
- np.abs(
- spec_m[
- :,
- mp.param["pre_filter_start"]
- - 10
- - input_high_end.shape[1] : mp.param["pre_filter_start"]
- - 10,
- :,
- ]
- ),
- 1,
- )
- mi = np.multiply(mirror, input_high_end * 1.7)
-
- return np.where(np.abs(input_high_end) <= np.abs(mi), input_high_end, mi)
-
-
-def ensembling(a, specs):
- for i in range(1, len(specs)):
- if i == 1:
- spec = specs[0]
-
- ln = min([spec.shape[2], specs[i].shape[2]])
- spec = spec[:, :, :ln]
- specs[i] = specs[i][:, :, :ln]
-
- if "min_mag" == a:
- spec = np.where(np.abs(specs[i]) <= np.abs(spec), specs[i], spec)
- if "max_mag" == a:
- spec = np.where(np.abs(specs[i]) >= np.abs(spec), specs[i], spec)
-
- return spec
-
-
-def stft(wave, nfft, hl):
- wave_left = np.asfortranarray(wave[0])
- wave_right = np.asfortranarray(wave[1])
- spec_left = librosa.stft(wave_left, nfft, hop_length=hl)
- spec_right = librosa.stft(wave_right, nfft, hop_length=hl)
- spec = np.asfortranarray([spec_left, spec_right])
-
- return spec
-
-
-def istft(spec, hl):
- spec_left = np.asfortranarray(spec[0])
- spec_right = np.asfortranarray(spec[1])
-
- wave_left = librosa.istft(spec_left, hop_length=hl)
- wave_right = librosa.istft(spec_right, hop_length=hl)
- wave = np.asfortranarray([wave_left, wave_right])
-
-
-if __name__ == "__main__":
- import cv2
- import sys
- import time
- import argparse
- from model_param_init import ModelParameters
-
- p = argparse.ArgumentParser()
- p.add_argument(
- "--algorithm",
- "-a",
- type=str,
- choices=["invert", "invert_p", "min_mag", "max_mag", "deep", "align"],
- default="min_mag",
- )
- p.add_argument(
- "--model_params",
- "-m",
- type=str,
- default=os.path.join("modelparams", "1band_sr44100_hl512.json"),
- )
- p.add_argument("--output_name", "-o", type=str, default="output")
- p.add_argument("--vocals_only", "-v", action="store_true")
- p.add_argument("input", nargs="+")
- args = p.parse_args()
-
- start_time = time.time()
-
- if args.algorithm.startswith("invert") and len(args.input) != 2:
- raise ValueError("There should be two input files.")
-
- if not args.algorithm.startswith("invert") and len(args.input) < 2:
- raise ValueError("There must be at least two input files.")
-
- wave, specs = {}, {}
- mp = ModelParameters(args.model_params)
-
- for i in range(len(args.input)):
- spec = {}
-
- for d in range(len(mp.param["band"]), 0, -1):
- bp = mp.param["band"][d]
-
- if d == len(mp.param["band"]): # high-end band
- wave[d], _ = librosa.load(
- args.input[i],
- bp["sr"],
- False,
- dtype=np.float32,
- res_type=bp["res_type"],
- )
-
- if len(wave[d].shape) == 1: # mono to stereo
- wave[d] = np.array([wave[d], wave[d]])
- else: # lower bands
- wave[d] = librosa.resample(
- wave[d + 1],
- mp.param["band"][d + 1]["sr"],
- bp["sr"],
- res_type=bp["res_type"],
- )
-
- spec[d] = wave_to_spectrogram(
- wave[d],
- bp["hl"],
- bp["n_fft"],
- mp.param["mid_side"],
- mp.param["mid_side_b2"],
- mp.param["reverse"],
- )
-
- specs[i] = combine_spectrograms(spec, mp)
-
- del wave
-
- if args.algorithm == "deep":
- d_spec = np.where(np.abs(specs[0]) <= np.abs(spec[1]), specs[0], spec[1])
- v_spec = d_spec - specs[1]
- sf.write(
- os.path.join("{}.wav".format(args.output_name)),
- cmb_spectrogram_to_wave(v_spec, mp),
- mp.param["sr"],
- )
-
- if args.algorithm.startswith("invert"):
- ln = min([specs[0].shape[2], specs[1].shape[2]])
- specs[0] = specs[0][:, :, :ln]
- specs[1] = specs[1][:, :, :ln]
-
- if "invert_p" == args.algorithm:
- X_mag = np.abs(specs[0])
- y_mag = np.abs(specs[1])
- max_mag = np.where(X_mag >= y_mag, X_mag, y_mag)
- v_spec = specs[1] - max_mag * np.exp(1.0j * np.angle(specs[0]))
- else:
- specs[1] = reduce_vocal_aggressively(specs[0], specs[1], 0.2)
- v_spec = specs[0] - specs[1]
-
- if not args.vocals_only:
- X_mag = np.abs(specs[0])
- y_mag = np.abs(specs[1])
- v_mag = np.abs(v_spec)
-
- X_image = spectrogram_to_image(X_mag)
- y_image = spectrogram_to_image(y_mag)
- v_image = spectrogram_to_image(v_mag)
-
- cv2.imwrite("{}_X.png".format(args.output_name), X_image)
- cv2.imwrite("{}_y.png".format(args.output_name), y_image)
- cv2.imwrite("{}_v.png".format(args.output_name), v_image)
-
- sf.write(
- "{}_X.wav".format(args.output_name),
- cmb_spectrogram_to_wave(specs[0], mp),
- mp.param["sr"],
- )
- sf.write(
- "{}_y.wav".format(args.output_name),
- cmb_spectrogram_to_wave(specs[1], mp),
- mp.param["sr"],
- )
-
- sf.write(
- "{}_v.wav".format(args.output_name),
- cmb_spectrogram_to_wave(v_spec, mp),
- mp.param["sr"],
- )
- else:
- if not args.algorithm == "deep":
- sf.write(
- os.path.join("ensembled", "{}.wav".format(args.output_name)),
- cmb_spectrogram_to_wave(ensembling(args.algorithm, specs), mp),
- mp.param["sr"],
- )
-
- if args.algorithm == "align":
- trackalignment = [
- {
- "file1": '"{}"'.format(args.input[0]),
- "file2": '"{}"'.format(args.input[1]),
- }
- ]
-
- for i, e in tqdm(enumerate(trackalignment), desc="Performing Alignment..."):
- os.system(f"python lib/align_tracks.py {e['file1']} {e['file2']}")
-
- # print('Total time: {0:.{1}f}s'.format(time.time() - start_time, 1))
diff --git a/spaces/Benson/text-generation/Examples/Amanda El Aventurero Descargar Apk 2023.md b/spaces/Benson/text-generation/Examples/Amanda El Aventurero Descargar Apk 2023.md
deleted file mode 100644
index d9143626608b1b6c87e5199604f49e06102eca76..0000000000000000000000000000000000000000
--- a/spaces/Benson/text-generation/Examples/Amanda El Aventurero Descargar Apk 2023.md
+++ /dev/null
@@ -1,98 +0,0 @@
-
-
Amanda el aventurero Descargar APK 2023: Cómo jugar el espeluznante juego de terror de dibujos animados en su dispositivo Android
-
Si estás buscando un juego de terror único y aterrador para jugar en tu dispositivo Android, es posible que quieras echar un vistazo a Amanda the Adventurer. Este juego es un juego de terror al estilo de dibujos animados de imágenes encontradas que te hará cuestionar tu cordura mientras ves e interactúas con una serie de cintas de VHS con un programa infantil aparentemente inocente. En este artículo, te diremos todo lo que necesitas saber sobre Amanda the Adventurer, por qué deberías descargar su archivo APK, cómo instalarlo en tu dispositivo y cómo jugarlo.
Amanda the Adventurer es un juego de terror desarrollado por MANGLEDmaw Games y publicado por DreadXP. Fue lanzado en Steam en abril de 2023 y recibió críticas abrumadoramente positivas de jugadores y críticos por igual. El juego sigue a Riley Park, quien hereda la casa de su tía Kate después de su muerte. Mientras explora el ático, Riley encuentra una pila de cintas de VHS junto a un viejo televisor. Las cintas parecen ser episodios de una caricatura infantil de principios de la década de 2000 que nunca habían visto antes, protagonizada por una niña llamada Amanda y su leal pero tímida mejor amiga, Wooly the Sheep. Sin embargo, mientras Riley mira las cintas, se dan cuenta de que algo está muy mal con Amanda y Wooly, y que parecen estar comunicándose directamente a través del televisor. ¿Qué secretos se esconden en estas cintas? ¿Y qué quiere Amanda de Riley?
-
Las principales características y elementos de juego del juego
-
Amanda the Adventurer es una corta pero intrincada experiencia de terror para un solo jugador que combina cintas animadas con rompecabezas estilo sala de escape. El juego tiene varias características que lo hacen destacar de otros juegos de terror, como:
-
-
Clásico, CGI estilo 90 que recuerda una era más simple de animación
-
-
Desafiante, escapar de rompecabezas de estilo sala de usar pistas ocultas dentro de las cintas
-
Múltiples finales dependiendo de sus opciones y acciones
-
Una historia oscura y retorcida que te mantendrá al límite hasta el final
-
-
¿Por qué descargar Amanda el aventurero APK 2023?
-
Los beneficios de descargar el archivo APK en lugar de usar Google Play Store
-
Un archivo APK es un archivo de paquete utilizado para distribuir e instalar aplicaciones en dispositivos Android. Puede descargar archivos APK de varios sitios web en lugar de usar Google Play Store por varias razones, como:
-
-
Puede acceder a aplicaciones que no están disponibles o compatibles con su dispositivo o región
-
Puede obtener aplicaciones que se actualizan más rápido o tienen más características que sus versiones oficiales
-
Puede ahorrar espacio de almacenamiento instalando solo las partes de una aplicación que necesitaLos riesgos y precauciones de descargar archivos APK de fuentes desconocidas
-
Sin embargo, la descarga de archivos APK de fuentes desconocidas también viene con algunos riesgos y desventajas, como:
-
-
Puede descargar malware o virus que pueden dañar su dispositivo o robar sus datos
-
Usted puede violar los términos y condiciones del desarrollador de aplicaciones o Google Play Store
-
Es posible que no reciba actualizaciones o soporte del desarrollador de aplicaciones o Google Play Store
-
Es posible que encuentre problemas de compatibilidad o rendimiento con su dispositivo u otras aplicaciones
-
-
Por lo tanto, siempre debe tener cuidado y precaución al descargar archivos APK de fuentes desconocidas. Aquí hay algunos consejos para ayudarle a evitar cualquier problema:
-
-
-
Solo descargar archivos APK de sitios web de confianza y de buena reputación que tienen críticas y valoraciones positivas
-
Escanear el archivo APK con un antivirus o escáner de malware antes de instalarlo en su dispositivo
-
Compruebe los permisos y el acceso que las solicitudes de archivos APK y asegúrese de que son razonables y necesarias para la aplicación
-
-
-
¿Cómo descargar e instalar Amanda el Aventurero APK 2023?
-
Los pasos para descargar el archivo APK de un sitio web de confianza
-
Si desea descargar Amanda el aventurero APK 2023, puede seguir estos sencillos pasos:
-
-
Ir a un sitio web de confianza que ofrece Amanda el Aventurero APK 2023, tales como [APKPure] o [APKMirror]
-
Busca a Amanda la aventurera en la barra de búsqueda del sitio web o navega por las categorías hasta que lo encuentres
-
Haga clic en el botón de descarga y espere a que el archivo APK se descargue en su dispositivo
-
Busque el archivo APK en el administrador de archivos de su dispositivo o carpeta de descargas y toque en él para abrirlo
-
-
Los pasos para habilitar fuentes desconocidas e instalar el archivo APK en su dispositivo Android
-
Antes de que pueda instalar Amanda el Aventurero APK 2023 en su dispositivo Android, es necesario habilitar fuentes desconocidas en la configuración de su dispositivo. Esto le permitirá instalar aplicaciones desde fuentes distintas de Google Play Store. Para hacer esto, siga estos pasos:
-
-
Ir a la configuración de su dispositivo y buscar opciones de seguridad o privacidad
-
Encontrar la opción que dice fuentes desconocidas o instalar aplicaciones desconocidas y alternar en
-
Aparecerá un mensaje de advertencia pidiéndole que confirme su elección. Pulse en OK o Permitir que proceda
-
Ahora puede volver al archivo APK que ha descargado y toque en él de nuevo para iniciar el proceso de instalación
-
Siga las instrucciones en la pantalla y espere a que la instalación termine
-
Ahora puede iniciar Amanda el aventurero desde el cajón de la aplicación o la pantalla de inicio y disfrutar del juego
-
-
¿Cómo se juega Amanda el aventurero en su dispositivo Android?
-
Los controles básicos y la interfaz del juego
-
-
-
Para ver una cinta, toque en ella en el menú del ático y luego toque en jugar. Puede pausar, rebobinar, avanzar rápidamente o detener la cinta usando los botones de la pantalla del televisor.
-
Para interactuar con objetos en las cintas, toque en ellos cuando brillan. También puede arrastrarlos o combinarlos con otros objetos.
-
Para acceder a su inventario, toque en el icono de la mochila en la parte inferior de la pantalla. Puede ver qué artículos ha recogido y utilizarlos cuando sea necesario.
-
Para acceder a su diario, toque en el icono del cuaderno en la parte inferior de la pantalla. Puedes ver qué pistas has encontrado y qué puzzles necesitas resolver.
-
Para acceder a la configuración, toque en el icono de engranaje en la esquina superior derecha de la pantalla. Puede ajustar su sonido, gráficos, idioma y otras opciones.
-
-
Los consejos y trucos para sobrevivir y resolver los puzzles en el juego
-
Amanda el aventurero es un juego desafiante que pondrá a prueba tu ingenio y nervios. Aquí hay algunos consejos y trucos para ayudarle a sobrevivir y resolver los puzzles en el juego:
-
-
Presta atención a todo lo que Amanda y Wooly dicen y hacen. Pueden darte pistas sobre qué hacer a continuación.
-
Explora cada escena a fondo y busca objetos ocultos o detalles que puedan ser útiles.
-
Usa tu inventario sabiamente y prueba diferentes combinaciones de objetos para ver si funcionan juntos.
-
Usa tu diario con frecuencia y revisa las pistas y rompecabezas que has encontrado. Podrías notar algo nuevo o recordar algo importante.
-
No tengas miedo de experimentar y probar cosas diferentes. Nunca sabes lo que puede pasar o lo que puedes descubrir.
-
Tenga cuidado y precaución cuando se trata de Amanda y Wooly. Pueden parecer amigables e inofensivos, pero también pueden ser peligrosos e impredecibles.
-
-
Conclusión
-
-
¿Estás listo para unirte a Amanda la aventurera en su viaje? Descarga el juego ahora y ver por ti mismo!
-
Preguntas frecuentes
-
¿Cuáles son los requisitos del sistema para Amanda the Adventurer?
-
Amanda the Adventurer es un juego relativamente ligero que no requiere muchos recursos para funcionar. Sin embargo, todavía necesita tener un dispositivo Android compatible que cumpla con los siguientes requisitos mínimos del sistema:
-
-
Versión para Android: 4.4 o superior
-
RAM: 1 GB o más
-
Almacenamiento: 500 MB o más
-
Conexión a Internet: No se requiere (pero se recomienda para actualizaciones y soporte)
-
-
¿Amanda la aventurera es libre de jugar?
-
Amanda el Aventurero no es un juego gratis. Cuesta $4.99 en Steam y $3.99 en Google Play Store. Sin embargo, puede descargar su archivo APK de forma gratuita desde algunos sitios web que lo ofrecen. Sin embargo, usted debe ser consciente de los riesgos y desventajas de descargar archivos APK de fuentes desconocidas, como hemos explicado anteriormente.
-
¿Cuánto tiempo es Amanda la aventurera?
-
Amanda el aventurero es un juego corto que se puede completar en aproximadamente una hora o menos. Sin embargo, el juego tiene múltiples finales que dependen de tus elecciones y acciones a lo largo del juego. Por lo tanto, es posible que desee volver a jugar el juego varias veces para ver todos los posibles resultados y secretos.
-
¿Amanda la aventurera tiene múltiples finales?
-
Sí, Amanda la aventurera tiene múltiples finales que varían en función de sus opciones y acciones a lo largo del juego. Algunos finales son buenos, algunos son malos, y algunos son francamente horripilantes. Puedes intentar lograr todos los finales tomando diferentes decisiones y explorando diferentes caminos en el juego.
-
¿Amanda la aventurera se basa en una historia real?
64aa2da5cf
-
-
\ No newline at end of file
diff --git a/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/pygments/formatters/html.py b/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/pygments/formatters/html.py
deleted file mode 100644
index f22b200c0e63d75c6def15e321a8bed14f57b64b..0000000000000000000000000000000000000000
--- a/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/pygments/formatters/html.py
+++ /dev/null
@@ -1,991 +0,0 @@
-"""
- pygments.formatters.html
- ~~~~~~~~~~~~~~~~~~~~~~~~
-
- Formatter for HTML output.
-
- :copyright: Copyright 2006-2022 by the Pygments team, see AUTHORS.
- :license: BSD, see LICENSE for details.
-"""
-
-import functools
-import os
-import sys
-import os.path
-from io import StringIO
-
-from pip._vendor.pygments.formatter import Formatter
-from pip._vendor.pygments.token import Token, Text, STANDARD_TYPES
-from pip._vendor.pygments.util import get_bool_opt, get_int_opt, get_list_opt
-
-try:
- import ctags
-except ImportError:
- ctags = None
-
-__all__ = ['HtmlFormatter']
-
-
-_escape_html_table = {
- ord('&'): '&',
- ord('<'): '<',
- ord('>'): '>',
- ord('"'): '"',
- ord("'"): ''',
-}
-
-
-def escape_html(text, table=_escape_html_table):
- """Escape &, <, > as well as single and double quotes for HTML."""
- return text.translate(table)
-
-
-def webify(color):
- if color.startswith('calc') or color.startswith('var'):
- return color
- else:
- return '#' + color
-
-
-def _get_ttype_class(ttype):
- fname = STANDARD_TYPES.get(ttype)
- if fname:
- return fname
- aname = ''
- while fname is None:
- aname = '-' + ttype[-1] + aname
- ttype = ttype.parent
- fname = STANDARD_TYPES.get(ttype)
- return fname + aname
-
-
-CSSFILE_TEMPLATE = '''\
-/*
-generated by Pygments
-Copyright 2006-2022 by the Pygments team.
-Licensed under the BSD license, see LICENSE for details.
-*/
-%(styledefs)s
-'''
-
-DOC_HEADER = '''\
-
-
-
-
- %(title)s
-
-
-
-
-
-Welcome to DeciCoder!
-DeciCoder is a 1B parameter code generation model trained on The Stack dataset and released under an Apache 2.0 license. It's capable of writing code in Python,
-JavaScript, and Java. It's a code-completion model, not an instruction-tuned model; you should prompt the model with a function signature and docstring
-and let it complete the rest. The model can also do infilling, specify where you would like the model to complete code with the <FILL_HERE>
-token."""
-
-token = os.environ["HUGGINGFACEHUB_API_TOKEN"]
-device="cuda" if torch.cuda.is_available() else "cpu"
-
-
-FIM_PREFIX = ""
-FIM_MIDDLE = ""
-FIM_SUFFIX = ""
-FIM_PAD = ""
-EOD = "<|endoftext|>"
-
-GENERATION_TITLE= "
"
- return GENERATION_TITLE + code_html
-
-
-def post_processing_fim(prefix: str, middle: str, suffix: str) -> str:
- """
- Post-processes the FIM (fill in the middle) generated code with HTML styling.
-
- Args:
- prefix (str): The prefix part of the code.
- middle (str): The generated middle part of the code.
- suffix (str): The suffix part of the code.
-
- Returns:
- str: The HTML-styled code with prefix, middle, and suffix.
- """
- prefix = "" + prefix + ""
- middle = "" + middle + ""
- suffix = "" + suffix + ""
- code_html = f"
{prefix}{middle}{suffix}
"
- return GENERATION_TITLE + code_html
-
-def fim_generation(prompt: str, max_new_tokens: int, temperature: float) -> str:
- """
- Generates code for FIM (fill in the middle) task.
-
- Args:
- prompt (str): The input code prompt with token.
- max_new_tokens (int): Maximum number of tokens to generate.
- temperature (float): Sampling temperature for generation.
-
- Returns:
- str: The HTML-styled code with filled missing part.
- """
- prefix = prompt.split("")[0]
- suffix = prompt.split("")[1]
- [middle] = infill((prefix, suffix), max_new_tokens, temperature)
- return post_processing_fim(prefix, middle, suffix)
-
-def extract_fim_part(s: str) -> str:
- """
- Extracts the FIM (fill in the middle) part from the generated string.
-
- Args:
- s (str): The generated string with FIM tokens.
-
- Returns:
- str: The extracted FIM part.
- """
- # Find the index of
- start = s.find(FIM_MIDDLE) + len(FIM_MIDDLE)
- stop = s.find(EOD, start) or len(s)
- return s[start:stop]
-
-def infill(prefix_suffix_tuples: Union[Tuple[str, str], List[Tuple[str, str]]], max_new_tokens: int, temperature: float) -> List[str]:
- """
- Generates the infill for the given prefix and suffix tuples.
-
- Args:
- prefix_suffix_tuples (Union[Tuple[str, str], List[Tuple[str, str]]]): Prefix and suffix tuples.
- max_new_tokens (int): Maximum number of tokens to generate.
- temperature (float): Sampling temperature for generation.
-
- Returns:
- List[str]: The list of generated infill strings.
- """
- if type(prefix_suffix_tuples) == tuple:
- prefix_suffix_tuples = [prefix_suffix_tuples]
-
- prompts = [f"{FIM_PREFIX}{prefix}{FIM_SUFFIX}{suffix}{FIM_MIDDLE}" for prefix, suffix in prefix_suffix_tuples]
- # `return_token_type_ids=False` is essential, or we get nonsense output.
- inputs = tokenizer_fim(prompts, return_tensors="pt", padding=True, return_token_type_ids=False).to(device)
- with torch.no_grad():
- outputs = model.generate(
- **inputs,
- do_sample=True,
- temperature=temperature,
- max_new_tokens=max_new_tokens,
- pad_token_id=tokenizer.pad_token_id
- )
- # WARNING: cannot use skip_special_tokens, because it blows away the FIM special tokens.
- return [
- extract_fim_part(tokenizer_fim.decode(tensor, skip_special_tokens=False)) for tensor in outputs
- ]
-
-def code_generation(prompt: str, max_new_tokens: int, temperature: float = 0.2, seed: int = 42) -> str:
- """
- Generates code based on the given prompt. Handles both regular and FIM (Fill-In-Missing) generation.
-
- Args:
- prompt (str): The input code prompt.
- max_new_tokens (int): Maximum number of tokens to generate.
- temperature (float, optional): Sampling temperature for generation. Defaults to 0.2.
- seed (int, optional): Random seed for reproducibility. Defaults to 42.
-
- Returns:
- str: The HTML-styled generated code.
- """
- if "" in prompt:
- return fim_generation(prompt, max_new_tokens, temperature=temperature)
- else:
- completion = pipe(prompt, do_sample=True, top_p=0.95, temperature=temperature, max_new_tokens=max_new_tokens)[0]['generated_text']
- completion = completion[len(prompt):]
- return post_processing(prompt, completion)
-
-demo = gr.Blocks(
- css=".gradio-container {background-color: #FAFBFF; color: #292b47}"
-)
-with demo:
- with gr.Row():
- _, colum_2, _ = gr.Column(scale=1), gr.Column(scale=6), gr.Column(scale=1)
- with colum_2:
- gr.Markdown(value=description)
- code = gr.Code(lines=5, language="python", label="Input code", value="def nth_element_in_fibonnaci(element):\n \"\"\"Returns the nth element of the Fibonnaci sequence.\"\"\"")
-
- with gr.Accordion("Additional settings", open=True):
- max_new_tokens= gr.Slider(
- minimum=8,
- maximum=2048,
- step=1,
- value=80,
- label="Number of tokens to generate",
- )
- temperature = gr.Slider(
- minimum=0.1,
- maximum=2.5,
- step=0.01,
- value=0.2,
- label="Temperature",
- )
- seed = gr.inputs.Number(
- default=42,
- label="Enter a seed value (integer)"
- )
- run = gr.Button(value="👨🏽💻 Generate code", size='lg')
- output = gr.HTML(label="💻 Your generated code")
-
-
- event = run.click(code_generation, [code, max_new_tokens, temperature, seed], output, api_name="predict")
- gr.HTML(label="Keep in touch", value="")
-
-demo.launch()
\ No newline at end of file
diff --git a/spaces/Deep1994/t5-paraphrase/app.py b/spaces/Deep1994/t5-paraphrase/app.py
deleted file mode 100644
index 7391702429d98d41c66d45a14e25b2045ff6238a..0000000000000000000000000000000000000000
--- a/spaces/Deep1994/t5-paraphrase/app.py
+++ /dev/null
@@ -1,71 +0,0 @@
-import streamlit as st
-from transformers import T5ForConditionalGeneration, T5Tokenizer
-import torch
-
-def set_seed(seed):
- torch.manual_seed(seed)
- if torch.cuda.is_available():
- torch.cuda.manual_seed_all(seed)
-
-tokenizer = T5Tokenizer.from_pretrained('Deep1994/t5-paraphrase-quora')
-
-@st.cache(allow_output_mutation=True)
-def load_model():
- model = T5ForConditionalGeneration.from_pretrained('Deep1994/t5-paraphrase-quora')
-
- return model
-
-model = load_model()
-
-st.sidebar.subheader('Select decoding strategy below.')
-decoding_strategy = st.sidebar.selectbox("decoding_strategy", ['Top k/p sampling', 'Beam Search'])
-
-st.title('Paraphrase a question in English.')
-
-st.write('This is a fine-tuned t5 model that will paraphrase\
- your English input text into another English output\
- by leveraging a pre-trained [Text-To-Text Transfer Tranformers](https://arxiv.org/abs/1910.10683) model.')
-
-
-st.subheader('Input Text')
-text = st.text_area(' ', height=100)
-
-if text != '':
- set_seed(1234) # for reproducibility
- prefix = 'paraphrase: '
- encoding = tokenizer.encode_plus(prefix + text, padding=True, return_tensors="pt")
- input_ids, attention_masks = encoding["input_ids"], encoding["attention_mask"]
-
- if str(decoding_strategy) == 'Top k/p sampling':
- beam_outputs = model.generate(
- input_ids=input_ids, attention_mask=attention_masks,
- do_sample=True,
- max_length=20,
- top_k=50,
- top_p=0.95,
- early_stopping=True,
- num_return_sequences=10
- )
- elif str(decoding_strategy) == 'Beam Search':
- beam_outputs = model.generate(
- input_ids=input_ids,
- attention_mask=attention_masks,
- max_length=20,
- num_beams=10,
- no_repeat_ngram_size=2,
- num_return_sequences=10,
- early_stopping=True
- )
-
- final_outputs =[]
- for beam_output in beam_outputs:
- sent = tokenizer.decode(beam_output, skip_special_tokens=True, clean_up_tokenization_spaces=True)
- if sent.lower() != text.lower() and sent not in final_outputs:
- final_outputs.append(sent)
- if len(final_outputs) == 5:
- break
- # final_outputs.append(sent)
-
- st.subheader('Paraphrased Text')
- for i, final_output in enumerate(final_outputs):
- st.write(final_output + '\n')
\ No newline at end of file
diff --git a/spaces/Detomo/ai-comic-generation/src/components/ui/accordion.tsx b/spaces/Detomo/ai-comic-generation/src/components/ui/accordion.tsx
deleted file mode 100644
index 937620af27e5d8ef577f0baca229a9b753ebd017..0000000000000000000000000000000000000000
--- a/spaces/Detomo/ai-comic-generation/src/components/ui/accordion.tsx
+++ /dev/null
@@ -1,60 +0,0 @@
-"use client"
-
-import * as React from "react"
-import * as AccordionPrimitive from "@radix-ui/react-accordion"
-import { ChevronDown } from "lucide-react"
-
-import { cn } from "@/lib/utils"
-
-const Accordion = AccordionPrimitive.Root
-
-const AccordionItem = React.forwardRef<
- React.ElementRef,
- React.ComponentPropsWithoutRef
->(({ className, ...props }, ref) => (
-
-))
-AccordionItem.displayName = "AccordionItem"
-
-const AccordionTrigger = React.forwardRef<
- React.ElementRef,
- React.ComponentPropsWithoutRef
->(({ className, children, ...props }, ref) => (
-
- svg]:rotate-180",
- className
- )}
- {...props}
- >
- {children}
-
-
-
-))
-AccordionTrigger.displayName = AccordionPrimitive.Trigger.displayName
-
-const AccordionContent = React.forwardRef<
- React.ElementRef,
- React.ComponentPropsWithoutRef
->(({ className, children, ...props }, ref) => (
-
-
{children}
-
-))
-AccordionContent.displayName = AccordionPrimitive.Content.displayName
-
-export { Accordion, AccordionItem, AccordionTrigger, AccordionContent }
diff --git a/spaces/Dinoking/Garbage-Classifier-V4/README.md b/spaces/Dinoking/Garbage-Classifier-V4/README.md
deleted file mode 100644
index 3e6de5da46cd97a231b53c3a5d88e19edd98b6f2..0000000000000000000000000000000000000000
--- a/spaces/Dinoking/Garbage-Classifier-V4/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Garbage Classifer v4
-emoji: 🐠
-colorFrom: yellow
-colorTo: yellow
-sdk: gradio
-sdk_version: 3.1.4
-app_file: app.py
-pinned: false
-python_version: 3.7.6
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/DragGan/DragGan-Inversion/PTI/torch_utils/ops/conv2d_gradfix.py b/spaces/DragGan/DragGan-Inversion/PTI/torch_utils/ops/conv2d_gradfix.py
deleted file mode 100644
index e95e10d0b1d0315a63a76446fd4c5c293c8bbc6d..0000000000000000000000000000000000000000
--- a/spaces/DragGan/DragGan-Inversion/PTI/torch_utils/ops/conv2d_gradfix.py
+++ /dev/null
@@ -1,170 +0,0 @@
-# Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
-#
-# NVIDIA CORPORATION and its licensors retain all intellectual property
-# and proprietary rights in and to this software, related documentation
-# and any modifications thereto. Any use, reproduction, disclosure or
-# distribution of this software and related documentation without an express
-# license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-"""Custom replacement for `torch.nn.functional.conv2d` that supports
-arbitrarily high order gradients with zero performance penalty."""
-
-import warnings
-import contextlib
-import torch
-
-# pylint: disable=redefined-builtin
-# pylint: disable=arguments-differ
-# pylint: disable=protected-access
-
-#----------------------------------------------------------------------------
-
-enabled = False # Enable the custom op by setting this to true.
-weight_gradients_disabled = False # Forcefully disable computation of gradients with respect to the weights.
-
-@contextlib.contextmanager
-def no_weight_gradients():
- global weight_gradients_disabled
- old = weight_gradients_disabled
- weight_gradients_disabled = True
- yield
- weight_gradients_disabled = old
-
-#----------------------------------------------------------------------------
-
-def conv2d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1):
- if _should_use_custom_op(input):
- return _conv2d_gradfix(transpose=False, weight_shape=weight.shape, stride=stride, padding=padding, output_padding=0, dilation=dilation, groups=groups).apply(input, weight, bias)
- return torch.nn.functional.conv2d(input=input, weight=weight, bias=bias, stride=stride, padding=padding, dilation=dilation, groups=groups)
-
-def conv_transpose2d(input, weight, bias=None, stride=1, padding=0, output_padding=0, groups=1, dilation=1):
- if _should_use_custom_op(input):
- return _conv2d_gradfix(transpose=True, weight_shape=weight.shape, stride=stride, padding=padding, output_padding=output_padding, groups=groups, dilation=dilation).apply(input, weight, bias)
- return torch.nn.functional.conv_transpose2d(input=input, weight=weight, bias=bias, stride=stride, padding=padding, output_padding=output_padding, groups=groups, dilation=dilation)
-
-#----------------------------------------------------------------------------
-
-def _should_use_custom_op(input):
- assert isinstance(input, torch.Tensor)
- if (not enabled) or (not torch.backends.cudnn.enabled):
- return False
- if input.device.type != 'cuda':
- return False
- if any(torch.__version__.startswith(x) for x in ['1.7.', '1.8.', '1.9']):
- return True
- warnings.warn(f'conv2d_gradfix not supported on PyTorch {torch.__version__}. Falling back to torch.nn.functional.conv2d().')
- return False
-
-def _tuple_of_ints(xs, ndim):
- xs = tuple(xs) if isinstance(xs, (tuple, list)) else (xs,) * ndim
- assert len(xs) == ndim
- assert all(isinstance(x, int) for x in xs)
- return xs
-
-#----------------------------------------------------------------------------
-
-_conv2d_gradfix_cache = dict()
-
-def _conv2d_gradfix(transpose, weight_shape, stride, padding, output_padding, dilation, groups):
- # Parse arguments.
- ndim = 2
- weight_shape = tuple(weight_shape)
- stride = _tuple_of_ints(stride, ndim)
- padding = _tuple_of_ints(padding, ndim)
- output_padding = _tuple_of_ints(output_padding, ndim)
- dilation = _tuple_of_ints(dilation, ndim)
-
- # Lookup from cache.
- key = (transpose, weight_shape, stride, padding, output_padding, dilation, groups)
- if key in _conv2d_gradfix_cache:
- return _conv2d_gradfix_cache[key]
-
- # Validate arguments.
- assert groups >= 1
- assert len(weight_shape) == ndim + 2
- assert all(stride[i] >= 1 for i in range(ndim))
- assert all(padding[i] >= 0 for i in range(ndim))
- assert all(dilation[i] >= 0 for i in range(ndim))
- if not transpose:
- assert all(output_padding[i] == 0 for i in range(ndim))
- else: # transpose
- assert all(0 <= output_padding[i] < max(stride[i], dilation[i]) for i in range(ndim))
-
- # Helpers.
- common_kwargs = dict(stride=stride, padding=padding, dilation=dilation, groups=groups)
- def calc_output_padding(input_shape, output_shape):
- if transpose:
- return [0, 0]
- return [
- input_shape[i + 2]
- - (output_shape[i + 2] - 1) * stride[i]
- - (1 - 2 * padding[i])
- - dilation[i] * (weight_shape[i + 2] - 1)
- for i in range(ndim)
- ]
-
- # Forward & backward.
- class Conv2d(torch.autograd.Function):
- @staticmethod
- def forward(ctx, input, weight, bias):
- assert weight.shape == weight_shape
- if not transpose:
- output = torch.nn.functional.conv2d(input=input, weight=weight, bias=bias, **common_kwargs)
- else: # transpose
- output = torch.nn.functional.conv_transpose2d(input=input, weight=weight, bias=bias, output_padding=output_padding, **common_kwargs)
- ctx.save_for_backward(input, weight)
- return output
-
- @staticmethod
- def backward(ctx, grad_output):
- input, weight = ctx.saved_tensors
- grad_input = None
- grad_weight = None
- grad_bias = None
-
- if ctx.needs_input_grad[0]:
- p = calc_output_padding(input_shape=input.shape, output_shape=grad_output.shape)
- grad_input = _conv2d_gradfix(transpose=(not transpose), weight_shape=weight_shape, output_padding=p, **common_kwargs).apply(grad_output, weight, None)
- assert grad_input.shape == input.shape
-
- if ctx.needs_input_grad[1] and not weight_gradients_disabled:
- grad_weight = Conv2dGradWeight.apply(grad_output, input)
- assert grad_weight.shape == weight_shape
-
- if ctx.needs_input_grad[2]:
- grad_bias = grad_output.sum([0, 2, 3])
-
- return grad_input, grad_weight, grad_bias
-
- # Gradient with respect to the weights.
- class Conv2dGradWeight(torch.autograd.Function):
- @staticmethod
- def forward(ctx, grad_output, input):
- op = torch._C._jit_get_operation('aten::cudnn_convolution_backward_weight' if not transpose else 'aten::cudnn_convolution_transpose_backward_weight')
- flags = [torch.backends.cudnn.benchmark, torch.backends.cudnn.deterministic, torch.backends.cudnn.allow_tf32]
- grad_weight = op(weight_shape, grad_output, input, padding, stride, dilation, groups, *flags)
- assert grad_weight.shape == weight_shape
- ctx.save_for_backward(grad_output, input)
- return grad_weight
-
- @staticmethod
- def backward(ctx, grad2_grad_weight):
- grad_output, input = ctx.saved_tensors
- grad2_grad_output = None
- grad2_input = None
-
- if ctx.needs_input_grad[0]:
- grad2_grad_output = Conv2d.apply(input, grad2_grad_weight, None)
- assert grad2_grad_output.shape == grad_output.shape
-
- if ctx.needs_input_grad[1]:
- p = calc_output_padding(input_shape=input.shape, output_shape=grad_output.shape)
- grad2_input = _conv2d_gradfix(transpose=(not transpose), weight_shape=weight_shape, output_padding=p, **common_kwargs).apply(grad_output, grad2_grad_weight, None)
- assert grad2_input.shape == input.shape
-
- return grad2_grad_output, grad2_input
-
- _conv2d_gradfix_cache[key] = Conv2d
- return Conv2d
-
-#----------------------------------------------------------------------------
diff --git a/spaces/DragGan/DragGan/stylegan_human/training_scripts/sg3/training/dataset.py b/spaces/DragGan/DragGan/stylegan_human/training_scripts/sg3/training/dataset.py
deleted file mode 100644
index df0aaec62a4771e63cbfd42b253790547c766baa..0000000000000000000000000000000000000000
--- a/spaces/DragGan/DragGan/stylegan_human/training_scripts/sg3/training/dataset.py
+++ /dev/null
@@ -1,260 +0,0 @@
-# Copyright (c) SenseTime Research. All rights reserved.
-
-# Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
-#
-# NVIDIA CORPORATION and its licensors retain all intellectual property
-# and proprietary rights in and to this software, related documentation
-# and any modifications thereto. Any use, reproduction, disclosure or
-# distribution of this software and related documentation without an express
-# license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-"""Streaming images and labels from datasets created with dataset_tool.py."""
-
-import os
-import numpy as np
-import zipfile
-import PIL.Image
-import json
-import torch
-import dnnlib
-from petrel_client.client import Client
-import cv2
-
-
-try:
- import pyspng
-except ImportError:
- pyspng = None
-
-#----------------------------------------------------------------------------
-
-class Dataset(torch.utils.data.Dataset):
- def __init__(self,
- name, # Name of the dataset.
- raw_shape, # Shape of the raw image data (NCHW).
- max_size = None, # Artificially limit the size of the dataset. None = no limit. Applied before xflip.
- use_labels = False, # Enable conditioning labels? False = label dimension is zero.
- xflip = False, # Artificially double the size of the dataset via x-flips. Applied after max_size.
- random_seed = 0, # Random seed to use when applying max_size.
- square = False,
- ):
- print('Inside Dataset')
- self._name = name
- self._raw_shape = list(raw_shape)
- self._use_labels = use_labels
- self._raw_labels = None
- self._label_shape = None
- self._square = square
- print("inside dataset, _square: ", self._square)
-
- # Apply max_size.
- self._raw_idx = np.arange(self._raw_shape[0], dtype=np.int64)
- if (max_size is not None) and (self._raw_idx.size > max_size):
- np.random.RandomState(random_seed).shuffle(self._raw_idx)
- self._raw_idx = np.sort(self._raw_idx[:max_size])
-
- # Apply xflip.
- self._xflip = np.zeros(self._raw_idx.size, dtype=np.uint8)
- if xflip:
- self._raw_idx = np.tile(self._raw_idx, 2)
- self._xflip = np.concatenate([self._xflip, np.ones_like(self._xflip)])
-
- def _get_raw_labels(self):
- if self._raw_labels is None:
- self._raw_labels = self._load_raw_labels() if self._use_labels else None
- if self._raw_labels is None:
- self._raw_labels = np.zeros([self._raw_shape[0], 0], dtype=np.float32)
- assert isinstance(self._raw_labels, np.ndarray)
- assert self._raw_labels.shape[0] == self._raw_shape[0]
- assert self._raw_labels.dtype in [np.float32, np.int64]
- if self._raw_labels.dtype == np.int64:
- assert self._raw_labels.ndim == 1
- assert np.all(self._raw_labels >= 0)
- return self._raw_labels
-
- def close(self): # to be overridden by subclass
- pass
-
- def _load_raw_image(self, raw_idx): # to be overridden by subclass
- raise NotImplementedError
-
- def _load_raw_labels(self): # to be overridden by subclass
- raise NotImplementedError
-
- def __getstate__(self):
- return dict(self.__dict__, _raw_labels=None)
-
- def __del__(self):
- try:
- self.close()
- except:
- pass
-
- def __len__(self):
- return self._raw_idx.size
-
- def __getitem__(self, idx):
- image = self._load_raw_image(self._raw_idx[idx])
- assert isinstance(image, np.ndarray)
- assert list(image.shape) == self.image_shape
- assert image.dtype == np.uint8
- if self._xflip[idx]:
- assert image.ndim == 3 # CHW
- image = image[:, :, ::-1]
- return image.copy(), self.get_label(idx)
-
- def get_label(self, idx):
- label = self._get_raw_labels()[self._raw_idx[idx]]
- if label.dtype == np.int64:
- onehot = np.zeros(self.label_shape, dtype=np.float32)
- onehot[label] = 1
- label = onehot
- return label.copy()
-
- def get_details(self, idx):
- d = dnnlib.EasyDict()
- d.raw_idx = int(self._raw_idx[idx])
- d.xflip = (int(self._xflip[idx]) != 0)
- d.raw_label = self._get_raw_labels()[d.raw_idx].copy()
- return d
-
- @property
- def name(self):
- return self._name
-
- @property
- def image_shape(self):
- return list(self._raw_shape[1:])
-
- @property
- def num_channels(self):
- assert len(self.image_shape) == 3 # CHW
- return self.image_shape[0]
-
- @property
- def resolution(self):
- assert len(self.image_shape) == 3 # CHW
- if self._square:
- assert self.image_shape[1] == self.image_shape[2]
- else:
- assert self.image_shape[1] == self.image_shape[2] * 2
- return self.image_shape[1]
-
- @property
- def label_shape(self):
- if self._label_shape is None:
- raw_labels = self._get_raw_labels()
- if raw_labels.dtype == np.int64:
- self._label_shape = [int(np.max(raw_labels)) + 1]
- else:
- self._label_shape = raw_labels.shape[1:]
- return list(self._label_shape)
-
- @property
- def label_dim(self):
- assert len(self.label_shape) == 1
- return self.label_shape[0]
-
- @property
- def has_labels(self):
- return any(x != 0 for x in self.label_shape)
-
- @property
- def has_onehot_labels(self):
- return self._get_raw_labels().dtype == np.int64
-
-#----------------------------------------------------------------------------
-
-class ImageFolderDataset(Dataset):
- def __init__(self,
- path, # Path to directory or zip.
- resolution = None, # Ensure specific resolution, None = highest available.
- ceph = False,
- square = False,
- **super_kwargs, # Additional arguments for the Dataset base class.
- ):
- self._path = path
- self._zipfile = None
- self._square = square
-
- if os.path.isdir(self._path):
- self._type = 'dir'
- self._all_fnames = {os.path.relpath(os.path.join(root, fname), start=self._path) for root, _dirs, files in os.walk(self._path) for fname in files}
- elif self._file_ext(self._path) == '.zip':
- self._type = 'zip'
- self._all_fnames = set(self._get_zipfile().namelist())
- else:
- raise IOError('Path must point to a directory or zip')
-
- PIL.Image.init()
- self._image_fnames = sorted(fname for fname in self._all_fnames if self._file_ext(fname) in PIL.Image.EXTENSION)
- if len(self._image_fnames) == 0:
- raise IOError('No image files found in the specified path')
-
- name = os.path.splitext(os.path.basename(self._path))[0]
- raw_shape = [len(self._image_fnames)] + list(self._load_raw_image(0).shape)
- # if resolution is not None and (raw_shape[2] != resolution or raw_shape[3] != resolution):
- # raise IOError('Image files do not match the specified resolution')
- if resolution is not None:
- if self._square:
- raw_shape[2] = raw_shape[3] = resolution
- else:
- raw_shape[2] = resolution
- raw_shape[3] = resolution // 2
- # print(raw_shape)
- super().__init__(name=name, raw_shape=raw_shape,square=square, **super_kwargs)
-
- @staticmethod
- def _file_ext(fname):
- return os.path.splitext(fname)[1].lower()
-
- def _get_zipfile(self):
- assert self._type == 'zip'
- if self._zipfile is None:
- self._zipfile = zipfile.ZipFile(self._path)
- return self._zipfile
-
- def _open_file(self, fname):
- if self._type == 'dir':
- return open(os.path.join(self._path, fname), 'rb')
- if self._type == 'zip':
- return self._get_zipfile().open(fname, 'r')
- return None
-
- def close(self):
- try:
- if self._zipfile is not None:
- self._zipfile.close()
- finally:
- self._zipfile = None
-
- def __getstate__(self):
- return dict(super().__getstate__(), _zipfile=None)
-
- def _load_raw_image(self, raw_idx):
- fname = self._image_fnames[raw_idx]
- with self._open_file(fname) as f:
- if pyspng is not None and self._file_ext(fname) == '.png':
- image = pyspng.load(f.read())
- else:
- image = np.array(PIL.Image.open(f))
- if image.ndim == 2:
- image = image[:, :, np.newaxis] # HW => HWC
- image = image.transpose(2, 0, 1) # HWC => CHW
- return image
-
- def _load_raw_labels(self):
- fname = 'dataset.json'
- if fname not in self._all_fnames:
- return None
- with self._open_file(fname) as f:
- labels = json.load(f)['labels']
- if labels is None:
- return None
- labels = dict(labels)
- labels = [labels[fname.replace('\\', '/')] for fname in self._image_fnames]
- labels = np.array(labels)
- labels = labels.astype({1: np.int64, 2: np.float32}[labels.ndim])
- return labels
-
-#----------------------------------------------------------------------------
diff --git a/spaces/Eddycrack864/Applio-Inference/gui_v1.py b/spaces/Eddycrack864/Applio-Inference/gui_v1.py
deleted file mode 100644
index becba80cdda6987c1ad70c89e68a4e3a4da44639..0000000000000000000000000000000000000000
--- a/spaces/Eddycrack864/Applio-Inference/gui_v1.py
+++ /dev/null
@@ -1,708 +0,0 @@
-import os
-import logging
-import sys
-from dotenv import load_dotenv
-
-load_dotenv()
-
-os.environ["OMP_NUM_THREADS"] = "4"
-if sys.platform == "darwin":
- os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] = "1"
-
-now_dir = os.getcwd()
-sys.path.append(now_dir)
-import multiprocessing
-
-logger = logging.getLogger(__name__)
-
-
-class Harvest(multiprocessing.Process):
- def __init__(self, inp_q, opt_q):
- multiprocessing.Process.__init__(self)
- self.inp_q = inp_q
- self.opt_q = opt_q
-
- def run(self):
- import numpy as np
- import pyworld
-
- while 1:
- idx, x, res_f0, n_cpu, ts = self.inp_q.get()
- f0, t = pyworld.harvest(
- x.astype(np.double),
- fs=16000,
- f0_ceil=1100,
- f0_floor=50,
- frame_period=10,
- )
- res_f0[idx] = f0
- if len(res_f0.keys()) >= n_cpu:
- self.opt_q.put(ts)
-
-
-if __name__ == "__main__":
- import json
- import multiprocessing
- import re
- import threading
- import time
- import traceback
- from multiprocessing import Queue, cpu_count
- from queue import Empty
-
- import librosa
- from tools.torchgate import TorchGate
- import numpy as np
- import PySimpleGUI as sg
- import sounddevice as sd
- import torch
- import torch.nn.functional as F
- import torchaudio.transforms as tat
-
- import tools.rvc_for_realtime as rvc_for_realtime
- from i18n.i18n import I18nAuto
-
- i18n = I18nAuto()
- device = rvc_for_realtime.config.device
- # device = torch.device(
- # "cuda"
- # if torch.cuda.is_available()
- # else ("mps" if torch.backends.mps.is_available() else "cpu")
- # )
- current_dir = os.getcwd()
- inp_q = Queue()
- opt_q = Queue()
- n_cpu = min(cpu_count(), 8)
- for _ in range(n_cpu):
- Harvest(inp_q, opt_q).start()
-
- class GUIConfig:
- def __init__(self) -> None:
- self.pth_path: str = ""
- self.index_path: str = ""
- self.pitch: int = 0
- self.samplerate: int = 40000
- self.block_time: float = 1.0 # s
- self.buffer_num: int = 1
- self.threhold: int = -60
- self.crossfade_time: float = 0.04
- self.extra_time: float = 2.0
- self.I_noise_reduce = False
- self.O_noise_reduce = False
- self.rms_mix_rate = 0.0
- self.index_rate = 0.3
- self.n_cpu = min(n_cpu, 6)
- self.f0method = "harvest"
- self.sg_input_device = ""
- self.sg_output_device = ""
-
- class GUI:
- def __init__(self) -> None:
- self.config = GUIConfig()
- self.flag_vc = False
-
- self.launcher()
-
- def load(self):
- input_devices, output_devices, _, _ = self.get_devices()
- try:
- with open("configs/config.json", "r") as j:
- data = json.load(j)
- data["pm"] = data["f0method"] == "pm"
- data["harvest"] = data["f0method"] == "harvest"
- data["crepe"] = data["f0method"] == "crepe"
- data["rmvpe"] = data["f0method"] == "rmvpe"
- except:
- with open("configs/config.json", "w") as j:
- data = {
- "pth_path": " ",
- "index_path": " ",
- "sg_input_device": input_devices[sd.default.device[0]],
- "sg_output_device": output_devices[sd.default.device[1]],
- "threhold": "-60",
- "pitch": "0",
- "index_rate": "0",
- "rms_mix_rate": "0",
- "block_time": "0.25",
- "crossfade_length": "0.04",
- "extra_time": "2",
- "f0method": "rmvpe",
- }
- data["pm"] = data["f0method"] == "pm"
- data["harvest"] = data["f0method"] == "harvest"
- data["crepe"] = data["f0method"] == "crepe"
- data["rmvpe"] = data["f0method"] == "rmvpe"
- return data
-
- def launcher(self):
- data = self.load()
- sg.theme("LightBlue3")
- input_devices, output_devices, _, _ = self.get_devices()
- layout = [
- [
- sg.Frame(
- title=i18n("加载模型"),
- layout=[
- [
- sg.Input(
- default_text=data.get("pth_path", ""),
- key="pth_path",
- ),
- sg.FileBrowse(
- i18n("选择.pth文件"),
- initial_folder=os.path.join(
- os.getcwd(), "assets/weights"
- ),
- file_types=((". pth"),),
- ),
- ],
- [
- sg.Input(
- default_text=data.get("index_path", ""),
- key="index_path",
- ),
- sg.FileBrowse(
- i18n("选择.index文件"),
- initial_folder=os.path.join(os.getcwd(), "logs"),
- file_types=((". index"),),
- ),
- ],
- ],
- )
- ],
- [
- sg.Frame(
- layout=[
- [
- sg.Text(i18n("输入设备")),
- sg.Combo(
- input_devices,
- key="sg_input_device",
- default_value=data.get("sg_input_device", ""),
- ),
- ],
- [
- sg.Text(i18n("输出设备")),
- sg.Combo(
- output_devices,
- key="sg_output_device",
- default_value=data.get("sg_output_device", ""),
- ),
- ],
- [sg.Button(i18n("重载设备列表"), key="reload_devices")],
- ],
- title=i18n("音频设备(请使用同种类驱动)"),
- )
- ],
- [
- sg.Frame(
- layout=[
- [
- sg.Text(i18n("响应阈值")),
- sg.Slider(
- range=(-60, 0),
- key="threhold",
- resolution=1,
- orientation="h",
- default_value=data.get("threhold", "-60"),
- enable_events=True,
- ),
- ],
- [
- sg.Text(i18n("音调设置")),
- sg.Slider(
- range=(-24, 24),
- key="pitch",
- resolution=1,
- orientation="h",
- default_value=data.get("pitch", "0"),
- enable_events=True,
- ),
- ],
- [
- sg.Text(i18n("Index Rate")),
- sg.Slider(
- range=(0.0, 1.0),
- key="index_rate",
- resolution=0.01,
- orientation="h",
- default_value=data.get("index_rate", "0"),
- enable_events=True,
- ),
- ],
- [
- sg.Text(i18n("响度因子")),
- sg.Slider(
- range=(0.0, 1.0),
- key="rms_mix_rate",
- resolution=0.01,
- orientation="h",
- default_value=data.get("rms_mix_rate", "0"),
- enable_events=True,
- ),
- ],
- [
- sg.Text(i18n("音高算法")),
- sg.Radio(
- "pm",
- "f0method",
- key="pm",
- default=data.get("pm", "") == True,
- enable_events=True,
- ),
- sg.Radio(
- "harvest",
- "f0method",
- key="harvest",
- default=data.get("harvest", "") == True,
- enable_events=True,
- ),
- sg.Radio(
- "crepe",
- "f0method",
- key="crepe",
- default=data.get("crepe", "") == True,
- enable_events=True,
- ),
- sg.Radio(
- "rmvpe",
- "f0method",
- key="rmvpe",
- default=data.get("rmvpe", "") == True,
- enable_events=True,
- ),
- ],
- ],
- title=i18n("常规设置"),
- ),
- sg.Frame(
- layout=[
- [
- sg.Text(i18n("采样长度")),
- sg.Slider(
- range=(0.05, 2.4),
- key="block_time",
- resolution=0.01,
- orientation="h",
- default_value=data.get("block_time", "0.25"),
- enable_events=True,
- ),
- ],
- [
- sg.Text(i18n("harvest进程数")),
- sg.Slider(
- range=(1, n_cpu),
- key="n_cpu",
- resolution=1,
- orientation="h",
- default_value=data.get(
- "n_cpu", min(self.config.n_cpu, n_cpu)
- ),
- enable_events=True,
- ),
- ],
- [
- sg.Text(i18n("淡入淡出长度")),
- sg.Slider(
- range=(0.01, 0.15),
- key="crossfade_length",
- resolution=0.01,
- orientation="h",
- default_value=data.get("crossfade_length", "0.04"),
- enable_events=True,
- ),
- ],
- [
- sg.Text(i18n("额外推理时长")),
- sg.Slider(
- range=(0.05, 5.00),
- key="extra_time",
- resolution=0.01,
- orientation="h",
- default_value=data.get("extra_time", "2.0"),
- enable_events=True,
- ),
- ],
- [
- sg.Checkbox(
- i18n("输入降噪"),
- key="I_noise_reduce",
- enable_events=True,
- ),
- sg.Checkbox(
- i18n("输出降噪"),
- key="O_noise_reduce",
- enable_events=True,
- ),
- ],
- ],
- title=i18n("性能设置"),
- ),
- ],
- [
- sg.Button(i18n("开始音频转换"), key="start_vc"),
- sg.Button(i18n("停止音频转换"), key="stop_vc"),
- sg.Text(i18n("推理时间(ms):")),
- sg.Text("0", key="infer_time"),
- ],
- ]
- self.window = sg.Window("RVC - GUI", layout=layout, finalize=True)
- self.event_handler()
-
- def event_handler(self):
- while True:
- event, values = self.window.read()
- if event == sg.WINDOW_CLOSED:
- self.flag_vc = False
- exit()
- if event == "reload_devices":
- prev_input = self.window["sg_input_device"].get()
- prev_output = self.window["sg_output_device"].get()
- input_devices, output_devices, _, _ = self.get_devices(update=True)
- if prev_input not in input_devices:
- self.config.sg_input_device = input_devices[0]
- else:
- self.config.sg_input_device = prev_input
- self.window["sg_input_device"].Update(values=input_devices)
- self.window["sg_input_device"].Update(
- value=self.config.sg_input_device
- )
- if prev_output not in output_devices:
- self.config.sg_output_device = output_devices[0]
- else:
- self.config.sg_output_device = prev_output
- self.window["sg_output_device"].Update(values=output_devices)
- self.window["sg_output_device"].Update(
- value=self.config.sg_output_device
- )
- if event == "start_vc" and self.flag_vc == False:
- if self.set_values(values) == True:
- logger.info("Use CUDA: %s", torch.cuda.is_available())
- self.start_vc()
- settings = {
- "pth_path": values["pth_path"],
- "index_path": values["index_path"],
- "sg_input_device": values["sg_input_device"],
- "sg_output_device": values["sg_output_device"],
- "threhold": values["threhold"],
- "pitch": values["pitch"],
- "rms_mix_rate": values["rms_mix_rate"],
- "index_rate": values["index_rate"],
- "block_time": values["block_time"],
- "crossfade_length": values["crossfade_length"],
- "extra_time": values["extra_time"],
- "n_cpu": values["n_cpu"],
- "f0method": ["pm", "harvest", "crepe", "rmvpe"][
- [
- values["pm"],
- values["harvest"],
- values["crepe"],
- values["rmvpe"],
- ].index(True)
- ],
- }
- with open("configs/config.json", "w") as j:
- json.dump(settings, j)
- if event == "stop_vc" and self.flag_vc == True:
- self.flag_vc = False
-
- # Parameter hot update
- if event == "threhold":
- self.config.threhold = values["threhold"]
- elif event == "pitch":
- self.config.pitch = values["pitch"]
- if hasattr(self, "rvc"):
- self.rvc.change_key(values["pitch"])
- elif event == "index_rate":
- self.config.index_rate = values["index_rate"]
- if hasattr(self, "rvc"):
- self.rvc.change_index_rate(values["index_rate"])
- elif event == "rms_mix_rate":
- self.config.rms_mix_rate = values["rms_mix_rate"]
- elif event in ["pm", "harvest", "crepe", "rmvpe"]:
- self.config.f0method = event
- elif event == "I_noise_reduce":
- self.config.I_noise_reduce = values["I_noise_reduce"]
- elif event == "O_noise_reduce":
- self.config.O_noise_reduce = values["O_noise_reduce"]
- elif event != "start_vc" and self.flag_vc == True:
- # Other parameters do not support hot update
- self.flag_vc = False
-
- def set_values(self, values):
- if len(values["pth_path"].strip()) == 0:
- sg.popup(i18n("请选择pth文件"))
- return False
- if len(values["index_path"].strip()) == 0:
- sg.popup(i18n("请选择index文件"))
- return False
- pattern = re.compile("[^\x00-\x7F]+")
- if pattern.findall(values["pth_path"]):
- sg.popup(i18n("pth文件路径不可包含中文"))
- return False
- if pattern.findall(values["index_path"]):
- sg.popup(i18n("index文件路径不可包含中文"))
- return False
- self.set_devices(values["sg_input_device"], values["sg_output_device"])
- self.config.pth_path = values["pth_path"]
- self.config.index_path = values["index_path"]
- self.config.threhold = values["threhold"]
- self.config.pitch = values["pitch"]
- self.config.block_time = values["block_time"]
- self.config.crossfade_time = values["crossfade_length"]
- self.config.extra_time = values["extra_time"]
- self.config.I_noise_reduce = values["I_noise_reduce"]
- self.config.O_noise_reduce = values["O_noise_reduce"]
- self.config.rms_mix_rate = values["rms_mix_rate"]
- self.config.index_rate = values["index_rate"]
- self.config.n_cpu = values["n_cpu"]
- self.config.f0method = ["pm", "harvest", "crepe", "rmvpe"][
- [
- values["pm"],
- values["harvest"],
- values["crepe"],
- values["rmvpe"],
- ].index(True)
- ]
- return True
-
- def start_vc(self):
- torch.cuda.empty_cache()
- self.flag_vc = True
- self.rvc = rvc_for_realtime.RVC(
- self.config.pitch,
- self.config.pth_path,
- self.config.index_path,
- self.config.index_rate,
- self.config.n_cpu,
- inp_q,
- opt_q,
- device,
- self.rvc if hasattr(self, "rvc") else None
- )
- self.config.samplerate = self.rvc.tgt_sr
- self.zc = self.rvc.tgt_sr // 100
- self.block_frame = int(np.round(self.config.block_time * self.config.samplerate / self.zc)) * self.zc
- self.block_frame_16k = 160 * self.block_frame // self.zc
- self.crossfade_frame = int(np.round(self.config.crossfade_time * self.config.samplerate / self.zc)) * self.zc
- self.sola_search_frame = self.zc
- self.extra_frame = int(np.round(self.config.extra_time * self.config.samplerate / self.zc)) * self.zc
- self.input_wav: torch.Tensor = torch.zeros(
- self.extra_frame
- + self.crossfade_frame
- + self.sola_search_frame
- + self.block_frame,
- device=device,
- dtype=torch.float32,
- )
- self.input_wav_res: torch.Tensor= torch.zeros(160 * self.input_wav.shape[0] // self.zc, device=device,dtype=torch.float32)
- self.pitch: np.ndarray = np.zeros(
- self.input_wav.shape[0] // self.zc,
- dtype="int32",
- )
- self.pitchf: np.ndarray = np.zeros(
- self.input_wav.shape[0] // self.zc,
- dtype="float64",
- )
- self.sola_buffer: torch.Tensor = torch.zeros(
- self.crossfade_frame, device=device, dtype=torch.float32
- )
- self.nr_buffer: torch.Tensor = self.sola_buffer.clone()
- self.output_buffer: torch.Tensor = self.input_wav.clone()
- self.res_buffer: torch.Tensor = torch.zeros(2 * self.zc, device=device,dtype=torch.float32)
- self.valid_rate = 1 - (self.extra_frame - 1) / self.input_wav.shape[0]
- self.fade_in_window: torch.Tensor = (
- torch.sin(
- 0.5
- * np.pi
- * torch.linspace(
- 0.0,
- 1.0,
- steps=self.crossfade_frame,
- device=device,
- dtype=torch.float32,
- )
- )
- ** 2
- )
- self.fade_out_window: torch.Tensor = 1 - self.fade_in_window
- self.resampler = tat.Resample(
- orig_freq=self.config.samplerate, new_freq=16000, dtype=torch.float32
- ).to(device)
- self.tg = TorchGate(sr=self.config.samplerate, n_fft=4*self.zc, prop_decrease=0.9).to(device)
- thread_vc = threading.Thread(target=self.soundinput)
- thread_vc.start()
-
- def soundinput(self):
- """
- 接受音频输入
- """
- channels = 1 if sys.platform == "darwin" else 2
- with sd.Stream(
- channels=channels,
- callback=self.audio_callback,
- blocksize=self.block_frame,
- samplerate=self.config.samplerate,
- dtype="float32",
- ):
- while self.flag_vc:
- time.sleep(self.config.block_time)
- logger.debug("Audio block passed.")
- logger.debug("ENDing VC")
-
- def audio_callback(
- self, indata: np.ndarray, outdata: np.ndarray, frames, times, status
- ):
- """
- 音频处理
- """
- start_time = time.perf_counter()
- indata = librosa.to_mono(indata.T)
- if self.config.threhold > -60:
- rms = librosa.feature.rms(
- y=indata, frame_length=4*self.zc, hop_length=self.zc
- )
- db_threhold = (
- librosa.amplitude_to_db(rms, ref=1.0)[0] < self.config.threhold
- )
- for i in range(db_threhold.shape[0]):
- if db_threhold[i]:
- indata[i * self.zc : (i + 1) * self.zc] = 0
- self.input_wav[: -self.block_frame] = self.input_wav[self.block_frame :].clone()
- self.input_wav[-self.block_frame: ] = torch.from_numpy(indata).to(device)
- self.input_wav_res[ : -self.block_frame_16k] = self.input_wav_res[self.block_frame_16k :].clone()
- # input noise reduction and resampling
- if self.config.I_noise_reduce:
- input_wav = self.input_wav[-self.crossfade_frame -self.block_frame-2*self.zc: ]
- input_wav = self.tg(input_wav.unsqueeze(0), self.input_wav.unsqueeze(0))[0, 2*self.zc:]
- input_wav[: self.crossfade_frame] *= self.fade_in_window
- input_wav[: self.crossfade_frame] += self.nr_buffer * self.fade_out_window
- self.nr_buffer[:] = input_wav[-self.crossfade_frame: ]
- input_wav = torch.cat((self.res_buffer[:], input_wav[: self.block_frame]))
- self.res_buffer[:] = input_wav[-2*self.zc: ]
- self.input_wav_res[-self.block_frame_16k-160: ] = self.resampler(input_wav)[160: ]
- else:
- self.input_wav_res[-self.block_frame_16k-160: ] = self.resampler(self.input_wav[-self.block_frame-2*self.zc: ])[160: ]
- # infer
- f0_extractor_frame = self.block_frame_16k + 800
- if self.config.f0method == 'rmvpe':
- f0_extractor_frame = 5120 * ((f0_extractor_frame - 1) // 5120 + 1)
- infer_wav = self.rvc.infer(
- self.input_wav_res,
- self.input_wav_res[-f0_extractor_frame :].cpu().numpy(),
- self.block_frame_16k,
- self.valid_rate,
- self.pitch,
- self.pitchf,
- self.config.f0method,
- )
- infer_wav = infer_wav[
- -self.crossfade_frame - self.sola_search_frame - self.block_frame :
- ]
- # output noise reduction
- if self.config.O_noise_reduce:
- self.output_buffer[: -self.block_frame] = self.output_buffer[self.block_frame :].clone()
- self.output_buffer[-self.block_frame: ] = infer_wav[-self.block_frame:]
- infer_wav = self.tg(infer_wav.unsqueeze(0), self.output_buffer.unsqueeze(0)).squeeze(0)
- # volume envelop mixing
- if self.config.rms_mix_rate < 1:
- rms1 = librosa.feature.rms(
- y=self.input_wav_res[-160*infer_wav.shape[0]//self.zc :].cpu().numpy(),
- frame_length=640,
- hop_length=160,
- )
- rms1 = torch.from_numpy(rms1).to(device)
- rms1 = F.interpolate(
- rms1.unsqueeze(0), size=infer_wav.shape[0] + 1, mode="linear",align_corners=True,
- )[0,0,:-1]
- rms2 = librosa.feature.rms(
- y=infer_wav[:].cpu().numpy(), frame_length=4*self.zc, hop_length=self.zc
- )
- rms2 = torch.from_numpy(rms2).to(device)
- rms2 = F.interpolate(
- rms2.unsqueeze(0), size=infer_wav.shape[0] + 1, mode="linear",align_corners=True,
- )[0,0,:-1]
- rms2 = torch.max(rms2, torch.zeros_like(rms2) + 1e-3)
- infer_wav *= torch.pow(rms1 / rms2, torch.tensor(1 - self.config.rms_mix_rate))
- # SOLA algorithm from https://github.com/yxlllc/DDSP-SVC
- conv_input = infer_wav[None, None, : self.crossfade_frame + self.sola_search_frame]
- cor_nom = F.conv1d(conv_input, self.sola_buffer[None, None, :])
- cor_den = torch.sqrt(
- F.conv1d(conv_input ** 2, torch.ones(1, 1, self.crossfade_frame, device=device)) + 1e-8)
- if sys.platform == "darwin":
- _, sola_offset = torch.max(cor_nom[0, 0] / cor_den[0, 0])
- sola_offset = sola_offset.item()
- else:
- sola_offset = torch.argmax(cor_nom[0, 0] / cor_den[0, 0])
- logger.debug("sola_offset = %d", int(sola_offset))
- infer_wav = infer_wav[sola_offset: sola_offset + self.block_frame + self.crossfade_frame]
- infer_wav[: self.crossfade_frame] *= self.fade_in_window
- infer_wav[: self.crossfade_frame] += self.sola_buffer *self.fade_out_window
- self.sola_buffer[:] = infer_wav[-self.crossfade_frame:]
- if sys.platform == "darwin":
- outdata[:] = infer_wav[:-self.crossfade_frame].cpu().numpy()[:, np.newaxis]
- else:
- outdata[:] = infer_wav[:-self.crossfade_frame].repeat(2, 1).t().cpu().numpy()
- total_time = time.perf_counter() - start_time
- self.window["infer_time"].update(int(total_time * 1000))
- logger.info("Infer time: %.2f", total_time)
-
- def get_devices(self, update: bool = True):
- """获取设备列表"""
- if update:
- sd._terminate()
- sd._initialize()
- devices = sd.query_devices()
- hostapis = sd.query_hostapis()
- for hostapi in hostapis:
- for device_idx in hostapi["devices"]:
- devices[device_idx]["hostapi_name"] = hostapi["name"]
- input_devices = [
- f"{d['name']} ({d['hostapi_name']})"
- for d in devices
- if d["max_input_channels"] > 0
- ]
- output_devices = [
- f"{d['name']} ({d['hostapi_name']})"
- for d in devices
- if d["max_output_channels"] > 0
- ]
- input_devices_indices = [
- d["index"] if "index" in d else d["name"]
- for d in devices
- if d["max_input_channels"] > 0
- ]
- output_devices_indices = [
- d["index"] if "index" in d else d["name"]
- for d in devices
- if d["max_output_channels"] > 0
- ]
- return (
- input_devices,
- output_devices,
- input_devices_indices,
- output_devices_indices,
- )
-
- def set_devices(self, input_device, output_device):
- """设置输出设备"""
- (
- input_devices,
- output_devices,
- input_device_indices,
- output_device_indices,
- ) = self.get_devices()
- sd.default.device[0] = input_device_indices[
- input_devices.index(input_device)
- ]
- sd.default.device[1] = output_device_indices[
- output_devices.index(output_device)
- ]
- logger.info(
- "Input device: %s:%s", str(sd.default.device[0]), input_device
- )
- logger.info(
- "Output device: %s:%s", str(sd.default.device[1]), output_device
- )
-
- gui = GUI()
\ No newline at end of file
diff --git a/spaces/ElainaFanBoy/IRONY-Real-ESRGAN/realesrgan/__init__.py b/spaces/ElainaFanBoy/IRONY-Real-ESRGAN/realesrgan/__init__.py
deleted file mode 100644
index bfea78f284116dee22510d4aa91f9e44afb7d472..0000000000000000000000000000000000000000
--- a/spaces/ElainaFanBoy/IRONY-Real-ESRGAN/realesrgan/__init__.py
+++ /dev/null
@@ -1,6 +0,0 @@
-# flake8: noqa
-from .archs import *
-from .data import *
-from .models import *
-from .utils import *
-#from .version import *
diff --git a/spaces/ElainaFanBoy/IRONY-Real-ESRGAN/tests/test_model.py b/spaces/ElainaFanBoy/IRONY-Real-ESRGAN/tests/test_model.py
deleted file mode 100644
index c20bb1d56ed20222e929e9c94026f6ea383c6026..0000000000000000000000000000000000000000
--- a/spaces/ElainaFanBoy/IRONY-Real-ESRGAN/tests/test_model.py
+++ /dev/null
@@ -1,126 +0,0 @@
-import torch
-import yaml
-from basicsr.archs.rrdbnet_arch import RRDBNet
-from basicsr.data.paired_image_dataset import PairedImageDataset
-from basicsr.losses.losses import GANLoss, L1Loss, PerceptualLoss
-
-from realesrgan.archs.discriminator_arch import UNetDiscriminatorSN
-from realesrgan.models.realesrgan_model import RealESRGANModel
-from realesrgan.models.realesrnet_model import RealESRNetModel
-
-
-def test_realesrnet_model():
- with open('tests/data/test_realesrnet_model.yml', mode='r') as f:
- opt = yaml.load(f, Loader=yaml.FullLoader)
-
- # build model
- model = RealESRNetModel(opt)
- # test attributes
- assert model.__class__.__name__ == 'RealESRNetModel'
- assert isinstance(model.net_g, RRDBNet)
- assert isinstance(model.cri_pix, L1Loss)
- assert isinstance(model.optimizers[0], torch.optim.Adam)
-
- # prepare data
- gt = torch.rand((1, 3, 32, 32), dtype=torch.float32)
- kernel1 = torch.rand((1, 5, 5), dtype=torch.float32)
- kernel2 = torch.rand((1, 5, 5), dtype=torch.float32)
- sinc_kernel = torch.rand((1, 5, 5), dtype=torch.float32)
- data = dict(gt=gt, kernel1=kernel1, kernel2=kernel2, sinc_kernel=sinc_kernel)
- model.feed_data(data)
- # check dequeue
- model.feed_data(data)
- # check data shape
- assert model.lq.shape == (1, 3, 8, 8)
- assert model.gt.shape == (1, 3, 32, 32)
-
- # change probability to test if-else
- model.opt['gaussian_noise_prob'] = 0
- model.opt['gray_noise_prob'] = 0
- model.opt['second_blur_prob'] = 0
- model.opt['gaussian_noise_prob2'] = 0
- model.opt['gray_noise_prob2'] = 0
- model.feed_data(data)
- # check data shape
- assert model.lq.shape == (1, 3, 8, 8)
- assert model.gt.shape == (1, 3, 32, 32)
-
- # ----------------- test nondist_validation -------------------- #
- # construct dataloader
- dataset_opt = dict(
- name='Demo',
- dataroot_gt='tests/data/gt',
- dataroot_lq='tests/data/lq',
- io_backend=dict(type='disk'),
- scale=4,
- phase='val')
- dataset = PairedImageDataset(dataset_opt)
- dataloader = torch.utils.data.DataLoader(dataset=dataset, batch_size=1, shuffle=False, num_workers=0)
- assert model.is_train is True
- model.nondist_validation(dataloader, 1, None, False)
- assert model.is_train is True
-
-
-def test_realesrgan_model():
- with open('tests/data/test_realesrgan_model.yml', mode='r') as f:
- opt = yaml.load(f, Loader=yaml.FullLoader)
-
- # build model
- model = RealESRGANModel(opt)
- # test attributes
- assert model.__class__.__name__ == 'RealESRGANModel'
- assert isinstance(model.net_g, RRDBNet) # generator
- assert isinstance(model.net_d, UNetDiscriminatorSN) # discriminator
- assert isinstance(model.cri_pix, L1Loss)
- assert isinstance(model.cri_perceptual, PerceptualLoss)
- assert isinstance(model.cri_gan, GANLoss)
- assert isinstance(model.optimizers[0], torch.optim.Adam)
- assert isinstance(model.optimizers[1], torch.optim.Adam)
-
- # prepare data
- gt = torch.rand((1, 3, 32, 32), dtype=torch.float32)
- kernel1 = torch.rand((1, 5, 5), dtype=torch.float32)
- kernel2 = torch.rand((1, 5, 5), dtype=torch.float32)
- sinc_kernel = torch.rand((1, 5, 5), dtype=torch.float32)
- data = dict(gt=gt, kernel1=kernel1, kernel2=kernel2, sinc_kernel=sinc_kernel)
- model.feed_data(data)
- # check dequeue
- model.feed_data(data)
- # check data shape
- assert model.lq.shape == (1, 3, 8, 8)
- assert model.gt.shape == (1, 3, 32, 32)
-
- # change probability to test if-else
- model.opt['gaussian_noise_prob'] = 0
- model.opt['gray_noise_prob'] = 0
- model.opt['second_blur_prob'] = 0
- model.opt['gaussian_noise_prob2'] = 0
- model.opt['gray_noise_prob2'] = 0
- model.feed_data(data)
- # check data shape
- assert model.lq.shape == (1, 3, 8, 8)
- assert model.gt.shape == (1, 3, 32, 32)
-
- # ----------------- test nondist_validation -------------------- #
- # construct dataloader
- dataset_opt = dict(
- name='Demo',
- dataroot_gt='tests/data/gt',
- dataroot_lq='tests/data/lq',
- io_backend=dict(type='disk'),
- scale=4,
- phase='val')
- dataset = PairedImageDataset(dataset_opt)
- dataloader = torch.utils.data.DataLoader(dataset=dataset, batch_size=1, shuffle=False, num_workers=0)
- assert model.is_train is True
- model.nondist_validation(dataloader, 1, None, False)
- assert model.is_train is True
-
- # ----------------- test optimize_parameters -------------------- #
- model.feed_data(data)
- model.optimize_parameters(1)
- assert model.output.shape == (1, 3, 32, 32)
- assert isinstance(model.log_dict, dict)
- # check returned keys
- expected_keys = ['l_g_pix', 'l_g_percep', 'l_g_gan', 'l_d_real', 'out_d_real', 'l_d_fake', 'out_d_fake']
- assert set(expected_keys).issubset(set(model.log_dict.keys()))
diff --git a/spaces/EleutherAI/VQGAN_CLIP/taming-transformers/scripts/sample_conditional.py b/spaces/EleutherAI/VQGAN_CLIP/taming-transformers/scripts/sample_conditional.py
deleted file mode 100644
index 174cf2af07c1a1ca4e6c35fc0e4f8d6e53591b56..0000000000000000000000000000000000000000
--- a/spaces/EleutherAI/VQGAN_CLIP/taming-transformers/scripts/sample_conditional.py
+++ /dev/null
@@ -1,355 +0,0 @@
-import argparse, os, sys, glob, math, time
-import torch
-import numpy as np
-from omegaconf import OmegaConf
-import streamlit as st
-from streamlit import caching
-from PIL import Image
-from main import instantiate_from_config, DataModuleFromConfig
-from torch.utils.data import DataLoader
-from torch.utils.data.dataloader import default_collate
-
-
-rescale = lambda x: (x + 1.) / 2.
-
-
-def bchw_to_st(x):
- return rescale(x.detach().cpu().numpy().transpose(0,2,3,1))
-
-def save_img(xstart, fname):
- I = (xstart.clip(0,1)[0]*255).astype(np.uint8)
- Image.fromarray(I).save(fname)
-
-
-
-def get_interactive_image(resize=False):
- image = st.file_uploader("Input", type=["jpg", "JPEG", "png"])
- if image is not None:
- image = Image.open(image)
- if not image.mode == "RGB":
- image = image.convert("RGB")
- image = np.array(image).astype(np.uint8)
- print("upload image shape: {}".format(image.shape))
- img = Image.fromarray(image)
- if resize:
- img = img.resize((256, 256))
- image = np.array(img)
- return image
-
-
-def single_image_to_torch(x, permute=True):
- assert x is not None, "Please provide an image through the upload function"
- x = np.array(x)
- x = torch.FloatTensor(x/255.*2. - 1.)[None,...]
- if permute:
- x = x.permute(0, 3, 1, 2)
- return x
-
-
-def pad_to_M(x, M):
- hp = math.ceil(x.shape[2]/M)*M-x.shape[2]
- wp = math.ceil(x.shape[3]/M)*M-x.shape[3]
- x = torch.nn.functional.pad(x, (0,wp,0,hp,0,0,0,0))
- return x
-
-@torch.no_grad()
-def run_conditional(model, dsets):
- if len(dsets.datasets) > 1:
- split = st.sidebar.radio("Split", sorted(dsets.datasets.keys()))
- dset = dsets.datasets[split]
- else:
- dset = next(iter(dsets.datasets.values()))
- batch_size = 1
- start_index = st.sidebar.number_input("Example Index (Size: {})".format(len(dset)), value=0,
- min_value=0,
- max_value=len(dset)-batch_size)
- indices = list(range(start_index, start_index+batch_size))
-
- example = default_collate([dset[i] for i in indices])
-
- x = model.get_input("image", example).to(model.device)
-
- cond_key = model.cond_stage_key
- c = model.get_input(cond_key, example).to(model.device)
-
- scale_factor = st.sidebar.slider("Scale Factor", min_value=0.5, max_value=4.0, step=0.25, value=1.00)
- if scale_factor != 1.0:
- x = torch.nn.functional.interpolate(x, scale_factor=scale_factor, mode="bicubic")
- c = torch.nn.functional.interpolate(c, scale_factor=scale_factor, mode="bicubic")
-
- quant_z, z_indices = model.encode_to_z(x)
- quant_c, c_indices = model.encode_to_c(c)
-
- cshape = quant_z.shape
-
- xrec = model.first_stage_model.decode(quant_z)
- st.write("image: {}".format(x.shape))
- st.image(bchw_to_st(x), clamp=True, output_format="PNG")
- st.write("image reconstruction: {}".format(xrec.shape))
- st.image(bchw_to_st(xrec), clamp=True, output_format="PNG")
-
- if cond_key == "segmentation":
- # get image from segmentation mask
- num_classes = c.shape[1]
- c = torch.argmax(c, dim=1, keepdim=True)
- c = torch.nn.functional.one_hot(c, num_classes=num_classes)
- c = c.squeeze(1).permute(0, 3, 1, 2).float()
- c = model.cond_stage_model.to_rgb(c)
-
- st.write(f"{cond_key}: {tuple(c.shape)}")
- st.image(bchw_to_st(c), clamp=True, output_format="PNG")
-
- idx = z_indices
-
- half_sample = st.sidebar.checkbox("Image Completion", value=False)
- if half_sample:
- start = idx.shape[1]//2
- else:
- start = 0
-
- idx[:,start:] = 0
- idx = idx.reshape(cshape[0],cshape[2],cshape[3])
- start_i = start//cshape[3]
- start_j = start %cshape[3]
-
- if not half_sample and quant_z.shape == quant_c.shape:
- st.info("Setting idx to c_indices")
- idx = c_indices.clone().reshape(cshape[0],cshape[2],cshape[3])
-
- cidx = c_indices
- cidx = cidx.reshape(quant_c.shape[0],quant_c.shape[2],quant_c.shape[3])
-
- xstart = model.decode_to_img(idx[:,:cshape[2],:cshape[3]], cshape)
- st.image(bchw_to_st(xstart), clamp=True, output_format="PNG")
-
- temperature = st.number_input("Temperature", value=1.0)
- top_k = st.number_input("Top k", value=100)
- sample = st.checkbox("Sample", value=True)
- update_every = st.number_input("Update every", value=75)
-
- st.text(f"Sampling shape ({cshape[2]},{cshape[3]})")
-
- animate = st.checkbox("animate")
- if animate:
- import imageio
- outvid = "sampling.mp4"
- writer = imageio.get_writer(outvid, fps=25)
- elapsed_t = st.empty()
- info = st.empty()
- st.text("Sampled")
- if st.button("Sample"):
- output = st.empty()
- start_t = time.time()
- for i in range(start_i,cshape[2]-0):
- if i <= 8:
- local_i = i
- elif cshape[2]-i < 8:
- local_i = 16-(cshape[2]-i)
- else:
- local_i = 8
- for j in range(start_j,cshape[3]-0):
- if j <= 8:
- local_j = j
- elif cshape[3]-j < 8:
- local_j = 16-(cshape[3]-j)
- else:
- local_j = 8
-
- i_start = i-local_i
- i_end = i_start+16
- j_start = j-local_j
- j_end = j_start+16
- elapsed_t.text(f"Time: {time.time() - start_t} seconds")
- info.text(f"Step: ({i},{j}) | Local: ({local_i},{local_j}) | Crop: ({i_start}:{i_end},{j_start}:{j_end})")
- patch = idx[:,i_start:i_end,j_start:j_end]
- patch = patch.reshape(patch.shape[0],-1)
- cpatch = cidx[:, i_start:i_end, j_start:j_end]
- cpatch = cpatch.reshape(cpatch.shape[0], -1)
- patch = torch.cat((cpatch, patch), dim=1)
- logits,_ = model.transformer(patch[:,:-1])
- logits = logits[:, -256:, :]
- logits = logits.reshape(cshape[0],16,16,-1)
- logits = logits[:,local_i,local_j,:]
-
- logits = logits/temperature
-
- if top_k is not None:
- logits = model.top_k_logits(logits, top_k)
- # apply softmax to convert to probabilities
- probs = torch.nn.functional.softmax(logits, dim=-1)
- # sample from the distribution or take the most likely
- if sample:
- ix = torch.multinomial(probs, num_samples=1)
- else:
- _, ix = torch.topk(probs, k=1, dim=-1)
- idx[:,i,j] = ix
-
- if (i*cshape[3]+j)%update_every==0:
- xstart = model.decode_to_img(idx[:, :cshape[2], :cshape[3]], cshape,)
-
- xstart = bchw_to_st(xstart)
- output.image(xstart, clamp=True, output_format="PNG")
-
- if animate:
- writer.append_data((xstart[0]*255).clip(0, 255).astype(np.uint8))
-
- xstart = model.decode_to_img(idx[:,:cshape[2],:cshape[3]], cshape)
- xstart = bchw_to_st(xstart)
- output.image(xstart, clamp=True, output_format="PNG")
- #save_img(xstart, "full_res_sample.png")
- if animate:
- writer.close()
- st.video(outvid)
-
-
-def get_parser():
- parser = argparse.ArgumentParser()
- parser.add_argument(
- "-r",
- "--resume",
- type=str,
- nargs="?",
- help="load from logdir or checkpoint in logdir",
- )
- parser.add_argument(
- "-b",
- "--base",
- nargs="*",
- metavar="base_config.yaml",
- help="paths to base configs. Loaded from left-to-right. "
- "Parameters can be overwritten or added with command-line options of the form `--key value`.",
- default=list(),
- )
- parser.add_argument(
- "-c",
- "--config",
- nargs="?",
- metavar="single_config.yaml",
- help="path to single config. If specified, base configs will be ignored "
- "(except for the last one if left unspecified).",
- const=True,
- default="",
- )
- parser.add_argument(
- "--ignore_base_data",
- action="store_true",
- help="Ignore data specification from base configs. Useful if you want "
- "to specify a custom datasets on the command line.",
- )
- return parser
-
-
-def load_model_from_config(config, sd, gpu=True, eval_mode=True):
- if "ckpt_path" in config.params:
- st.warning("Deleting the restore-ckpt path from the config...")
- config.params.ckpt_path = None
- if "downsample_cond_size" in config.params:
- st.warning("Deleting downsample-cond-size from the config and setting factor=0.5 instead...")
- config.params.downsample_cond_size = -1
- config.params["downsample_cond_factor"] = 0.5
- try:
- if "ckpt_path" in config.params.first_stage_config.params:
- config.params.first_stage_config.params.ckpt_path = None
- st.warning("Deleting the first-stage restore-ckpt path from the config...")
- if "ckpt_path" in config.params.cond_stage_config.params:
- config.params.cond_stage_config.params.ckpt_path = None
- st.warning("Deleting the cond-stage restore-ckpt path from the config...")
- except:
- pass
-
- model = instantiate_from_config(config)
- if sd is not None:
- missing, unexpected = model.load_state_dict(sd, strict=False)
- st.info(f"Missing Keys in State Dict: {missing}")
- st.info(f"Unexpected Keys in State Dict: {unexpected}")
- if gpu:
- model.cuda()
- if eval_mode:
- model.eval()
- return {"model": model}
-
-
-def get_data(config):
- # get data
- data = instantiate_from_config(config.data)
- data.prepare_data()
- data.setup()
- return data
-
-
-@st.cache(allow_output_mutation=True, suppress_st_warning=True)
-def load_model_and_dset(config, ckpt, gpu, eval_mode):
- # get data
- dsets = get_data(config) # calls data.config ...
-
- # now load the specified checkpoint
- if ckpt:
- pl_sd = torch.load(ckpt, map_location="cpu")
- global_step = pl_sd["global_step"]
- else:
- pl_sd = {"state_dict": None}
- global_step = None
- model = load_model_from_config(config.model,
- pl_sd["state_dict"],
- gpu=gpu,
- eval_mode=eval_mode)["model"]
- return dsets, model, global_step
-
-
-if __name__ == "__main__":
- sys.path.append(os.getcwd())
-
- parser = get_parser()
-
- opt, unknown = parser.parse_known_args()
-
- ckpt = None
- if opt.resume:
- if not os.path.exists(opt.resume):
- raise ValueError("Cannot find {}".format(opt.resume))
- if os.path.isfile(opt.resume):
- paths = opt.resume.split("/")
- try:
- idx = len(paths)-paths[::-1].index("logs")+1
- except ValueError:
- idx = -2 # take a guess: path/to/logdir/checkpoints/model.ckpt
- logdir = "/".join(paths[:idx])
- ckpt = opt.resume
- else:
- assert os.path.isdir(opt.resume), opt.resume
- logdir = opt.resume.rstrip("/")
- ckpt = os.path.join(logdir, "checkpoints", "last.ckpt")
- print(f"logdir:{logdir}")
- base_configs = sorted(glob.glob(os.path.join(logdir, "configs/*-project.yaml")))
- opt.base = base_configs+opt.base
-
- if opt.config:
- if type(opt.config) == str:
- opt.base = [opt.config]
- else:
- opt.base = [opt.base[-1]]
-
- configs = [OmegaConf.load(cfg) for cfg in opt.base]
- cli = OmegaConf.from_dotlist(unknown)
- if opt.ignore_base_data:
- for config in configs:
- if hasattr(config, "data"): del config["data"]
- config = OmegaConf.merge(*configs, cli)
-
- st.sidebar.text(ckpt)
- gs = st.sidebar.empty()
- gs.text(f"Global step: ?")
- st.sidebar.text("Options")
- #gpu = st.sidebar.checkbox("GPU", value=True)
- gpu = True
- #eval_mode = st.sidebar.checkbox("Eval Mode", value=True)
- eval_mode = True
- #show_config = st.sidebar.checkbox("Show Config", value=False)
- show_config = False
- if show_config:
- st.info("Checkpoint: {}".format(ckpt))
- st.json(OmegaConf.to_container(config))
-
- dsets, model, global_step = load_model_and_dset(config, ckpt, gpu, eval_mode)
- gs.text(f"Global step: {global_step}")
- run_conditional(model, dsets)
diff --git a/spaces/EliotLacroix/Fine-tuned_Resnet_Face_Segmentation/app.py b/spaces/EliotLacroix/Fine-tuned_Resnet_Face_Segmentation/app.py
deleted file mode 100644
index b6f0b7c4d154af75da6f045aa6abf0373203554a..0000000000000000000000000000000000000000
--- a/spaces/EliotLacroix/Fine-tuned_Resnet_Face_Segmentation/app.py
+++ /dev/null
@@ -1,28 +0,0 @@
-from fastai.vision.all import *
-import gradio as gr
-import numpy as np
-from skimage import color
-import pathlib
-
-# temp = pathlib.PosixPath
-# pathlib.PosixPath = pathlib.WindowsPath
-
-def get_label(filepath):
- return None
-
-learn = load_learner("resnet18_5epochs.pkl")
-
-def segment(img):
- mask, _, _ = learn.predict(img)
- result = color.label2rgb(np.array(mask),img, colors=['red', 'green', 'blue', 'chocolate', 'cyan', 'purple', 'yellow', 'darkorange', 'turquoise', 'lime'] , bg_label=0)
- return result
-
-TITLE = "Pixel-level Face Segmentation"
-DESCRIPTION = "Resnet18 fine-tuned for face features segmentation via fastai and [Mut1ny's Face Segmentation Dataset](https://store.mut1ny.com/product/face-head-segmentation-dataset-community-edition?v=a04a1cb60875).\
- \n I am now trying to reproduce this fine-tuning in Pytorch, you can check my progress on this [Kaggle notebook](https://www.kaggle.com/eliotlacroix/pixel-level-face-segmentation)"
-INPUT = gr.Image(shape=(224, 224))
-OUTPUT = gr.ImageMask(shape=(224, 224), label='Resnet18')
-EXAMPLES = [f for f in pathlib.Path('examples').iterdir()]
-
-intf = gr.Interface(fn=segment, inputs=INPUT, outputs=OUTPUT, examples=EXAMPLES, title=TITLE, description=DESCRIPTION)
-intf.launch(inline=False)
\ No newline at end of file
diff --git a/spaces/Epitech/Scarecrow/original_app/scarecrow.py b/spaces/Epitech/Scarecrow/original_app/scarecrow.py
deleted file mode 100644
index cad87398bf281325d977ff69190bea0bf23ced3e..0000000000000000000000000000000000000000
--- a/spaces/Epitech/Scarecrow/original_app/scarecrow.py
+++ /dev/null
@@ -1,60 +0,0 @@
-import cv2
-import numpy as np
-import socket
-import sys
-import pickle
-import struct
-import pygame
-
-# Initialize pygame mixer
-pygame.mixer.init()
-
-# Set up dictionary of label-sound pairs
-label_sound_dict = {
- "person": "a.mp3",
- "cell_phone": "b.mp3",
-}
-
-cap = cv2.VideoCapture(0)
-clientsocket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
-clientsocket.connect(('localhost',8089))
-
-# Initialize variables for label detection
-label_count = 0
-current_label = None
-
-while True:
- ret, frame = cap.read()
- # Serialize frame
- data = pickle.dumps(frame)
-
- # Send message length first
- message_size = struct.pack("L", len(data)) ### CHANGED
-
- # Then data
- clientsocket.sendall(message_size + data)
-
- # Receive response from server
- response = clientsocket.recv(1024)
- decoded_response = response.decode()
- print(decoded_response)
-
- # Check if response is a label we care about
- if "[Scarecrow]: " in decoded_response:
- label = decoded_response.split("[Scarecrow]: ")[1]
- if label in label_sound_dict:
- if label != current_label:
- # Reset label count if new label detected
- current_label = label
- label_count = 1
- else:
- # Increment label count if same label detected
- label_count += 1
- if label_count >= 5: # play sound if label detected 5 times in a row
- sound_file = label_sound_dict[label]
- sound = pygame.mixer.Sound(sound_file)
- sound.play()
- label_count = 0
- else:
- current_label = None
- label_count = 0
diff --git a/spaces/EuroPython2022/Paddy_Disease_Classification/README.md b/spaces/EuroPython2022/Paddy_Disease_Classification/README.md
deleted file mode 100644
index 97ef101b59ea7585daffd73ea3da4ea9e9cf63ae..0000000000000000000000000000000000000000
--- a/spaces/EuroPython2022/Paddy_Disease_Classification/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: PaddyDiseaseClassification
-emoji: 📈
-colorFrom: pink
-colorTo: gray
-sdk: gradio
-sdk_version: 3.0.24
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/EuroPython2022/mmocr-demo/configs/_base_/det_pipelines/fcenet_pipeline.py b/spaces/EuroPython2022/mmocr-demo/configs/_base_/det_pipelines/fcenet_pipeline.py
deleted file mode 100644
index badb4536b10bd74760fdf519fe03f5c8d2bd7767..0000000000000000000000000000000000000000
--- a/spaces/EuroPython2022/mmocr-demo/configs/_base_/det_pipelines/fcenet_pipeline.py
+++ /dev/null
@@ -1,118 +0,0 @@
-img_norm_cfg = dict(
- mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
-
-# for icdar2015
-leval_prop_range_icdar2015 = ((0, 0.4), (0.3, 0.7), (0.6, 1.0))
-train_pipeline_icdar2015 = [
- dict(type='LoadImageFromFile', color_type='color_ignore_orientation'),
- dict(
- type='LoadTextAnnotations',
- with_bbox=True,
- with_mask=True,
- poly2mask=False),
- dict(
- type='ColorJitter',
- brightness=32.0 / 255,
- saturation=0.5,
- contrast=0.5),
- dict(type='Normalize', **img_norm_cfg),
- dict(type='RandomScaling', size=800, scale=(3. / 4, 5. / 2)),
- dict(
- type='RandomCropFlip', crop_ratio=0.5, iter_num=1, min_area_ratio=0.2),
- dict(
- type='RandomCropPolyInstances',
- instance_key='gt_masks',
- crop_ratio=0.8,
- min_side_ratio=0.3),
- dict(
- type='RandomRotatePolyInstances',
- rotate_ratio=0.5,
- max_angle=30,
- pad_with_fixed_color=False),
- dict(type='SquareResizePad', target_size=800, pad_ratio=0.6),
- dict(type='RandomFlip', flip_ratio=0.5, direction='horizontal'),
- dict(type='Pad', size_divisor=32),
- dict(
- type='FCENetTargets',
- fourier_degree=5,
- level_proportion_range=leval_prop_range_icdar2015),
- dict(
- type='CustomFormatBundle',
- keys=['p3_maps', 'p4_maps', 'p5_maps'],
- visualize=dict(flag=False, boundary_key=None)),
- dict(type='Collect', keys=['img', 'p3_maps', 'p4_maps', 'p5_maps'])
-]
-
-img_scale_icdar2015 = (2260, 2260)
-test_pipeline_icdar2015 = [
- dict(type='LoadImageFromFile', color_type='color_ignore_orientation'),
- dict(
- type='MultiScaleFlipAug',
- img_scale=img_scale_icdar2015, # used by Resize
- flip=False,
- transforms=[
- dict(type='Resize', keep_ratio=True),
- dict(type='Normalize', **img_norm_cfg),
- dict(type='Pad', size_divisor=32),
- dict(type='ImageToTensor', keys=['img']),
- dict(type='Collect', keys=['img']),
- ])
-]
-
-# for ctw1500
-leval_prop_range_ctw1500 = ((0, 0.25), (0.2, 0.65), (0.55, 1.0))
-train_pipeline_ctw1500 = [
- dict(type='LoadImageFromFile', color_type='color_ignore_orientation'),
- dict(
- type='LoadTextAnnotations',
- with_bbox=True,
- with_mask=True,
- poly2mask=False),
- dict(
- type='ColorJitter',
- brightness=32.0 / 255,
- saturation=0.5,
- contrast=0.5),
- dict(type='Normalize', **img_norm_cfg),
- dict(type='RandomScaling', size=800, scale=(3. / 4, 5. / 2)),
- dict(
- type='RandomCropFlip', crop_ratio=0.5, iter_num=1, min_area_ratio=0.2),
- dict(
- type='RandomCropPolyInstances',
- instance_key='gt_masks',
- crop_ratio=0.8,
- min_side_ratio=0.3),
- dict(
- type='RandomRotatePolyInstances',
- rotate_ratio=0.5,
- max_angle=30,
- pad_with_fixed_color=False),
- dict(type='SquareResizePad', target_size=800, pad_ratio=0.6),
- dict(type='RandomFlip', flip_ratio=0.5, direction='horizontal'),
- dict(type='Pad', size_divisor=32),
- dict(
- type='FCENetTargets',
- fourier_degree=5,
- level_proportion_range=leval_prop_range_ctw1500),
- dict(
- type='CustomFormatBundle',
- keys=['p3_maps', 'p4_maps', 'p5_maps'],
- visualize=dict(flag=False, boundary_key=None)),
- dict(type='Collect', keys=['img', 'p3_maps', 'p4_maps', 'p5_maps'])
-]
-
-img_scale_ctw1500 = (1080, 736)
-test_pipeline_ctw1500 = [
- dict(type='LoadImageFromFile', color_type='color_ignore_orientation'),
- dict(
- type='MultiScaleFlipAug',
- img_scale=img_scale_ctw1500, # used by Resize
- flip=False,
- transforms=[
- dict(type='Resize', keep_ratio=True),
- dict(type='Normalize', **img_norm_cfg),
- dict(type='Pad', size_divisor=32),
- dict(type='ImageToTensor', keys=['img']),
- dict(type='Collect', keys=['img']),
- ])
-]
diff --git a/spaces/Evel/Evel_Space/README.md b/spaces/Evel/Evel_Space/README.md
deleted file mode 100644
index c29108864c9d3c8ff637222d04f33fb0f576e74a..0000000000000000000000000000000000000000
--- a/spaces/Evel/Evel_Space/README.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-title: Finetuned Diffusion
-emoji: 🪄🖼️
-colorFrom: red
-colorTo: pink
-sdk: gradio
-sdk_version: 3.6
-app_file: app.py
-pinned: true
-license: mit
-duplicated_from: anzorq/finetuned_diffusion
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/FaceOnLive/Face-Recognition-SDK/README.md b/spaces/FaceOnLive/Face-Recognition-SDK/README.md
deleted file mode 100644
index 6e64d1f4654da459e7669c3c01114209995c076f..0000000000000000000000000000000000000000
--- a/spaces/FaceOnLive/Face-Recognition-SDK/README.md
+++ /dev/null
@@ -1,11 +0,0 @@
----
-title: Face Recognition SDK
-emoji: ⚡
-colorFrom: yellow
-colorTo: pink
-sdk: docker
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/FaceOnLive/ID-Document-Recognition-SDK/app.py b/spaces/FaceOnLive/ID-Document-Recognition-SDK/app.py
deleted file mode 100644
index 3049b459c6fe6bdb60f1a8ee5a01c263a1584633..0000000000000000000000000000000000000000
--- a/spaces/FaceOnLive/ID-Document-Recognition-SDK/app.py
+++ /dev/null
@@ -1,222 +0,0 @@
-import sys
-sys.path.append('.')
-
-from flask import Flask, render_template, request, jsonify, send_from_directory
-from time import gmtime, strftime
-import os
-import base64
-import json
-import uuid
-import cv2
-import numpy as np
-
-from ocrengine.ocrengine import TTVOcrGetHWID
-from ocrengine.ocrengine import TTVOcrSetActivation
-from ocrengine.ocrengine import TTVOcrInit
-from ocrengine.ocrengine import TTVOcrProcess
-from ocrengine.ocrengine import TTVOcrCreditCard
-from ocrengine.ocrengine import TTVOcrBarCode
-from ocrengine.ocrengine import ttv_if_checker
-
-app = Flask(__name__)
-
-ocrHWID = TTVOcrGetHWID()
-licenseKey = os.environ.get("LICENSE_KEY")
-ocrRet = TTVOcrSetActivation(licenseKey.encode('utf-8'))
-print('ocr activation: ', ocrRet.decode('utf-8'))
-
-dictPath = os.path.abspath(os.path.dirname(__file__)) + '/ocrengine/dict'
-ocrRet = TTVOcrInit(dictPath.encode('utf-8'))
-print('ocr engine init: ', ocrRet.decode('utf-8'))
-
-@app.route('/ocr/idcard', methods=['POST'])
-def ocr_idcard():
- file1 = request.files['image1']
-
- file_name1 = uuid.uuid4().hex[:6]
- save_path1 = '/tmp/' + file_name1 + '_' + file1.filename
- file1.save(save_path1)
-
- file_path1 = os.path.abspath(save_path1)
-
- if 'image2' not in request.files:
- file_path2 = ''
- else:
- file2 = request.files['image2']
-
- file_name2 = uuid.uuid4().hex[:6]
- save_path2 = '/tmp/' + file_name2 + '_' + file2.filename
- file2.save(save_path2)
-
- file_path2 = os.path.abspath(save_path2)
-
-
- ocrResult = TTVOcrProcess(file_path1.encode('utf-8'), file_path2.encode('utf-8'))
- status = "ok"
- if not ocrResult:
- ocrResDict = {}
- status = "error"
- else:
- ocrResDict = json.loads(ocrResult)
-
- if_check = ttv_if_checker(file_path1.encode('utf-8'))
- response = jsonify({"status": status, "data": ocrResDict, "authenticity": if_check})
-
- os.remove(file_path1)
- if 'image2' in request.files:
- os.remove(file_path2)
-
- response.status_code = 200
- response.headers["Content-Type"] = "application/json; charset=utf-8"
- return response
-
-@app.route('/ocr/idcard_base64', methods=['POST'])
-def ocr_idcard_base64():
- content = request.get_json()
- imageBase64 = content['image']
-
- file_name = uuid.uuid4().hex[:6]
- save_path = '/tmp/' + file_name
- with open(save_path, "wb") as fh:
- fh.write(base64.b64decode(imageBase64))
-
- file_path = os.path.abspath(save_path)
-
- ocrResult = TTVOcrProcess(file_path.encode('utf-8'))
- status = "ok"
- if not ocrResult:
- ocrResDict = {}
- status = "error"
- else:
- ocrResDict = json.loads(ocrResult)
-
- if_check = ttv_if_checker(file_path.encode('utf-8'))
- response = jsonify({"status": status, "data": ocrResDict, "authenticity": if_check})
-
- os.remove(file_path)
-
- response.status_code = 200
- response.headers["Content-Type"] = "application/json; charset=utf-8"
- return response
-
-
-@app.route('/ocr/credit', methods=['POST'])
-def ocr_credit():
- file = request.files['image']
- print('ocr_credit ', file)
-
- image = cv2.imdecode(np.fromstring(file.read(), np.uint8), cv2.IMREAD_COLOR)
- file_name = uuid.uuid4().hex[:6]
- save_path = '/tmp/' + file_name + '.png'
- cv2.imwrite(save_path, image)
-
- file_path = os.path.abspath(save_path)
-
- ocrResult = TTVOcrCreditCard(file_path.encode('utf-8'))
- status = "ok"
- if not ocrResult:
- ocrResDict = {}
- status = "error"
- else:
- ocrResDict = json.loads(ocrResult)
-
- response = jsonify({"status": status, "data": ocrResDict})
-
- os.remove(file_path)
-
- response.status_code = 200
- response.headers["Content-Type"] = "application/json; charset=utf-8"
- return response
-
-@app.route('/ocr/credit_base64', methods=['POST'])
-def ocr_credit_base64():
- print('ocr_credit_base64');
- content = request.get_json()
- imageBase64 = content['image']
- image = cv2.imdecode(np.frombuffer(base64.b64decode(imageBase64), dtype=np.uint8), cv2.IMREAD_COLOR)
-
- file_name = uuid.uuid4().hex[:6]
- save_path = '/tmp/' + file_name + '.png'
- cv2.imwrite(save_path, image)
-
- file_path = os.path.abspath(save_path)
-
- ocrResult = TTVOcrCreditCard(file_path.encode('utf-8'))
- status = "ok"
- if not ocrResult:
- ocrResDict = {}
- status = "error"
- else:
- ocrResDict = json.loads(ocrResult)
-
- response = jsonify({"status": status, "data": ocrResDict})
-
- os.remove(file_path)
-
- response.status_code = 200
- response.headers["Content-Type"] = "application/json; charset=utf-8"
- return response
-
-@app.route('/ocr/barcode', methods=['POST'])
-def ocr_barcode():
- file = request.files['image']
- print('ocr_barcode ', file)
-
- image = cv2.imdecode(np.fromstring(file.read(), np.uint8), cv2.IMREAD_COLOR)
- file_name = uuid.uuid4().hex[:6]
- save_path = '/tmp/' + file_name + '.png'
- cv2.imwrite(save_path, image)
-
- file_path = os.path.abspath(save_path)
-
- ocrResult = TTVOcrBarCode(file_path.encode('utf-8'))
- status = "ok"
- if not ocrResult:
- ocrResDict = {}
- status = "error"
- else:
- ocrResDict = json.loads(ocrResult)
-
- response = jsonify({"status": status, "data": ocrResDict})
-
- os.remove(file_path)
-
- response.status_code = 200
- response.headers["Content-Type"] = "application/json; charset=utf-8"
- return response
-
-@app.route('/ocr/barcode_base64', methods=['POST'])
-def ocr_barcode_base64():
- content = request.get_json()
- imageBase64 = content['image']
- image = cv2.imdecode(np.frombuffer(base64.b64decode(imageBase64), dtype=np.uint8), cv2.IMREAD_COLOR)
-
- file_name = uuid.uuid4().hex[:6]
- save_path = '/tmp/' + file_name + '.png'
- cv2.imwrite(save_path, image)
-
- file_path = os.path.abspath(save_path)
- print('file_path: ', file_path)
-
- ocrResult = TTVOcrBarCode(file_path.encode('utf-8'))
- status = "ok"
- if not ocrResult:
- ocrResDict = {}
- status = "error"
- else:
- ocrResDict = json.loads(ocrResult)
-
- response = jsonify({"status": status, "data": ocrResDict})
-
- os.remove(file_path)
-
- response.status_code = 200
- response.headers["Content-Type"] = "application/json; charset=utf-8"
-
- return response
-
-
-
-if __name__ == '__main__':
- port = int(os.environ.get("PORT", 8000))
- app.run(host='0.0.0.0', port=port)
diff --git a/spaces/Forever003/VPN/README.md b/spaces/Forever003/VPN/README.md
deleted file mode 100644
index 2733724491db64588d2b286b801cb65e11464b2f..0000000000000000000000000000000000000000
--- a/spaces/Forever003/VPN/README.md
+++ /dev/null
@@ -1,11 +0,0 @@
----
-title: VPN
-emoji: 🏆
-colorFrom: blue
-colorTo: gray
-sdk: docker
-pinned: false
-license: openrail
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/FrankZxShen/vits-fast-fineturning-models-ba/text/mandarin.py b/spaces/FrankZxShen/vits-fast-fineturning-models-ba/text/mandarin.py
deleted file mode 100644
index 162e1b912dabec4b448ccd3d00d56306f82ce076..0000000000000000000000000000000000000000
--- a/spaces/FrankZxShen/vits-fast-fineturning-models-ba/text/mandarin.py
+++ /dev/null
@@ -1,326 +0,0 @@
-import os
-import sys
-import re
-from pypinyin import lazy_pinyin, BOPOMOFO
-import jieba
-import cn2an
-import logging
-
-
-# List of (Latin alphabet, bopomofo) pairs:
-_latin_to_bopomofo = [(re.compile('%s' % x[0], re.IGNORECASE), x[1]) for x in [
- ('a', 'ㄟˉ'),
- ('b', 'ㄅㄧˋ'),
- ('c', 'ㄙㄧˉ'),
- ('d', 'ㄉㄧˋ'),
- ('e', 'ㄧˋ'),
- ('f', 'ㄝˊㄈㄨˋ'),
- ('g', 'ㄐㄧˋ'),
- ('h', 'ㄝˇㄑㄩˋ'),
- ('i', 'ㄞˋ'),
- ('j', 'ㄐㄟˋ'),
- ('k', 'ㄎㄟˋ'),
- ('l', 'ㄝˊㄛˋ'),
- ('m', 'ㄝˊㄇㄨˋ'),
- ('n', 'ㄣˉ'),
- ('o', 'ㄡˉ'),
- ('p', 'ㄆㄧˉ'),
- ('q', 'ㄎㄧㄡˉ'),
- ('r', 'ㄚˋ'),
- ('s', 'ㄝˊㄙˋ'),
- ('t', 'ㄊㄧˋ'),
- ('u', 'ㄧㄡˉ'),
- ('v', 'ㄨㄧˉ'),
- ('w', 'ㄉㄚˋㄅㄨˋㄌㄧㄡˋ'),
- ('x', 'ㄝˉㄎㄨˋㄙˋ'),
- ('y', 'ㄨㄞˋ'),
- ('z', 'ㄗㄟˋ')
-]]
-
-# List of (bopomofo, romaji) pairs:
-_bopomofo_to_romaji = [(re.compile('%s' % x[0]), x[1]) for x in [
- ('ㄅㄛ', 'p⁼wo'),
- ('ㄆㄛ', 'pʰwo'),
- ('ㄇㄛ', 'mwo'),
- ('ㄈㄛ', 'fwo'),
- ('ㄅ', 'p⁼'),
- ('ㄆ', 'pʰ'),
- ('ㄇ', 'm'),
- ('ㄈ', 'f'),
- ('ㄉ', 't⁼'),
- ('ㄊ', 'tʰ'),
- ('ㄋ', 'n'),
- ('ㄌ', 'l'),
- ('ㄍ', 'k⁼'),
- ('ㄎ', 'kʰ'),
- ('ㄏ', 'h'),
- ('ㄐ', 'ʧ⁼'),
- ('ㄑ', 'ʧʰ'),
- ('ㄒ', 'ʃ'),
- ('ㄓ', 'ʦ`⁼'),
- ('ㄔ', 'ʦ`ʰ'),
- ('ㄕ', 's`'),
- ('ㄖ', 'ɹ`'),
- ('ㄗ', 'ʦ⁼'),
- ('ㄘ', 'ʦʰ'),
- ('ㄙ', 's'),
- ('ㄚ', 'a'),
- ('ㄛ', 'o'),
- ('ㄜ', 'ə'),
- ('ㄝ', 'e'),
- ('ㄞ', 'ai'),
- ('ㄟ', 'ei'),
- ('ㄠ', 'au'),
- ('ㄡ', 'ou'),
- ('ㄧㄢ', 'yeNN'),
- ('ㄢ', 'aNN'),
- ('ㄧㄣ', 'iNN'),
- ('ㄣ', 'əNN'),
- ('ㄤ', 'aNg'),
- ('ㄧㄥ', 'iNg'),
- ('ㄨㄥ', 'uNg'),
- ('ㄩㄥ', 'yuNg'),
- ('ㄥ', 'əNg'),
- ('ㄦ', 'əɻ'),
- ('ㄧ', 'i'),
- ('ㄨ', 'u'),
- ('ㄩ', 'ɥ'),
- ('ˉ', '→'),
- ('ˊ', '↑'),
- ('ˇ', '↓↑'),
- ('ˋ', '↓'),
- ('˙', ''),
- ('，', ','),
- ('。', '.'),
- ('！', '!'),
- ('？', '?'),
- ('—', '-')
-]]
-
-# List of (romaji, ipa) pairs:
-_romaji_to_ipa = [(re.compile('%s' % x[0], re.IGNORECASE), x[1]) for x in [
- ('ʃy', 'ʃ'),
- ('ʧʰy', 'ʧʰ'),
- ('ʧ⁼y', 'ʧ⁼'),
- ('NN', 'n'),
- ('Ng', 'ŋ'),
- ('y', 'j'),
- ('h', 'x')
-]]
-
-# List of (bopomofo, ipa) pairs:
-_bopomofo_to_ipa = [(re.compile('%s' % x[0]), x[1]) for x in [
- ('ㄅㄛ', 'p⁼wo'),
- ('ㄆㄛ', 'pʰwo'),
- ('ㄇㄛ', 'mwo'),
- ('ㄈㄛ', 'fwo'),
- ('ㄅ', 'p⁼'),
- ('ㄆ', 'pʰ'),
- ('ㄇ', 'm'),
- ('ㄈ', 'f'),
- ('ㄉ', 't⁼'),
- ('ㄊ', 'tʰ'),
- ('ㄋ', 'n'),
- ('ㄌ', 'l'),
- ('ㄍ', 'k⁼'),
- ('ㄎ', 'kʰ'),
- ('ㄏ', 'x'),
- ('ㄐ', 'tʃ⁼'),
- ('ㄑ', 'tʃʰ'),
- ('ㄒ', 'ʃ'),
- ('ㄓ', 'ts`⁼'),
- ('ㄔ', 'ts`ʰ'),
- ('ㄕ', 's`'),
- ('ㄖ', 'ɹ`'),
- ('ㄗ', 'ts⁼'),
- ('ㄘ', 'tsʰ'),
- ('ㄙ', 's'),
- ('ㄚ', 'a'),
- ('ㄛ', 'o'),
- ('ㄜ', 'ə'),
- ('ㄝ', 'ɛ'),
- ('ㄞ', 'aɪ'),
- ('ㄟ', 'eɪ'),
- ('ㄠ', 'ɑʊ'),
- ('ㄡ', 'oʊ'),
- ('ㄧㄢ', 'jɛn'),
- ('ㄩㄢ', 'ɥæn'),
- ('ㄢ', 'an'),
- ('ㄧㄣ', 'in'),
- ('ㄩㄣ', 'ɥn'),
- ('ㄣ', 'ən'),
- ('ㄤ', 'ɑŋ'),
- ('ㄧㄥ', 'iŋ'),
- ('ㄨㄥ', 'ʊŋ'),
- ('ㄩㄥ', 'jʊŋ'),
- ('ㄥ', 'əŋ'),
- ('ㄦ', 'əɻ'),
- ('ㄧ', 'i'),
- ('ㄨ', 'u'),
- ('ㄩ', 'ɥ'),
- ('ˉ', '→'),
- ('ˊ', '↑'),
- ('ˇ', '↓↑'),
- ('ˋ', '↓'),
- ('˙', ''),
- ('，', ','),
- ('。', '.'),
- ('！', '!'),
- ('？', '?'),
- ('—', '-')
-]]
-
-# List of (bopomofo, ipa2) pairs:
-_bopomofo_to_ipa2 = [(re.compile('%s' % x[0]), x[1]) for x in [
- ('ㄅㄛ', 'pwo'),
- ('ㄆㄛ', 'pʰwo'),
- ('ㄇㄛ', 'mwo'),
- ('ㄈㄛ', 'fwo'),
- ('ㄅ', 'p'),
- ('ㄆ', 'pʰ'),
- ('ㄇ', 'm'),
- ('ㄈ', 'f'),
- ('ㄉ', 't'),
- ('ㄊ', 'tʰ'),
- ('ㄋ', 'n'),
- ('ㄌ', 'l'),
- ('ㄍ', 'k'),
- ('ㄎ', 'kʰ'),
- ('ㄏ', 'h'),
- ('ㄐ', 'tɕ'),
- ('ㄑ', 'tɕʰ'),
- ('ㄒ', 'ɕ'),
- ('ㄓ', 'tʂ'),
- ('ㄔ', 'tʂʰ'),
- ('ㄕ', 'ʂ'),
- ('ㄖ', 'ɻ'),
- ('ㄗ', 'ts'),
- ('ㄘ', 'tsʰ'),
- ('ㄙ', 's'),
- ('ㄚ', 'a'),
- ('ㄛ', 'o'),
- ('ㄜ', 'ɤ'),
- ('ㄝ', 'ɛ'),
- ('ㄞ', 'aɪ'),
- ('ㄟ', 'eɪ'),
- ('ㄠ', 'ɑʊ'),
- ('ㄡ', 'oʊ'),
- ('ㄧㄢ', 'jɛn'),
- ('ㄩㄢ', 'yæn'),
- ('ㄢ', 'an'),
- ('ㄧㄣ', 'in'),
- ('ㄩㄣ', 'yn'),
- ('ㄣ', 'ən'),
- ('ㄤ', 'ɑŋ'),
- ('ㄧㄥ', 'iŋ'),
- ('ㄨㄥ', 'ʊŋ'),
- ('ㄩㄥ', 'jʊŋ'),
- ('ㄥ', 'ɤŋ'),
- ('ㄦ', 'əɻ'),
- ('ㄧ', 'i'),
- ('ㄨ', 'u'),
- ('ㄩ', 'y'),
- ('ˉ', '˥'),
- ('ˊ', '˧˥'),
- ('ˇ', '˨˩˦'),
- ('ˋ', '˥˩'),
- ('˙', ''),
- ('，', ','),
- ('。', '.'),
- ('！', '!'),
- ('？', '?'),
- ('—', '-')
-]]
-
-
-def number_to_chinese(text):
- numbers = re.findall(r'\d+(?:\.?\d+)?', text)
- for number in numbers:
- text = text.replace(number, cn2an.an2cn(number), 1)
- return text
-
-
-def chinese_to_bopomofo(text):
- text = text.replace('、', '，').replace('；', '，').replace('：', '，')
- words = jieba.lcut(text, cut_all=False)
- text = ''
- for word in words:
- bopomofos = lazy_pinyin(word, BOPOMOFO)
- if not re.search('[\u4e00-\u9fff]', word):
- text += word
- continue
- for i in range(len(bopomofos)):
- bopomofos[i] = re.sub(r'([\u3105-\u3129])$', r'\1ˉ', bopomofos[i])
- if text != '':
- text += ' '
- text += ''.join(bopomofos)
- return text
-
-
-def latin_to_bopomofo(text):
- for regex, replacement in _latin_to_bopomofo:
- text = re.sub(regex, replacement, text)
- return text
-
-
-def bopomofo_to_romaji(text):
- for regex, replacement in _bopomofo_to_romaji:
- text = re.sub(regex, replacement, text)
- return text
-
-
-def bopomofo_to_ipa(text):
- for regex, replacement in _bopomofo_to_ipa:
- text = re.sub(regex, replacement, text)
- return text
-
-
-def bopomofo_to_ipa2(text):
- for regex, replacement in _bopomofo_to_ipa2:
- text = re.sub(regex, replacement, text)
- return text
-
-
-def chinese_to_romaji(text):
- text = number_to_chinese(text)
- text = chinese_to_bopomofo(text)
- text = latin_to_bopomofo(text)
- text = bopomofo_to_romaji(text)
- text = re.sub('i([aoe])', r'y\1', text)
- text = re.sub('u([aoəe])', r'w\1', text)
- text = re.sub('([ʦsɹ]`[⁼ʰ]?)([→↓↑ ]+|$)',
- r'\1ɹ`\2', text).replace('ɻ', 'ɹ`')
- text = re.sub('([ʦs][⁼ʰ]?)([→↓↑ ]+|$)', r'\1ɹ\2', text)
- return text
-
-
-def chinese_to_lazy_ipa(text):
- text = chinese_to_romaji(text)
- for regex, replacement in _romaji_to_ipa:
- text = re.sub(regex, replacement, text)
- return text
-
-
-def chinese_to_ipa(text):
- text = number_to_chinese(text)
- text = chinese_to_bopomofo(text)
- text = latin_to_bopomofo(text)
- text = bopomofo_to_ipa(text)
- text = re.sub('i([aoe])', r'j\1', text)
- text = re.sub('u([aoəe])', r'w\1', text)
- text = re.sub('([sɹ]`[⁼ʰ]?)([→↓↑ ]+|$)',
- r'\1ɹ`\2', text).replace('ɻ', 'ɹ`')
- text = re.sub('([s][⁼ʰ]?)([→↓↑ ]+|$)', r'\1ɹ\2', text)
- return text
-
-
-def chinese_to_ipa2(text):
- text = number_to_chinese(text)
- text = chinese_to_bopomofo(text)
- text = latin_to_bopomofo(text)
- text = bopomofo_to_ipa2(text)
- text = re.sub(r'i([aoe])', r'j\1', text)
- text = re.sub(r'u([aoəe])', r'w\1', text)
- text = re.sub(r'([ʂɹ]ʰ?)([˩˨˧˦˥ ]+|$)', r'\1ʅ\2', text)
- text = re.sub(r'(sʰ?)([˩˨˧˦˥ ]+|$)', r'\1ɿ\2', text)
- return text
diff --git a/spaces/GT4SD/multitask-text-and-chemistry-t5/utils.py b/spaces/GT4SD/multitask-text-and-chemistry-t5/utils.py
deleted file mode 100644
index 34a817843a959d6ef46ae527efd08788f55a3196..0000000000000000000000000000000000000000
--- a/spaces/GT4SD/multitask-text-and-chemistry-t5/utils.py
+++ /dev/null
@@ -1,48 +0,0 @@
-import logging
-from collections import defaultdict
-from typing import List
-
-import mols2grid
-import pandas as pd
-
-logger = logging.getLogger(__name__)
-logger.addHandler(logging.NullHandler())
-
-
-def draw_grid_generate(
- samples: List[str],
- seeds: List[str] = [],
- n_cols: int = 3,
- size=(140, 200),
-) -> str:
- """
- Uses mols2grid to draw a HTML grid for the generated molecules
-
- Args:
- samples: The generated samples.
- n_cols: Number of columns in grid. Defaults to 5.
- size: Size of molecule in grid. Defaults to (140, 200).
-
- Returns:
- HTML to display
- """
-
- result = defaultdict(list)
- result.update(
- {
- "SMILES": seeds + samples,
- "Name": [f"Seed_{i}" for i in range(len(seeds))]
- + [f"Generated_{i}" for i in range(len(samples))],
- },
- )
-
- result_df = pd.DataFrame(result)
- obj = mols2grid.display(
- result_df,
- tooltip=list(result.keys()),
- height=1100,
- n_cols=n_cols,
- name="Results",
- size=size,
- )
- return obj.data
diff --git a/spaces/GorroRojo/nitrosocke-Ghibli-Diffusion/app.py b/spaces/GorroRojo/nitrosocke-Ghibli-Diffusion/app.py
deleted file mode 100644
index ba88009ae25eab75b12152bde1aae34c4cb52907..0000000000000000000000000000000000000000
--- a/spaces/GorroRojo/nitrosocke-Ghibli-Diffusion/app.py
+++ /dev/null
@@ -1,3 +0,0 @@
-import gradio as gr
-
-gr.Interface.load("models/nitrosocke/Ghibli-Diffusion").launch()
\ No newline at end of file
diff --git a/spaces/Gradio-Blocks/uniformer_image_detection/configs/fast_rcnn/fast_rcnn_r101_caffe_fpn_1x_coco.py b/spaces/Gradio-Blocks/uniformer_image_detection/configs/fast_rcnn/fast_rcnn_r101_caffe_fpn_1x_coco.py
deleted file mode 100644
index 6db24b1e8aa26de5b153f4adcc8ae8dbd885186b..0000000000000000000000000000000000000000
--- a/spaces/Gradio-Blocks/uniformer_image_detection/configs/fast_rcnn/fast_rcnn_r101_caffe_fpn_1x_coco.py
+++ /dev/null
@@ -1,4 +0,0 @@
-_base_ = './fast_rcnn_r50_caffe_fpn_1x_coco.py'
-model = dict(
- pretrained='open-mmlab://detectron2/resnet101_caffe',
- backbone=dict(depth=101))
diff --git a/spaces/Gradio-Blocks/uniformer_image_detection/mmdet/core/bbox/iou_calculators/builder.py b/spaces/Gradio-Blocks/uniformer_image_detection/mmdet/core/bbox/iou_calculators/builder.py
deleted file mode 100644
index 09094d7ece46a9f18a28ed0960feac2afa9331bb..0000000000000000000000000000000000000000
--- a/spaces/Gradio-Blocks/uniformer_image_detection/mmdet/core/bbox/iou_calculators/builder.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from mmcv.utils import Registry, build_from_cfg
-
-IOU_CALCULATORS = Registry('IoU calculator')
-
-
-def build_iou_calculator(cfg, default_args=None):
- """Builder of IoU calculator."""
- return build_from_cfg(cfg, IOU_CALCULATORS, default_args)
diff --git a/spaces/Gradio-Blocks/uniformer_image_detection/mmdet/models/detectors/paa.py b/spaces/Gradio-Blocks/uniformer_image_detection/mmdet/models/detectors/paa.py
deleted file mode 100644
index 9b4bb5e0939b824d9fef7fc3bd49a0164c29613a..0000000000000000000000000000000000000000
--- a/spaces/Gradio-Blocks/uniformer_image_detection/mmdet/models/detectors/paa.py
+++ /dev/null
@@ -1,17 +0,0 @@
-from ..builder import DETECTORS
-from .single_stage import SingleStageDetector
-
-
-@DETECTORS.register_module()
-class PAA(SingleStageDetector):
- """Implementation of `PAA `_."""
-
- def __init__(self,
- backbone,
- neck,
- bbox_head,
- train_cfg=None,
- test_cfg=None,
- pretrained=None):
- super(PAA, self).__init__(backbone, neck, bbox_head, train_cfg,
- test_cfg, pretrained)
diff --git a/spaces/Gradio-Blocks/uniformer_image_segmentation/configs/pspnet/pspnet_r50-d8_512x1024_80k_cityscapes.py b/spaces/Gradio-Blocks/uniformer_image_segmentation/configs/pspnet/pspnet_r50-d8_512x1024_80k_cityscapes.py
deleted file mode 100644
index 4e9972849d6899fe43f435284d0e0b1bc3b0e7a9..0000000000000000000000000000000000000000
--- a/spaces/Gradio-Blocks/uniformer_image_segmentation/configs/pspnet/pspnet_r50-d8_512x1024_80k_cityscapes.py
+++ /dev/null
@@ -1,4 +0,0 @@
-_base_ = [
- '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
- '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
diff --git a/spaces/GrandaddyShmax/MusicGen_Plus_hfv2/MODEL_CARD.md b/spaces/GrandaddyShmax/MusicGen_Plus_hfv2/MODEL_CARD.md
deleted file mode 100644
index 6c2c9f883969eb905e74ad3376966d156cc5ca00..0000000000000000000000000000000000000000
--- a/spaces/GrandaddyShmax/MusicGen_Plus_hfv2/MODEL_CARD.md
+++ /dev/null
@@ -1,81 +0,0 @@
-# MusicGen Model Card
-
-## Model details
-
-**Organization developing the model:** The FAIR team of Meta AI.
-
-**Model date:** MusicGen was trained between April 2023 and May 2023.
-
-**Model version:** This is the version 1 of the model.
-
-**Model type:** MusicGen consists of an EnCodec model for audio tokenization, an auto-regressive language model based on the transformer architecture for music modeling. The model comes in different sizes: 300M, 1.5B and 3.3B parameters ; and two variants: a model trained for text-to-music generation task and a model trained for melody-guided music generation.
-
-**Paper or resources for more information:** More information can be found in the paper [Simple and Controllable Music Generation][arxiv].
-
-**Citation details** See [our paper][arxiv]
-
-**License** Code is released under MIT, model weights are released under CC-BY-NC 4.0.
-
-**Where to send questions or comments about the model:** Questions and comments about MusicGen can be sent via the [Github repository](https://github.com/facebookresearch/audiocraft) of the project, or by opening an issue.
-
-## Intended use
-**Primary intended use:** The primary use of MusicGen is research on AI-based music generation, including:
-
-- Research efforts, such as probing and better understanding the limitations of generative models to further improve the state of science
-- Generation of music guided by text or melody to understand current abilities of generative AI models by machine learning amateurs
-
-**Primary intended users:** The primary intended users of the model are researchers in audio, machine learning and artificial intelligence, as well as amateur seeking to better understand those models.
-
-**Out-of-scope use cases** The model should not be used on downstream applications without further risk evaluation and mitigation. The model should not be used to intentionally create or disseminate music pieces that create hostile or alienating environments for people. This includes generating music that people would foreseeably find disturbing, distressing, or offensive; or content that propagates historical or current stereotypes.
-
-## Metrics
-
-**Models performance measures:** We used the following objective measure to evaluate the model on a standard music benchmark:
-
-- Frechet Audio Distance computed on features extracted from a pre-trained audio classifier (VGGish)
-- Kullback-Leibler Divergence on label distributions extracted from a pre-trained audio classifier (PaSST)
-- CLAP Score between audio embedding and text embedding extracted from a pre-trained CLAP model
-
-Additionally, we run qualitative studies with human participants, evaluating the performance of the model with the following axes:
-
-- Overall quality of the music samples;
-- Text relevance to the provided text input;
-- Adherence to the melody for melody-guided music generation.
-
-More details on performance measures and human studies can be found in the paper.
-
-**Decision thresholds:** Not applicable.
-
-## Evaluation datasets
-
-The model was evaluated on the [MusicCaps benchmark](https://www.kaggle.com/datasets/googleai/musiccaps) and on an in-domain held-out evaluation set, with no artist overlap with the training set.
-
-## Training datasets
-
-The model was trained on licensed data using the following sources: the [Meta Music Initiative Sound Collection](https://www.fb.com/sound), [Shutterstock music collection](https://www.shutterstock.com/music) and the [Pond5 music collection](https://www.pond5.com/). See the paper for more details about the training set and corresponding preprocessing.
-
-## Quantitative analysis
-
-More information can be found in the paper [Simple and Controllable Music Generation][arxiv], in the Experimental Setup section.
-
-## Limitations and biases
-
-**Data:** The data sources used to train the model are created by music professionals and covered by legal agreements with the right holders. The model is trained on 20K hours of data, we believe that scaling the model on larger datasets can further improve the performance of the model.
-
-**Mitigations:** Vocals have been removed from the data source using corresponding tags, and then using using a state-of-the-art music source separation method, namely using the open source [Hybrid Transformer for Music Source Separation](https://github.com/facebookresearch/demucs) (HT-Demucs).
-
-**Limitations:**
-
-- The model is not able to generate realistic vocals.
-- The model has been trained with English descriptions and will not perform as well in other languages.
-- The model does not perform equally well for all music styles and cultures.
-- The model sometimes generates end of songs, collapsing to silence.
-- It is sometimes difficult to assess what types of text descriptions provide the best generations. Prompt engineering may be required to obtain satisfying results.
-
-**Biases:** The source of data is potentially lacking diversity and all music cultures are not equally represented in the dataset. The model may not perform equally well on the wide variety of music genres that exists. The generated samples from the model will reflect the biases from the training data. Further work on this model should include methods for balanced and just representations of cultures, for example, by scaling the training data to be both diverse and inclusive.
-
-**Risks and harms:** Biases and limitations of the model may lead to generation of samples that may be considered as biased, inappropriate or offensive. We believe that providing the code to reproduce the research and train new models will allow to broaden the application to new and more representative data.
-
-**Use cases:** Users must be aware of the biases, limitations and risks of the model. MusicGen is a model developed for artificial intelligence research on controllable music generation. As such, it should not be used for downstream applications without further investigation and mitigation of risks.
-
-[arxiv]: https://arxiv.org/abs/2306.05284
diff --git a/spaces/HaHaBill/LandShapes-Antarctica/netdissect/pidfile.py b/spaces/HaHaBill/LandShapes-Antarctica/netdissect/pidfile.py
deleted file mode 100644
index 96a66814326bad444606ad829307fe225f4135e1..0000000000000000000000000000000000000000
--- a/spaces/HaHaBill/LandShapes-Antarctica/netdissect/pidfile.py
+++ /dev/null
@@ -1,81 +0,0 @@
-'''
-Utility for simple distribution of work on multiple processes, by
-making sure only one process is working on a job at once.
-'''
-
-import os, errno, socket, atexit, time, sys
-
-def exit_if_job_done(directory):
- if pidfile_taken(os.path.join(directory, 'lockfile.pid'), verbose=True):
- sys.exit(0)
- if os.path.isfile(os.path.join(directory, 'done.txt')):
- with open(os.path.join(directory, 'done.txt')) as f:
- msg = f.read()
- print(msg)
- sys.exit(0)
-
-def mark_job_done(directory):
- with open(os.path.join(directory, 'done.txt'), 'w') as f:
- f.write('Done by %d@%s %s at %s' %
- (os.getpid(), socket.gethostname(),
- os.getenv('STY', ''),
- time.strftime('%c')))
-
-def pidfile_taken(path, verbose=False):
- '''
- Usage. To grab an exclusive lock for the remaining duration of the
- current process (and exit if another process already has the lock),
- do this:
-
- if pidfile_taken('job_423/lockfile.pid', verbose=True):
- sys.exit(0)
-
- To do a batch of jobs, just run a script that does them all on
- each available machine, sharing a network filesystem. When each
- job grabs a lock, then this will automatically distribute the
- jobs so that each one is done just once on one machine.
- '''
-
- # Try to create the file exclusively and write my pid into it.
- try:
- os.makedirs(os.path.dirname(path), exist_ok=True)
- fd = os.open(path, os.O_CREAT | os.O_EXCL | os.O_RDWR)
- except OSError as e:
- if e.errno == errno.EEXIST:
- # If we cannot because there was a race, yield the conflicter.
- conflicter = 'race'
- try:
- with open(path, 'r') as lockfile:
- conflicter = lockfile.read().strip() or 'empty'
- except:
- pass
- if verbose:
- print('%s held by %s' % (path, conflicter))
- return conflicter
- else:
- # Other problems get an exception.
- raise
- # Register to delete this file on exit.
- lockfile = os.fdopen(fd, 'r+')
- atexit.register(delete_pidfile, lockfile, path)
- # Write my pid into the open file.
- lockfile.write('%d@%s %s\n' % (os.getpid(), socket.gethostname(),
- os.getenv('STY', '')))
- lockfile.flush()
- os.fsync(lockfile)
- # Return 'None' to say there was not a conflict.
- return None
-
-def delete_pidfile(lockfile, path):
- '''
- Runs at exit after pidfile_taken succeeds.
- '''
- if lockfile is not None:
- try:
- lockfile.close()
- except:
- pass
- try:
- os.unlink(path)
- except:
- pass
diff --git a/spaces/Hallucinate/demo/midas/backbones/beit.py b/spaces/Hallucinate/demo/midas/backbones/beit.py
deleted file mode 100644
index 7a24e02cd2b979844bf638b46ac60949ee9ce691..0000000000000000000000000000000000000000
--- a/spaces/Hallucinate/demo/midas/backbones/beit.py
+++ /dev/null
@@ -1,196 +0,0 @@
-import timm
-import torch
-import types
-
-import numpy as np
-import torch.nn.functional as F
-
-from .utils import forward_adapted_unflatten, make_backbone_default
-from timm.models.beit import gen_relative_position_index
-from torch.utils.checkpoint import checkpoint
-from typing import Optional
-
-
-def forward_beit(pretrained, x):
- return forward_adapted_unflatten(pretrained, x, "forward_features")
-
-
-def patch_embed_forward(self, x):
- """
- Modification of timm.models.layers.patch_embed.py: PatchEmbed.forward to support arbitrary window sizes.
- """
- x = self.proj(x)
- if self.flatten:
- x = x.flatten(2).transpose(1, 2)
- x = self.norm(x)
- return x
-
-
-def _get_rel_pos_bias(self, window_size):
- """
- Modification of timm.models.beit.py: Attention._get_rel_pos_bias to support arbitrary window sizes.
- """
- old_height = 2 * self.window_size[0] - 1
- old_width = 2 * self.window_size[1] - 1
-
- new_height = 2 * window_size[0] - 1
- new_width = 2 * window_size[1] - 1
-
- old_relative_position_bias_table = self.relative_position_bias_table
-
- old_num_relative_distance = self.num_relative_distance
- new_num_relative_distance = new_height * new_width + 3
-
- old_sub_table = old_relative_position_bias_table[:old_num_relative_distance - 3]
-
- old_sub_table = old_sub_table.reshape(1, old_width, old_height, -1).permute(0, 3, 1, 2)
- new_sub_table = F.interpolate(old_sub_table, size=(new_height, new_width), mode="bilinear")
- new_sub_table = new_sub_table.permute(0, 2, 3, 1).reshape(new_num_relative_distance - 3, -1)
-
- new_relative_position_bias_table = torch.cat(
- [new_sub_table, old_relative_position_bias_table[old_num_relative_distance - 3:]])
-
- key = str(window_size[1]) + "," + str(window_size[0])
- if key not in self.relative_position_indices.keys():
- self.relative_position_indices[key] = gen_relative_position_index(window_size)
-
- relative_position_bias = new_relative_position_bias_table[
- self.relative_position_indices[key].view(-1)].view(
- window_size[0] * window_size[1] + 1,
- window_size[0] * window_size[1] + 1, -1) # Wh*Ww,Wh*Ww,nH
- relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous() # nH, Wh*Ww, Wh*Ww
- return relative_position_bias.unsqueeze(0)
-
-
-def attention_forward(self, x, resolution, shared_rel_pos_bias: Optional[torch.Tensor] = None):
- """
- Modification of timm.models.beit.py: Attention.forward to support arbitrary window sizes.
- """
- B, N, C = x.shape
-
- qkv_bias = torch.cat((self.q_bias, self.k_bias, self.v_bias)) if self.q_bias is not None else None
- qkv = F.linear(input=x, weight=self.qkv.weight, bias=qkv_bias)
- qkv = qkv.reshape(B, N, 3, self.num_heads, -1).permute(2, 0, 3, 1, 4)
- q, k, v = qkv.unbind(0) # make torchscript happy (cannot use tensor as tuple)
-
- q = q * self.scale
- attn = (q @ k.transpose(-2, -1))
-
- if self.relative_position_bias_table is not None:
- window_size = tuple(np.array(resolution) // 16)
- attn = attn + self._get_rel_pos_bias(window_size)
- if shared_rel_pos_bias is not None:
- attn = attn + shared_rel_pos_bias
-
- attn = attn.softmax(dim=-1)
- attn = self.attn_drop(attn)
-
- x = (attn @ v).transpose(1, 2).reshape(B, N, -1)
- x = self.proj(x)
- x = self.proj_drop(x)
- return x
-
-
-def block_forward(self, x, resolution, shared_rel_pos_bias: Optional[torch.Tensor] = None):
- """
- Modification of timm.models.beit.py: Block.forward to support arbitrary window sizes.
- """
- if self.gamma_1 is None:
- x = x + self.drop_path(self.attn(self.norm1(x), resolution, shared_rel_pos_bias=shared_rel_pos_bias))
- x = x + self.drop_path(self.mlp(self.norm2(x)))
- else:
- x = x + self.drop_path(self.gamma_1 * self.attn(self.norm1(x), resolution,
- shared_rel_pos_bias=shared_rel_pos_bias))
- x = x + self.drop_path(self.gamma_2 * self.mlp(self.norm2(x)))
- return x
-
-
-def beit_forward_features(self, x):
- """
- Modification of timm.models.beit.py: Beit.forward_features to support arbitrary window sizes.
- """
- resolution = x.shape[2:]
-
- x = self.patch_embed(x)
- x = torch.cat((self.cls_token.expand(x.shape[0], -1, -1), x), dim=1)
- if self.pos_embed is not None:
- x = x + self.pos_embed
- x = self.pos_drop(x)
-
- rel_pos_bias = self.rel_pos_bias() if self.rel_pos_bias is not None else None
- for blk in self.blocks:
- if self.grad_checkpointing and not torch.jit.is_scripting():
- x = checkpoint(blk, x, shared_rel_pos_bias=rel_pos_bias)
- else:
- x = blk(x, resolution, shared_rel_pos_bias=rel_pos_bias)
- x = self.norm(x)
- return x
-
-
-def _make_beit_backbone(
- model,
- features=[96, 192, 384, 768],
- size=[384, 384],
- hooks=[0, 4, 8, 11],
- vit_features=768,
- use_readout="ignore",
- start_index=1,
- start_index_readout=1,
-):
- backbone = make_backbone_default(model, features, size, hooks, vit_features, use_readout, start_index,
- start_index_readout)
-
- backbone.model.patch_embed.forward = types.MethodType(patch_embed_forward, backbone.model.patch_embed)
- backbone.model.forward_features = types.MethodType(beit_forward_features, backbone.model)
-
- for block in backbone.model.blocks:
- attn = block.attn
- attn._get_rel_pos_bias = types.MethodType(_get_rel_pos_bias, attn)
- attn.forward = types.MethodType(attention_forward, attn)
- attn.relative_position_indices = {}
-
- block.forward = types.MethodType(block_forward, block)
-
- return backbone
-
-
-def _make_pretrained_beitl16_512(pretrained, use_readout="ignore", hooks=None):
- model = timm.create_model("beit_large_patch16_512", pretrained=pretrained)
-
- hooks = [5, 11, 17, 23] if hooks is None else hooks
-
- features = [256, 512, 1024, 1024]
-
- return _make_beit_backbone(
- model,
- features=features,
- size=[512, 512],
- hooks=hooks,
- vit_features=1024,
- use_readout=use_readout,
- )
-
-
-def _make_pretrained_beitl16_384(pretrained, use_readout="ignore", hooks=None):
- model = timm.create_model("beit_large_patch16_384", pretrained=pretrained)
-
- hooks = [5, 11, 17, 23] if hooks is None else hooks
- return _make_beit_backbone(
- model,
- features=[256, 512, 1024, 1024],
- hooks=hooks,
- vit_features=1024,
- use_readout=use_readout,
- )
-
-
-def _make_pretrained_beitb16_384(pretrained, use_readout="ignore", hooks=None):
- model = timm.create_model("beit_base_patch16_384", pretrained=pretrained)
-
- hooks = [2, 5, 8, 11] if hooks is None else hooks
- return _make_beit_backbone(
- model,
- features=[96, 192, 384, 768],
- hooks=hooks,
- use_readout=use_readout,
- )
diff --git a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/conv_seq2seq/README.md b/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/conv_seq2seq/README.md
deleted file mode 100644
index 95fe7e7909a77ee0e50fe31d4b8be38daa8f3be7..0000000000000000000000000000000000000000
--- a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/conv_seq2seq/README.md
+++ /dev/null
@@ -1,25 +0,0 @@
-# Convolutional Sequence to Sequence Learning (Gehring et al., 2017)
-
-## Pre-trained models
-
-Description | Dataset | Model | Test set(s)
----|---|---|---
-Convolutional ([Gehring et al., 2017](https://arxiv.org/abs/1705.03122)) | [WMT14 English-French](http://statmt.org/wmt14/translation-task.html#Download) | [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/models/wmt14.v2.en-fr.fconv-py.tar.bz2) | newstest2014: [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/data/wmt14.v2.en-fr.newstest2014.tar.bz2) newstest2012/2013: [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/data/wmt14.v2.en-fr.ntst1213.tar.bz2)
-Convolutional ([Gehring et al., 2017](https://arxiv.org/abs/1705.03122)) | [WMT14 English-German](http://statmt.org/wmt14/translation-task.html#Download) | [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/models/wmt14.en-de.fconv-py.tar.bz2) | newstest2014: [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/data/wmt14.en-de.newstest2014.tar.bz2)
-Convolutional ([Gehring et al., 2017](https://arxiv.org/abs/1705.03122)) | [WMT17 English-German](http://statmt.org/wmt17/translation-task.html#Download) | [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/models/wmt17.v2.en-de.fconv-py.tar.bz2) | newstest2014: [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/data/wmt17.v2.en-de.newstest2014.tar.bz2)
-
-## Example usage
-
-See the [translation README](../translation/README.md) for instructions on reproducing results for WMT'14 En-De and
-WMT'14 En-Fr using the `fconv_wmt_en_de` and `fconv_wmt_en_fr` model architectures.
-
-## Citation
-
-```bibtex
-@inproceedings{gehring2017convs2s,
- title = {Convolutional Sequence to Sequence Learning},
- author = {Gehring, Jonas, and Auli, Michael and Grangier, David and Yarats, Denis and Dauphin, Yann N},
- booktitle = {Proc. of ICML},
- year = 2017,
-}
-```
diff --git a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/laser/laser_src/multitask_data_utils.py b/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/laser/laser_src/multitask_data_utils.py
deleted file mode 100644
index b05caea26793bf5112a7abc29d76225f578f3ebe..0000000000000000000000000000000000000000
--- a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/laser/laser_src/multitask_data_utils.py
+++ /dev/null
@@ -1,143 +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 collections import OrderedDict
-
-import numpy as np
-
-from fairseq.data import BaseWrapperDataset, FairseqDataset, iterators
-
-
-class MultiItr(object):
- def __init__(self, itr):
- self.itr = itr
- self._counts = [0 for x in itr]
-
- def __len__(self):
- return sum(len(itr) for itr in self.itr)
-
- def __iter__(self):
- return self
-
- def __next__(self):
- ratios = [count / len(itr) for count, itr in zip(self._counts, self.itr)]
- idx = ratios.index(min(ratios))
- self._counts[idx] += 1
- return next(self.itr[idx])
-
-
-class MultidatasetEpochBatchIterator(iterators.EpochBatchIterating):
- """A wrapper around multiple epoch batch iterators."""
-
- def __init__(
- self,
- dataset,
- batch_sampler,
- seed=1,
- num_shards=1,
- shard_id=0,
- num_workers=0,
- epoch=1,
- ):
-
- assert isinstance(dataset, OrderedDict)
- assert len(dataset)
- assert isinstance(dataset[next(iter(dataset))], FairseqDataset)
-
- self.iterators = []
-
- self.epoch = epoch
- for key, dt in dataset.items():
- epoch_iter = iterators.EpochBatchIterator(
- dataset=dt,
- collate_fn=dt.collater,
- batch_sampler=batch_sampler[key],
- seed=seed,
- num_shards=num_shards,
- shard_id=shard_id,
- num_workers=0,
- epoch=epoch,
- )
- self.iterators.append(epoch_iter)
-
- def __len__(self):
- return sum(len(itr) for itr in self.iterators)
-
- def next_epoch_itr(self, shuffle=True, fix_batches_to_gpus=False):
- # `self.epoch += 1` should be handled by underlying `EpochBatchIterator`s.
- return MultiItr(
- [
- itr.next_epoch_itr(
- shuffle=shuffle, fix_batches_to_gpus=fix_batches_to_gpus
- )
- for itr in self.iterators
- ]
- )
-
- def end_of_epoch(self):
- return all(itr.end_of_epoch() for itr in self.iterators)
-
- @property
- def next_epoch_idx(self):
- """Return the epoch index after *next_epoch_itr* is called."""
-
- epochs = [itr.next_epoch_idx for itr in self.iterators]
- self.epoch = epochs[0]
- assert all(epoch == self.epoch for epoch in epochs)
-
- return self.epoch
-
- @property
- def iterations_in_epoch(self):
- return sum(itr.iterations_in_epoch for itr in self.iterators)
-
- def state_dict(self):
- return {
- "iterators": [it.state_dict() for it in self.iterators],
- "epoch": self.epoch,
- }
-
- def load_state_dict(self, state_dict):
- self.epoch = state_dict["epoch"]
- for it, d in zip(self.iterators, state_dict["iterators"]):
- it.load_state_dict(d)
-
-
-class MultitaskDatasetWrapper(BaseWrapperDataset):
- """A wrapper for a multitask dataset."""
-
- def __init__(self, dataset, target_language_id, sample=1.0, name=""):
- super().__init__(dataset)
- self.target_language_id = target_language_id
- self.sample = sample
- self.name = name
-
- def collater(self, *args, **kwargs):
- ans = self.dataset.collater(*args, **kwargs)
- if "net_input" in ans:
- ans["net_input"]["target_language_id"] = self.target_language_id
- ans["net_input"]["dataset_name"] = self.name
- return ans
-
- def num_tokens(self, *args, **kwargs):
- return self.dataset.num_tokens(*args, **kwargs)
-
- def ordered_indices(self, *args, **kwargs):
- indices = self.dataset.ordered_indices(*args, **kwargs)
- # Hacky solution for sampling
- size = int(self.sample * indices.shape[0])
-
- return indices.take(np.sort(np.random.permutation(indices.shape[0])[:size]))
-
- def size(self, index: int):
- return self.dataset.size(index)
-
- @property
- def supports_prefetch(self):
- """Whether this dataset supports prefetching."""
- return getattr(self.dataset, "supports_prefetch", False)
-
- def prefetch(self, indices):
- return self.dataset.prefetch(indices)
diff --git a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/m2m_100/process_data/remove_too_much_punc.py b/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/m2m_100/process_data/remove_too_much_punc.py
deleted file mode 100644
index 6c280de2403daffab477ac88e2008a68b9e61ff0..0000000000000000000000000000000000000000
--- a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/m2m_100/process_data/remove_too_much_punc.py
+++ /dev/null
@@ -1,36 +0,0 @@
-import gzip
-import argparse
-from string import punctuation
-
-def len_no_punc(s, punc):
- return len([ch for ch in s if ch in punc])
-
-def filter_overpunc(len_npunc, len_sen):
- return len_npunc < 0.5*len_sen
-
-def main(args):
- punc = punctuation + "—|–"
- print('Processing file {}'.format(args.input))
- with gzip.open(args.input, 'rt', encoding=args.encoding) as tsv:
- with open(args.bitext + '.' + args.src_lang, 'wt', encoding=args.encoding) as fsrc:
- with open(args.bitext + '.' + args.tgt_lang, 'wt', encoding=args.encoding) as ftgt:
- line = tsv.readline()
- fields = line.split('\t')
-
- src, tgt = fields[1], fields[2]
-
- nchar_npunc_src = len_no_punc(src, punc)
- nchar_npunc_tgt = len_no_punc(tgt, punc)
-
- if filter_overpunc(nchar_npunc_src, len(src)) and filter_overpunc(nchar_npunc_tgt, len(tgt)):
- fsrc.write(src.strip() + '\n')
- ftgt.write(tgt.strip() + '\n')
-
-if __name__ == '__main__':
- parser = argparse.ArgumentParser()
- parser.add_argument("--input", required=True, type=str)
- parser.add_argument('--encoding', default='utf-8', help='character encoding for input/output')
- parser.add_argument('--bitext', type=str, required=True, help='language direction')
- parser.add_argument('--src-lang', type=str, required=True, help='Source language')
- parser.add_argument('--tgt-lang', type=str, required=True, help='Target language')
- main(parser.parse_args())
diff --git a/spaces/Harveenchadha/Vakyansh-Odia-TTS/ttsv/tts_infer/transliterate.py b/spaces/Harveenchadha/Vakyansh-Odia-TTS/ttsv/tts_infer/transliterate.py
deleted file mode 100644
index 575430562683434cd44fd8d2e77d26dab9ced73b..0000000000000000000000000000000000000000
--- a/spaces/Harveenchadha/Vakyansh-Odia-TTS/ttsv/tts_infer/transliterate.py
+++ /dev/null
@@ -1,919 +0,0 @@
-import torch
-import torch.nn as nn
-import numpy as np
-import pandas as pd
-import random
-import sys
-import os
-import json
-import enum
-import traceback
-import re
-
-F_DIR = os.path.dirname(os.environ.get('translit_model_base_path', os.path.realpath(__file__)))
-
-
-class XlitError(enum.Enum):
- lang_err = "Unsupported langauge ID requested ;( Please check available languages."
- string_err = "String passed is incompatable ;("
- internal_err = "Internal crash ;("
- unknown_err = "Unknown Failure"
- loading_err = "Loading failed ;( Check if metadata/paths are correctly configured."
-
-
-##=================== Network ==================================================
-
-
-class Encoder(nn.Module):
- def __init__(
- self,
- input_dim,
- embed_dim,
- hidden_dim,
- rnn_type="gru",
- layers=1,
- bidirectional=False,
- dropout=0,
- device="cpu",
- ):
- super(Encoder, self).__init__()
-
- self.input_dim = input_dim # src_vocab_sz
- self.enc_embed_dim = embed_dim
- self.enc_hidden_dim = hidden_dim
- self.enc_rnn_type = rnn_type
- self.enc_layers = layers
- self.enc_directions = 2 if bidirectional else 1
- self.device = device
-
- self.embedding = nn.Embedding(self.input_dim, self.enc_embed_dim)
-
- if self.enc_rnn_type == "gru":
- self.enc_rnn = nn.GRU(
- input_size=self.enc_embed_dim,
- hidden_size=self.enc_hidden_dim,
- num_layers=self.enc_layers,
- bidirectional=bidirectional,
- )
- elif self.enc_rnn_type == "lstm":
- self.enc_rnn = nn.LSTM(
- input_size=self.enc_embed_dim,
- hidden_size=self.enc_hidden_dim,
- num_layers=self.enc_layers,
- bidirectional=bidirectional,
- )
- else:
- raise Exception("XlitError: unknown RNN type mentioned")
-
- def forward(self, x, x_sz, hidden=None):
- """
- x_sz: (batch_size, 1) - Unpadded sequence lengths used for pack_pad
- """
- batch_sz = x.shape[0]
- # x: batch_size, max_length, enc_embed_dim
- x = self.embedding(x)
-
- ## pack the padded data
- # x: max_length, batch_size, enc_embed_dim -> for pack_pad
- x = x.permute(1, 0, 2)
- x = nn.utils.rnn.pack_padded_sequence(x, x_sz, enforce_sorted=False) # unpad
-
- # output: packed_size, batch_size, enc_embed_dim
- # hidden: n_layer**num_directions, batch_size, hidden_dim | if LSTM (h_n, c_n)
- output, hidden = self.enc_rnn(
- x
- ) # gru returns hidden state of all timesteps as well as hidden state at last timestep
-
- ## pad the sequence to the max length in the batch
- # output: max_length, batch_size, enc_emb_dim*directions)
- output, _ = nn.utils.rnn.pad_packed_sequence(output)
-
- # output: batch_size, max_length, hidden_dim
- output = output.permute(1, 0, 2)
-
- return output, hidden
-
- def get_word_embedding(self, x):
- """ """
- x_sz = torch.tensor([len(x)])
- x_ = torch.tensor(x).unsqueeze(0).to(dtype=torch.long)
- # x: 1, max_length, enc_embed_dim
- x = self.embedding(x_)
-
- ## pack the padded data
- # x: max_length, 1, enc_embed_dim -> for pack_pad
- x = x.permute(1, 0, 2)
- x = nn.utils.rnn.pack_padded_sequence(x, x_sz, enforce_sorted=False) # unpad
-
- # output: packed_size, 1, enc_embed_dim
- # hidden: n_layer**num_directions, 1, hidden_dim | if LSTM (h_n, c_n)
- output, hidden = self.enc_rnn(
- x
- ) # gru returns hidden state of all timesteps as well as hidden state at last timestep
-
- out_embed = hidden[0].squeeze()
-
- return out_embed
-
-
-class Decoder(nn.Module):
- def __init__(
- self,
- output_dim,
- embed_dim,
- hidden_dim,
- rnn_type="gru",
- layers=1,
- use_attention=True,
- enc_outstate_dim=None, # enc_directions * enc_hidden_dim
- dropout=0,
- device="cpu",
- ):
- super(Decoder, self).__init__()
-
- self.output_dim = output_dim # tgt_vocab_sz
- self.dec_hidden_dim = hidden_dim
- self.dec_embed_dim = embed_dim
- self.dec_rnn_type = rnn_type
- self.dec_layers = layers
- self.use_attention = use_attention
- self.device = device
- if self.use_attention:
- self.enc_outstate_dim = enc_outstate_dim if enc_outstate_dim else hidden_dim
- else:
- self.enc_outstate_dim = 0
-
- self.embedding = nn.Embedding(self.output_dim, self.dec_embed_dim)
-
- if self.dec_rnn_type == "gru":
- self.dec_rnn = nn.GRU(
- input_size=self.dec_embed_dim
- + self.enc_outstate_dim, # to concat attention_output
- hidden_size=self.dec_hidden_dim, # previous Hidden
- num_layers=self.dec_layers,
- batch_first=True,
- )
- elif self.dec_rnn_type == "lstm":
- self.dec_rnn = nn.LSTM(
- input_size=self.dec_embed_dim
- + self.enc_outstate_dim, # to concat attention_output
- hidden_size=self.dec_hidden_dim, # previous Hidden
- num_layers=self.dec_layers,
- batch_first=True,
- )
- else:
- raise Exception("XlitError: unknown RNN type mentioned")
-
- self.fc = nn.Sequential(
- nn.Linear(self.dec_hidden_dim, self.dec_embed_dim),
- nn.LeakyReLU(),
- # nn.Linear(self.dec_embed_dim, self.dec_embed_dim), nn.LeakyReLU(), # removing to reduce size
- nn.Linear(self.dec_embed_dim, self.output_dim),
- )
-
- ##----- Attention ----------
- if self.use_attention:
- self.W1 = nn.Linear(self.enc_outstate_dim, self.dec_hidden_dim)
- self.W2 = nn.Linear(self.dec_hidden_dim, self.dec_hidden_dim)
- self.V = nn.Linear(self.dec_hidden_dim, 1)
-
- def attention(self, x, hidden, enc_output):
- """
- x: (batch_size, 1, dec_embed_dim) -> after Embedding
- enc_output: batch_size, max_length, enc_hidden_dim *num_directions
- hidden: n_layers, batch_size, hidden_size | if LSTM (h_n, c_n)
- """
-
- ## perform addition to calculate the score
-
- # hidden_with_time_axis: batch_size, 1, hidden_dim
- ## hidden_with_time_axis = hidden.permute(1, 0, 2) ## replaced with below 2lines
- hidden_with_time_axis = (
- torch.sum(hidden, axis=0)
- if self.dec_rnn_type != "lstm"
- else torch.sum(hidden[0], axis=0)
- ) # h_n
-
- hidden_with_time_axis = hidden_with_time_axis.unsqueeze(1)
-
- # score: batch_size, max_length, hidden_dim
- score = torch.tanh(self.W1(enc_output) + self.W2(hidden_with_time_axis))
-
- # attention_weights: batch_size, max_length, 1
- # we get 1 at the last axis because we are applying score to self.V
- attention_weights = torch.softmax(self.V(score), dim=1)
-
- # context_vector shape after sum == (batch_size, hidden_dim)
- context_vector = attention_weights * enc_output
- context_vector = torch.sum(context_vector, dim=1)
- # context_vector: batch_size, 1, hidden_dim
- context_vector = context_vector.unsqueeze(1)
-
- # attend_out (batch_size, 1, dec_embed_dim + hidden_size)
- attend_out = torch.cat((context_vector, x), -1)
-
- return attend_out, attention_weights
-
- def forward(self, x, hidden, enc_output):
- """
- x: (batch_size, 1)
- enc_output: batch_size, max_length, dec_embed_dim
- hidden: n_layer, batch_size, hidden_size | lstm: (h_n, c_n)
- """
- if (hidden is None) and (self.use_attention is False):
- raise Exception(
- "XlitError: No use of a decoder with No attention and No Hidden"
- )
-
- batch_sz = x.shape[0]
-
- if hidden is None:
- # hidden: n_layers, batch_size, hidden_dim
- hid_for_att = torch.zeros(
- (self.dec_layers, batch_sz, self.dec_hidden_dim)
- ).to(self.device)
- elif self.dec_rnn_type == "lstm":
- hid_for_att = hidden[1] # c_n
-
- # x (batch_size, 1, dec_embed_dim) -> after embedding
- x = self.embedding(x)
-
- if self.use_attention:
- # x (batch_size, 1, dec_embed_dim + hidden_size) -> after attention
- # aw: (batch_size, max_length, 1)
- x, aw = self.attention(x, hidden, enc_output)
- else:
- x, aw = x, 0
-
- # passing the concatenated vector to the GRU
- # output: (batch_size, n_layers, hidden_size)
- # hidden: n_layers, batch_size, hidden_size | if LSTM (h_n, c_n)
- output, hidden = (
- self.dec_rnn(x, hidden) if hidden is not None else self.dec_rnn(x)
- )
-
- # output :shp: (batch_size * 1, hidden_size)
- output = output.view(-1, output.size(2))
-
- # output :shp: (batch_size * 1, output_dim)
- output = self.fc(output)
-
- return output, hidden, aw
-
-
-class Seq2Seq(nn.Module):
- """
- Class dependency: Encoder, Decoder
- """
-
- def __init__(
- self, encoder, decoder, pass_enc2dec_hid=False, dropout=0, device="cpu"
- ):
- super(Seq2Seq, self).__init__()
-
- self.encoder = encoder
- self.decoder = decoder
- self.device = device
- self.pass_enc2dec_hid = pass_enc2dec_hid
- _force_en2dec_hid_conv = False
-
- if self.pass_enc2dec_hid:
- assert (
- decoder.dec_hidden_dim == encoder.enc_hidden_dim
- ), "Hidden Dimension of encoder and decoder must be same, or unset `pass_enc2dec_hid`"
- if decoder.use_attention:
- assert (
- decoder.enc_outstate_dim
- == encoder.enc_directions * encoder.enc_hidden_dim
- ), "Set `enc_out_dim` correctly in decoder"
- assert (
- self.pass_enc2dec_hid or decoder.use_attention
- ), "No use of a decoder with No attention and No Hidden from Encoder"
-
- self.use_conv_4_enc2dec_hid = False
- if (
- self.pass_enc2dec_hid
- and (encoder.enc_directions * encoder.enc_layers != decoder.dec_layers)
- ) or _force_en2dec_hid_conv:
- if encoder.enc_rnn_type == "lstm" or encoder.enc_rnn_type == "lstm":
- raise Exception(
- "XlitError: conv for enc2dec_hid not implemented; Change the layer numbers appropriately"
- )
-
- self.use_conv_4_enc2dec_hid = True
- self.enc_hid_1ax = encoder.enc_directions * encoder.enc_layers
- self.dec_hid_1ax = decoder.dec_layers
- self.e2d_hidden_conv = nn.Conv1d(self.enc_hid_1ax, self.dec_hid_1ax, 1)
-
- def enc2dec_hidden(self, enc_hidden):
- """
- enc_hidden: n_layer, batch_size, hidden_dim*num_directions
- TODO: Implement the logic for LSTm bsed model
- """
- # hidden: batch_size, enc_layer*num_directions, enc_hidden_dim
- hidden = enc_hidden.permute(1, 0, 2).contiguous()
- # hidden: batch_size, dec_layers, dec_hidden_dim -> [N,C,Tstep]
- hidden = self.e2d_hidden_conv(hidden)
-
- # hidden: dec_layers, batch_size , dec_hidden_dim
- hidden_for_dec = hidden.permute(1, 0, 2).contiguous()
-
- return hidden_for_dec
-
- def active_beam_inference(self, src, beam_width=3, max_tgt_sz=50):
- """Search based decoding
- src: (sequence_len)
- """
-
- def _avg_score(p_tup):
- """Used for Sorting
- TODO: Dividing by length of sequence power alpha as hyperparam
- """
- return p_tup[0]
-
- import sys
-
- batch_size = 1
- start_tok = src[0]
- end_tok = src[-1]
- src_sz = torch.tensor([len(src)])
- src_ = src.unsqueeze(0)
-
- # enc_output: (batch_size, padded_seq_length, enc_hidden_dim*num_direction)
- # enc_hidden: (enc_layers*num_direction, batch_size, hidden_dim)
- enc_output, enc_hidden = self.encoder(src_, src_sz)
-
- if self.pass_enc2dec_hid:
- # dec_hidden: dec_layers, batch_size , dec_hidden_dim
- if self.use_conv_4_enc2dec_hid:
- init_dec_hidden = self.enc2dec_hidden(enc_hidden)
- else:
- init_dec_hidden = enc_hidden
- else:
- # dec_hidden -> Will be initialized to zeros internally
- init_dec_hidden = None
-
- # top_pred[][0] = Σ-log_softmax
- # top_pred[][1] = sequence torch.tensor shape: (1)
- # top_pred[][2] = dec_hidden
- top_pred_list = [(0, start_tok.unsqueeze(0), init_dec_hidden)]
-
- for t in range(max_tgt_sz):
- cur_pred_list = []
-
- for p_tup in top_pred_list:
- if p_tup[1][-1] == end_tok:
- cur_pred_list.append(p_tup)
- continue
-
- # dec_hidden: dec_layers, 1, hidden_dim
- # dec_output: 1, output_dim
- dec_output, dec_hidden, _ = self.decoder(
- x=p_tup[1][-1].view(1, 1), # dec_input: (1,1)
- hidden=p_tup[2],
- enc_output=enc_output,
- )
-
- ## π{prob} = Σ{log(prob)} -> to prevent diminishing
- # dec_output: (1, output_dim)
- dec_output = nn.functional.log_softmax(dec_output, dim=1)
- # pred_topk.values & pred_topk.indices: (1, beam_width)
- pred_topk = torch.topk(dec_output, k=beam_width, dim=1)
-
- for i in range(beam_width):
- sig_logsmx_ = p_tup[0] + pred_topk.values[0][i]
- # seq_tensor_ : (seq_len)
- seq_tensor_ = torch.cat((p_tup[1], pred_topk.indices[0][i].view(1)))
-
- cur_pred_list.append((sig_logsmx_, seq_tensor_, dec_hidden))
-
- cur_pred_list.sort(key=_avg_score, reverse=True) # Maximized order
- top_pred_list = cur_pred_list[:beam_width]
-
- # check if end_tok of all topk
- end_flags_ = [1 if t[1][-1] == end_tok else 0 for t in top_pred_list]
- if beam_width == sum(end_flags_):
- break
-
- pred_tnsr_list = [t[1] for t in top_pred_list]
-
- return pred_tnsr_list
-
-
-##===================== Glyph handlers =======================================
-
-
-class GlyphStrawboss:
- def __init__(self, glyphs="en"):
- """list of letters in a language in unicode
- lang: ISO Language code
- glyphs: json file with script information
- """
- if glyphs == "en":
- # Smallcase alone
- self.glyphs = [chr(alpha) for alpha in range(97, 122 + 1)]
- else:
- self.dossier = json.load(open(glyphs, encoding="utf-8"))
- self.glyphs = self.dossier["glyphs"]
- self.numsym_map = self.dossier["numsym_map"]
-
- self.char2idx = {}
- self.idx2char = {}
- self._create_index()
-
- def _create_index(self):
-
- self.char2idx["_"] = 0 # pad
- self.char2idx["$"] = 1 # start
- self.char2idx["#"] = 2 # end
- self.char2idx["*"] = 3 # Mask
- self.char2idx["'"] = 4 # apostrophe U+0027
- self.char2idx["%"] = 5 # unused
- self.char2idx["!"] = 6 # unused
-
- # letter to index mapping
- for idx, char in enumerate(self.glyphs):
- self.char2idx[char] = idx + 7 # +7 token initially
-
- # index to letter mapping
- for char, idx in self.char2idx.items():
- self.idx2char[idx] = char
-
- def size(self):
- return len(self.char2idx)
-
- def word2xlitvec(self, word):
- """Converts given string of gyphs(word) to vector(numpy)
- Also adds tokens for start and end
- """
- try:
- vec = [self.char2idx["$"]] # start token
- for i in list(word):
- vec.append(self.char2idx[i])
- vec.append(self.char2idx["#"]) # end token
-
- vec = np.asarray(vec, dtype=np.int64)
- return vec
-
- except Exception as error:
- print("XlitError: In word:", word, "Error Char not in Token:", error)
- sys.exit()
-
- def xlitvec2word(self, vector):
- """Converts vector(numpy) to string of glyphs(word)"""
- char_list = []
- for i in vector:
- char_list.append(self.idx2char[i])
-
- word = "".join(char_list).replace("$", "").replace("#", "") # remove tokens
- word = word.replace("_", "").replace("*", "") # remove tokens
- return word
-
-
-class VocabSanitizer:
- def __init__(self, data_file):
- """
- data_file: path to file conatining vocabulary list
- """
- extension = os.path.splitext(data_file)[-1]
- if extension == ".json":
- self.vocab_set = set(json.load(open(data_file, encoding="utf-8")))
- elif extension == ".csv":
- self.vocab_df = pd.read_csv(data_file).set_index("WORD")
- self.vocab_set = set(self.vocab_df.index)
- else:
- print("XlitError: Only Json/CSV file extension supported")
-
- def reposition(self, word_list):
- """Reorder Words in list"""
- new_list = []
- temp_ = word_list.copy()
- for v in word_list:
- if v in self.vocab_set:
- new_list.append(v)
- temp_.remove(v)
- new_list.extend(temp_)
-
- return new_list
-
-
-##=============== INSTANTIATION ================================================
-
-
-class XlitPiston:
- """
- For handling prediction & post-processing of transliteration for a single language
- Class dependency: Seq2Seq, GlyphStrawboss, VocabSanitizer
- Global Variables: F_DIR
- """
-
- def __init__(
- self,
- weight_path,
- vocab_file,
- tglyph_cfg_file,
- iglyph_cfg_file="en",
- device="cpu",
- ):
-
- self.device = device
- self.in_glyph_obj = GlyphStrawboss(iglyph_cfg_file)
- self.tgt_glyph_obj = GlyphStrawboss(glyphs=tglyph_cfg_file)
- self.voc_sanity = VocabSanitizer(vocab_file)
-
- self._numsym_set = set(
- json.load(open(tglyph_cfg_file, encoding="utf-8"))["numsym_map"].keys()
- )
- self._inchar_set = set("abcdefghijklmnopqrstuvwxyz")
- self._natscr_set = set().union(
- self.tgt_glyph_obj.glyphs, sum(self.tgt_glyph_obj.numsym_map.values(), [])
- )
-
- ## Model Config Static TODO: add defining in json support
- input_dim = self.in_glyph_obj.size()
- output_dim = self.tgt_glyph_obj.size()
- enc_emb_dim = 300
- dec_emb_dim = 300
- enc_hidden_dim = 512
- dec_hidden_dim = 512
- rnn_type = "lstm"
- enc2dec_hid = True
- attention = True
- enc_layers = 1
- dec_layers = 2
- m_dropout = 0
- enc_bidirect = True
- enc_outstate_dim = enc_hidden_dim * (2 if enc_bidirect else 1)
-
- enc = Encoder(
- input_dim=input_dim,
- embed_dim=enc_emb_dim,
- hidden_dim=enc_hidden_dim,
- rnn_type=rnn_type,
- layers=enc_layers,
- dropout=m_dropout,
- device=self.device,
- bidirectional=enc_bidirect,
- )
- dec = Decoder(
- output_dim=output_dim,
- embed_dim=dec_emb_dim,
- hidden_dim=dec_hidden_dim,
- rnn_type=rnn_type,
- layers=dec_layers,
- dropout=m_dropout,
- use_attention=attention,
- enc_outstate_dim=enc_outstate_dim,
- device=self.device,
- )
- self.model = Seq2Seq(enc, dec, pass_enc2dec_hid=enc2dec_hid, device=self.device)
- self.model = self.model.to(self.device)
- weights = torch.load(weight_path, map_location=torch.device(self.device))
-
- self.model.load_state_dict(weights)
- self.model.eval()
-
- def character_model(self, word, beam_width=1):
- in_vec = torch.from_numpy(self.in_glyph_obj.word2xlitvec(word)).to(self.device)
- ## change to active or passive beam
- p_out_list = self.model.active_beam_inference(in_vec, beam_width=beam_width)
- p_result = [
- self.tgt_glyph_obj.xlitvec2word(out.cpu().numpy()) for out in p_out_list
- ]
-
- result = self.voc_sanity.reposition(p_result)
-
- # List type
- return result
-
- def numsym_model(self, seg):
- """tgt_glyph_obj.numsym_map[x] returns a list object"""
- if len(seg) == 1:
- return [seg] + self.tgt_glyph_obj.numsym_map[seg]
-
- a = [self.tgt_glyph_obj.numsym_map[n][0] for n in seg]
- return [seg] + ["".join(a)]
-
- def _word_segementer(self, sequence):
-
- sequence = sequence.lower()
- accepted = set().union(self._numsym_set, self._inchar_set, self._natscr_set)
- # sequence = ''.join([i for i in sequence if i in accepted])
-
- segment = []
- idx = 0
- seq_ = list(sequence)
- while len(seq_):
- # for Number-Symbol
- temp = ""
- while len(seq_) and seq_[0] in self._numsym_set:
- temp += seq_[0]
- seq_.pop(0)
- if temp != "":
- segment.append(temp)
-
- # for Target Chars
- temp = ""
- while len(seq_) and seq_[0] in self._natscr_set:
- temp += seq_[0]
- seq_.pop(0)
- if temp != "":
- segment.append(temp)
-
- # for Input-Roman Chars
- temp = ""
- while len(seq_) and seq_[0] in self._inchar_set:
- temp += seq_[0]
- seq_.pop(0)
- if temp != "":
- segment.append(temp)
-
- temp = ""
- while len(seq_) and seq_[0] not in accepted:
- temp += seq_[0]
- seq_.pop(0)
- if temp != "":
- segment.append(temp)
-
- return segment
-
- def inferencer(self, sequence, beam_width=10):
-
- seg = self._word_segementer(sequence[:120])
- lit_seg = []
-
- p = 0
- while p < len(seg):
- if seg[p][0] in self._natscr_set:
- lit_seg.append([seg[p]])
- p += 1
-
- elif seg[p][0] in self._inchar_set:
- lit_seg.append(self.character_model(seg[p], beam_width=beam_width))
- p += 1
-
- elif seg[p][0] in self._numsym_set: # num & punc
- lit_seg.append(self.numsym_model(seg[p]))
- p += 1
- else:
- lit_seg.append([seg[p]])
- p += 1
-
- ## IF segment less/equal to 2 then return combinotorial,
- ## ELSE only return top1 of each result concatenated
- if len(lit_seg) == 1:
- final_result = lit_seg[0]
-
- elif len(lit_seg) == 2:
- final_result = [""]
- for seg in lit_seg:
- new_result = []
- for s in seg:
- for f in final_result:
- new_result.append(f + s)
- final_result = new_result
-
- else:
- new_result = []
- for seg in lit_seg:
- new_result.append(seg[0])
- final_result = ["".join(new_result)]
-
- return final_result
-
-
-from collections.abc import Iterable
-from pydload import dload
-import zipfile
-
-MODEL_DOWNLOAD_URL_PREFIX = "https://github.com/AI4Bharat/IndianNLP-Transliteration/releases/download/xlit_v0.5.0/"
-
-
-def is_folder_writable(folder):
- try:
- os.makedirs(folder, exist_ok=True)
- tmp_file = os.path.join(folder, ".write_test")
- with open(tmp_file, "w") as f:
- f.write("Permission Check")
- os.remove(tmp_file)
- return True
- except:
- return False
-
-
-def is_directory_writable(path):
- if os.name == "nt":
- return is_folder_writable(path)
- return os.access(path, os.W_OK | os.X_OK)
-
-
-class XlitEngine:
- """
- For Managing the top level tasks and applications of transliteration
- Global Variables: F_DIR
- """
-
- def __init__(
- self, lang2use="all", config_path="translit_models/default_lineup.json"
- ):
-
- lineup = json.load(open(os.path.join(F_DIR, config_path), encoding="utf-8"))
- self.lang_config = {}
- if isinstance(lang2use, str):
- if lang2use == "all":
- self.lang_config = lineup
- elif lang2use in lineup:
- self.lang_config[lang2use] = lineup[lang2use]
- else:
- raise Exception(
- "XlitError: The entered Langauge code not found. Available are {}".format(
- lineup.keys()
- )
- )
-
- elif isinstance(lang2use, Iterable):
- for l in lang2use:
- try:
- self.lang_config[l] = lineup[l]
- except:
- print(
- "XlitError: Language code {} not found, Skipping...".format(l)
- )
- else:
- raise Exception(
- "XlitError: lang2use must be a list of language codes (or) string of single language code"
- )
-
- if is_directory_writable(F_DIR):
- models_path = os.path.join(F_DIR, "translit_models")
- else:
- user_home = os.path.expanduser("~")
- models_path = os.path.join(user_home, ".AI4Bharat_Xlit_Models")
- os.makedirs(models_path, exist_ok=True)
- self.download_models(models_path)
-
- self.langs = {}
- self.lang_model = {}
- for la in self.lang_config:
- try:
- print("Loading {}...".format(la))
- self.lang_model[la] = XlitPiston(
- weight_path=os.path.join(
- models_path, self.lang_config[la]["weight"]
- ),
- vocab_file=os.path.join(models_path, self.lang_config[la]["vocab"]),
- tglyph_cfg_file=os.path.join(
- models_path, self.lang_config[la]["script"]
- ),
- iglyph_cfg_file="en",
- )
- self.langs[la] = self.lang_config[la]["name"]
- except Exception as error:
- print("XlitError: Failure in loading {} \n".format(la), error)
- print(XlitError.loading_err.value)
-
- def download_models(self, models_path):
- """
- Download models from GitHub Releases if not exists
- """
- for l in self.lang_config:
- lang_name = self.lang_config[l]["eng_name"]
- lang_model_path = os.path.join(models_path, lang_name)
- if not os.path.isdir(lang_model_path):
- print("Downloading model for language: %s" % lang_name)
- remote_url = MODEL_DOWNLOAD_URL_PREFIX + lang_name + ".zip"
- downloaded_zip_path = os.path.join(models_path, lang_name + ".zip")
- dload(url=remote_url, save_to_path=downloaded_zip_path, max_time=None)
-
- if not os.path.isfile(downloaded_zip_path):
- exit(
- f"ERROR: Unable to download model from {remote_url} into {models_path}"
- )
-
- with zipfile.ZipFile(downloaded_zip_path, "r") as zip_ref:
- zip_ref.extractall(models_path)
-
- if os.path.isdir(lang_model_path):
- os.remove(downloaded_zip_path)
- else:
- exit(
- f"ERROR: Unable to find models in {lang_model_path} after download"
- )
- return
-
- def translit_word(self, eng_word, lang_code="default", topk=7, beam_width=10):
- if eng_word == "":
- return []
-
- if lang_code in self.langs:
- try:
- res_list = self.lang_model[lang_code].inferencer(
- eng_word, beam_width=beam_width
- )
- return res_list[:topk]
-
- except Exception as error:
- print("XlitError:", traceback.format_exc())
- print(XlitError.internal_err.value)
- return XlitError.internal_err
-
- elif lang_code == "default":
- try:
- res_dict = {}
- for la in self.lang_model:
- res = self.lang_model[la].inferencer(
- eng_word, beam_width=beam_width
- )
- res_dict[la] = res[:topk]
- return res_dict
-
- except Exception as error:
- print("XlitError:", traceback.format_exc())
- print(XlitError.internal_err.value)
- return XlitError.internal_err
-
- else:
- print("XlitError: Unknown Langauge requested", lang_code)
- print(XlitError.lang_err.value)
- return XlitError.lang_err
-
- def translit_sentence(self, eng_sentence, lang_code="default", beam_width=10):
- if eng_sentence == "":
- return []
-
- if lang_code in self.langs:
- try:
- out_str = ""
- for word in eng_sentence.split():
- res_ = self.lang_model[lang_code].inferencer(
- word, beam_width=beam_width
- )
- out_str = out_str + res_[0] + " "
- return out_str[:-1]
-
- except Exception as error:
- print("XlitError:", traceback.format_exc())
- print(XlitError.internal_err.value)
- return XlitError.internal_err
-
- elif lang_code == "default":
- try:
- res_dict = {}
- for la in self.lang_model:
- out_str = ""
- for word in eng_sentence.split():
- res_ = self.lang_model[la].inferencer(
- word, beam_width=beam_width
- )
- out_str = out_str + res_[0] + " "
- res_dict[la] = out_str[:-1]
- return res_dict
-
- except Exception as error:
- print("XlitError:", traceback.format_exc())
- print(XlitError.internal_err.value)
- return XlitError.internal_err
-
- else:
- print("XlitError: Unknown Langauge requested", lang_code)
- print(XlitError.lang_err.value)
- return XlitError.lang_err
-
-
-if __name__ == "__main__":
-
- available_lang = [
- "bn",
- "gu",
- "hi",
- "kn",
- "gom",
- "mai",
- "ml",
- "mr",
- "pa",
- "sd",
- "si",
- "ta",
- "te",
- "ur",
- ]
-
- reg = re.compile(r"[a-zA-Z]")
- lang = "hi"
- engine = XlitEngine(
- lang
- ) # if you don't specify lang code here, this will give results in all langs available
- sent = "Hello World! ABCD क्या हाल है आपका?"
- words = [
- engine.translit_word(word, topk=1)[lang][0] if reg.match(word) else word
- for word in sent.split()
- ] # only transliterated en words, leaves rest as it is
- updated_sent = " ".join(words)
-
- print(updated_sent)
-
- # output : हेलो वर्ल्ड! क्या हाल है आपका?
-
- # y = engine.translit_sentence("Hello World !")['hi']
- # print(y)
diff --git a/spaces/Harveenchadha/oiTrans/indic_nlp_library/indicnlp/transliterate/acronym_transliterator.py b/spaces/Harveenchadha/oiTrans/indic_nlp_library/indicnlp/transliterate/acronym_transliterator.py
deleted file mode 100644
index 09c71d15a23bbd56119c046aa5ddf76b7a42851b..0000000000000000000000000000000000000000
--- a/spaces/Harveenchadha/oiTrans/indic_nlp_library/indicnlp/transliterate/acronym_transliterator.py
+++ /dev/null
@@ -1,75 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2013-present, Anoop Kunchukuttan
-# All rights reserved.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-#
-
-#Program to transliterate acronyms from one Latin script to Indic languages
-#
-# @author Anoop Kunchukuttan
-#
-
-from indicnlp.transliterate.unicode_transliterate import UnicodeIndicTransliterator
-import string
-import random
-
-class LatinToIndicAcronymTransliterator(object):
-
- LATIN_TO_DEVANAGARI_TRANSTABLE = str.maketrans({
- 'a':'ए',
- 'b':'बी',
- 'c':'सी',
- 'd':'डी',
- 'e':'ई',
- 'f':'एफ',
- 'g':'जी',
- 'h':'एच',
- 'i':'आई',
- 'j':'जे',
- 'k':'के',
- 'l':'एल',
- 'm':'एम',
- 'n':'एन',
- 'o':'ओ',
- 'p':'पी',
- 'q':'क्यू',
- 'r':'आर',
- 's':'एस',
- 't':'टी',
- 'u':'यू',
- 'v':'वी',
- 'w':'डब्ल्यू',
- 'x':'एक्स',
- 'y':'वाय',
- 'z':'जेड',
- })
-
- # a_unichr=ord('a')
- # alphabet = [ chr(a_unichr+n) for n in range(26) ]
- LATIN_ALPHABET = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
-
- @staticmethod
- def get_transtable():
- return LatinToIndicAcronymTransliterator.LATIN_TO_DEVANAGARI_TRANSTABLE
-
- @staticmethod
- def transliterate(w,lang):
- return UnicodeIndicTransliterator.transliterate(w.lower().translate(LatinToIndicAcronymTransliterator.LATIN_TO_DEVANAGARI_TRANSTABLE),'hi',lang)
-
- @staticmethod
- def generate_latin_acronyms(num_acronyms, min_len=2, max_len=6, strategy='random'):
- """
- generate Latin acronyms in lower case
- """
-
- def sample_acronym(strategy='random'):
- if strategy=='random':
- slen=random.randint(min_len,max_len)
- return ''.join(random.choices(LatinToIndicAcronymTransliterator.LATIN_ALPHABET,k=slen))
-
-
- return [ sample_acronym(strategy) for i in range(num_acronyms) ]
-
\ No newline at end of file
diff --git a/spaces/Harveenchadha/oiTrans/subword-nmt/subword_nmt/segment_char_ngrams.py b/spaces/Harveenchadha/oiTrans/subword-nmt/subword_nmt/segment_char_ngrams.py
deleted file mode 100644
index 8d94bc7a36eb3163271e95e167190d7423564308..0000000000000000000000000000000000000000
--- a/spaces/Harveenchadha/oiTrans/subword-nmt/subword_nmt/segment_char_ngrams.py
+++ /dev/null
@@ -1,95 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-# Author: Rico Sennrich
-
-from __future__ import unicode_literals, division
-
-import sys
-import codecs
-import argparse
-
-# hack for python2/3 compatibility
-from io import open
-argparse.open = open
-
-def create_parser(subparsers=None):
-
- if subparsers:
- parser = subparsers.add_parser('segment-char-ngrams',
- formatter_class=argparse.RawDescriptionHelpFormatter,
- description="segment rare words into character n-grams")
- else:
- parser = argparse.ArgumentParser(
- formatter_class=argparse.RawDescriptionHelpFormatter,
- description="segment rare words into character n-grams")
-
- parser.add_argument(
- '--input', '-i', type=argparse.FileType('r'), default=sys.stdin,
- metavar='PATH',
- help="Input file (default: standard input).")
- parser.add_argument(
- '--vocab', type=argparse.FileType('r'), metavar='PATH',
- required=True,
- help="Vocabulary file.")
- parser.add_argument(
- '--shortlist', type=int, metavar='INT', default=0,
- help="do not segment INT most frequent words in vocabulary (default: '%(default)s')).")
- parser.add_argument(
- '-n', type=int, metavar='INT', default=2,
- help="segment rare words into character n-grams of size INT (default: '%(default)s')).")
- parser.add_argument(
- '--output', '-o', type=argparse.FileType('w'), default=sys.stdout,
- metavar='PATH',
- help="Output file (default: standard output)")
- parser.add_argument(
- '--separator', '-s', type=str, default='@@', metavar='STR',
- help="Separator between non-final subword units (default: '%(default)s'))")
-
- return parser
-
-def segment_char_ngrams(args):
-
- vocab = [line.split()[0] for line in args.vocab if len(line.split()) == 2]
- vocab = dict((y,x) for (x,y) in enumerate(vocab))
-
- for line in args.input:
- for word in line.split():
- if word not in vocab or vocab[word] > args.shortlist:
- i = 0
- while i*args.n < len(word):
- args.output.write(word[i*args.n:i*args.n+args.n])
- i += 1
- if i*args.n < len(word):
- args.output.write(args.separator)
- args.output.write(' ')
- else:
- args.output.write(word + ' ')
- args.output.write('\n')
-
-
-if __name__ == '__main__':
-
- # python 2/3 compatibility
- if sys.version_info < (3, 0):
- sys.stderr = codecs.getwriter('UTF-8')(sys.stderr)
- sys.stdout = codecs.getwriter('UTF-8')(sys.stdout)
- sys.stdin = codecs.getreader('UTF-8')(sys.stdin)
- else:
- sys.stderr = codecs.getwriter('UTF-8')(sys.stderr.buffer)
- sys.stdout = codecs.getwriter('UTF-8')(sys.stdout.buffer)
- sys.stdin = codecs.getreader('UTF-8')(sys.stdin.buffer)
-
- parser = create_parser()
- args = parser.parse_args()
-
- if sys.version_info < (3, 0):
- args.separator = args.separator.decode('UTF-8')
-
- # read/write files as UTF-8
- args.vocab = codecs.open(args.vocab.name, encoding='utf-8')
- if args.input.name != '':
- args.input = codecs.open(args.input.name, encoding='utf-8')
- if args.output.name != '':
- args.output = codecs.open(args.output.name, 'w', encoding='utf-8')
-
- segment_char_ngrams(args)
\ No newline at end of file
diff --git a/spaces/HuangLab/CELL-E_2-Image_Prediction/celle/utils.py b/spaces/HuangLab/CELL-E_2-Image_Prediction/celle/utils.py
deleted file mode 100644
index 6de2728e5b913d75e6d283558e8631901f7c4423..0000000000000000000000000000000000000000
--- a/spaces/HuangLab/CELL-E_2-Image_Prediction/celle/utils.py
+++ /dev/null
@@ -1,228 +0,0 @@
-import torch
-from torchvision import transforms
-from math import pi
-import torchvision.transforms.functional as TF
-
-
-# Define helper functions
-def exists(val):
- """Check if a variable exists"""
- return val is not None
-
-
-def uniq(arr):
- return {el: True for el in arr}.keys()
-
-
-def default(val, d):
- """If a value exists, return it; otherwise, return a default value"""
- return val if exists(val) else d
-
-
-def max_neg_value(t):
- return -torch.finfo(t.dtype).max
-
-
-def cast_tuple(val, depth=1):
- if isinstance(val, list):
- val = tuple(val)
- return val if isinstance(val, tuple) else (val,) * depth
-
-
-def is_empty(t):
- """Check if a tensor is empty"""
- # Return True if the number of elements in the tensor is zero, else False
- return t.nelement() == 0
-
-
-def masked_mean(t, mask, dim=1):
- """
- Compute the mean of a tensor, masked by a given mask
-
- Args:
- t (torch.Tensor): input tensor of shape (batch_size, seq_len, hidden_dim)
- mask (torch.Tensor): mask tensor of shape (batch_size, seq_len)
- dim (int): dimension along which to compute the mean (default=1)
-
- Returns:
- torch.Tensor: masked mean tensor of shape (batch_size, hidden_dim)
- """
- t = t.masked_fill(~mask[:, :, None], 0.0)
- return t.sum(dim=1) / mask.sum(dim=1)[..., None]
-
-
-def set_requires_grad(model, value):
- """
- Set whether or not the model's parameters require gradients
-
- Args:
- model (torch.nn.Module): the PyTorch model to modify
- value (bool): whether or not to require gradients
- """
- for param in model.parameters():
- param.requires_grad = value
-
-
-def eval_decorator(fn):
- """
- Decorator function to evaluate a given function
-
- Args:
- fn (callable): function to evaluate
-
- Returns:
- callable: the decorated function
- """
-
- def inner(model, *args, **kwargs):
- was_training = model.training
- model.eval()
- out = fn(model, *args, **kwargs)
- model.train(was_training)
- return out
-
- return inner
-
-
-def log(t, eps=1e-20):
- """
- Compute the natural logarithm of a tensor
-
- Args:
- t (torch.Tensor): input tensor
- eps (float): small value to add to prevent taking the log of 0 (default=1e-20)
-
- Returns:
- torch.Tensor: the natural logarithm of the input tensor
- """
- return torch.log(t + eps)
-
-
-def gumbel_noise(t):
- """
- Generate Gumbel noise
-
- Args:
- t (torch.Tensor): input tensor
-
- Returns:
- torch.Tensor: a tensor of Gumbel noise with the same shape as the input tensor
- """
- noise = torch.zeros_like(t).uniform_(0, 1)
- return -log(-log(noise))
-
-
-def gumbel_sample(t, temperature=0.9, dim=-1):
- """
- Sample from a Gumbel-softmax distribution
-
- Args:
- t (torch.Tensor): input tensor of shape (batch_size, num_classes)
- temperature (float): temperature for the Gumbel-softmax distribution (default=0.9)
- dim (int): dimension along which to sample (default=-1)
-
- Returns:
- torch.Tensor: a tensor of samples from the Gumbel-softmax distribution with the same shape as the input tensor
- """
- return (t / max(temperature, 1e-10)) + gumbel_noise(t)
-
-
-def top_k(logits, thres=0.5):
- """
- Return a tensor where all but the top k values are set to negative infinity
-
- Args:
- logits (torch.Tensor): input tensor of shape (batch_size, num_classes)
- thres (float): threshold for the top k values (default=0.5)
-
- Returns:
- torch.Tensor: a tensor with the same shape as the input tensor, where all but the top k values are set to negative infinity
- """
- num_logits = logits.shape[-1]
- k = max(int((1 - thres) * num_logits), 1)
- val, ind = torch.topk(logits, k)
- probs = torch.full_like(logits, float("-inf"))
- probs.scatter_(-1, ind, val)
- return probs
-
-
-def gamma_func(mode="cosine", scale=0.15):
- """Return a function that takes a single input r and returns a value based on the selected mode"""
-
- # Define a different function based on the selected mode
- if mode == "linear":
- return lambda r: 1 - r
- elif mode == "cosine":
- return lambda r: torch.cos(r * pi / 2)
- elif mode == "square":
- return lambda r: 1 - r**2
- elif mode == "cubic":
- return lambda r: 1 - r**3
- elif mode == "scaled-cosine":
- return lambda r: scale * (torch.cos(r * pi / 2))
- else:
- # Raise an error if the selected mode is not implemented
- raise NotImplementedError
-
-
-class always:
- """Helper class to always return a given value"""
-
- def __init__(self, val):
- self.val = val
-
- def __call__(self, x, *args, **kwargs):
- return self.val
-
-
-class DivideMax(torch.nn.Module):
- def __init__(self, dim):
- super().__init__()
- self.dim = dim
-
- def forward(self, x):
- maxes = x.amax(dim=self.dim, keepdim=True).detach()
- return x / maxes
-
-def replace_outliers(image, percentile=0.0001):
-
- lower_bound, upper_bound = torch.quantile(image, percentile), torch.quantile(
- image, 1 - percentile
- )
- mask = (image <= upper_bound) & (image >= lower_bound)
-
- valid_pixels = image[mask]
-
- image[~mask] = torch.clip(image[~mask], min(valid_pixels), max(valid_pixels))
-
- return image
-
-
-def process_image(image, dataset=None, image_type=None):
- image /= image.max()
-
- if dataset == "HPA":
- if image_type == 'nucleus':
- normalize = (0.0655, 0.0650)
-
- elif image_type == 'protein':
- normalize = (0.1732, 0.1208)
-
- elif dataset == "OpenCell":
-
- if image_type == 'nucleus':
- normalize = (0.0272, 0.0244)
-
- elif image_type == 'protein':
- normalize = (0.0486, 0.0671)
-
- t_forms = []
-
- t_forms.append(transforms.RandomCrop(256))
-
- # t_forms.append(transforms.Normalize(normalize[0],normalize[1]))
-
-
- image = transforms.Compose(t_forms)(image)
-
- return image
diff --git a/spaces/HuangLab/CELL-E_2-Sequence_Prediction/app.py b/spaces/HuangLab/CELL-E_2-Sequence_Prediction/app.py
deleted file mode 100644
index cff9216400679af0d275e17fbfbbecc548d85926..0000000000000000000000000000000000000000
--- a/spaces/HuangLab/CELL-E_2-Sequence_Prediction/app.py
+++ /dev/null
@@ -1,216 +0,0 @@
-import os
-import gradio as gr
-from prediction import run_sequence_prediction
-import torch
-import torchvision.transforms as T
-from celle.utils import process_image
-from celle_main import instantiate_from_config
-from omegaconf import OmegaConf
-from huggingface_hub import hf_hub_download
-
-def bold_predicted_letters(input_string: str, output_string: str) -> str:
- result = []
- i = j = 0
- input_string = input_string.upper()
- output_string = output_string.upper()
-
- while i < len(input_string):
- if input_string[i:i+6] == "":
- start_index = i
- end_index = i + 6
- while end_index < len(input_string) and input_string[end_index:end_index+6] == "":
- end_index += 6
-
- result.append("**" + output_string[j:j+(end_index-start_index)//6] + "**")
- i = end_index
- j += (end_index-start_index)//6
- else:
- result.append(input_string[i])
- i += 1
- if input_string[i-1] != "<":
- j += 1
-
- return "".join(result)
-
-def diff_texts(string):
- new_string = []
-
- bold = False
-
- for idx, letter in enumerate(string):
-
- if letter == '*' and string[min(idx + 1, len(string)-1)] == '*' and bold == False:
- bold = True
-
- elif letter == '*' and string[min(idx + 1, len(string)-1)] == '*' and bold == True:
- bold = False
- if letter != '*':
- if bold :
- new_string.append((letter,'+'))
- else:
- new_string.append((letter, None))
-
- return new_string
-
-class model:
- def __init__(self):
- self.model = None
- self.model_name = None
- self.model_path = None
-
- def gradio_demo(self, model_name, sequence_input, image):
- device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
- if self.model_name != model_name:
- if self.model_path is not None:
- os.remove(self.model_path)
- del self.model
- self.model_name = model_name
- model_ckpt_path = hf_hub_download(repo_id=f"HuangLab/{model_name}", filename="model.ckpt")
- self.model_path = model_ckpt_path
- model_config_path = hf_hub_download(repo_id=f"HuangLab/{model_name}", filename="config.yaml")
- hf_hub_download(repo_id=f"HuangLab/{model_name}", filename="nucleus_vqgan.yaml")
- hf_hub_download(repo_id=f"HuangLab/{model_name}", filename="threshold_vqgan.yaml")
-
- # Load model config and set ckpt_path if not provided in config
- config = OmegaConf.load(model_config_path)
- if config["model"]["params"]["ckpt_path"] is None:
- config["model"]["params"]["ckpt_path"] = model_ckpt_path
-
- # Set condition_model_path and vqgan_model_path to None
- config["model"]["params"]["condition_model_path"] = None
- config["model"]["params"]["vqgan_model_path"] = None
-
- base_path = os.getcwd()
-
- os.chdir(os.path.dirname(model_ckpt_path))
-
- # Instantiate model from config and move to device
- self.model = instantiate_from_config(config.model).to(device)
- self.model = torch.compile(self.model,mode='max-autotune')
-
- os.chdir(base_path)
-
-
- if "Finetuned" in model_name:
- dataset = "OpenCell"
-
- else:
- dataset = "HPA"
-
-
- nucleus_image = image['image'].convert('L')
- protein_image = image['mask'].convert('L')
-
- to_tensor = T.ToTensor()
- nucleus_image = to_tensor(nucleus_image)
- protein_image = to_tensor(protein_image)
- stacked_images = torch.stack([nucleus_image, protein_image], dim=0)
- processed_images = process_image(stacked_images, dataset)
-
- nucleus_image = processed_images[0].unsqueeze(0)
- protein_image = processed_images[1].unsqueeze(0)
- protein_image = protein_image/torch.max(protein_image)
-
- formatted_predicted_sequence = run_sequence_prediction(
- sequence_input=sequence_input,
- nucleus_image=nucleus_image,
- protein_image=protein_image,
- model=self.model,
- device=device,
- )
- print('test2')
- formatted_predicted_sequence = formatted_predicted_sequence[0]
- formatted_predicted_sequence = formatted_predicted_sequence.replace("","")
- formatted_predicted_sequence = formatted_predicted_sequence.replace("","")
- formatted_predicted_sequence = formatted_predicted_sequence.replace("","")
-
- formatted_predicted_sequence = bold_predicted_letters(sequence_input, formatted_predicted_sequence)
- formatted_predicted_sequence = diff_texts(formatted_predicted_sequence)
- return T.ToPILImage()(protein_image[0,0]), T.ToPILImage()(nucleus_image[0,0]), formatted_predicted_sequence
-
-base_class = model()
-
-with gr.Blocks(theme='gradio/soft') as demo:
- gr.Markdown("## Inputs")
- gr.Markdown("Select the prediction model. **Note the first run may take ~2-3 minutes, but will take 3-4 seconds afterwards.**")
- gr.Markdown(
- "- ```CELL-E_2_HPA_2560``` is a good general purpose model for various cell types using ICC-IF."
- )
- gr.Markdown(
- "- ```CELL-E_2_OpenCell_2560``` is trained on OpenCell and is good more live-cell predictions on HEK cells."
- )
- with gr.Row():
- model_name = gr.Dropdown(
- ["CELL-E_2_HPA_2560", "CELL-E_2_OpenCell_2560"],
- value="CELL-E_2_HPA_2560",
- label="Model Name",
- )
- with gr.Row():
- gr.Markdown(
- "Input the desired amino acid sequence. GFP is shown below by default. The sequence must include `````` for a prediction to be run."
- )
-
- with gr.Row():
- sequence_input = gr.Textbox(
- value="MSKGEELFTGVVPILVELDGDVNGHKFSVSGEGEGDATYGKLTLKFICTTGKLPVPWPTLVTTFSYGVQCFSRYPDHMKQHDFFKSAMPEGYVQERTIFFKDDGNYKTRAEVKFEGDTLVNRIELKGIDFKEDGNILGHKLEYNYNSHNVYIMADKQKNGIKVNFKIRHNIEDGSVQLADHYQQNTPIGDGPVLLPDNHYLSTQSALSKDPNEKRDHMVLLEFVTAAGITHGMDELYK",
- label="Sequence",
- )
- with gr.Row():
- gr.Markdown(
- "Uploading a nucleus image is necessary. A random crop of 256 x 256 will be applied if larger. We provide default images in [images](https://huggingface.co/spaces/HuangLab/CELL-E_2/tree/main/images). Draw the desired localization on top of the nucelus image."
- )
-
- with gr.Row(equal_height=True):
- #nucleus_image = gr.Image(
- # source="upload",
- # tool="color-sketch",
- # label="Nucleus Image",
- # interactive=True,
- # image_mode="RGBA",
- # type="pil"
- #)
- nucleus_image = gr.ImageMask(
- label = "Nucleus Image",
- interactive = "True",
- image_mode = "L",
- brush_color = "#ffffff",
- type = "pil"
- )
-
- with gr.Row():
- gr.Markdown("## Outputs")
-
- with gr.Row(equal_height=True):
- nucleus_crop = gr.Image(
- label="Nucleus Image (Crop)",
- image_mode="L",
- type="pil"
- )
-
- mask = gr.Image(
- label="Threshold Image",
- image_mode="L",
- type="pil"
- )
- with gr.Row():
- gr.Markdown("Sequence predictions are show below.")
-
- with gr.Row(equal_height=True):
- # predicted_sequence = gr.Markdown(label='Predicted Sequence')
- predicted_sequence = gr.HighlightedText(
- label="Predicted Sequence",
- combine_adjacent=True,
- show_legend=False,
- color_map={"+": "green"})
-
-
- with gr.Row():
- button = gr.Button("Run Model")
-
- inputs = [model_name, sequence_input, nucleus_image]
-
- outputs = [mask, nucleus_crop, predicted_sequence]
-
- button.click(base_class.gradio_demo, inputs, outputs)
-
-demo.queue(max_size=1).launch()
diff --git a/spaces/ICML2022/OFA/fairseq/examples/wav2vec/unsupervised/scripts/wer.py b/spaces/ICML2022/OFA/fairseq/examples/wav2vec/unsupervised/scripts/wer.py
deleted file mode 100644
index 613ab50d39019f6edf67c56c2353646be2a2f17d..0000000000000000000000000000000000000000
--- a/spaces/ICML2022/OFA/fairseq/examples/wav2vec/unsupervised/scripts/wer.py
+++ /dev/null
@@ -1,82 +0,0 @@
-#!/usr/bin/env python3 -u
-# 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.
-
-"""
-Implement unsupervised metric for decoding hyperparameter selection:
- $$ alpha * LM_PPL + ViterbitUER(%) * 100 $$
-"""
-import argparse
-import logging
-import sys
-
-import editdistance
-
-logging.root.setLevel(logging.INFO)
-logging.basicConfig(stream=sys.stdout, level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-
-def get_parser():
- parser = argparse.ArgumentParser()
- parser.add_argument("-s", "--hypo", help="hypo transcription", required=True)
- parser.add_argument(
- "-r", "--reference", help="reference transcription", required=True
- )
- return parser
-
-
-def compute_wer(ref_uid_to_tra, hyp_uid_to_tra, g2p):
- d_cnt = 0
- w_cnt = 0
- w_cnt_h = 0
- for uid in hyp_uid_to_tra:
- ref = ref_uid_to_tra[uid].split()
- if g2p is not None:
- hyp = g2p(hyp_uid_to_tra[uid])
- hyp = [p for p in hyp if p != "'" and p != " "]
- hyp = [p[:-1] if p[-1].isnumeric() else p for p in hyp]
- else:
- hyp = hyp_uid_to_tra[uid].split()
- d_cnt += editdistance.eval(ref, hyp)
- w_cnt += len(ref)
- w_cnt_h += len(hyp)
- wer = float(d_cnt) / w_cnt
- logger.debug(
- (
- f"wer = {wer * 100:.2f}%; num. of ref words = {w_cnt}; "
- f"num. of hyp words = {w_cnt_h}; num. of sentences = {len(ref_uid_to_tra)}"
- )
- )
- return wer
-
-
-def main():
- args = get_parser().parse_args()
-
- errs = 0
- count = 0
- with open(args.hypo, "r") as hf, open(args.reference, "r") as rf:
- for h, r in zip(hf, rf):
- h = h.rstrip().split()
- r = r.rstrip().split()
- errs += editdistance.eval(r, h)
- count += len(r)
-
- logger.info(f"UER: {errs / count * 100:.2f}%")
-
-
-if __name__ == "__main__":
- main()
-
-
-def load_tra(tra_path):
- with open(tra_path, "r") as f:
- uid_to_tra = {}
- for line in f:
- uid, tra = line.split(None, 1)
- uid_to_tra[uid] = tra
- logger.debug(f"loaded {len(uid_to_tra)} utterances from {tra_path}")
- return uid_to_tra
diff --git a/spaces/ICML2022/OFA/fairseq/fairseq/models/fconv.py b/spaces/ICML2022/OFA/fairseq/fairseq/models/fconv.py
deleted file mode 100644
index c99a2151014d816ec9aff6f4b27d71224dd7b4cf..0000000000000000000000000000000000000000
--- a/spaces/ICML2022/OFA/fairseq/fairseq/models/fconv.py
+++ /dev/null
@@ -1,756 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import math
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from fairseq import utils
-from fairseq.models import (
- FairseqEncoder,
- FairseqEncoderDecoderModel,
- FairseqIncrementalDecoder,
- register_model,
- register_model_architecture,
-)
-from fairseq.modules import (
- AdaptiveSoftmax,
- BeamableMM,
- FairseqDropout,
- GradMultiply,
- LearnedPositionalEmbedding,
- LinearizedConvolution,
-)
-
-
-@register_model("fconv")
-class FConvModel(FairseqEncoderDecoderModel):
- """
- A fully convolutional model, i.e. a convolutional encoder and a
- convolutional decoder, as described in `"Convolutional Sequence to Sequence
- Learning" (Gehring et al., 2017) `_.
-
- Args:
- encoder (FConvEncoder): the encoder
- decoder (FConvDecoder): the decoder
-
- The Convolutional model provides the following named architectures and
- command-line arguments:
-
- .. argparse::
- :ref: fairseq.models.fconv_parser
- :prog:
- """
-
- @classmethod
- def hub_models(cls):
- def moses_subword(path):
- return {
- "path": path,
- "tokenizer": "moses",
- "bpe": "subword_nmt",
- }
-
- return {
- "conv.wmt14.en-fr": moses_subword(
- "https://dl.fbaipublicfiles.com/fairseq/models/wmt14.v2.en-fr.fconv-py.tar.bz2"
- ),
- "conv.wmt14.en-de": moses_subword(
- "https://dl.fbaipublicfiles.com/fairseq/models/wmt14.en-de.fconv-py.tar.bz2"
- ),
- "conv.wmt17.en-de": moses_subword(
- "https://dl.fbaipublicfiles.com/fairseq/models/wmt17.v2.en-de.fconv-py.tar.bz2"
- ),
- }
-
- def __init__(self, encoder, decoder):
- super().__init__(encoder, decoder)
- self.encoder.num_attention_layers = sum(
- layer is not None for layer in decoder.attention
- )
-
- @staticmethod
- def add_args(parser):
- """Add model-specific arguments to the parser."""
- # fmt: off
- parser.add_argument('--dropout', type=float, metavar='D',
- help='dropout probability')
- parser.add_argument('--encoder-embed-dim', type=int, metavar='N',
- help='encoder embedding dimension')
- parser.add_argument('--encoder-embed-path', type=str, metavar='STR',
- help='path to pre-trained encoder embedding')
- parser.add_argument('--encoder-layers', type=str, metavar='EXPR',
- help='encoder layers [(dim, kernel_size), ...]')
- parser.add_argument('--decoder-embed-dim', type=int, metavar='N',
- help='decoder embedding dimension')
- parser.add_argument('--decoder-embed-path', type=str, metavar='STR',
- help='path to pre-trained decoder embedding')
- parser.add_argument('--decoder-layers', type=str, metavar='EXPR',
- help='decoder layers [(dim, kernel_size), ...]')
- parser.add_argument('--decoder-out-embed-dim', type=int, metavar='N',
- help='decoder output embedding dimension')
- parser.add_argument('--decoder-attention', type=str, metavar='EXPR',
- help='decoder attention [True, ...]')
- parser.add_argument('--share-input-output-embed', action='store_true',
- help='share input and output embeddings (requires'
- ' --decoder-out-embed-dim and --decoder-embed-dim'
- ' to be equal)')
- # fmt: on
-
- @classmethod
- def build_model(cls, args, task):
- """Build a new model instance."""
- # make sure that all args are properly defaulted (in case there are any new ones)
- base_architecture(args)
-
- encoder_embed_dict = None
- if args.encoder_embed_path:
- encoder_embed_dict = utils.parse_embedding(args.encoder_embed_path)
- utils.print_embed_overlap(encoder_embed_dict, task.source_dictionary)
-
- decoder_embed_dict = None
- if args.decoder_embed_path:
- decoder_embed_dict = utils.parse_embedding(args.decoder_embed_path)
- utils.print_embed_overlap(decoder_embed_dict, task.target_dictionary)
-
- encoder = FConvEncoder(
- dictionary=task.source_dictionary,
- embed_dim=args.encoder_embed_dim,
- embed_dict=encoder_embed_dict,
- convolutions=eval(args.encoder_layers),
- dropout=args.dropout,
- max_positions=args.max_source_positions,
- )
- decoder = FConvDecoder(
- dictionary=task.target_dictionary,
- embed_dim=args.decoder_embed_dim,
- embed_dict=decoder_embed_dict,
- convolutions=eval(args.decoder_layers),
- out_embed_dim=args.decoder_out_embed_dim,
- attention=eval(args.decoder_attention),
- dropout=args.dropout,
- max_positions=args.max_target_positions,
- share_embed=args.share_input_output_embed,
- )
- return FConvModel(encoder, decoder)
-
-
-class FConvEncoder(FairseqEncoder):
- """
- Convolutional encoder consisting of `len(convolutions)` layers.
-
- Args:
- dictionary (~fairseq.data.Dictionary): encoding dictionary
- embed_dim (int, optional): embedding dimension
- embed_dict (str, optional): filename from which to load pre-trained
- embeddings
- max_positions (int, optional): maximum supported input sequence length
- convolutions (list, optional): the convolutional layer structure. Each
- list item `i` corresponds to convolutional layer `i`. Layers are
- given as ``(out_channels, kernel_width, [residual])``. Residual
- connections are added between layers when ``residual=1`` (which is
- the default behavior).
- dropout (float, optional): dropout to be applied before each conv layer
- """
-
- def __init__(
- self,
- dictionary,
- embed_dim=512,
- embed_dict=None,
- max_positions=1024,
- convolutions=((512, 3),) * 20,
- dropout=0.1,
- ):
- super().__init__(dictionary)
- self.dropout_module = FairseqDropout(
- dropout, module_name=self.__class__.__name__
- )
- self.num_attention_layers = None
-
- num_embeddings = len(dictionary)
- self.padding_idx = dictionary.pad()
- self.embed_tokens = Embedding(num_embeddings, embed_dim, self.padding_idx)
- if embed_dict:
- self.embed_tokens = utils.load_embedding(
- embed_dict, self.dictionary, self.embed_tokens
- )
-
- self.embed_positions = PositionalEmbedding(
- max_positions,
- embed_dim,
- self.padding_idx,
- )
-
- convolutions = extend_conv_spec(convolutions)
- in_channels = convolutions[0][0]
- self.fc1 = Linear(embed_dim, in_channels, dropout=dropout)
- self.projections = nn.ModuleList()
- self.convolutions = nn.ModuleList()
- self.residuals = []
-
- layer_in_channels = [in_channels]
- for _, (out_channels, kernel_size, residual) in enumerate(convolutions):
- if residual == 0:
- residual_dim = out_channels
- else:
- residual_dim = layer_in_channels[-residual]
- self.projections.append(
- Linear(residual_dim, out_channels)
- if residual_dim != out_channels
- else None
- )
- if kernel_size % 2 == 1:
- padding = kernel_size // 2
- else:
- padding = 0
- self.convolutions.append(
- ConvTBC(
- in_channels,
- out_channels * 2,
- kernel_size,
- dropout=dropout,
- padding=padding,
- )
- )
- self.residuals.append(residual)
- in_channels = out_channels
- layer_in_channels.append(out_channels)
- self.fc2 = Linear(in_channels, embed_dim)
-
- def forward(self, src_tokens, src_lengths):
- """
- Args:
- src_tokens (LongTensor): tokens in the source language of shape
- `(batch, src_len)`
- src_lengths (LongTensor): lengths of each source sentence of shape
- `(batch)`
-
- Returns:
- dict:
- - **encoder_out** (tuple): a tuple with two elements, where the
- first element is the last encoder layer's output and the
- second element is the same quantity summed with the input
- embedding (used for attention). The shape of both tensors is
- `(batch, src_len, embed_dim)`.
- - **encoder_padding_mask** (ByteTensor): the positions of
- padding elements of shape `(batch, src_len)`
- """
- # embed tokens and positions
- x = self.embed_tokens(src_tokens) + self.embed_positions(src_tokens)
- x = self.dropout_module(x)
- input_embedding = x
-
- # project to size of convolution
- x = self.fc1(x)
-
- # used to mask padding in input
- encoder_padding_mask = src_tokens.eq(self.padding_idx).t() # -> T x B
- if not encoder_padding_mask.any():
- encoder_padding_mask = None
-
- # B x T x C -> T x B x C
- x = x.transpose(0, 1)
-
- residuals = [x]
- # temporal convolutions
- for proj, conv, res_layer in zip(
- self.projections, self.convolutions, self.residuals
- ):
- if res_layer > 0:
- residual = residuals[-res_layer]
- residual = residual if proj is None else proj(residual)
- else:
- residual = None
-
- if encoder_padding_mask is not None:
- x = x.masked_fill(encoder_padding_mask.unsqueeze(-1), 0)
-
- x = self.dropout_module(x)
- if conv.kernel_size[0] % 2 == 1:
- # padding is implicit in the conv
- x = conv(x)
- else:
- padding_l = (conv.kernel_size[0] - 1) // 2
- padding_r = conv.kernel_size[0] // 2
- x = F.pad(x, (0, 0, 0, 0, padding_l, padding_r))
- x = conv(x)
- x = F.glu(x, dim=2)
-
- if residual is not None:
- x = (x + residual) * math.sqrt(0.5)
- residuals.append(x)
-
- # T x B x C -> B x T x C
- x = x.transpose(1, 0)
-
- # project back to size of embedding
- x = self.fc2(x)
-
- if encoder_padding_mask is not None:
- encoder_padding_mask = encoder_padding_mask.t() # -> B x T
- x = x.masked_fill(encoder_padding_mask.unsqueeze(-1), 0)
-
- # scale gradients (this only affects backward, not forward)
- x = GradMultiply.apply(x, 1.0 / (2.0 * self.num_attention_layers))
-
- # add output to input embedding for attention
- y = (x + input_embedding) * math.sqrt(0.5)
-
- return {
- "encoder_out": (x, y),
- "encoder_padding_mask": encoder_padding_mask, # B x T
- }
-
- def reorder_encoder_out(self, encoder_out, new_order):
- if encoder_out["encoder_out"] is not None:
- encoder_out["encoder_out"] = (
- encoder_out["encoder_out"][0].index_select(0, new_order),
- encoder_out["encoder_out"][1].index_select(0, new_order),
- )
- if encoder_out["encoder_padding_mask"] is not None:
- encoder_out["encoder_padding_mask"] = encoder_out[
- "encoder_padding_mask"
- ].index_select(0, new_order)
- return encoder_out
-
- def max_positions(self):
- """Maximum input length supported by the encoder."""
- return self.embed_positions.max_positions
-
-
-class AttentionLayer(nn.Module):
- def __init__(self, conv_channels, embed_dim, bmm=None):
- super().__init__()
- # projects from output of convolution to embedding dimension
- self.in_projection = Linear(conv_channels, embed_dim)
- # projects from embedding dimension to convolution size
- self.out_projection = Linear(embed_dim, conv_channels)
-
- self.bmm = bmm if bmm is not None else torch.bmm
-
- def forward(self, x, target_embedding, encoder_out, encoder_padding_mask):
- residual = x
-
- # attention
- x = (self.in_projection(x) + target_embedding) * math.sqrt(0.5)
- x = self.bmm(x, encoder_out[0])
-
- # don't attend over padding
- if encoder_padding_mask is not None:
- x = (
- x.float()
- .masked_fill(encoder_padding_mask.unsqueeze(1), float("-inf"))
- .type_as(x)
- ) # FP16 support: cast to float and back
-
- # softmax over last dim
- sz = x.size()
- x = F.softmax(x.view(sz[0] * sz[1], sz[2]), dim=1)
- x = x.view(sz)
- attn_scores = x
-
- x = self.bmm(x, encoder_out[1])
-
- # scale attention output (respecting potentially different lengths)
- s = encoder_out[1].size(1)
- if encoder_padding_mask is None:
- x = x * (s * math.sqrt(1.0 / s))
- else:
- s = s - encoder_padding_mask.type_as(x).sum(
- dim=1, keepdim=True
- ) # exclude padding
- s = s.unsqueeze(-1)
- x = x * (s * s.rsqrt())
-
- # project back
- x = (self.out_projection(x) + residual) * math.sqrt(0.5)
- return x, attn_scores
-
- def make_generation_fast_(self, beamable_mm_beam_size=None, **kwargs):
- """Replace torch.bmm with BeamableMM."""
- if beamable_mm_beam_size is not None:
- del self.bmm
- self.add_module("bmm", BeamableMM(beamable_mm_beam_size))
-
-
-class FConvDecoder(FairseqIncrementalDecoder):
- """Convolutional decoder"""
-
- def __init__(
- self,
- dictionary,
- embed_dim=512,
- embed_dict=None,
- out_embed_dim=256,
- max_positions=1024,
- convolutions=((512, 3),) * 20,
- attention=True,
- dropout=0.1,
- share_embed=False,
- positional_embeddings=True,
- adaptive_softmax_cutoff=None,
- adaptive_softmax_dropout=0.0,
- ):
- super().__init__(dictionary)
- self.register_buffer("version", torch.Tensor([2]))
- self.dropout_module = FairseqDropout(
- dropout, module_name=self.__class__.__name__
- )
- self.need_attn = True
-
- convolutions = extend_conv_spec(convolutions)
- in_channels = convolutions[0][0]
- if isinstance(attention, bool):
- # expand True into [True, True, ...] and do the same with False
- attention = [attention] * len(convolutions)
- if not isinstance(attention, list) or len(attention) != len(convolutions):
- raise ValueError(
- "Attention is expected to be a list of booleans of "
- "length equal to the number of layers."
- )
-
- num_embeddings = len(dictionary)
- padding_idx = dictionary.pad()
- self.embed_tokens = Embedding(num_embeddings, embed_dim, padding_idx)
- if embed_dict:
- self.embed_tokens = utils.load_embedding(
- embed_dict, self.dictionary, self.embed_tokens
- )
-
- self.embed_positions = (
- PositionalEmbedding(
- max_positions,
- embed_dim,
- padding_idx,
- )
- if positional_embeddings
- else None
- )
-
- self.fc1 = Linear(embed_dim, in_channels, dropout=dropout)
- self.projections = nn.ModuleList()
- self.convolutions = nn.ModuleList()
- self.attention = nn.ModuleList()
- self.residuals = []
-
- layer_in_channels = [in_channels]
- for i, (out_channels, kernel_size, residual) in enumerate(convolutions):
- if residual == 0:
- residual_dim = out_channels
- else:
- residual_dim = layer_in_channels[-residual]
- self.projections.append(
- Linear(residual_dim, out_channels)
- if residual_dim != out_channels
- else None
- )
- self.convolutions.append(
- LinearizedConv1d(
- in_channels,
- out_channels * 2,
- kernel_size,
- padding=(kernel_size - 1),
- dropout=dropout,
- )
- )
- self.attention.append(
- AttentionLayer(out_channels, embed_dim) if attention[i] else None
- )
- self.residuals.append(residual)
- in_channels = out_channels
- layer_in_channels.append(out_channels)
-
- self.adaptive_softmax = None
- self.fc2 = self.fc3 = None
-
- if adaptive_softmax_cutoff is not None:
- assert not share_embed
- self.adaptive_softmax = AdaptiveSoftmax(
- num_embeddings,
- in_channels,
- adaptive_softmax_cutoff,
- dropout=adaptive_softmax_dropout,
- )
- else:
- self.fc2 = Linear(in_channels, out_embed_dim)
- if share_embed:
- assert out_embed_dim == embed_dim, (
- "Shared embed weights implies same dimensions "
- " out_embed_dim={} vs embed_dim={}".format(out_embed_dim, embed_dim)
- )
- self.fc3 = nn.Linear(out_embed_dim, num_embeddings)
- self.fc3.weight = self.embed_tokens.weight
- else:
- self.fc3 = Linear(out_embed_dim, num_embeddings, dropout=dropout)
-
- def forward(
- self, prev_output_tokens, encoder_out=None, incremental_state=None, **unused
- ):
- if encoder_out is not None:
- encoder_padding_mask = encoder_out["encoder_padding_mask"]
- encoder_out = encoder_out["encoder_out"]
-
- # split and transpose encoder outputs
- encoder_a, encoder_b = self._split_encoder_out(
- encoder_out, incremental_state
- )
-
- if self.embed_positions is not None:
- pos_embed = self.embed_positions(prev_output_tokens, incremental_state)
- else:
- pos_embed = 0
-
- if incremental_state is not None:
- prev_output_tokens = prev_output_tokens[:, -1:]
- x = self._embed_tokens(prev_output_tokens, incremental_state)
-
- # embed tokens and combine with positional embeddings
- x += pos_embed
- x = self.dropout_module(x)
- target_embedding = x
-
- # project to size of convolution
- x = self.fc1(x)
-
- # B x T x C -> T x B x C
- x = self._transpose_if_training(x, incremental_state)
-
- # temporal convolutions
- avg_attn_scores = None
- num_attn_layers = len(self.attention)
- residuals = [x]
- for proj, conv, attention, res_layer in zip(
- self.projections, self.convolutions, self.attention, self.residuals
- ):
- if res_layer > 0:
- residual = residuals[-res_layer]
- residual = residual if proj is None else proj(residual)
- else:
- residual = None
-
- x = self.dropout_module(x)
- x = conv(x, incremental_state)
- x = F.glu(x, dim=2)
-
- # attention
- if attention is not None:
- x = self._transpose_if_training(x, incremental_state)
-
- x, attn_scores = attention(
- x, target_embedding, (encoder_a, encoder_b), encoder_padding_mask
- )
-
- if not self.training and self.need_attn:
- attn_scores = attn_scores / num_attn_layers
- if avg_attn_scores is None:
- avg_attn_scores = attn_scores
- else:
- avg_attn_scores.add_(attn_scores)
-
- x = self._transpose_if_training(x, incremental_state)
-
- # residual
- if residual is not None:
- x = (x + residual) * math.sqrt(0.5)
- residuals.append(x)
-
- # T x B x C -> B x T x C
- x = self._transpose_if_training(x, incremental_state)
-
- # project back to size of vocabulary if not using adaptive softmax
- if self.fc2 is not None and self.fc3 is not None:
- x = self.fc2(x)
- x = self.dropout_module(x)
- x = self.fc3(x)
-
- return x, avg_attn_scores
-
- def reorder_incremental_state(self, incremental_state, new_order):
- super().reorder_incremental_state(incremental_state, new_order)
- encoder_out = utils.get_incremental_state(
- self, incremental_state, "encoder_out"
- )
- if encoder_out is not None:
- encoder_out = tuple(eo.index_select(0, new_order) for eo in encoder_out)
- utils.set_incremental_state(
- self, incremental_state, "encoder_out", encoder_out
- )
-
- def max_positions(self):
- """Maximum output length supported by the decoder."""
- return (
- self.embed_positions.max_positions
- if self.embed_positions is not None
- else float("inf")
- )
-
- def upgrade_state_dict(self, state_dict):
- if utils.item(state_dict.get("decoder.version", torch.Tensor([1]))[0]) < 2:
- # old models use incorrect weight norm dimension
- for i, conv in enumerate(self.convolutions):
- # reconfigure weight norm
- nn.utils.remove_weight_norm(conv)
- self.convolutions[i] = nn.utils.weight_norm(conv, dim=0)
- state_dict["decoder.version"] = torch.Tensor([1])
- return state_dict
-
- def make_generation_fast_(self, need_attn=False, **kwargs):
- self.need_attn = need_attn
-
- def _embed_tokens(self, tokens, incremental_state):
- if incremental_state is not None:
- # keep only the last token for incremental forward pass
- tokens = tokens[:, -1:]
- return self.embed_tokens(tokens)
-
- def _split_encoder_out(self, encoder_out, incremental_state):
- """Split and transpose encoder outputs.
-
- This is cached when doing incremental inference.
- """
- cached_result = utils.get_incremental_state(
- self, incremental_state, "encoder_out"
- )
- if cached_result is not None:
- return cached_result
-
- # transpose only once to speed up attention layers
- encoder_a, encoder_b = encoder_out
- encoder_a = encoder_a.transpose(1, 2).contiguous()
- result = (encoder_a, encoder_b)
-
- if incremental_state is not None:
- utils.set_incremental_state(self, incremental_state, "encoder_out", result)
- return result
-
- def _transpose_if_training(self, x, incremental_state):
- if incremental_state is None:
- x = x.transpose(0, 1)
- return x
-
-
-def extend_conv_spec(convolutions):
- """
- Extends convolutional spec that is a list of tuples of 2 or 3 parameters
- (kernel size, dim size and optionally how many layers behind to look for residual)
- to default the residual propagation param if it is not specified
- """
- extended = []
- for spec in convolutions:
- if len(spec) == 3:
- extended.append(spec)
- elif len(spec) == 2:
- extended.append(spec + (1,))
- else:
- raise Exception(
- "invalid number of parameters in convolution spec "
- + str(spec)
- + ". expected 2 or 3"
- )
- return tuple(extended)
-
-
-def Embedding(num_embeddings, embedding_dim, padding_idx):
- m = nn.Embedding(num_embeddings, embedding_dim, padding_idx=padding_idx)
- nn.init.normal_(m.weight, 0, 0.1)
- nn.init.constant_(m.weight[padding_idx], 0)
- return m
-
-
-def PositionalEmbedding(num_embeddings, embedding_dim, padding_idx):
- m = LearnedPositionalEmbedding(num_embeddings, embedding_dim, padding_idx)
- nn.init.normal_(m.weight, 0, 0.1)
- nn.init.constant_(m.weight[padding_idx], 0)
- return m
-
-
-def Linear(in_features, out_features, dropout=0.0):
- """Weight-normalized Linear layer (input: N x T x C)"""
- m = nn.Linear(in_features, out_features)
- nn.init.normal_(m.weight, mean=0, std=math.sqrt((1 - dropout) / in_features))
- nn.init.constant_(m.bias, 0)
- return nn.utils.weight_norm(m)
-
-
-def LinearizedConv1d(in_channels, out_channels, kernel_size, dropout=0.0, **kwargs):
- """Weight-normalized Conv1d layer optimized for decoding"""
- m = LinearizedConvolution(in_channels, out_channels, kernel_size, **kwargs)
- std = math.sqrt((4 * (1.0 - dropout)) / (m.kernel_size[0] * in_channels))
- nn.init.normal_(m.weight, mean=0, std=std)
- nn.init.constant_(m.bias, 0)
- return nn.utils.weight_norm(m, dim=2)
-
-
-def ConvTBC(in_channels, out_channels, kernel_size, dropout=0.0, **kwargs):
- """Weight-normalized Conv1d layer"""
- from fairseq.modules import ConvTBC
-
- m = ConvTBC(in_channels, out_channels, kernel_size, **kwargs)
- std = math.sqrt((4 * (1.0 - dropout)) / (m.kernel_size[0] * in_channels))
- nn.init.normal_(m.weight, mean=0, std=std)
- nn.init.constant_(m.bias, 0)
- return nn.utils.weight_norm(m, dim=2)
-
-
-@register_model_architecture("fconv", "fconv")
-def base_architecture(args):
- args.dropout = getattr(args, "dropout", 0.1)
- args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 512)
- args.encoder_embed_path = getattr(args, "encoder_embed_path", None)
- args.encoder_layers = getattr(args, "encoder_layers", "[(512, 3)] * 20")
- args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 512)
- args.decoder_embed_path = getattr(args, "decoder_embed_path", None)
- args.decoder_layers = getattr(args, "decoder_layers", "[(512, 3)] * 20")
- args.decoder_out_embed_dim = getattr(args, "decoder_out_embed_dim", 256)
- args.decoder_attention = getattr(args, "decoder_attention", "True")
- args.share_input_output_embed = getattr(args, "share_input_output_embed", False)
-
-
-@register_model_architecture("fconv", "fconv_iwslt_de_en")
-def fconv_iwslt_de_en(args):
- args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 256)
- args.encoder_layers = getattr(args, "encoder_layers", "[(256, 3)] * 4")
- args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 256)
- args.decoder_layers = getattr(args, "decoder_layers", "[(256, 3)] * 3")
- args.decoder_out_embed_dim = getattr(args, "decoder_out_embed_dim", 256)
- base_architecture(args)
-
-
-@register_model_architecture("fconv", "fconv_wmt_en_ro")
-def fconv_wmt_en_ro(args):
- args.decoder_out_embed_dim = getattr(args, "decoder_out_embed_dim", 512)
- base_architecture(args)
-
-
-@register_model_architecture("fconv", "fconv_wmt_en_de")
-def fconv_wmt_en_de(args):
- convs = "[(512, 3)] * 9" # first 9 layers have 512 units
- convs += " + [(1024, 3)] * 4" # next 4 layers have 1024 units
- convs += " + [(2048, 1)] * 2" # final 2 layers use 1x1 convolutions
-
- args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 768)
- args.encoder_layers = getattr(args, "encoder_layers", convs)
- args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 768)
- args.decoder_layers = getattr(args, "decoder_layers", convs)
- args.decoder_out_embed_dim = getattr(args, "decoder_out_embed_dim", 512)
- base_architecture(args)
-
-
-@register_model_architecture("fconv", "fconv_wmt_en_fr")
-def fconv_wmt_en_fr(args):
- convs = "[(512, 3)] * 6" # first 6 layers have 512 units
- convs += " + [(768, 3)] * 4" # next 4 layers have 768 units
- convs += " + [(1024, 3)] * 3" # next 3 layers have 1024 units
- convs += " + [(2048, 1)] * 1" # next 1 layer uses 1x1 convolutions
- convs += " + [(4096, 1)] * 1" # final 1 layer uses 1x1 convolutions
-
- args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 768)
- args.encoder_layers = getattr(args, "encoder_layers", convs)
- args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 768)
- args.decoder_layers = getattr(args, "decoder_layers", convs)
- args.decoder_out_embed_dim = getattr(args, "decoder_out_embed_dim", 512)
- base_architecture(args)
diff --git a/spaces/ICML2022/resefa/models/__init__.py b/spaces/ICML2022/resefa/models/__init__.py
deleted file mode 100644
index 51eeba1c1a5f08d9af654c806421ec788c8d5377..0000000000000000000000000000000000000000
--- a/spaces/ICML2022/resefa/models/__init__.py
+++ /dev/null
@@ -1,45 +0,0 @@
-# python3.7
-"""Collects all models."""
-
-from .pggan_generator import PGGANGenerator
-from .pggan_discriminator import PGGANDiscriminator
-from .stylegan_generator import StyleGANGenerator
-from .stylegan_discriminator import StyleGANDiscriminator
-from .stylegan2_generator import StyleGAN2Generator
-from .stylegan2_discriminator import StyleGAN2Discriminator
-from .stylegan3_generator import StyleGAN3Generator
-from .ghfeat_encoder import GHFeatEncoder
-from .perceptual_model import PerceptualModel
-from .inception_model import InceptionModel
-
-__all__ = ['build_model']
-
-_MODELS = {
- 'PGGANGenerator': PGGANGenerator,
- 'PGGANDiscriminator': PGGANDiscriminator,
- 'StyleGANGenerator': StyleGANGenerator,
- 'StyleGANDiscriminator': StyleGANDiscriminator,
- 'StyleGAN2Generator': StyleGAN2Generator,
- 'StyleGAN2Discriminator': StyleGAN2Discriminator,
- 'StyleGAN3Generator': StyleGAN3Generator,
- 'GHFeatEncoder': GHFeatEncoder,
- 'PerceptualModel': PerceptualModel.build_model,
- 'InceptionModel': InceptionModel.build_model
-}
-
-
-def build_model(model_type, **kwargs):
- """Builds a model based on its class type.
-
- Args:
- model_type: Class type to which the model belongs, which is case
- sensitive.
- **kwargs: Additional arguments to build the model.
-
- Raises:
- ValueError: If the `model_type` is not supported.
- """
- if model_type not in _MODELS:
- raise ValueError(f'Invalid model type: `{model_type}`!\n'
- f'Types allowed: {list(_MODELS)}.')
- return _MODELS[model_type](**kwargs)
diff --git a/spaces/IVentureISB/Gen-AI/README.md b/spaces/IVentureISB/Gen-AI/README.md
deleted file mode 100644
index 1d10f8597b74dea931d68e5fa77a5e9730f3653c..0000000000000000000000000000000000000000
--- a/spaces/IVentureISB/Gen-AI/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Gen AI
-emoji: 🏆
-colorFrom: indigo
-colorTo: gray
-sdk: gradio
-sdk_version: 3.37.0
-app_file: app.py
-pinned: false
-python_version: 3.9.13
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/Iceclear/StableSR/StableSR/basicsr/utils/flow_util.py b/spaces/Iceclear/StableSR/StableSR/basicsr/utils/flow_util.py
deleted file mode 100644
index 3d7180b4e9b5c8f2eb36a9a0e4ff6affdaae84b8..0000000000000000000000000000000000000000
--- a/spaces/Iceclear/StableSR/StableSR/basicsr/utils/flow_util.py
+++ /dev/null
@@ -1,170 +0,0 @@
-# Modified from https://github.com/open-mmlab/mmcv/blob/master/mmcv/video/optflow.py # noqa: E501
-import cv2
-import numpy as np
-import os
-
-
-def flowread(flow_path, quantize=False, concat_axis=0, *args, **kwargs):
- """Read an optical flow map.
-
- Args:
- flow_path (ndarray or str): Flow path.
- quantize (bool): whether to read quantized pair, if set to True,
- remaining args will be passed to :func:`dequantize_flow`.
- concat_axis (int): The axis that dx and dy are concatenated,
- can be either 0 or 1. Ignored if quantize is False.
-
- Returns:
- ndarray: Optical flow represented as a (h, w, 2) numpy array
- """
- if quantize:
- assert concat_axis in [0, 1]
- cat_flow = cv2.imread(flow_path, cv2.IMREAD_UNCHANGED)
- if cat_flow.ndim != 2:
- raise IOError(f'{flow_path} is not a valid quantized flow file, its dimension is {cat_flow.ndim}.')
- assert cat_flow.shape[concat_axis] % 2 == 0
- dx, dy = np.split(cat_flow, 2, axis=concat_axis)
- flow = dequantize_flow(dx, dy, *args, **kwargs)
- else:
- with open(flow_path, 'rb') as f:
- try:
- header = f.read(4).decode('utf-8')
- except Exception:
- raise IOError(f'Invalid flow file: {flow_path}')
- else:
- if header != 'PIEH':
- raise IOError(f'Invalid flow file: {flow_path}, header does not contain PIEH')
-
- w = np.fromfile(f, np.int32, 1).squeeze()
- h = np.fromfile(f, np.int32, 1).squeeze()
- flow = np.fromfile(f, np.float32, w * h * 2).reshape((h, w, 2))
-
- return flow.astype(np.float32)
-
-
-def flowwrite(flow, filename, quantize=False, concat_axis=0, *args, **kwargs):
- """Write optical flow to file.
-
- If the flow is not quantized, it will be saved as a .flo file losslessly,
- otherwise a jpeg image which is lossy but of much smaller size. (dx and dy
- will be concatenated horizontally into a single image if quantize is True.)
-
- Args:
- flow (ndarray): (h, w, 2) array of optical flow.
- filename (str): Output filepath.
- quantize (bool): Whether to quantize the flow and save it to 2 jpeg
- images. If set to True, remaining args will be passed to
- :func:`quantize_flow`.
- concat_axis (int): The axis that dx and dy are concatenated,
- can be either 0 or 1. Ignored if quantize is False.
- """
- if not quantize:
- with open(filename, 'wb') as f:
- f.write('PIEH'.encode('utf-8'))
- np.array([flow.shape[1], flow.shape[0]], dtype=np.int32).tofile(f)
- flow = flow.astype(np.float32)
- flow.tofile(f)
- f.flush()
- else:
- assert concat_axis in [0, 1]
- dx, dy = quantize_flow(flow, *args, **kwargs)
- dxdy = np.concatenate((dx, dy), axis=concat_axis)
- os.makedirs(os.path.dirname(filename), exist_ok=True)
- cv2.imwrite(filename, dxdy)
-
-
-def quantize_flow(flow, max_val=0.02, norm=True):
- """Quantize flow to [0, 255].
-
- After this step, the size of flow will be much smaller, and can be
- dumped as jpeg images.
-
- Args:
- flow (ndarray): (h, w, 2) array of optical flow.
- max_val (float): Maximum value of flow, values beyond
- [-max_val, max_val] will be truncated.
- norm (bool): Whether to divide flow values by image width/height.
-
- Returns:
- tuple[ndarray]: Quantized dx and dy.
- """
- h, w, _ = flow.shape
- dx = flow[..., 0]
- dy = flow[..., 1]
- if norm:
- dx = dx / w # avoid inplace operations
- dy = dy / h
- # use 255 levels instead of 256 to make sure 0 is 0 after dequantization.
- flow_comps = [quantize(d, -max_val, max_val, 255, np.uint8) for d in [dx, dy]]
- return tuple(flow_comps)
-
-
-def dequantize_flow(dx, dy, max_val=0.02, denorm=True):
- """Recover from quantized flow.
-
- Args:
- dx (ndarray): Quantized dx.
- dy (ndarray): Quantized dy.
- max_val (float): Maximum value used when quantizing.
- denorm (bool): Whether to multiply flow values with width/height.
-
- Returns:
- ndarray: Dequantized flow.
- """
- assert dx.shape == dy.shape
- assert dx.ndim == 2 or (dx.ndim == 3 and dx.shape[-1] == 1)
-
- dx, dy = [dequantize(d, -max_val, max_val, 255) for d in [dx, dy]]
-
- if denorm:
- dx *= dx.shape[1]
- dy *= dx.shape[0]
- flow = np.dstack((dx, dy))
- return flow
-
-
-def quantize(arr, min_val, max_val, levels, dtype=np.int64):
- """Quantize an array of (-inf, inf) to [0, levels-1].
-
- Args:
- arr (ndarray): Input array.
- min_val (scalar): Minimum value to be clipped.
- max_val (scalar): Maximum value to be clipped.
- levels (int): Quantization levels.
- dtype (np.type): The type of the quantized array.
-
- Returns:
- tuple: Quantized array.
- """
- if not (isinstance(levels, int) and levels > 1):
- raise ValueError(f'levels must be a positive integer, but got {levels}')
- if min_val >= max_val:
- raise ValueError(f'min_val ({min_val}) must be smaller than max_val ({max_val})')
-
- arr = np.clip(arr, min_val, max_val) - min_val
- quantized_arr = np.minimum(np.floor(levels * arr / (max_val - min_val)).astype(dtype), levels - 1)
-
- return quantized_arr
-
-
-def dequantize(arr, min_val, max_val, levels, dtype=np.float64):
- """Dequantize an array.
-
- Args:
- arr (ndarray): Input array.
- min_val (scalar): Minimum value to be clipped.
- max_val (scalar): Maximum value to be clipped.
- levels (int): Quantization levels.
- dtype (np.type): The type of the dequantized array.
-
- Returns:
- tuple: Dequantized array.
- """
- if not (isinstance(levels, int) and levels > 1):
- raise ValueError(f'levels must be a positive integer, but got {levels}')
- if min_val >= max_val:
- raise ValueError(f'min_val ({min_val}) must be smaller than max_val ({max_val})')
-
- dequantized_arr = (arr + 0.5).astype(dtype) * (max_val - min_val) / levels + min_val
-
- return dequantized_arr
diff --git a/spaces/Imran1/Flower-image-classification/app.py b/spaces/Imran1/Flower-image-classification/app.py
deleted file mode 100644
index cc528a34534c7f0c5a7d7de036985081f5c0de0e..0000000000000000000000000000000000000000
--- a/spaces/Imran1/Flower-image-classification/app.py
+++ /dev/null
@@ -1,91 +0,0 @@
-import numpy as np
-import gradio as gr
-import os
-import PIL
-import PIL.Image
-import tensorflow as tf
-import tensorflow_datasets as tfds
-
-import pathlib
-dataset_url = "https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz"
-data_dir = tf.keras.utils.get_file(origin=dataset_url,
- fname='flower_photos',
- untar=True)
-data_dir = pathlib.Path(data_dir)
-batch_size = 32
-img_height = 180
-img_width = 180
-
-train_ds = tf.keras.utils.image_dataset_from_directory(
- data_dir,
- validation_split=0.2,
- subset="training",
- seed=123,
- image_size=(img_height, img_width),
- batch_size=batch_size)
-val_ds = tf.keras.utils.image_dataset_from_directory(
- data_dir,
- validation_split=0.2,
- subset="validation",
- seed=123,
- image_size=(img_height, img_width),
- batch_size=batch_size)
-
-class_names = train_ds.class_names
-#print(class_names)
-
-normalization_layer = tf.keras.layers.Rescaling(1./255)
-normalized_ds = train_ds.map(lambda x, y: (normalization_layer(x), y))
-image_batch, labels_batch = next(iter(normalized_ds))
-first_image = image_batch[0]
-# Notice the pixel values are now in `[0,1]`.
-#print(np.min(first_image), np.max(first_image))
-
-AUTOTUNE = tf.data.AUTOTUNE
-
-train_ds = train_ds.cache().prefetch(buffer_size=AUTOTUNE)
-val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)
-
-num_classes = 5
-
-model = tf.keras.Sequential([
- tf.keras.layers.Rescaling(1./255),
- tf.keras.layers.Conv2D(32, 3, activation='relu'),
- tf.keras.layers.MaxPooling2D(),
- tf.keras.layers.Dropout(0.4),
- tf.keras.layers.Conv2D(32, 3, activation='relu'),
- tf.keras.layers.MaxPooling2D(),
- tf.keras.layers.Dropout(0.4),
- tf.keras.layers.Conv2D(32, 3, activation='relu'),
- tf.keras.layers.MaxPooling2D(),
- tf.keras.layers.Flatten(),
- tf.keras.layers.Dense(256, activation='relu'),
- tf.keras.layers.Dense(num_classes, activation="softmax")
-])
-model.compile(
- optimizer='adam',
- loss='SparseCategoricalCrossentropy',
- metrics=['accuracy'])
-
-model.fit(
- train_ds,
- validation_data=val_ds,
- epochs=5
-)
-
-def predict_input_image(img):
- img_4d=img.reshape(-1,180,180,3)
- prediction=model.predict(img_4d)[0]
-
- return {class_names[i]: float(prediction[i]*0.100) for i in range(5)}
-
-
-
-
-
-
-image = gr.inputs.Image(shape=(180,180))
-label =gr.outputs.Label(num_top_classes=5)
-
-gr.Interface(fn=predict_input_image, inputs=image, outputs=label,title="Flowers Image Classification").launch()
-#pt
\ No newline at end of file
diff --git a/spaces/InpaintAI/Inpaint-Anything/third_party/lama/saicinpainting/evaluation/vis.py b/spaces/InpaintAI/Inpaint-Anything/third_party/lama/saicinpainting/evaluation/vis.py
deleted file mode 100644
index c2910b4ef8c61efee72dabd0531a9b669ec8bf98..0000000000000000000000000000000000000000
--- a/spaces/InpaintAI/Inpaint-Anything/third_party/lama/saicinpainting/evaluation/vis.py
+++ /dev/null
@@ -1,37 +0,0 @@
-import numpy as np
-from skimage import io
-from skimage.segmentation import mark_boundaries
-
-
-def save_item_for_vis(item, out_file):
- mask = item['mask'] > 0.5
- if mask.ndim == 3:
- mask = mask[0]
- img = mark_boundaries(np.transpose(item['image'], (1, 2, 0)),
- mask,
- color=(1., 0., 0.),
- outline_color=(1., 1., 1.),
- mode='thick')
-
- if 'inpainted' in item:
- inp_img = mark_boundaries(np.transpose(item['inpainted'], (1, 2, 0)),
- mask,
- color=(1., 0., 0.),
- mode='outer')
- img = np.concatenate((img, inp_img), axis=1)
-
- img = np.clip(img * 255, 0, 255).astype('uint8')
- io.imsave(out_file, img)
-
-
-def save_mask_for_sidebyside(item, out_file):
- mask = item['mask']# > 0.5
- if mask.ndim == 3:
- mask = mask[0]
- mask = np.clip(mask * 255, 0, 255).astype('uint8')
- io.imsave(out_file, mask)
-
-def save_img_for_sidebyside(item, out_file):
- img = np.transpose(item['image'], (1, 2, 0))
- img = np.clip(img * 255, 0, 255).astype('uint8')
- io.imsave(out_file, img)
\ No newline at end of file
diff --git a/spaces/Jamkonams/AutoGPT/autogpt/processing/text.py b/spaces/Jamkonams/AutoGPT/autogpt/processing/text.py
deleted file mode 100644
index 52add81401775c1b111512d8149f86a175fd9acb..0000000000000000000000000000000000000000
--- a/spaces/Jamkonams/AutoGPT/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/Jeff2323/ai-comic-factory/src/app/interface/panel/bubble.tsx b/spaces/Jeff2323/ai-comic-factory/src/app/interface/panel/bubble.tsx
deleted file mode 100644
index dad1498e68f6ba79b2fec29fe528657b80b09098..0000000000000000000000000000000000000000
--- a/spaces/Jeff2323/ai-comic-factory/src/app/interface/panel/bubble.tsx
+++ /dev/null
@@ -1,45 +0,0 @@
-import { ReactNode } from "react"
-
-import { cn } from "@/lib/utils"
-
-export function Bubble({
- children,
- className
-}: {
- children?: ReactNode
- className?: string
-}) {
-
- if (!children) {
- return null
- }
-
- return (
-
-
-
- {children}
-
-
-
- )
-}
\ No newline at end of file
diff --git a/spaces/Kevin676/ChatGPT-with-Voice-Cloning-in-Chinese/synthesizer/utils/_cmudict.py b/spaces/Kevin676/ChatGPT-with-Voice-Cloning-in-Chinese/synthesizer/utils/_cmudict.py
deleted file mode 100644
index 2cef1f896d4fb78478884fe8e810956998d5e3b3..0000000000000000000000000000000000000000
--- a/spaces/Kevin676/ChatGPT-with-Voice-Cloning-in-Chinese/synthesizer/utils/_cmudict.py
+++ /dev/null
@@ -1,62 +0,0 @@
-import re
-
-valid_symbols = [
- "AA", "AA0", "AA1", "AA2", "AE", "AE0", "AE1", "AE2", "AH", "AH0", "AH1", "AH2",
- "AO", "AO0", "AO1", "AO2", "AW", "AW0", "AW1", "AW2", "AY", "AY0", "AY1", "AY2",
- "B", "CH", "D", "DH", "EH", "EH0", "EH1", "EH2", "ER", "ER0", "ER1", "ER2", "EY",
- "EY0", "EY1", "EY2", "F", "G", "HH", "IH", "IH0", "IH1", "IH2", "IY", "IY0", "IY1",
- "IY2", "JH", "K", "L", "M", "N", "NG", "OW", "OW0", "OW1", "OW2", "OY", "OY0",
- "OY1", "OY2", "P", "R", "S", "SH", "T", "TH", "UH", "UH0", "UH1", "UH2", "UW",
- "UW0", "UW1", "UW2", "V", "W", "Y", "Z", "ZH"
-]
-
-_valid_symbol_set = set(valid_symbols)
-
-
-class CMUDict:
- """Thin wrapper around CMUDict data. http://www.speech.cs.cmu.edu/cgi-bin/cmudict"""
- def __init__(self, file_or_path, keep_ambiguous=True):
- if isinstance(file_or_path, str):
- with open(file_or_path, encoding="latin-1") as f:
- entries = _parse_cmudict(f)
- else:
- entries = _parse_cmudict(file_or_path)
- if not keep_ambiguous:
- entries = {word: pron for word, pron in entries.items() if len(pron) == 1}
- self._entries = entries
-
-
- def __len__(self):
- return len(self._entries)
-
-
- def lookup(self, word):
- """Returns list of ARPAbet pronunciations of the given word."""
- return self._entries.get(word.upper())
-
-
-
-_alt_re = re.compile(r"\([0-9]+\)")
-
-
-def _parse_cmudict(file):
- cmudict = {}
- for line in file:
- if len(line) and (line[0] >= "A" and line[0] <= "Z" or line[0] == "'"):
- parts = line.split(" ")
- word = re.sub(_alt_re, "", parts[0])
- pronunciation = _get_pronunciation(parts[1])
- if pronunciation:
- if word in cmudict:
- cmudict[word].append(pronunciation)
- else:
- cmudict[word] = [pronunciation]
- return cmudict
-
-
-def _get_pronunciation(s):
- parts = s.strip().split(" ")
- for part in parts:
- if part not in _valid_symbol_set:
- return None
- return " ".join(parts)
diff --git a/spaces/Kevin676/Clone-Your-Voice/synthesizer/utils/symbols.py b/spaces/Kevin676/Clone-Your-Voice/synthesizer/utils/symbols.py
deleted file mode 100644
index 132d3a612c3b13e2ada905a706001cff29a4f63a..0000000000000000000000000000000000000000
--- a/spaces/Kevin676/Clone-Your-Voice/synthesizer/utils/symbols.py
+++ /dev/null
@@ -1,17 +0,0 @@
-"""
-Defines the set of symbols used in text input to the model.
-
-The default is a set of ASCII characters that works well for English or text that has been run
-through Unidecode. For other data, you can modify _characters. See TRAINING_DATA.md for details.
-"""
-# from . import cmudict
-
-_pad = "_"
-_eos = "~"
-_characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!\'\"(),-.:;? "
-
-# Prepend "@" to ARPAbet symbols to ensure uniqueness (some are the same as uppercase letters):
-#_arpabet = ["@' + s for s in cmudict.valid_symbols]
-
-# Export all symbols:
-symbols = [_pad, _eos] + list(_characters) #+ _arpabet
diff --git a/spaces/Kevin676/Real-Time-Voice-Cloning/encoder_preprocess.py b/spaces/Kevin676/Real-Time-Voice-Cloning/encoder_preprocess.py
deleted file mode 100644
index 11502013c8d75d4652fb0ffdcdc49d55e8fb8bc9..0000000000000000000000000000000000000000
--- a/spaces/Kevin676/Real-Time-Voice-Cloning/encoder_preprocess.py
+++ /dev/null
@@ -1,70 +0,0 @@
-from encoder.preprocess import preprocess_librispeech, preprocess_voxceleb1, preprocess_voxceleb2
-from utils.argutils import print_args
-from pathlib import Path
-import argparse
-
-if __name__ == "__main__":
- class MyFormatter(argparse.ArgumentDefaultsHelpFormatter, argparse.RawDescriptionHelpFormatter):
- pass
-
- parser = argparse.ArgumentParser(
- description="Preprocesses audio files from datasets, encodes them as mel spectrograms and "
- "writes them to the disk. This will allow you to train the encoder. The "
- "datasets required are at least one of VoxCeleb1, VoxCeleb2 and LibriSpeech. "
- "Ideally, you should have all three. You should extract them as they are "
- "after having downloaded them and put them in a same directory, e.g.:\n"
- "-[datasets_root]\n"
- " -LibriSpeech\n"
- " -train-other-500\n"
- " -VoxCeleb1\n"
- " -wav\n"
- " -vox1_meta.csv\n"
- " -VoxCeleb2\n"
- " -dev",
- formatter_class=MyFormatter
- )
- parser.add_argument("datasets_root", type=Path, help=\
- "Path to the directory containing your LibriSpeech/TTS and VoxCeleb datasets.")
- parser.add_argument("-o", "--out_dir", type=Path, default=argparse.SUPPRESS, help=\
- "Path to the output directory that will contain the mel spectrograms. If left out, "
- "defaults to /SV2TTS/encoder/")
- parser.add_argument("-d", "--datasets", type=str,
- default="librispeech_other,voxceleb1,voxceleb2", help=\
- "Comma-separated list of the name of the datasets you want to preprocess. Only the train "
- "set of these datasets will be used. Possible names: librispeech_other, voxceleb1, "
- "voxceleb2.")
- parser.add_argument("-s", "--skip_existing", action="store_true", help=\
- "Whether to skip existing output files with the same name. Useful if this script was "
- "interrupted.")
- parser.add_argument("--no_trim", action="store_true", help=\
- "Preprocess audio without trimming silences (not recommended).")
- args = parser.parse_args()
-
- # Verify webrtcvad is available
- if not args.no_trim:
- try:
- import webrtcvad
- except:
- raise ModuleNotFoundError("Package 'webrtcvad' not found. This package enables "
- "noise removal and is recommended. Please install and try again. If installation fails, "
- "use --no_trim to disable this error message.")
- del args.no_trim
-
- # Process the arguments
- args.datasets = args.datasets.split(",")
- if not hasattr(args, "out_dir"):
- args.out_dir = args.datasets_root.joinpath("SV2TTS", "encoder")
- assert args.datasets_root.exists()
- args.out_dir.mkdir(exist_ok=True, parents=True)
-
- # Preprocess the datasets
- print_args(args, parser)
- preprocess_func = {
- "librispeech_other": preprocess_librispeech,
- "voxceleb1": preprocess_voxceleb1,
- "voxceleb2": preprocess_voxceleb2,
- }
- args = vars(args)
- for dataset in args.pop("datasets"):
- print("Preprocessing %s" % dataset)
- preprocess_func[dataset](**args)
diff --git a/spaces/KunalKharalkar/imagetostory/app.py b/spaces/KunalKharalkar/imagetostory/app.py
deleted file mode 100644
index 0d1e266642119df0e575f69f2b256fb57c02a37b..0000000000000000000000000000000000000000
--- a/spaces/KunalKharalkar/imagetostory/app.py
+++ /dev/null
@@ -1,72 +0,0 @@
-from dotenv import find_dotenv, load_dotenv
-from transformers import pipeline
-from langchain import PromptTemplate, LLMChain, OpenAI
-import requests
-import os
-import streamlit as st
-
-load_dotenv(find_dotenv())
-HUGGINGFACEHUB_API_TOKEN = os.getenv("HUGGINGFACEHUB_API_TOKEN")
-
-#module1: image to text
-def imgtotxt(url):
- img_to_txt = pipeline("image-to-text",model="Salesforce/blip-image-captioning-base")
- text = img_to_txt(url)[0]["generated_text"]
- print(text)
- return text
-
-
-#module2: llm
-def generate_story(scenario):
- template = """
- You are a story teller;
- You can generate a short story based on a simple narrative, the story should be no more than 50 words;
-
- CONTEXT: {scenario}
- STORY:
- """
-
- prompt = PromptTemplate(template=template, input_variables=["scenario"])
-
- story_llm = LLMChain(llm=OpenAI(model_name="gpt-3.5-turbo", temperature=1), prompt=prompt, verbose=True)
- story = story_llm.predict(scenario=scenario)
-
- print(story)
- return story
-
-
-#module3: text to speech
-def texttospeech(message):
- API_URL = "https://api-inference.huggingface.co/models/espnet/kan-bayashi_ljspeech_vits"
- headers = {"Authorization": f"Bearer {HUGGINGFACEHUB_API_TOKEN}"}
- payloads = {
- "inputs": message
- }
-
- response = requests.post(API_URL, headers=headers, json=payloads)
- with open('audio.flac', 'wb') as file:
- file.write(response.content)
-
-def main():
- st.set_page_config(page_title="Image to Audio Story", page_icon="🗣️")
- st.header("Turn Image into Audio Story")
- uploaded_file = st.file_uploader("Choose an Image...", type="jpg")
-
- if uploaded_file is not None:
- bytes_data = uploaded_file.getvalue()
- with open(uploaded_file.name, "wb") as file:
- file.write(bytes_data)
- st.image(uploaded_file, caption="Uploaded Image.", use_column_width=True)
- scenario = imgtotxt(uploaded_file.name)
- story= generate_story(scenario)
- texttospeech(story)
-
- with st.expander("Scenario"):
- st.write(scenario)
- with st.expander("Story"):
- st.write(story)
-
- st.audio("audio.flac")
-
-if __name__ == '__main__':
- main()
diff --git a/spaces/KyanChen/RSPrompter/mmdet/models/dense_heads/solo_head.py b/spaces/KyanChen/RSPrompter/mmdet/models/dense_heads/solo_head.py
deleted file mode 100644
index 65278b2cb5617fea0cc2ed7953a14bb5b7667165..0000000000000000000000000000000000000000
--- a/spaces/KyanChen/RSPrompter/mmdet/models/dense_heads/solo_head.py
+++ /dev/null
@@ -1,1268 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from typing import List, Optional, Tuple
-
-import mmcv
-import numpy as np
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from mmcv.cnn import ConvModule
-from mmengine.structures import InstanceData
-from torch import Tensor
-
-from mmdet.models.utils.misc import floordiv
-from mmdet.registry import MODELS
-from mmdet.utils import ConfigType, InstanceList, MultiConfig, OptConfigType
-from ..layers import mask_matrix_nms
-from ..utils import center_of_mass, generate_coordinate, multi_apply
-from .base_mask_head import BaseMaskHead
-from ...structures.mask import mask2bbox
-
-
-@MODELS.register_module()
-class SOLOHead(BaseMaskHead):
- """SOLO mask head used in `SOLO: Segmenting Objects by Locations.
-
- `_
-
- Args:
- num_classes (int): Number of categories excluding the background
- category.
- in_channels (int): Number of channels in the input feature map.
- feat_channels (int): Number of hidden channels. Used in child classes.
- Defaults to 256.
- stacked_convs (int): Number of stacking convs of the head.
- Defaults to 4.
- strides (tuple): Downsample factor of each feature map.
- scale_ranges (tuple[tuple[int, int]]): Area range of multiple
- level masks, in the format [(min1, max1), (min2, max2), ...].
- A range of (16, 64) means the area range between (16, 64).
- pos_scale (float): Constant scale factor to control the center region.
- num_grids (list[int]): Divided image into a uniform grids, each
- feature map has a different grid value. The number of output
- channels is grid ** 2. Defaults to [40, 36, 24, 16, 12].
- cls_down_index (int): The index of downsample operation in
- classification branch. Defaults to 0.
- loss_mask (dict): Config of mask loss.
- loss_cls (dict): Config of classification loss.
- norm_cfg (dict): Dictionary to construct and config norm layer.
- Defaults to norm_cfg=dict(type='GN', num_groups=32,
- requires_grad=True).
- train_cfg (dict): Training config of head.
- test_cfg (dict): Testing config of head.
- init_cfg (dict or list[dict], optional): Initialization config dict.
- """
-
- def __init__(
- self,
- num_classes: int,
- in_channels: int,
- feat_channels: int = 256,
- stacked_convs: int = 4,
- strides: tuple = (4, 8, 16, 32, 64),
- scale_ranges: tuple = ((8, 32), (16, 64), (32, 128), (64, 256), (128,
- 512)),
- pos_scale: float = 0.2,
- num_grids: list = [40, 36, 24, 16, 12],
- cls_down_index: int = 0,
- loss_mask: ConfigType = dict(
- type='DiceLoss', use_sigmoid=True, loss_weight=3.0),
- loss_cls: ConfigType = dict(
- type='FocalLoss',
- use_sigmoid=True,
- gamma=2.0,
- alpha=0.25,
- loss_weight=1.0),
- norm_cfg: ConfigType = dict(
- type='GN', num_groups=32, requires_grad=True),
- train_cfg: OptConfigType = None,
- test_cfg: OptConfigType = None,
- init_cfg: MultiConfig = [
- dict(type='Normal', layer='Conv2d', std=0.01),
- dict(
- type='Normal',
- std=0.01,
- bias_prob=0.01,
- override=dict(name='conv_mask_list')),
- dict(
- type='Normal',
- std=0.01,
- bias_prob=0.01,
- override=dict(name='conv_cls'))
- ]
- ) -> None:
- super().__init__(init_cfg=init_cfg)
- self.num_classes = num_classes
- self.cls_out_channels = self.num_classes
- self.in_channels = in_channels
- self.feat_channels = feat_channels
- self.stacked_convs = stacked_convs
- self.strides = strides
- self.num_grids = num_grids
- # number of FPN feats
- self.num_levels = len(strides)
- assert self.num_levels == len(scale_ranges) == len(num_grids)
- self.scale_ranges = scale_ranges
- self.pos_scale = pos_scale
-
- self.cls_down_index = cls_down_index
- self.loss_cls = MODELS.build(loss_cls)
- self.loss_mask = MODELS.build(loss_mask)
- self.norm_cfg = norm_cfg
- self.init_cfg = init_cfg
- self.train_cfg = train_cfg
- self.test_cfg = test_cfg
- self._init_layers()
-
- def _init_layers(self) -> None:
- """Initialize layers of the head."""
- self.mask_convs = nn.ModuleList()
- self.cls_convs = nn.ModuleList()
- for i in range(self.stacked_convs):
- chn = self.in_channels + 2 if i == 0 else self.feat_channels
- self.mask_convs.append(
- ConvModule(
- chn,
- self.feat_channels,
- 3,
- stride=1,
- padding=1,
- norm_cfg=self.norm_cfg))
- chn = self.in_channels if i == 0 else self.feat_channels
- self.cls_convs.append(
- ConvModule(
- chn,
- self.feat_channels,
- 3,
- stride=1,
- padding=1,
- norm_cfg=self.norm_cfg))
- self.conv_mask_list = nn.ModuleList()
- for num_grid in self.num_grids:
- self.conv_mask_list.append(
- nn.Conv2d(self.feat_channels, num_grid**2, 1))
-
- self.conv_cls = nn.Conv2d(
- self.feat_channels, self.cls_out_channels, 3, padding=1)
-
- def resize_feats(self, x: Tuple[Tensor]) -> List[Tensor]:
- """Downsample the first feat and upsample last feat in feats.
-
- Args:
- x (tuple[Tensor]): Features from the upstream network, each is
- a 4D-tensor.
-
- Returns:
- list[Tensor]: Features after resizing, each is a 4D-tensor.
- """
- out = []
- for i in range(len(x)):
- if i == 0:
- out.append(
- F.interpolate(x[0], scale_factor=0.5, mode='bilinear'))
- elif i == len(x) - 1:
- out.append(
- F.interpolate(
- x[i], size=x[i - 1].shape[-2:], mode='bilinear'))
- else:
- out.append(x[i])
- return out
-
- def forward(self, x: Tuple[Tensor]) -> tuple:
- """Forward features from the upstream network.
-
- Args:
- x (tuple[Tensor]): Features from the upstream network, each is
- a 4D-tensor.
-
- Returns:
- tuple: A tuple of classification scores and mask prediction.
-
- - mlvl_mask_preds (list[Tensor]): Multi-level mask prediction.
- Each element in the list has shape
- (batch_size, num_grids**2 ,h ,w).
- - mlvl_cls_preds (list[Tensor]): Multi-level scores.
- Each element in the list has shape
- (batch_size, num_classes, num_grids ,num_grids).
- """
- assert len(x) == self.num_levels
- feats = self.resize_feats(x)
- mlvl_mask_preds = []
- mlvl_cls_preds = []
- for i in range(self.num_levels):
- x = feats[i]
- mask_feat = x
- cls_feat = x
- # generate and concat the coordinate
- coord_feat = generate_coordinate(mask_feat.size(),
- mask_feat.device)
- mask_feat = torch.cat([mask_feat, coord_feat], 1)
-
- for mask_layer in (self.mask_convs):
- mask_feat = mask_layer(mask_feat)
-
- mask_feat = F.interpolate(
- mask_feat, scale_factor=2, mode='bilinear')
- mask_preds = self.conv_mask_list[i](mask_feat)
-
- # cls branch
- for j, cls_layer in enumerate(self.cls_convs):
- if j == self.cls_down_index:
- num_grid = self.num_grids[i]
- cls_feat = F.interpolate(
- cls_feat, size=num_grid, mode='bilinear')
- cls_feat = cls_layer(cls_feat)
-
- cls_pred = self.conv_cls(cls_feat)
-
- if not self.training:
- feat_wh = feats[0].size()[-2:]
- upsampled_size = (feat_wh[0] * 2, feat_wh[1] * 2)
- mask_preds = F.interpolate(
- mask_preds.sigmoid(), size=upsampled_size, mode='bilinear')
- cls_pred = cls_pred.sigmoid()
- # get local maximum
- local_max = F.max_pool2d(cls_pred, 2, stride=1, padding=1)
- keep_mask = local_max[:, :, :-1, :-1] == cls_pred
- cls_pred = cls_pred * keep_mask
-
- mlvl_mask_preds.append(mask_preds)
- mlvl_cls_preds.append(cls_pred)
- return mlvl_mask_preds, mlvl_cls_preds
-
- def loss_by_feat(self, mlvl_mask_preds: List[Tensor],
- mlvl_cls_preds: List[Tensor],
- batch_gt_instances: InstanceList,
- batch_img_metas: List[dict], **kwargs) -> dict:
- """Calculate the loss based on the features extracted by the mask head.
-
- Args:
- mlvl_mask_preds (list[Tensor]): Multi-level mask prediction.
- Each element in the list has shape
- (batch_size, num_grids**2 ,h ,w).
- batch_gt_instances (list[:obj:`InstanceData`]): Batch of
- gt_instance. It usually includes ``bboxes``, ``masks``,
- and ``labels`` attributes.
- batch_img_metas (list[dict]): Meta information of multiple images.
-
- Returns:
- dict[str, Tensor]: A dictionary of loss components.
- """
- num_levels = self.num_levels
- num_imgs = len(batch_img_metas)
-
- featmap_sizes = [featmap.size()[-2:] for featmap in mlvl_mask_preds]
-
- # `BoolTensor` in `pos_masks` represent
- # whether the corresponding point is
- # positive
- pos_mask_targets, labels, pos_masks = multi_apply(
- self._get_targets_single,
- batch_gt_instances,
- featmap_sizes=featmap_sizes)
-
- # change from the outside list meaning multi images
- # to the outside list meaning multi levels
- mlvl_pos_mask_targets = [[] for _ in range(num_levels)]
- mlvl_pos_mask_preds = [[] for _ in range(num_levels)]
- mlvl_pos_masks = [[] for _ in range(num_levels)]
- mlvl_labels = [[] for _ in range(num_levels)]
- for img_id in range(num_imgs):
- assert num_levels == len(pos_mask_targets[img_id])
- for lvl in range(num_levels):
- mlvl_pos_mask_targets[lvl].append(
- pos_mask_targets[img_id][lvl])
- mlvl_pos_mask_preds[lvl].append(
- mlvl_mask_preds[lvl][img_id, pos_masks[img_id][lvl], ...])
- mlvl_pos_masks[lvl].append(pos_masks[img_id][lvl].flatten())
- mlvl_labels[lvl].append(labels[img_id][lvl].flatten())
-
- # cat multiple image
- temp_mlvl_cls_preds = []
- for lvl in range(num_levels):
- mlvl_pos_mask_targets[lvl] = torch.cat(
- mlvl_pos_mask_targets[lvl], dim=0)
- mlvl_pos_mask_preds[lvl] = torch.cat(
- mlvl_pos_mask_preds[lvl], dim=0)
- mlvl_pos_masks[lvl] = torch.cat(mlvl_pos_masks[lvl], dim=0)
- mlvl_labels[lvl] = torch.cat(mlvl_labels[lvl], dim=0)
- temp_mlvl_cls_preds.append(mlvl_cls_preds[lvl].permute(
- 0, 2, 3, 1).reshape(-1, self.cls_out_channels))
-
- num_pos = sum(item.sum() for item in mlvl_pos_masks)
- # dice loss
- loss_mask = []
- for pred, target in zip(mlvl_pos_mask_preds, mlvl_pos_mask_targets):
- if pred.size()[0] == 0:
- loss_mask.append(pred.sum().unsqueeze(0))
- continue
- loss_mask.append(
- self.loss_mask(pred, target, reduction_override='none'))
- if num_pos > 0:
- loss_mask = torch.cat(loss_mask).sum() / num_pos
- else:
- loss_mask = torch.cat(loss_mask).mean()
-
- flatten_labels = torch.cat(mlvl_labels)
- flatten_cls_preds = torch.cat(temp_mlvl_cls_preds)
- loss_cls = self.loss_cls(
- flatten_cls_preds, flatten_labels, avg_factor=num_pos + 1)
- return dict(loss_mask=loss_mask, loss_cls=loss_cls)
-
- def _get_targets_single(self,
- gt_instances: InstanceData,
- featmap_sizes: Optional[list] = None) -> tuple:
- """Compute targets for predictions of single image.
-
- Args:
- gt_instances (:obj:`InstanceData`): Ground truth of instance
- annotations. It should includes ``bboxes``, ``labels``,
- and ``masks`` attributes.
- featmap_sizes (list[:obj:`torch.size`]): Size of each
- feature map from feature pyramid, each element
- means (feat_h, feat_w). Defaults to None.
-
- Returns:
- Tuple: Usually returns a tuple containing targets for predictions.
-
- - mlvl_pos_mask_targets (list[Tensor]): Each element represent
- the binary mask targets for positive points in this
- level, has shape (num_pos, out_h, out_w).
- - mlvl_labels (list[Tensor]): Each element is
- classification labels for all
- points in this level, has shape
- (num_grid, num_grid).
- - mlvl_pos_masks (list[Tensor]): Each element is
- a `BoolTensor` to represent whether the
- corresponding point in single level
- is positive, has shape (num_grid **2).
- """
- gt_labels = gt_instances.labels
- device = gt_labels.device
-
- gt_bboxes = gt_instances.bboxes
- gt_areas = torch.sqrt((gt_bboxes[:, 2] - gt_bboxes[:, 0]) *
- (gt_bboxes[:, 3] - gt_bboxes[:, 1]))
-
- gt_masks = gt_instances.masks.to_tensor(
- dtype=torch.bool, device=device)
-
- mlvl_pos_mask_targets = []
- mlvl_labels = []
- mlvl_pos_masks = []
- for (lower_bound, upper_bound), stride, featmap_size, num_grid \
- in zip(self.scale_ranges, self.strides,
- featmap_sizes, self.num_grids):
-
- mask_target = torch.zeros(
- [num_grid**2, featmap_size[0], featmap_size[1]],
- dtype=torch.uint8,
- device=device)
- # FG cat_id: [0, num_classes -1], BG cat_id: num_classes
- labels = torch.zeros([num_grid, num_grid],
- dtype=torch.int64,
- device=device) + self.num_classes
- pos_mask = torch.zeros([num_grid**2],
- dtype=torch.bool,
- device=device)
-
- gt_inds = ((gt_areas >= lower_bound) &
- (gt_areas <= upper_bound)).nonzero().flatten()
- if len(gt_inds) == 0:
- mlvl_pos_mask_targets.append(
- mask_target.new_zeros(0, featmap_size[0], featmap_size[1]))
- mlvl_labels.append(labels)
- mlvl_pos_masks.append(pos_mask)
- continue
- hit_gt_bboxes = gt_bboxes[gt_inds]
- hit_gt_labels = gt_labels[gt_inds]
- hit_gt_masks = gt_masks[gt_inds, ...]
-
- pos_w_ranges = 0.5 * (hit_gt_bboxes[:, 2] -
- hit_gt_bboxes[:, 0]) * self.pos_scale
- pos_h_ranges = 0.5 * (hit_gt_bboxes[:, 3] -
- hit_gt_bboxes[:, 1]) * self.pos_scale
-
- # Make sure hit_gt_masks has a value
- valid_mask_flags = hit_gt_masks.sum(dim=-1).sum(dim=-1) > 0
- output_stride = stride / 2
-
- for gt_mask, gt_label, pos_h_range, pos_w_range, \
- valid_mask_flag in \
- zip(hit_gt_masks, hit_gt_labels, pos_h_ranges,
- pos_w_ranges, valid_mask_flags):
- if not valid_mask_flag:
- continue
- upsampled_size = (featmap_sizes[0][0] * 4,
- featmap_sizes[0][1] * 4)
- center_h, center_w = center_of_mass(gt_mask)
-
- coord_w = int(
- floordiv((center_w / upsampled_size[1]), (1. / num_grid),
- rounding_mode='trunc'))
- coord_h = int(
- floordiv((center_h / upsampled_size[0]), (1. / num_grid),
- rounding_mode='trunc'))
-
- # left, top, right, down
- top_box = max(
- 0,
- int(
- floordiv(
- (center_h - pos_h_range) / upsampled_size[0],
- (1. / num_grid),
- rounding_mode='trunc')))
- down_box = min(
- num_grid - 1,
- int(
- floordiv(
- (center_h + pos_h_range) / upsampled_size[0],
- (1. / num_grid),
- rounding_mode='trunc')))
- left_box = max(
- 0,
- int(
- floordiv(
- (center_w - pos_w_range) / upsampled_size[1],
- (1. / num_grid),
- rounding_mode='trunc')))
- right_box = min(
- num_grid - 1,
- int(
- floordiv(
- (center_w + pos_w_range) / upsampled_size[1],
- (1. / num_grid),
- rounding_mode='trunc')))
-
- top = max(top_box, coord_h - 1)
- down = min(down_box, coord_h + 1)
- left = max(coord_w - 1, left_box)
- right = min(right_box, coord_w + 1)
-
- labels[top:(down + 1), left:(right + 1)] = gt_label
- # ins
- gt_mask = np.uint8(gt_mask.cpu().numpy())
- # Follow the original implementation, F.interpolate is
- # different from cv2 and opencv
- gt_mask = mmcv.imrescale(gt_mask, scale=1. / output_stride)
- gt_mask = torch.from_numpy(gt_mask).to(device=device)
-
- for i in range(top, down + 1):
- for j in range(left, right + 1):
- index = int(i * num_grid + j)
- mask_target[index, :gt_mask.shape[0], :gt_mask.
- shape[1]] = gt_mask
- pos_mask[index] = True
- mlvl_pos_mask_targets.append(mask_target[pos_mask])
- mlvl_labels.append(labels)
- mlvl_pos_masks.append(pos_mask)
- return mlvl_pos_mask_targets, mlvl_labels, mlvl_pos_masks
-
- def predict_by_feat(self, mlvl_mask_preds: List[Tensor],
- mlvl_cls_scores: List[Tensor],
- batch_img_metas: List[dict], **kwargs) -> InstanceList:
- """Transform a batch of output features extracted from the head into
- mask results.
-
- Args:
- mlvl_mask_preds (list[Tensor]): Multi-level mask prediction.
- Each element in the list has shape
- (batch_size, num_grids**2 ,h ,w).
- mlvl_cls_scores (list[Tensor]): Multi-level scores. Each element
- in the list has shape
- (batch_size, num_classes, num_grids ,num_grids).
- batch_img_metas (list[dict]): Meta information of all images.
-
- Returns:
- list[:obj:`InstanceData`]: Processed results of multiple
- images.Each :obj:`InstanceData` usually contains
- following keys.
-
- - scores (Tensor): Classification scores, has shape
- (num_instance,).
- - labels (Tensor): Has shape (num_instances,).
- - masks (Tensor): Processed mask results, has
- shape (num_instances, h, w).
- """
- mlvl_cls_scores = [
- item.permute(0, 2, 3, 1) for item in mlvl_cls_scores
- ]
- assert len(mlvl_mask_preds) == len(mlvl_cls_scores)
- num_levels = len(mlvl_cls_scores)
-
- results_list = []
- for img_id in range(len(batch_img_metas)):
- cls_pred_list = [
- mlvl_cls_scores[lvl][img_id].view(-1, self.cls_out_channels)
- for lvl in range(num_levels)
- ]
- mask_pred_list = [
- mlvl_mask_preds[lvl][img_id] for lvl in range(num_levels)
- ]
-
- cls_pred_list = torch.cat(cls_pred_list, dim=0)
- mask_pred_list = torch.cat(mask_pred_list, dim=0)
- img_meta = batch_img_metas[img_id]
-
- results = self._predict_by_feat_single(
- cls_pred_list, mask_pred_list, img_meta=img_meta)
- results_list.append(results)
-
- return results_list
-
- def _predict_by_feat_single(self,
- cls_scores: Tensor,
- mask_preds: Tensor,
- img_meta: dict,
- cfg: OptConfigType = None) -> InstanceData:
- """Transform a single image's features extracted from the head into
- mask results.
-
- Args:
- cls_scores (Tensor): Classification score of all points
- in single image, has shape (num_points, num_classes).
- mask_preds (Tensor): Mask prediction of all points in
- single image, has shape (num_points, feat_h, feat_w).
- img_meta (dict): Meta information of corresponding image.
- cfg (dict, optional): Config used in test phase.
- Defaults to None.
-
- Returns:
- :obj:`InstanceData`: Processed results of single image.
- it usually contains following keys.
-
- - scores (Tensor): Classification scores, has shape
- (num_instance,).
- - labels (Tensor): Has shape (num_instances,).
- - masks (Tensor): Processed mask results, has
- shape (num_instances, h, w).
- """
-
- def empty_results(cls_scores, ori_shape):
- """Generate a empty results."""
- results = InstanceData()
- results.scores = cls_scores.new_ones(0)
- results.masks = cls_scores.new_zeros(0, *ori_shape)
- results.labels = cls_scores.new_ones(0)
- results.bboxes = cls_scores.new_zeros(0, 4)
- return results
-
- cfg = self.test_cfg if cfg is None else cfg
- assert len(cls_scores) == len(mask_preds)
-
- featmap_size = mask_preds.size()[-2:]
-
- h, w = img_meta['img_shape'][:2]
- upsampled_size = (featmap_size[0] * 4, featmap_size[1] * 4)
-
- score_mask = (cls_scores > cfg.score_thr)
- cls_scores = cls_scores[score_mask]
- if len(cls_scores) == 0:
- return empty_results(cls_scores, img_meta['ori_shape'][:2])
-
- inds = score_mask.nonzero()
- cls_labels = inds[:, 1]
-
- # Filter the mask mask with an area is smaller than
- # stride of corresponding feature level
- lvl_interval = cls_labels.new_tensor(self.num_grids).pow(2).cumsum(0)
- strides = cls_scores.new_ones(lvl_interval[-1])
- strides[:lvl_interval[0]] *= self.strides[0]
- for lvl in range(1, self.num_levels):
- strides[lvl_interval[lvl -
- 1]:lvl_interval[lvl]] *= self.strides[lvl]
- strides = strides[inds[:, 0]]
- mask_preds = mask_preds[inds[:, 0]]
-
- masks = mask_preds > cfg.mask_thr
- sum_masks = masks.sum((1, 2)).float()
- keep = sum_masks > strides
- if keep.sum() == 0:
- return empty_results(cls_scores, img_meta['ori_shape'][:2])
- masks = masks[keep]
- mask_preds = mask_preds[keep]
- sum_masks = sum_masks[keep]
- cls_scores = cls_scores[keep]
- cls_labels = cls_labels[keep]
-
- # maskness.
- mask_scores = (mask_preds * masks).sum((1, 2)) / sum_masks
- cls_scores *= mask_scores
-
- scores, labels, _, keep_inds = mask_matrix_nms(
- masks,
- cls_labels,
- cls_scores,
- mask_area=sum_masks,
- nms_pre=cfg.nms_pre,
- max_num=cfg.max_per_img,
- kernel=cfg.kernel,
- sigma=cfg.sigma,
- filter_thr=cfg.filter_thr)
- # mask_matrix_nms may return an empty Tensor
- if len(keep_inds) == 0:
- return empty_results(cls_scores, img_meta['ori_shape'][:2])
- mask_preds = mask_preds[keep_inds]
- mask_preds = F.interpolate(
- mask_preds.unsqueeze(0), size=upsampled_size,
- mode='bilinear')[:, :, :h, :w]
- mask_preds = F.interpolate(
- mask_preds, size=img_meta['ori_shape'][:2],
- mode='bilinear').squeeze(0)
- masks = mask_preds > cfg.mask_thr
-
- results = InstanceData()
- results.masks = masks
- results.labels = labels
- results.scores = scores
- # create an empty bbox in InstanceData to avoid bugs when
- # calculating metrics.
- bboxes = mask2bbox(masks)
- # results.bboxes = results.scores.new_zeros(len(scores), 4)
- results.bboxes = bboxes
- return results
-
-
-@MODELS.register_module()
-class DecoupledSOLOHead(SOLOHead):
- """Decoupled SOLO mask head used in `SOLO: Segmenting Objects by Locations.
-
- `_
-
- Args:
- init_cfg (dict or list[dict], optional): Initialization config dict.
- """
-
- def __init__(self,
- *args,
- init_cfg: MultiConfig = [
- dict(type='Normal', layer='Conv2d', std=0.01),
- dict(
- type='Normal',
- std=0.01,
- bias_prob=0.01,
- override=dict(name='conv_mask_list_x')),
- dict(
- type='Normal',
- std=0.01,
- bias_prob=0.01,
- override=dict(name='conv_mask_list_y')),
- dict(
- type='Normal',
- std=0.01,
- bias_prob=0.01,
- override=dict(name='conv_cls'))
- ],
- **kwargs) -> None:
- super().__init__(*args, init_cfg=init_cfg, **kwargs)
-
- def _init_layers(self) -> None:
- self.mask_convs_x = nn.ModuleList()
- self.mask_convs_y = nn.ModuleList()
- self.cls_convs = nn.ModuleList()
-
- for i in range(self.stacked_convs):
- chn = self.in_channels + 1 if i == 0 else self.feat_channels
- self.mask_convs_x.append(
- ConvModule(
- chn,
- self.feat_channels,
- 3,
- stride=1,
- padding=1,
- norm_cfg=self.norm_cfg))
- self.mask_convs_y.append(
- ConvModule(
- chn,
- self.feat_channels,
- 3,
- stride=1,
- padding=1,
- norm_cfg=self.norm_cfg))
-
- chn = self.in_channels if i == 0 else self.feat_channels
- self.cls_convs.append(
- ConvModule(
- chn,
- self.feat_channels,
- 3,
- stride=1,
- padding=1,
- norm_cfg=self.norm_cfg))
-
- self.conv_mask_list_x = nn.ModuleList()
- self.conv_mask_list_y = nn.ModuleList()
- for num_grid in self.num_grids:
- self.conv_mask_list_x.append(
- nn.Conv2d(self.feat_channels, num_grid, 3, padding=1))
- self.conv_mask_list_y.append(
- nn.Conv2d(self.feat_channels, num_grid, 3, padding=1))
- self.conv_cls = nn.Conv2d(
- self.feat_channels, self.cls_out_channels, 3, padding=1)
-
- def forward(self, x: Tuple[Tensor]) -> Tuple:
- """Forward features from the upstream network.
-
- Args:
- x (tuple[Tensor]): Features from the upstream network, each is
- a 4D-tensor.
-
- Returns:
- tuple: A tuple of classification scores and mask prediction.
-
- - mlvl_mask_preds_x (list[Tensor]): Multi-level mask prediction
- from x branch. Each element in the list has shape
- (batch_size, num_grids ,h ,w).
- - mlvl_mask_preds_y (list[Tensor]): Multi-level mask prediction
- from y branch. Each element in the list has shape
- (batch_size, num_grids ,h ,w).
- - mlvl_cls_preds (list[Tensor]): Multi-level scores.
- Each element in the list has shape
- (batch_size, num_classes, num_grids ,num_grids).
- """
- assert len(x) == self.num_levels
- feats = self.resize_feats(x)
- mask_preds_x = []
- mask_preds_y = []
- cls_preds = []
- for i in range(self.num_levels):
- x = feats[i]
- mask_feat = x
- cls_feat = x
- # generate and concat the coordinate
- coord_feat = generate_coordinate(mask_feat.size(),
- mask_feat.device)
- mask_feat_x = torch.cat([mask_feat, coord_feat[:, 0:1, ...]], 1)
- mask_feat_y = torch.cat([mask_feat, coord_feat[:, 1:2, ...]], 1)
-
- for mask_layer_x, mask_layer_y in \
- zip(self.mask_convs_x, self.mask_convs_y):
- mask_feat_x = mask_layer_x(mask_feat_x)
- mask_feat_y = mask_layer_y(mask_feat_y)
-
- mask_feat_x = F.interpolate(
- mask_feat_x, scale_factor=2, mode='bilinear')
- mask_feat_y = F.interpolate(
- mask_feat_y, scale_factor=2, mode='bilinear')
-
- mask_pred_x = self.conv_mask_list_x[i](mask_feat_x)
- mask_pred_y = self.conv_mask_list_y[i](mask_feat_y)
-
- # cls branch
- for j, cls_layer in enumerate(self.cls_convs):
- if j == self.cls_down_index:
- num_grid = self.num_grids[i]
- cls_feat = F.interpolate(
- cls_feat, size=num_grid, mode='bilinear')
- cls_feat = cls_layer(cls_feat)
-
- cls_pred = self.conv_cls(cls_feat)
-
- if not self.training:
- feat_wh = feats[0].size()[-2:]
- upsampled_size = (feat_wh[0] * 2, feat_wh[1] * 2)
- mask_pred_x = F.interpolate(
- mask_pred_x.sigmoid(),
- size=upsampled_size,
- mode='bilinear')
- mask_pred_y = F.interpolate(
- mask_pred_y.sigmoid(),
- size=upsampled_size,
- mode='bilinear')
- cls_pred = cls_pred.sigmoid()
- # get local maximum
- local_max = F.max_pool2d(cls_pred, 2, stride=1, padding=1)
- keep_mask = local_max[:, :, :-1, :-1] == cls_pred
- cls_pred = cls_pred * keep_mask
-
- mask_preds_x.append(mask_pred_x)
- mask_preds_y.append(mask_pred_y)
- cls_preds.append(cls_pred)
- return mask_preds_x, mask_preds_y, cls_preds
-
- def loss_by_feat(self, mlvl_mask_preds_x: List[Tensor],
- mlvl_mask_preds_y: List[Tensor],
- mlvl_cls_preds: List[Tensor],
- batch_gt_instances: InstanceList,
- batch_img_metas: List[dict], **kwargs) -> dict:
- """Calculate the loss based on the features extracted by the mask head.
-
- Args:
- mlvl_mask_preds_x (list[Tensor]): Multi-level mask prediction
- from x branch. Each element in the list has shape
- (batch_size, num_grids ,h ,w).
- mlvl_mask_preds_y (list[Tensor]): Multi-level mask prediction
- from y branch. Each element in the list has shape
- (batch_size, num_grids ,h ,w).
- mlvl_cls_preds (list[Tensor]): Multi-level scores. Each element
- in the list has shape
- (batch_size, num_classes, num_grids ,num_grids).
- batch_gt_instances (list[:obj:`InstanceData`]): Batch of
- gt_instance. It usually includes ``bboxes``, ``masks``,
- and ``labels`` attributes.
- batch_img_metas (list[dict]): Meta information of multiple images.
-
- Returns:
- dict[str, Tensor]: A dictionary of loss components.
- """
- num_levels = self.num_levels
- num_imgs = len(batch_img_metas)
- featmap_sizes = [featmap.size()[-2:] for featmap in mlvl_mask_preds_x]
-
- pos_mask_targets, labels, xy_pos_indexes = multi_apply(
- self._get_targets_single,
- batch_gt_instances,
- featmap_sizes=featmap_sizes)
-
- # change from the outside list meaning multi images
- # to the outside list meaning multi levels
- mlvl_pos_mask_targets = [[] for _ in range(num_levels)]
- mlvl_pos_mask_preds_x = [[] for _ in range(num_levels)]
- mlvl_pos_mask_preds_y = [[] for _ in range(num_levels)]
- mlvl_labels = [[] for _ in range(num_levels)]
- for img_id in range(num_imgs):
-
- for lvl in range(num_levels):
- mlvl_pos_mask_targets[lvl].append(
- pos_mask_targets[img_id][lvl])
- mlvl_pos_mask_preds_x[lvl].append(
- mlvl_mask_preds_x[lvl][img_id,
- xy_pos_indexes[img_id][lvl][:, 1]])
- mlvl_pos_mask_preds_y[lvl].append(
- mlvl_mask_preds_y[lvl][img_id,
- xy_pos_indexes[img_id][lvl][:, 0]])
- mlvl_labels[lvl].append(labels[img_id][lvl].flatten())
-
- # cat multiple image
- temp_mlvl_cls_preds = []
- for lvl in range(num_levels):
- mlvl_pos_mask_targets[lvl] = torch.cat(
- mlvl_pos_mask_targets[lvl], dim=0)
- mlvl_pos_mask_preds_x[lvl] = torch.cat(
- mlvl_pos_mask_preds_x[lvl], dim=0)
- mlvl_pos_mask_preds_y[lvl] = torch.cat(
- mlvl_pos_mask_preds_y[lvl], dim=0)
- mlvl_labels[lvl] = torch.cat(mlvl_labels[lvl], dim=0)
- temp_mlvl_cls_preds.append(mlvl_cls_preds[lvl].permute(
- 0, 2, 3, 1).reshape(-1, self.cls_out_channels))
-
- num_pos = 0.
- # dice loss
- loss_mask = []
- for pred_x, pred_y, target in \
- zip(mlvl_pos_mask_preds_x,
- mlvl_pos_mask_preds_y, mlvl_pos_mask_targets):
- num_masks = pred_x.size(0)
- if num_masks == 0:
- # make sure can get grad
- loss_mask.append((pred_x.sum() + pred_y.sum()).unsqueeze(0))
- continue
- num_pos += num_masks
- pred_mask = pred_y.sigmoid() * pred_x.sigmoid()
- loss_mask.append(
- self.loss_mask(pred_mask, target, reduction_override='none'))
- if num_pos > 0:
- loss_mask = torch.cat(loss_mask).sum() / num_pos
- else:
- loss_mask = torch.cat(loss_mask).mean()
-
- # cate
- flatten_labels = torch.cat(mlvl_labels)
- flatten_cls_preds = torch.cat(temp_mlvl_cls_preds)
-
- loss_cls = self.loss_cls(
- flatten_cls_preds, flatten_labels, avg_factor=num_pos + 1)
- return dict(loss_mask=loss_mask, loss_cls=loss_cls)
-
- def _get_targets_single(self,
- gt_instances: InstanceData,
- featmap_sizes: Optional[list] = None) -> tuple:
- """Compute targets for predictions of single image.
-
- Args:
- gt_instances (:obj:`InstanceData`): Ground truth of instance
- annotations. It should includes ``bboxes``, ``labels``,
- and ``masks`` attributes.
- featmap_sizes (list[:obj:`torch.size`]): Size of each
- feature map from feature pyramid, each element
- means (feat_h, feat_w). Defaults to None.
-
- Returns:
- Tuple: Usually returns a tuple containing targets for predictions.
-
- - mlvl_pos_mask_targets (list[Tensor]): Each element represent
- the binary mask targets for positive points in this
- level, has shape (num_pos, out_h, out_w).
- - mlvl_labels (list[Tensor]): Each element is
- classification labels for all
- points in this level, has shape
- (num_grid, num_grid).
- - mlvl_xy_pos_indexes (list[Tensor]): Each element
- in the list contains the index of positive samples in
- corresponding level, has shape (num_pos, 2), last
- dimension 2 present (index_x, index_y).
- """
- mlvl_pos_mask_targets, mlvl_labels, mlvl_pos_masks = \
- super()._get_targets_single(gt_instances,
- featmap_sizes=featmap_sizes)
-
- mlvl_xy_pos_indexes = [(item - self.num_classes).nonzero()
- for item in mlvl_labels]
-
- return mlvl_pos_mask_targets, mlvl_labels, mlvl_xy_pos_indexes
-
- def predict_by_feat(self, mlvl_mask_preds_x: List[Tensor],
- mlvl_mask_preds_y: List[Tensor],
- mlvl_cls_scores: List[Tensor],
- batch_img_metas: List[dict], **kwargs) -> InstanceList:
- """Transform a batch of output features extracted from the head into
- mask results.
-
- Args:
- mlvl_mask_preds_x (list[Tensor]): Multi-level mask prediction
- from x branch. Each element in the list has shape
- (batch_size, num_grids ,h ,w).
- mlvl_mask_preds_y (list[Tensor]): Multi-level mask prediction
- from y branch. Each element in the list has shape
- (batch_size, num_grids ,h ,w).
- mlvl_cls_scores (list[Tensor]): Multi-level scores. Each element
- in the list has shape
- (batch_size, num_classes ,num_grids ,num_grids).
- batch_img_metas (list[dict]): Meta information of all images.
-
- Returns:
- list[:obj:`InstanceData`]: Processed results of multiple
- images.Each :obj:`InstanceData` usually contains
- following keys.
-
- - scores (Tensor): Classification scores, has shape
- (num_instance,).
- - labels (Tensor): Has shape (num_instances,).
- - masks (Tensor): Processed mask results, has
- shape (num_instances, h, w).
- """
- mlvl_cls_scores = [
- item.permute(0, 2, 3, 1) for item in mlvl_cls_scores
- ]
- assert len(mlvl_mask_preds_x) == len(mlvl_cls_scores)
- num_levels = len(mlvl_cls_scores)
-
- results_list = []
- for img_id in range(len(batch_img_metas)):
- cls_pred_list = [
- mlvl_cls_scores[i][img_id].view(
- -1, self.cls_out_channels).detach()
- for i in range(num_levels)
- ]
- mask_pred_list_x = [
- mlvl_mask_preds_x[i][img_id] for i in range(num_levels)
- ]
- mask_pred_list_y = [
- mlvl_mask_preds_y[i][img_id] for i in range(num_levels)
- ]
-
- cls_pred_list = torch.cat(cls_pred_list, dim=0)
- mask_pred_list_x = torch.cat(mask_pred_list_x, dim=0)
- mask_pred_list_y = torch.cat(mask_pred_list_y, dim=0)
- img_meta = batch_img_metas[img_id]
-
- results = self._predict_by_feat_single(
- cls_pred_list,
- mask_pred_list_x,
- mask_pred_list_y,
- img_meta=img_meta)
- results_list.append(results)
- return results_list
-
- def _predict_by_feat_single(self,
- cls_scores: Tensor,
- mask_preds_x: Tensor,
- mask_preds_y: Tensor,
- img_meta: dict,
- cfg: OptConfigType = None) -> InstanceData:
- """Transform a single image's features extracted from the head into
- mask results.
-
- Args:
- cls_scores (Tensor): Classification score of all points
- in single image, has shape (num_points, num_classes).
- mask_preds_x (Tensor): Mask prediction of x branch of
- all points in single image, has shape
- (sum_num_grids, feat_h, feat_w).
- mask_preds_y (Tensor): Mask prediction of y branch of
- all points in single image, has shape
- (sum_num_grids, feat_h, feat_w).
- img_meta (dict): Meta information of corresponding image.
- cfg (dict): Config used in test phase.
-
- Returns:
- :obj:`InstanceData`: Processed results of single image.
- it usually contains following keys.
-
- - scores (Tensor): Classification scores, has shape
- (num_instance,).
- - labels (Tensor): Has shape (num_instances,).
- - masks (Tensor): Processed mask results, has
- shape (num_instances, h, w).
- """
-
- def empty_results(cls_scores, ori_shape):
- """Generate a empty results."""
- results = InstanceData()
- results.scores = cls_scores.new_ones(0)
- results.masks = cls_scores.new_zeros(0, *ori_shape)
- results.labels = cls_scores.new_ones(0)
- results.bboxes = cls_scores.new_zeros(0, 4)
- return results
-
- cfg = self.test_cfg if cfg is None else cfg
-
- featmap_size = mask_preds_x.size()[-2:]
-
- h, w = img_meta['img_shape'][:2]
- upsampled_size = (featmap_size[0] * 4, featmap_size[1] * 4)
-
- score_mask = (cls_scores > cfg.score_thr)
- cls_scores = cls_scores[score_mask]
- inds = score_mask.nonzero()
- lvl_interval = inds.new_tensor(self.num_grids).pow(2).cumsum(0)
- num_all_points = lvl_interval[-1]
- lvl_start_index = inds.new_ones(num_all_points)
- num_grids = inds.new_ones(num_all_points)
- seg_size = inds.new_tensor(self.num_grids).cumsum(0)
- mask_lvl_start_index = inds.new_ones(num_all_points)
- strides = inds.new_ones(num_all_points)
-
- lvl_start_index[:lvl_interval[0]] *= 0
- mask_lvl_start_index[:lvl_interval[0]] *= 0
- num_grids[:lvl_interval[0]] *= self.num_grids[0]
- strides[:lvl_interval[0]] *= self.strides[0]
-
- for lvl in range(1, self.num_levels):
- lvl_start_index[lvl_interval[lvl - 1]:lvl_interval[lvl]] *= \
- lvl_interval[lvl - 1]
- mask_lvl_start_index[lvl_interval[lvl - 1]:lvl_interval[lvl]] *= \
- seg_size[lvl - 1]
- num_grids[lvl_interval[lvl - 1]:lvl_interval[lvl]] *= \
- self.num_grids[lvl]
- strides[lvl_interval[lvl - 1]:lvl_interval[lvl]] *= \
- self.strides[lvl]
-
- lvl_start_index = lvl_start_index[inds[:, 0]]
- mask_lvl_start_index = mask_lvl_start_index[inds[:, 0]]
- num_grids = num_grids[inds[:, 0]]
- strides = strides[inds[:, 0]]
-
- y_lvl_offset = (inds[:, 0] - lvl_start_index) // num_grids
- x_lvl_offset = (inds[:, 0] - lvl_start_index) % num_grids
- y_inds = mask_lvl_start_index + y_lvl_offset
- x_inds = mask_lvl_start_index + x_lvl_offset
-
- cls_labels = inds[:, 1]
- mask_preds = mask_preds_x[x_inds, ...] * mask_preds_y[y_inds, ...]
-
- masks = mask_preds > cfg.mask_thr
- sum_masks = masks.sum((1, 2)).float()
- keep = sum_masks > strides
- if keep.sum() == 0:
- return empty_results(cls_scores, img_meta['ori_shape'][:2])
-
- masks = masks[keep]
- mask_preds = mask_preds[keep]
- sum_masks = sum_masks[keep]
- cls_scores = cls_scores[keep]
- cls_labels = cls_labels[keep]
-
- # maskness.
- mask_scores = (mask_preds * masks).sum((1, 2)) / sum_masks
- cls_scores *= mask_scores
-
- scores, labels, _, keep_inds = mask_matrix_nms(
- masks,
- cls_labels,
- cls_scores,
- mask_area=sum_masks,
- nms_pre=cfg.nms_pre,
- max_num=cfg.max_per_img,
- kernel=cfg.kernel,
- sigma=cfg.sigma,
- filter_thr=cfg.filter_thr)
- # mask_matrix_nms may return an empty Tensor
- if len(keep_inds) == 0:
- return empty_results(cls_scores, img_meta['ori_shape'][:2])
- mask_preds = mask_preds[keep_inds]
- mask_preds = F.interpolate(
- mask_preds.unsqueeze(0), size=upsampled_size,
- mode='bilinear')[:, :, :h, :w]
- mask_preds = F.interpolate(
- mask_preds, size=img_meta['ori_shape'][:2],
- mode='bilinear').squeeze(0)
- masks = mask_preds > cfg.mask_thr
-
- results = InstanceData()
- results.masks = masks
- results.labels = labels
- results.scores = scores
- # create an empty bbox in InstanceData to avoid bugs when
- # calculating metrics.
- bboxes = mask2bbox(masks)
- # results.bboxes = results.scores.new_zeros(len(scores), 4)
- results.bboxes = bboxes
-
- return results
-
-
-@MODELS.register_module()
-class DecoupledSOLOLightHead(DecoupledSOLOHead):
- """Decoupled Light SOLO mask head used in `SOLO: Segmenting Objects by
- Locations `_
-
- Args:
- with_dcn (bool): Whether use dcn in mask_convs and cls_convs,
- Defaults to False.
- init_cfg (dict or list[dict], optional): Initialization config dict.
- """
-
- def __init__(self,
- *args,
- dcn_cfg: OptConfigType = None,
- init_cfg: MultiConfig = [
- dict(type='Normal', layer='Conv2d', std=0.01),
- dict(
- type='Normal',
- std=0.01,
- bias_prob=0.01,
- override=dict(name='conv_mask_list_x')),
- dict(
- type='Normal',
- std=0.01,
- bias_prob=0.01,
- override=dict(name='conv_mask_list_y')),
- dict(
- type='Normal',
- std=0.01,
- bias_prob=0.01,
- override=dict(name='conv_cls'))
- ],
- **kwargs) -> None:
- assert dcn_cfg is None or isinstance(dcn_cfg, dict)
- self.dcn_cfg = dcn_cfg
- super().__init__(*args, init_cfg=init_cfg, **kwargs)
-
- def _init_layers(self) -> None:
- self.mask_convs = nn.ModuleList()
- self.cls_convs = nn.ModuleList()
-
- for i in range(self.stacked_convs):
- if self.dcn_cfg is not None \
- and i == self.stacked_convs - 1:
- conv_cfg = self.dcn_cfg
- else:
- conv_cfg = None
-
- chn = self.in_channels + 2 if i == 0 else self.feat_channels
- self.mask_convs.append(
- ConvModule(
- chn,
- self.feat_channels,
- 3,
- stride=1,
- padding=1,
- conv_cfg=conv_cfg,
- norm_cfg=self.norm_cfg))
-
- chn = self.in_channels if i == 0 else self.feat_channels
- self.cls_convs.append(
- ConvModule(
- chn,
- self.feat_channels,
- 3,
- stride=1,
- padding=1,
- conv_cfg=conv_cfg,
- norm_cfg=self.norm_cfg))
-
- self.conv_mask_list_x = nn.ModuleList()
- self.conv_mask_list_y = nn.ModuleList()
- for num_grid in self.num_grids:
- self.conv_mask_list_x.append(
- nn.Conv2d(self.feat_channels, num_grid, 3, padding=1))
- self.conv_mask_list_y.append(
- nn.Conv2d(self.feat_channels, num_grid, 3, padding=1))
- self.conv_cls = nn.Conv2d(
- self.feat_channels, self.cls_out_channels, 3, padding=1)
-
- def forward(self, x: Tuple[Tensor]) -> Tuple:
- """Forward features from the upstream network.
-
- Args:
- x (tuple[Tensor]): Features from the upstream network, each is
- a 4D-tensor.
-
- Returns:
- tuple: A tuple of classification scores and mask prediction.
-
- - mlvl_mask_preds_x (list[Tensor]): Multi-level mask prediction
- from x branch. Each element in the list has shape
- (batch_size, num_grids ,h ,w).
- - mlvl_mask_preds_y (list[Tensor]): Multi-level mask prediction
- from y branch. Each element in the list has shape
- (batch_size, num_grids ,h ,w).
- - mlvl_cls_preds (list[Tensor]): Multi-level scores.
- Each element in the list has shape
- (batch_size, num_classes, num_grids ,num_grids).
- """
- assert len(x) == self.num_levels
- feats = self.resize_feats(x)
- mask_preds_x = []
- mask_preds_y = []
- cls_preds = []
- for i in range(self.num_levels):
- x = feats[i]
- mask_feat = x
- cls_feat = x
- # generate and concat the coordinate
- coord_feat = generate_coordinate(mask_feat.size(),
- mask_feat.device)
- mask_feat = torch.cat([mask_feat, coord_feat], 1)
-
- for mask_layer in self.mask_convs:
- mask_feat = mask_layer(mask_feat)
-
- mask_feat = F.interpolate(
- mask_feat, scale_factor=2, mode='bilinear')
-
- mask_pred_x = self.conv_mask_list_x[i](mask_feat)
- mask_pred_y = self.conv_mask_list_y[i](mask_feat)
-
- # cls branch
- for j, cls_layer in enumerate(self.cls_convs):
- if j == self.cls_down_index:
- num_grid = self.num_grids[i]
- cls_feat = F.interpolate(
- cls_feat, size=num_grid, mode='bilinear')
- cls_feat = cls_layer(cls_feat)
-
- cls_pred = self.conv_cls(cls_feat)
-
- if not self.training:
- feat_wh = feats[0].size()[-2:]
- upsampled_size = (feat_wh[0] * 2, feat_wh[1] * 2)
- mask_pred_x = F.interpolate(
- mask_pred_x.sigmoid(),
- size=upsampled_size,
- mode='bilinear')
- mask_pred_y = F.interpolate(
- mask_pred_y.sigmoid(),
- size=upsampled_size,
- mode='bilinear')
- cls_pred = cls_pred.sigmoid()
- # get local maximum
- local_max = F.max_pool2d(cls_pred, 2, stride=1, padding=1)
- keep_mask = local_max[:, :, :-1, :-1] == cls_pred
- cls_pred = cls_pred * keep_mask
-
- mask_preds_x.append(mask_pred_x)
- mask_preds_y.append(mask_pred_y)
- cls_preds.append(cls_pred)
- return mask_preds_x, mask_preds_y, cls_preds
diff --git a/spaces/KyanChen/RSPrompter/mmdet/models/task_modules/assigners/hungarian_assigner.py b/spaces/KyanChen/RSPrompter/mmdet/models/task_modules/assigners/hungarian_assigner.py
deleted file mode 100644
index c120e1cb8c2f9f681e2d228ea3e041316b310766..0000000000000000000000000000000000000000
--- a/spaces/KyanChen/RSPrompter/mmdet/models/task_modules/assigners/hungarian_assigner.py
+++ /dev/null
@@ -1,149 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from typing import List, Optional, Union
-
-import torch
-from mmengine import ConfigDict
-from mmengine.structures import InstanceData
-from scipy.optimize import linear_sum_assignment
-from torch import Tensor
-
-from mmdet.registry import TASK_UTILS
-from .assign_result import AssignResult
-from .base_assigner import BaseAssigner
-
-
-@TASK_UTILS.register_module()
-class HungarianAssigner(BaseAssigner):
- """Computes one-to-one matching between predictions and ground truth.
-
- This class computes an assignment between the targets and the predictions
- based on the costs. The costs are weighted sum of some components.
- For DETR the costs are weighted sum of classification cost, regression L1
- cost and regression iou cost. The targets don't include the no_object, so
- generally there are more predictions than targets. After the one-to-one
- matching, the un-matched are treated as backgrounds. Thus each query
- prediction will be assigned with `0` or a positive integer indicating the
- ground truth index:
-
- - 0: negative sample, no assigned gt
- - positive integer: positive sample, index (1-based) of assigned gt
-
- Args:
- match_costs (:obj:`ConfigDict` or dict or \
- List[Union[:obj:`ConfigDict`, dict]]): Match cost configs.
- """
-
- def __init__(
- self, match_costs: Union[List[Union[dict, ConfigDict]], dict,
- ConfigDict]
- ) -> None:
-
- if isinstance(match_costs, dict):
- match_costs = [match_costs]
- elif isinstance(match_costs, list):
- assert len(match_costs) > 0, \
- 'match_costs must not be a empty list.'
-
- self.match_costs = [
- TASK_UTILS.build(match_cost) for match_cost in match_costs
- ]
-
- def assign(self,
- pred_instances: InstanceData,
- gt_instances: InstanceData,
- img_meta: Optional[dict] = None,
- **kwargs) -> AssignResult:
- """Computes one-to-one matching based on the weighted costs.
-
- This method assign each query prediction to a ground truth or
- background. The `assigned_gt_inds` with -1 means don't care,
- 0 means negative sample, and positive number is the index (1-based)
- of assigned gt.
- The assignment is done in the following steps, the order matters.
-
- 1. assign every prediction to -1
- 2. compute the weighted costs
- 3. do Hungarian matching on CPU based on the costs
- 4. assign all to 0 (background) first, then for each matched pair
- between predictions and gts, treat this prediction as foreground
- and assign the corresponding gt index (plus 1) to it.
-
- Args:
- pred_instances (:obj:`InstanceData`): Instances of model
- predictions. It includes ``priors``, and the priors can
- be anchors or points, or the bboxes predicted by the
- previous stage, has shape (n, 4). The bboxes predicted by
- the current model or stage will be named ``bboxes``,
- ``labels``, and ``scores``, the same as the ``InstanceData``
- in other places. It may includes ``masks``, with shape
- (n, h, w) or (n, l).
- gt_instances (:obj:`InstanceData`): Ground truth of instance
- annotations. It usually includes ``bboxes``, with shape (k, 4),
- ``labels``, with shape (k, ) and ``masks``, with shape
- (k, h, w) or (k, l).
- img_meta (dict): Image information.
-
- Returns:
- :obj:`AssignResult`: The assigned result.
- """
- assert isinstance(gt_instances.labels, Tensor)
- num_gts, num_preds = len(gt_instances), len(pred_instances)
- gt_labels = gt_instances.labels
- device = gt_labels.device
-
- # 1. assign -1 by default
- assigned_gt_inds = torch.full((num_preds, ),
- -1,
- dtype=torch.long,
- device=device)
- assigned_labels = torch.full((num_preds, ),
- -1,
- dtype=torch.long,
- device=device)
-
- if num_gts == 0 or num_preds == 0:
- # import ipdb; ipdb.set_trace()
- # No ground truth or boxes, return empty assignment
- if num_gts == 0:
- # No ground truth, assign all to background
- assigned_gt_inds[:] = 0
- return AssignResult(
- num_gts=num_gts,
- gt_inds=assigned_gt_inds,
- max_overlaps=None,
- labels=assigned_labels)
-
- # 2. compute weighted cost
- cost_list = []
- for match_cost in self.match_costs:
- cost = match_cost(
- pred_instances=pred_instances,
- gt_instances=gt_instances,
- img_meta=img_meta)
- cost_list.append(cost)
- cost = torch.stack(cost_list).sum(dim=0)
-
- # 3. do Hungarian matching on CPU using linear_sum_assignment
- cost = cost.detach().cpu()
- if linear_sum_assignment is None:
- raise ImportError('Please run "pip install scipy" '
- 'to install scipy first.')
- try:
- matched_row_inds, matched_col_inds = linear_sum_assignment(cost)
- except:
- import ipdb
- ipdb.set_trace()
- matched_row_inds = torch.from_numpy(matched_row_inds).to(device)
- matched_col_inds = torch.from_numpy(matched_col_inds).to(device)
-
- # 4. assign backgrounds and foregrounds
- # assign all indices to backgrounds first
- assigned_gt_inds[:] = 0
- # assign foregrounds based on matching results
- assigned_gt_inds[matched_row_inds] = matched_col_inds + 1
- assigned_labels[matched_row_inds] = gt_labels[matched_col_inds]
- return AssignResult(
- num_gts=num_gts,
- gt_inds=assigned_gt_inds,
- max_overlaps=None,
- labels=assigned_labels)
diff --git a/spaces/LZRi/LZR-Bert-VITS2/README.md b/spaces/LZRi/LZR-Bert-VITS2/README.md
deleted file mode 100644
index 84bded960ae78a9bd80a3ae881b2440039baf61e..0000000000000000000000000000000000000000
--- a/spaces/LZRi/LZR-Bert-VITS2/README.md
+++ /dev/null
@@ -1,19 +0,0 @@
----
-title: AI林中日（LZR-Bert-VITS2）
-emoji: 🏫
-colorFrom: blue
-colorTo: green
-sdk: gradio
-sdk_version: 3.45.2
-app_file: app.py
-pinned: false
-license: cc-by-nc-sa-4.0
----
-
-
-
-# LZR-Bert-VITS2
-### AI 林中日语音生成
-**WIP**
-
-
\ No newline at end of file
diff --git a/spaces/Lewdgirl89/Waifu-AI-WebUI/app.py b/spaces/Lewdgirl89/Waifu-AI-WebUI/app.py
deleted file mode 100644
index 5e51c0d452a4f1398806c3b82401337e1d5bc4bb..0000000000000000000000000000000000000000
--- a/spaces/Lewdgirl89/Waifu-AI-WebUI/app.py
+++ /dev/null
@@ -1,50 +0,0 @@
-import os
-from subprocess import getoutput
-
-gpu_info = getoutput('nvidia-smi')
-if("A10G" in gpu_info):
- os.system(f"pip install -q https://github.com/camenduru/stable-diffusion-webui-colab/releases/download/0.0.15/xformers-0.0.15.dev0+4c06c79.d20221205-cp38-cp38-linux_x86_64.whl")
-elif("T4" in gpu_info):
- os.system(f"pip install -q https://github.com/camenduru/stable-diffusion-webui-colab/releases/download/0.0.15/xformers-0.0.15.dev0+1515f77.d20221130-cp38-cp38-linux_x86_64.whl")
-
-os.system(f"git clone -b v1.5 https://github.com/camenduru/stable-diffusion-webui /home/user/app/stable-diffusion-webui")
-os.chdir("/home/user/app/stable-diffusion-webui")
-os.environ['CUDA_VISIBLE_DEVICES'] ='0'
-
-os.system(f"wget -q https://github.com/camenduru/webui/raw/main/env_patch.py -O /home/user/app/env_patch.py")
-os.system(f"sed -i -e '/import image_from_url_text/r /home/user/app/env_patch.py' /home/user/app/stable-diffusion-webui/modules/ui.py")
-os.system(f"sed -i -e '/(modelmerger_interface, \"Checkpoint Merger\", \"modelmerger\"),/d' /home/user/app/stable-diffusion-webui/modules/ui.py")
-os.system(f"sed -i -e '/(train_interface, \"Train\", \"ti\"),/d' /home/user/app/stable-diffusion-webui/modules/ui.py")
-os.system(f"sed -i -e '/extensions_interface, \"Extensions\", \"extensions\"/d' /home/user/app/stable-diffusion-webui/modules/ui.py")
-os.system(f"sed -i -e '/settings_interface, \"Settings\", \"settings\"/d' /home/user/app/stable-diffusion-webui/modules/ui.py")
-os.system(f'''sed -i -e "s/document.getElementsByTagName('gradio-app')\[0\].shadowRoot/!!document.getElementsByTagName('gradio-app')[0].shadowRoot ? document.getElementsByTagName('gradio-app')[0].shadowRoot : document/g" /home/user/app/stable-diffusion-webui/script.js''')
-os.system(f"sed -i -e 's/ show_progress=False,/ show_progress=True,/g' /home/user/app/stable-diffusion-webui/modules/ui.py")
-os.system(f"sed -i -e 's/shared.demo.launch/shared.demo.queue().launch/g' /home/user/app/stable-diffusion-webui/webui.py")
-os.system(f"sed -i -e 's/ outputs=\[/queue=False, &/g' /home/user/app/stable-diffusion-webui/modules/ui.py")
-os.system(f"sed -i -e 's/ queue=False, / /g' /home/user/app/stable-diffusion-webui/modules/ui.py")
-
-if "IS_SHARED_UI" in os.environ:
- os.system(f"rm -rfv /home/user/app/stable-diffusion-webui/scripts/")
-
- os.system(f"wget -q https://github.com/camenduru/webui/raw/main/shared-config.json -O /home/user/app/shared-config.json")
- os.system(f"wget -q https://github.com/camenduru/webui/raw/main/shared-ui-config.json -O /home/user/app/shared-ui-config.json")
-
- os.system(f"wget -q {os.getenv('MODEL_LINK')} -O /home/user/app/stable-diffusion-webui/models/Stable-diffusion/{os.getenv('MODEL_NAME')}")
- os.system(f"wget -q {os.getenv('VAE_LINK')} -O /home/user/app/stable-diffusion-webui/models/Stable-diffusion/{os.getenv('VAE_NAME')}")
- os.system(f"wget -q {os.getenv('YAML_LINK')} -O /home/user/app/stable-diffusion-webui/models/Stable-diffusion/{os.getenv('YAML_NAME')}")
-
- os.system(f"python launch.py --force-enable-xformers --disable-console-progressbars --enable-console-prompts --ui-config-file /home/user/app/shared-ui-config.json --ui-settings-file /home/user/app/shared-config.json --cors-allow-origins huggingface.co,hf.space --no-progressbar-hiding")
-else:
- os.system(f"rm -rfv /home/user/app/stable-diffusion-webui/scripts/")
- # Please duplicate this space and delete # character in front of the custom script you want to use or add here more custom scripts with same structure os.system(f"wget -q https://CUSTOM_SCRIPT_URL -O /home/user/app/stable-diffusion-webui/scripts/CUSTOM_SCRIPT_NAME.py")
- os.system(f"wget -q https://gist.github.com/camenduru/9ec5f8141db9902e375967e93250860f/raw/d0bcf01786f20107c329c03f8968584ee67be12a/run_n_times.py -O /home/user/app/stable-diffusion-webui/scripts/run_n_times.py")
-
- # Please duplicate this space and delete # character in front of the extension you want to use or add here more extensions with same structure os.system(f"git clone https://EXTENSION_GIT_URL /home/user/app/stable-diffusion-webui/extensions/EXTENSION_NAME")
- #os.system(f"git clone https://github.com/camenduru/stable-diffusion-webui-artists-to-study /home/user/app/stable-diffusion-webui/extensions/stable-diffusion-webui-artists-to-study")
-
- # Please duplicate this space and delete # character in front of the model you want to use or add here more ckpts with same structure os.system(f"wget -q https://CKPT_URL -O /home/user/app/stable-diffusion-webui/models/Stable-diffusion/CKPT_NAME.ckpt")
- os.system(f"wget -q https://huggingface.co/Linaqruf/anything-v3.0/resolve/main/Anything-V3.0-pruned.ckpt -O /home/user/app/stable-diffusion-webui/models/Stable-diffusion/Anything-V3.0-pruned.ckpt")
- os.system(f"wget -q https://huggingface.co/Linaqruf/anything-v3.0/resolve/main/Anything-V3.0.vae.pt -O /home/user/app/stable-diffusion-webui/models/Stable-diffusion/Anything-V3.0-pruned.vae.pt")
-
-
- os.system(f"python launch.py --force-enable-xformers --ui-config-file /home/user/app/ui-config.json --ui-settings-file /home/user/app/config.json --disable-console-progressbars --enable-console-prompts --cors-allow-origins huggingface.co,hf.space --no-progressbar-hiding --skip-torch-cuda-test")
\ No newline at end of file
diff --git a/spaces/LinkSoul/Chinese-Llama-2-7b/app.py b/spaces/LinkSoul/Chinese-Llama-2-7b/app.py
deleted file mode 100644
index 0a320817de7935bd65bf9fe6ff010f8a13492e14..0000000000000000000000000000000000000000
--- a/spaces/LinkSoul/Chinese-Llama-2-7b/app.py
+++ /dev/null
@@ -1,279 +0,0 @@
-from typing import Iterator
-
-import gradio as gr
-import torch
-
-from model import get_input_token_length, run
-
-DEFAULT_SYSTEM_PROMPT = """\
-You are a helpful, respectful and honest assistant. Always answer as helpfully as possible, while being safe. Your answers should not include any harmful, unethical, racist, sexist, toxic, dangerous, or illegal content. Please ensure that your responses are socially unbiased and positive in nature.
-
-If a question does not make any sense, or is not factually coherent, explain why instead of answering something not correct. If you don't know the answer to a question, please don't share false information.\
-"""
-MAX_MAX_NEW_TOKENS = 2048
-DEFAULT_MAX_NEW_TOKENS = 1024
-MAX_INPUT_TOKEN_LENGTH = 4000
-
-DESCRIPTION = """
-# Chinese Llama-2 7B Chat
-
-本空间是对于[Chinese-Llama-2-7b-4bit](https://huggingface.co/LinkSoul/Chinese-Llama-2-7b-4bit)和[Chinese-Llama-2-7b](https://huggingface.co/LinkSoul/Chinese-Llama-2-7b)模型的演示。该模型由LinkSoul开发，基于Llama 2基础模型和自行收集的大规模中英文指令数据集[instruction_merge_set](https://huggingface.co/datasets/LinkSoul/instruction_merge_set)训练得到。
-"""
-
-LICENSE = """
-
-
----
-As a derivate work of [Chinese-Llama-2-7b](https://huggingface.co/LinkSoul/Chinese-Llama-2-7b) by LinkSoul and [Llama-2-7b-chat](https://huggingface.co/meta-llama/Llama-2-7b-chat) by Meta,
-this demo is governed by the original [license](https://huggingface.co/spaces/LinkSoul/Chinese-Llama-2-7b/blob/main/LICENSE.txt) and [acceptable use policy](https://huggingface.co/spaces/LinkSoul/Chinese-Llama-2-7b/blob/main/USE_POLICY.md).
-"""
-
-if not torch.cuda.is_available():
- DESCRIPTION += '\n
Running on CPU 🥶 This demo does not work on CPU.
'
-
-
-def clear_and_save_textbox(message: str) -> tuple[str, str]:
- return '', message
-
-
-def display_input(message: str,
- history: list[tuple[str, str]]) -> list[tuple[str, str]]:
- history.append((message, ''))
- return history
-
-
-def delete_prev_fn(
- history: list[tuple[str, str]]) -> tuple[list[tuple[str, str]], str]:
- try:
- message, _ = history.pop()
- except IndexError:
- message = ''
- return history, message or ''
-
-
-def generate(
- message: str,
- history_with_input: list[tuple[str, str]],
- system_prompt: str,
- max_new_tokens: int,
- temperature: float,
- top_p: float,
- top_k: int,
-) -> Iterator[list[tuple[str, str]]]:
- if max_new_tokens > MAX_MAX_NEW_TOKENS:
- raise ValueError
-
- history = history_with_input[:-1]
- generator = run(message, history, system_prompt, max_new_tokens, temperature, top_p, top_k)
- try:
- first_response = next(generator)
- yield history + [(message, first_response)]
- except StopIteration:
- yield history + [(message, '')]
- for response in generator:
- yield history + [(message, response)]
-
-
-def process_example(message: str) -> tuple[str, list[tuple[str, str]]]:
- generator = generate(message, [], DEFAULT_SYSTEM_PROMPT, 1024, 1, 0.95, 50)
- for x in generator:
- pass
- return '', x
-
-
-def check_input_token_length(message: str, chat_history: list[tuple[str, str]], system_prompt: str) -> None:
- input_token_length = get_input_token_length(message, chat_history, system_prompt)
- if input_token_length > MAX_INPUT_TOKEN_LENGTH:
- raise gr.Error(f'The accumulated input is too long ({input_token_length} > {MAX_INPUT_TOKEN_LENGTH}). Clear your chat history and try again.')
-
-
-with gr.Blocks(css='style.css') as demo:
- gr.Markdown(DESCRIPTION)
- gr.DuplicateButton(value='Duplicate Space for private use',
- elem_id='duplicate-button')
-
- with gr.Group():
- chatbot = gr.Chatbot(label='Chatbot')
- with gr.Row():
- textbox = gr.Textbox(
- container=False,
- show_label=False,
- placeholder='Type a message...',
- scale=10,
- )
- submit_button = gr.Button('Submit',
- variant='primary',
- scale=1,
- min_width=0)
- with gr.Row():
- retry_button = gr.Button('🔄 Retry', variant='secondary')
- undo_button = gr.Button('↩️ Undo', variant='secondary')
- clear_button = gr.Button('🗑️ Clear', variant='secondary')
-
- saved_input = gr.State()
-
- with gr.Accordion(label='Advanced options', open=False):
- system_prompt = gr.Textbox(label='System prompt',
- value=DEFAULT_SYSTEM_PROMPT,
- lines=6)
- max_new_tokens = gr.Slider(
- label='Max new tokens',
- minimum=1,
- maximum=MAX_MAX_NEW_TOKENS,
- step=1,
- value=DEFAULT_MAX_NEW_TOKENS,
- )
- temperature = gr.Slider(
- label='Temperature',
- minimum=0.1,
- maximum=4.0,
- step=0.1,
- value=1.0,
- )
- top_p = gr.Slider(
- label='Top-p (nucleus sampling)',
- minimum=0.05,
- maximum=1.0,
- step=0.05,
- value=0.95,
- )
- top_k = gr.Slider(
- label='Top-k',
- minimum=1,
- maximum=1000,
- step=1,
- value=50,
- )
-
- gr.Examples(
- examples=[
- '用中文回答，When is the best time to visit Beijing, and do you have any suggestions for me?',
- '用英文回答，特朗普是谁？',
- 'Hello there! How are you doing?',
- 'Can you explain briefly to me what is the Python programming language?',
- 'Explain the plot of Cinderella in a sentence.',
- 'How many hours does it take a man to eat a Helicopter?',
- "Write a 100-word article on 'Benefits of Open-Source in AI research'",
- ],
- inputs=textbox,
- outputs=[textbox, chatbot],
- fn=process_example,
- cache_examples=True,
- )
-
- gr.Markdown(LICENSE)
-
- textbox.submit(
- fn=clear_and_save_textbox,
- inputs=textbox,
- outputs=[textbox, saved_input],
- api_name=False,
- queue=False,
- ).then(
- fn=display_input,
- inputs=[saved_input, chatbot],
- outputs=chatbot,
- api_name=False,
- queue=False,
- ).then(
- fn=check_input_token_length,
- inputs=[saved_input, chatbot, system_prompt],
- api_name=False,
- queue=False,
- ).success(
- fn=generate,
- inputs=[
- saved_input,
- chatbot,
- system_prompt,
- max_new_tokens,
- temperature,
- top_p,
- top_k,
- ],
- outputs=chatbot,
- api_name=False,
- )
-
- button_event_preprocess = submit_button.click(
- fn=clear_and_save_textbox,
- inputs=textbox,
- outputs=[textbox, saved_input],
- api_name=False,
- queue=False,
- ).then(
- fn=display_input,
- inputs=[saved_input, chatbot],
- outputs=chatbot,
- api_name=False,
- queue=False,
- ).then(
- fn=check_input_token_length,
- inputs=[saved_input, chatbot, system_prompt],
- api_name=False,
- queue=False,
- ).success(
- fn=generate,
- inputs=[
- saved_input,
- chatbot,
- system_prompt,
- max_new_tokens,
- temperature,
- top_p,
- top_k,
- ],
- outputs=chatbot,
- api_name=False,
- )
-
- retry_button.click(
- fn=delete_prev_fn,
- inputs=chatbot,
- outputs=[chatbot, saved_input],
- api_name=False,
- queue=False,
- ).then(
- fn=display_input,
- inputs=[saved_input, chatbot],
- outputs=chatbot,
- api_name=False,
- queue=False,
- ).then(
- fn=generate,
- inputs=[
- saved_input,
- chatbot,
- system_prompt,
- max_new_tokens,
- temperature,
- top_p,
- top_k,
- ],
- outputs=chatbot,
- api_name=False,
- )
-
- undo_button.click(
-
- fn=delete_prev_fn,
- inputs=chatbot,
- outputs=[chatbot, saved_input],
- api_name=False,
- queue=False,
- ).then(
- fn=lambda x: x,
- inputs=[saved_input],
- outputs=textbox,
- api_name=False,
- queue=False,
- )
-
- clear_button.click(
- fn=lambda: ([], ''),
- outputs=[chatbot, saved_input],
- queue=False,
- api_name=False,
- )
-
-demo.queue(max_size=20).launch()
diff --git a/spaces/Loren/Streamlit_OCR_comparator/configs/_base_/recog_models/master.py b/spaces/Loren/Streamlit_OCR_comparator/configs/_base_/recog_models/master.py
deleted file mode 100644
index 39eaef248e132f7ccd6675b63ba21ef41e350c3b..0000000000000000000000000000000000000000
--- a/spaces/Loren/Streamlit_OCR_comparator/configs/_base_/recog_models/master.py
+++ /dev/null
@@ -1,61 +0,0 @@
-label_convertor = dict(
- type='AttnConvertor', dict_type='DICT90', with_unknown=True)
-
-model = dict(
- type='MASTER',
- backbone=dict(
- type='ResNet',
- in_channels=3,
- stem_channels=[64, 128],
- block_cfgs=dict(
- type='BasicBlock',
- plugins=dict(
- cfg=dict(
- type='GCAModule',
- ratio=0.0625,
- n_head=1,
- pooling_type='att',
- is_att_scale=False,
- fusion_type='channel_add'),
- position='after_conv2')),
- arch_layers=[1, 2, 5, 3],
- arch_channels=[256, 256, 512, 512],
- strides=[1, 1, 1, 1],
- plugins=[
- dict(
- cfg=dict(type='Maxpool2d', kernel_size=2, stride=(2, 2)),
- stages=(True, True, False, False),
- position='before_stage'),
- dict(
- cfg=dict(type='Maxpool2d', kernel_size=(2, 1), stride=(2, 1)),
- stages=(False, False, True, False),
- position='before_stage'),
- dict(
- cfg=dict(
- type='ConvModule',
- kernel_size=3,
- stride=1,
- padding=1,
- norm_cfg=dict(type='BN'),
- act_cfg=dict(type='ReLU')),
- stages=(True, True, True, True),
- position='after_stage')
- ],
- init_cfg=[
- dict(type='Kaiming', layer='Conv2d'),
- dict(type='Constant', val=1, layer='BatchNorm2d'),
- ]),
- encoder=None,
- decoder=dict(
- type='MasterDecoder',
- d_model=512,
- n_head=8,
- attn_drop=0.,
- ffn_drop=0.,
- d_inner=2048,
- n_layers=3,
- feat_pe_drop=0.2,
- feat_size=6 * 40),
- loss=dict(type='TFLoss', reduction='mean'),
- label_convertor=label_convertor,
- max_seq_len=30)
diff --git a/spaces/MAGAer13/mPLUG-Owl2/mplug_owl2/serve/__init__.py b/spaces/MAGAer13/mPLUG-Owl2/mplug_owl2/serve/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/Manjushri/MusicGen/audiocraft/models/musicgen.py b/spaces/Manjushri/MusicGen/audiocraft/models/musicgen.py
deleted file mode 100644
index 2870b271d6c41794a9fba817cd7a12dc0c25342b..0000000000000000000000000000000000000000
--- a/spaces/Manjushri/MusicGen/audiocraft/models/musicgen.py
+++ /dev/null
@@ -1,361 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-"""
-Main model for using MusicGen. This will combine all the required components
-and provide easy access to the generation API.
-"""
-
-import os
-import typing as tp
-
-import torch
-
-from .encodec import CompressionModel
-from .lm import LMModel
-from .builders import get_debug_compression_model, get_debug_lm_model
-from .loaders import load_compression_model, load_lm_model, HF_MODEL_CHECKPOINTS_MAP
-from ..data.audio_utils import convert_audio
-from ..modules.conditioners import ConditioningAttributes, WavCondition
-from ..utils.autocast import TorchAutocast
-
-
-MelodyList = tp.List[tp.Optional[torch.Tensor]]
-MelodyType = tp.Union[torch.Tensor, MelodyList]
-
-
-class MusicGen:
- """MusicGen main model with convenient generation API.
-
- Args:
- name (str): name of the model.
- compression_model (CompressionModel): Compression model
- used to map audio to invertible discrete representations.
- lm (LMModel): Language model over discrete representations.
- """
- def __init__(self, name: str, compression_model: CompressionModel, lm: LMModel,
- max_duration: float = 30):
- self.name = name
- self.compression_model = compression_model
- self.lm = lm
- self.max_duration = max_duration
- self.device = next(iter(lm.parameters())).device
- self.generation_params: dict = {}
- self.set_generation_params(duration=15) # 15 seconds by default
- self._progress_callback: tp.Optional[tp.Callable[[int, int], None]] = None
- if self.device.type == 'cpu':
- self.autocast = TorchAutocast(enabled=False)
- else:
- self.autocast = TorchAutocast(
- enabled=True, device_type=self.device.type, dtype=torch.float16)
-
- @property
- def frame_rate(self) -> int:
- """Roughly the number of AR steps per seconds."""
- return self.compression_model.frame_rate
-
- @property
- def sample_rate(self) -> int:
- """Sample rate of the generated audio."""
- return self.compression_model.sample_rate
-
- @property
- def audio_channels(self) -> int:
- """Audio channels of the generated audio."""
- return self.compression_model.channels
-
- @staticmethod
- def get_pretrained(name: str = 'melody', device=None):
- """Return pretrained model, we provide four models:
- - small (300M), text to music, # see: https://huggingface.co/facebook/musicgen-small
- - medium (1.5B), text to music, # see: https://huggingface.co/facebook/musicgen-medium
- - melody (1.5B) text to music and text+melody to music, # see: https://huggingface.co/facebook/musicgen-melody
- - large (3.3B), text to music, # see: https://huggingface.co/facebook/musicgen-large
- """
-
- if device is None:
- if torch.cuda.device_count():
- device = 'cuda'
- else:
- device = 'cpu'
-
- if name == 'debug':
- # used only for unit tests
- compression_model = get_debug_compression_model(device)
- lm = get_debug_lm_model(device)
- return MusicGen(name, compression_model, lm)
-
- if name not in HF_MODEL_CHECKPOINTS_MAP:
- raise ValueError(
- f"{name} is not a valid checkpoint name. "
- f"Choose one of {', '.join(HF_MODEL_CHECKPOINTS_MAP.keys())}"
- )
-
- cache_dir = os.environ.get('MUSICGEN_ROOT', None)
- compression_model = load_compression_model(name, device=device, cache_dir=cache_dir)
- lm = load_lm_model(name, device=device, cache_dir=cache_dir)
- if name == 'melody':
- lm.condition_provider.conditioners['self_wav'].match_len_on_eval = True
-
- return MusicGen(name, compression_model, lm)
-
- def set_generation_params(self, use_sampling: bool = True, top_k: int = 250,
- top_p: float = 0.0, temperature: float = 1.0,
- duration: float = 30.0, cfg_coef: float = 3.0,
- two_step_cfg: bool = False, extend_stride: float = 18):
- """Set the generation parameters for MusicGen.
-
- Args:
- use_sampling (bool, optional): Use sampling if True, else do argmax decoding. Defaults to True.
- top_k (int, optional): top_k used for sampling. Defaults to 250.
- top_p (float, optional): top_p used for sampling, when set to 0 top_k is used. Defaults to 0.0.
- temperature (float, optional): Softmax temperature parameter. Defaults to 1.0.
- duration (float, optional): Duration of the generated waveform. Defaults to 30.0.
- cfg_coef (float, optional): Coefficient used for classifier free guidance. Defaults to 3.0.
- two_step_cfg (bool, optional): If True, performs 2 forward for Classifier Free Guidance,
- instead of batching together the two. This has some impact on how things
- are padded but seems to have little impact in practice.
- extend_stride: when doing extended generation (i.e. more than 30 seconds), by how much
- should we extend the audio each time. Larger values will mean less context is
- preserved, and shorter value will require extra computations.
- """
- assert extend_stride < self.max_duration, "Cannot stride by more than max generation duration."
- self.extend_stride = extend_stride
- self.duration = duration
- self.generation_params = {
- 'use_sampling': use_sampling,
- 'temp': temperature,
- 'top_k': top_k,
- 'top_p': top_p,
- 'cfg_coef': cfg_coef,
- 'two_step_cfg': two_step_cfg,
- }
-
- def set_custom_progress_callback(self, progress_callback: tp.Optional[tp.Callable[[int, int], None]] = None):
- """Override the default progress callback."""
- self._progress_callback = progress_callback
-
- def generate_unconditional(self, num_samples: int, progress: bool = False) -> torch.Tensor:
- """Generate samples in an unconditional manner.
-
- Args:
- num_samples (int): Number of samples to be generated.
- progress (bool, optional): Flag to display progress of the generation process. Defaults to False.
- """
- descriptions: tp.List[tp.Optional[str]] = [None] * num_samples
- attributes, prompt_tokens = self._prepare_tokens_and_attributes(descriptions, None)
- return self._generate_tokens(attributes, prompt_tokens, progress)
-
- def generate(self, descriptions: tp.List[str], progress: bool = False) -> torch.Tensor:
- """Generate samples conditioned on text.
-
- Args:
- descriptions (tp.List[str]): A list of strings used as text conditioning.
- progress (bool, optional): Flag to display progress of the generation process. Defaults to False.
- """
- attributes, prompt_tokens = self._prepare_tokens_and_attributes(descriptions, None)
- assert prompt_tokens is None
- return self._generate_tokens(attributes, prompt_tokens, progress)
-
- def generate_with_chroma(self, descriptions: tp.List[str], melody_wavs: MelodyType,
- melody_sample_rate: int, progress: bool = False) -> torch.Tensor:
- """Generate samples conditioned on text and melody.
-
- Args:
- descriptions (tp.List[str]): A list of strings used as text conditioning.
- melody_wavs: (torch.Tensor or list of Tensor): A batch of waveforms used as
- melody conditioning. Should have shape [B, C, T] with B matching the description length,
- C=1 or 2. It can be [C, T] if there is a single description. It can also be
- a list of [C, T] tensors.
- melody_sample_rate: (int): Sample rate of the melody waveforms.
- progress (bool, optional): Flag to display progress of the generation process. Defaults to False.
- """
- if isinstance(melody_wavs, torch.Tensor):
- if melody_wavs.dim() == 2:
- melody_wavs = melody_wavs[None]
- if melody_wavs.dim() != 3:
- raise ValueError("Melody wavs should have a shape [B, C, T].")
- melody_wavs = list(melody_wavs)
- else:
- for melody in melody_wavs:
- if melody is not None:
- assert melody.dim() == 2, "One melody in the list has the wrong number of dims."
-
- melody_wavs = [
- convert_audio(wav, melody_sample_rate, self.sample_rate, self.audio_channels)
- if wav is not None else None
- for wav in melody_wavs]
- attributes, prompt_tokens = self._prepare_tokens_and_attributes(descriptions=descriptions, prompt=None,
- melody_wavs=melody_wavs)
- assert prompt_tokens is None
- return self._generate_tokens(attributes, prompt_tokens, progress)
-
- def generate_continuation(self, prompt: torch.Tensor, prompt_sample_rate: int,
- descriptions: tp.Optional[tp.List[tp.Optional[str]]] = None,
- progress: bool = False) -> torch.Tensor:
- """Generate samples conditioned on audio prompts.
-
- Args:
- prompt (torch.Tensor): A batch of waveforms used for continuation.
- Prompt should be [B, C, T], or [C, T] if only one sample is generated.
- prompt_sample_rate (int): Sampling rate of the given audio waveforms.
- descriptions (tp.List[str], optional): A list of strings used as text conditioning. Defaults to None.
- progress (bool, optional): Flag to display progress of the generation process. Defaults to False.
- """
- if prompt.dim() == 2:
- prompt = prompt[None]
- if prompt.dim() != 3:
- raise ValueError("prompt should have 3 dimensions: [B, C, T] (C = 1).")
- prompt = convert_audio(prompt, prompt_sample_rate, self.sample_rate, self.audio_channels)
- if descriptions is None:
- descriptions = [None] * len(prompt)
- attributes, prompt_tokens = self._prepare_tokens_and_attributes(descriptions, prompt)
- assert prompt_tokens is not None
- return self._generate_tokens(attributes, prompt_tokens, progress)
-
- @torch.no_grad()
- def _prepare_tokens_and_attributes(
- self,
- descriptions: tp.Sequence[tp.Optional[str]],
- prompt: tp.Optional[torch.Tensor],
- melody_wavs: tp.Optional[MelodyList] = None,
- ) -> tp.Tuple[tp.List[ConditioningAttributes], tp.Optional[torch.Tensor]]:
- """Prepare model inputs.
-
- Args:
- descriptions (tp.List[str]): A list of strings used as text conditioning.
- prompt (torch.Tensor): A batch of waveforms used for continuation.
- melody_wavs (tp.Optional[torch.Tensor], optional): A batch of waveforms
- used as melody conditioning. Defaults to None.
- """
- attributes = [
- ConditioningAttributes(text={'description': description})
- for description in descriptions]
-
- if melody_wavs is None:
- for attr in attributes:
- attr.wav['self_wav'] = WavCondition(
- torch.zeros((1, 1), device=self.device),
- torch.tensor([0], device=self.device),
- path='null_wav') # type: ignore
- else:
- if self.name != "melody":
- raise RuntimeError("This model doesn't support melody conditioning. "
- "Use the `melody` model.")
- assert len(melody_wavs) == len(descriptions), \
- f"number of melody wavs must match number of descriptions! " \
- f"got melody len={len(melody_wavs)}, and descriptions len={len(descriptions)}"
- for attr, melody in zip(attributes, melody_wavs):
- if melody is None:
- attr.wav['self_wav'] = WavCondition(
- torch.zeros((1, 1), device=self.device),
- torch.tensor([0], device=self.device),
- path='null_wav') # type: ignore
- else:
- attr.wav['self_wav'] = WavCondition(
- melody.to(device=self.device),
- torch.tensor([melody.shape[-1]], device=self.device))
-
- if prompt is not None:
- if descriptions is not None:
- assert len(descriptions) == len(prompt), "Prompt and nb. descriptions doesn't match"
- prompt = prompt.to(self.device)
- prompt_tokens, scale = self.compression_model.encode(prompt)
- assert scale is None
- else:
- prompt_tokens = None
- return attributes, prompt_tokens
-
- def _generate_tokens(self, attributes: tp.List[ConditioningAttributes],
- prompt_tokens: tp.Optional[torch.Tensor], progress: bool = False) -> torch.Tensor:
- """Generate discrete audio tokens given audio prompt and/or conditions.
-
- Args:
- attributes (tp.List[ConditioningAttributes]): Conditions used for generation (text/melody).
- prompt_tokens (tp.Optional[torch.Tensor]): Audio prompt used for continuation.
- progress (bool, optional): Flag to display progress of the generation process. Defaults to False.
- Returns:
- torch.Tensor: Generated audio, of shape [B, C, T], T is defined by the generation params.
- """
- total_gen_len = int(self.duration * self.frame_rate)
- max_prompt_len = int(min(self.duration, self.max_duration) * self.frame_rate)
- current_gen_offset: int = 0
-
- def _progress_callback(generated_tokens: int, tokens_to_generate: int):
- generated_tokens += current_gen_offset
- if self._progress_callback is not None:
- # Note that total_gen_len might be quite wrong depending on the
- # codebook pattern used, but with delay it is almost accurate.
- self._progress_callback(generated_tokens, total_gen_len)
- else:
- print(f'{generated_tokens: 6d} / {total_gen_len: 6d}', end='\r')
-
- if prompt_tokens is not None:
- assert max_prompt_len >= prompt_tokens.shape[-1], \
- "Prompt is longer than audio to generate"
-
- callback = None
- if progress:
- callback = _progress_callback
-
- if self.duration <= self.max_duration:
- # generate by sampling from LM, simple case.
- with self.autocast:
- gen_tokens = self.lm.generate(
- prompt_tokens, attributes,
- callback=callback, max_gen_len=total_gen_len, **self.generation_params)
-
- else:
- # now this gets a bit messier, we need to handle prompts,
- # melody conditioning etc.
- ref_wavs = [attr.wav['self_wav'] for attr in attributes]
- all_tokens = []
- if prompt_tokens is None:
- prompt_length = 0
- else:
- all_tokens.append(prompt_tokens)
- prompt_length = prompt_tokens.shape[-1]
-
- stride_tokens = int(self.frame_rate * self.extend_stride)
-
- while current_gen_offset + prompt_length < total_gen_len:
- time_offset = current_gen_offset / self.frame_rate
- chunk_duration = min(self.duration - time_offset, self.max_duration)
- max_gen_len = int(chunk_duration * self.frame_rate)
- for attr, ref_wav in zip(attributes, ref_wavs):
- wav_length = ref_wav.length.item()
- if wav_length == 0:
- continue
- # We will extend the wav periodically if it not long enough.
- # we have to do it here rather than in conditioners.py as otherwise
- # we wouldn't have the full wav.
- initial_position = int(time_offset * self.sample_rate)
- wav_target_length = int(self.max_duration * self.sample_rate)
- print(initial_position / self.sample_rate, wav_target_length / self.sample_rate)
- positions = torch.arange(initial_position,
- initial_position + wav_target_length, device=self.device)
- attr.wav['self_wav'] = WavCondition(
- ref_wav[0][:, positions % wav_length],
- torch.full_like(ref_wav[1], wav_target_length))
- with self.autocast:
- gen_tokens = self.lm.generate(
- prompt_tokens, attributes,
- callback=callback, max_gen_len=max_gen_len, **self.generation_params)
- if prompt_tokens is None:
- all_tokens.append(gen_tokens)
- else:
- all_tokens.append(gen_tokens[:, :, prompt_tokens.shape[-1]:])
- prompt_tokens = gen_tokens[:, :, stride_tokens:]
- prompt_length = prompt_tokens.shape[-1]
- current_gen_offset += stride_tokens
-
- gen_tokens = torch.cat(all_tokens, dim=-1)
-
- # generate audio
- assert gen_tokens.dim() == 3
- with torch.no_grad():
- gen_audio = self.compression_model.decode(gen_tokens, None)
- return gen_audio
diff --git a/spaces/Mellow-ai/PhotoAI_Mellow/annotator/uniformer/mmseg/core/evaluation/__init__.py b/spaces/Mellow-ai/PhotoAI_Mellow/annotator/uniformer/mmseg/core/evaluation/__init__.py
deleted file mode 100644
index f7cc4b23413a0639e9de00eeb0bf600632d2c6cd..0000000000000000000000000000000000000000
--- a/spaces/Mellow-ai/PhotoAI_Mellow/annotator/uniformer/mmseg/core/evaluation/__init__.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from .class_names import get_classes, get_palette
-from .eval_hooks import DistEvalHook, EvalHook
-from .metrics import eval_metrics, mean_dice, mean_fscore, mean_iou
-
-__all__ = [
- 'EvalHook', 'DistEvalHook', 'mean_dice', 'mean_iou', 'mean_fscore',
- 'eval_metrics', 'get_classes', 'get_palette'
-]
diff --git a/spaces/Mellow-ai/PhotoAI_Mellow/ldm/models/autoencoder.py b/spaces/Mellow-ai/PhotoAI_Mellow/ldm/models/autoencoder.py
deleted file mode 100644
index d122549995ce2cd64092c81a58419ed4a15a02fd..0000000000000000000000000000000000000000
--- a/spaces/Mellow-ai/PhotoAI_Mellow/ldm/models/autoencoder.py
+++ /dev/null
@@ -1,219 +0,0 @@
-import torch
-import pytorch_lightning as pl
-import torch.nn.functional as F
-from contextlib import contextmanager
-
-from ldm.modules.diffusionmodules.model import Encoder, Decoder
-from ldm.modules.distributions.distributions import DiagonalGaussianDistribution
-
-from ldm.util import instantiate_from_config
-from ldm.modules.ema import LitEma
-
-
-class AutoencoderKL(pl.LightningModule):
- def __init__(self,
- ddconfig,
- lossconfig,
- embed_dim,
- ckpt_path=None,
- ignore_keys=[],
- image_key="image",
- colorize_nlabels=None,
- monitor=None,
- ema_decay=None,
- learn_logvar=False
- ):
- super().__init__()
- self.learn_logvar = learn_logvar
- self.image_key = image_key
- self.encoder = Encoder(**ddconfig)
- self.decoder = Decoder(**ddconfig)
- self.loss = instantiate_from_config(lossconfig)
- assert ddconfig["double_z"]
- self.quant_conv = torch.nn.Conv2d(2*ddconfig["z_channels"], 2*embed_dim, 1)
- self.post_quant_conv = torch.nn.Conv2d(embed_dim, ddconfig["z_channels"], 1)
- self.embed_dim = embed_dim
- if colorize_nlabels is not None:
- assert type(colorize_nlabels)==int
- self.register_buffer("colorize", torch.randn(3, colorize_nlabels, 1, 1))
- if monitor is not None:
- self.monitor = monitor
-
- self.use_ema = ema_decay is not None
- if self.use_ema:
- self.ema_decay = ema_decay
- assert 0. < ema_decay < 1.
- self.model_ema = LitEma(self, decay=ema_decay)
- print(f"Keeping EMAs of {len(list(self.model_ema.buffers()))}.")
-
- if ckpt_path is not None:
- self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys)
-
- def init_from_ckpt(self, path, ignore_keys=list()):
- sd = torch.load(path, map_location="cpu")["state_dict"]
- keys = list(sd.keys())
- for k in keys:
- for ik in ignore_keys:
- if k.startswith(ik):
- print("Deleting key {} from state_dict.".format(k))
- del sd[k]
- self.load_state_dict(sd, strict=False)
- print(f"Restored from {path}")
-
- @contextmanager
- def ema_scope(self, context=None):
- if self.use_ema:
- self.model_ema.store(self.parameters())
- self.model_ema.copy_to(self)
- if context is not None:
- print(f"{context}: Switched to EMA weights")
- try:
- yield None
- finally:
- if self.use_ema:
- self.model_ema.restore(self.parameters())
- if context is not None:
- print(f"{context}: Restored training weights")
-
- def on_train_batch_end(self, *args, **kwargs):
- if self.use_ema:
- self.model_ema(self)
-
- def encode(self, x):
- h = self.encoder(x)
- moments = self.quant_conv(h)
- posterior = DiagonalGaussianDistribution(moments)
- return posterior
-
- def decode(self, z):
- z = self.post_quant_conv(z)
- dec = self.decoder(z)
- return dec
-
- def forward(self, input, sample_posterior=True):
- posterior = self.encode(input)
- if sample_posterior:
- z = posterior.sample()
- else:
- z = posterior.mode()
- dec = self.decode(z)
- return dec, posterior
-
- def get_input(self, batch, k):
- x = batch[k]
- if len(x.shape) == 3:
- x = x[..., None]
- x = x.permute(0, 3, 1, 2).to(memory_format=torch.contiguous_format).float()
- return x
-
- def training_step(self, batch, batch_idx, optimizer_idx):
- inputs = self.get_input(batch, self.image_key)
- reconstructions, posterior = self(inputs)
-
- if optimizer_idx == 0:
- # train encoder+decoder+logvar
- aeloss, log_dict_ae = self.loss(inputs, reconstructions, posterior, optimizer_idx, self.global_step,
- last_layer=self.get_last_layer(), split="train")
- self.log("aeloss", aeloss, prog_bar=True, logger=True, on_step=True, on_epoch=True)
- self.log_dict(log_dict_ae, prog_bar=False, logger=True, on_step=True, on_epoch=False)
- return aeloss
-
- if optimizer_idx == 1:
- # train the discriminator
- discloss, log_dict_disc = self.loss(inputs, reconstructions, posterior, optimizer_idx, self.global_step,
- last_layer=self.get_last_layer(), split="train")
-
- self.log("discloss", discloss, prog_bar=True, logger=True, on_step=True, on_epoch=True)
- self.log_dict(log_dict_disc, prog_bar=False, logger=True, on_step=True, on_epoch=False)
- return discloss
-
- def validation_step(self, batch, batch_idx):
- log_dict = self._validation_step(batch, batch_idx)
- with self.ema_scope():
- log_dict_ema = self._validation_step(batch, batch_idx, postfix="_ema")
- return log_dict
-
- def _validation_step(self, batch, batch_idx, postfix=""):
- inputs = self.get_input(batch, self.image_key)
- reconstructions, posterior = self(inputs)
- aeloss, log_dict_ae = self.loss(inputs, reconstructions, posterior, 0, self.global_step,
- last_layer=self.get_last_layer(), split="val"+postfix)
-
- discloss, log_dict_disc = self.loss(inputs, reconstructions, posterior, 1, self.global_step,
- last_layer=self.get_last_layer(), split="val"+postfix)
-
- self.log(f"val{postfix}/rec_loss", log_dict_ae[f"val{postfix}/rec_loss"])
- self.log_dict(log_dict_ae)
- self.log_dict(log_dict_disc)
- return self.log_dict
-
- def configure_optimizers(self):
- lr = self.learning_rate
- ae_params_list = list(self.encoder.parameters()) + list(self.decoder.parameters()) + list(
- self.quant_conv.parameters()) + list(self.post_quant_conv.parameters())
- if self.learn_logvar:
- print(f"{self.__class__.__name__}: Learning logvar")
- ae_params_list.append(self.loss.logvar)
- opt_ae = torch.optim.Adam(ae_params_list,
- lr=lr, betas=(0.5, 0.9))
- opt_disc = torch.optim.Adam(self.loss.discriminator.parameters(),
- lr=lr, betas=(0.5, 0.9))
- return [opt_ae, opt_disc], []
-
- def get_last_layer(self):
- return self.decoder.conv_out.weight
-
- @torch.no_grad()
- def log_images(self, batch, only_inputs=False, log_ema=False, **kwargs):
- log = dict()
- x = self.get_input(batch, self.image_key)
- x = x.to(self.device)
- if not only_inputs:
- xrec, posterior = self(x)
- if x.shape[1] > 3:
- # colorize with random projection
- assert xrec.shape[1] > 3
- x = self.to_rgb(x)
- xrec = self.to_rgb(xrec)
- log["samples"] = self.decode(torch.randn_like(posterior.sample()))
- log["reconstructions"] = xrec
- if log_ema or self.use_ema:
- with self.ema_scope():
- xrec_ema, posterior_ema = self(x)
- if x.shape[1] > 3:
- # colorize with random projection
- assert xrec_ema.shape[1] > 3
- xrec_ema = self.to_rgb(xrec_ema)
- log["samples_ema"] = self.decode(torch.randn_like(posterior_ema.sample()))
- log["reconstructions_ema"] = xrec_ema
- log["inputs"] = x
- return log
-
- def to_rgb(self, x):
- assert self.image_key == "segmentation"
- if not hasattr(self, "colorize"):
- self.register_buffer("colorize", torch.randn(3, x.shape[1], 1, 1).to(x))
- x = F.conv2d(x, weight=self.colorize)
- x = 2.*(x-x.min())/(x.max()-x.min()) - 1.
- return x
-
-
-class IdentityFirstStage(torch.nn.Module):
- def __init__(self, *args, vq_interface=False, **kwargs):
- self.vq_interface = vq_interface
- super().__init__()
-
- def encode(self, x, *args, **kwargs):
- return x
-
- def decode(self, x, *args, **kwargs):
- return x
-
- def quantize(self, x, *args, **kwargs):
- if self.vq_interface:
- return x, None, [None, None, None]
- return x
-
- def forward(self, x, *args, **kwargs):
- return x
-
diff --git a/spaces/MichaelWelsch/FreeVC/speaker_encoder/compute_embed.py b/spaces/MichaelWelsch/FreeVC/speaker_encoder/compute_embed.py
deleted file mode 100644
index 2fee33db0168f40efc42145c06fa62016e3e008e..0000000000000000000000000000000000000000
--- a/spaces/MichaelWelsch/FreeVC/speaker_encoder/compute_embed.py
+++ /dev/null
@@ -1,40 +0,0 @@
-from speaker_encoder import inference as encoder
-from multiprocessing.pool import Pool
-from functools import partial
-from pathlib import Path
-# from utils import logmmse
-# from tqdm import tqdm
-# import numpy as np
-# import librosa
-
-
-def embed_utterance(fpaths, encoder_model_fpath):
- if not encoder.is_loaded():
- encoder.load_model(encoder_model_fpath)
-
- # Compute the speaker embedding of the utterance
- wav_fpath, embed_fpath = fpaths
- wav = np.load(wav_fpath)
- wav = encoder.preprocess_wav(wav)
- embed = encoder.embed_utterance(wav)
- np.save(embed_fpath, embed, allow_pickle=False)
-
-
-def create_embeddings(outdir_root: Path, wav_dir: Path, encoder_model_fpath: Path, n_processes: int):
-
- wav_dir = outdir_root.joinpath("audio")
- metadata_fpath = synthesizer_root.joinpath("train.txt")
- assert wav_dir.exists() and metadata_fpath.exists()
- embed_dir = synthesizer_root.joinpath("embeds")
- embed_dir.mkdir(exist_ok=True)
-
- # Gather the input wave filepath and the target output embed filepath
- with metadata_fpath.open("r") as metadata_file:
- metadata = [line.split("|") for line in metadata_file]
- fpaths = [(wav_dir.joinpath(m[0]), embed_dir.joinpath(m[2])) for m in metadata]
-
- # TODO: improve on the multiprocessing, it's terrible. Disk I/O is the bottleneck here.
- # Embed the utterances in separate threads
- func = partial(embed_utterance, encoder_model_fpath=encoder_model_fpath)
- job = Pool(n_processes).imap(func, fpaths)
- list(tqdm(job, "Embedding", len(fpaths), unit="utterances"))
\ No newline at end of file
diff --git a/spaces/Mountchicken/MAERec-Gradio/configs/textdet/psenet/psenet_resnet50_fpnf_600e_icdar2017.py b/spaces/Mountchicken/MAERec-Gradio/configs/textdet/psenet/psenet_resnet50_fpnf_600e_icdar2017.py
deleted file mode 100644
index a1bec586e96a51ddf2efa9b74d6b7354d32e8053..0000000000000000000000000000000000000000
--- a/spaces/Mountchicken/MAERec-Gradio/configs/textdet/psenet/psenet_resnet50_fpnf_600e_icdar2017.py
+++ /dev/null
@@ -1,16 +0,0 @@
-_base_ = [
- 'psenet_resnet50_fpnf_600e_icdar2015.py',
- '../_base_/datasets/icdar2017.py',
-]
-
-icdar2017_textdet_train = _base_.icdar2017_textdet_train
-icdar2017_textdet_test = _base_.icdar2017_textdet_test
-# use the same pipeline as icdar2015
-icdar2017_textdet_train.pipeline = _base_.train_pipeline
-icdar2017_textdet_test.pipeline = _base_.test_pipeline
-
-train_dataloader = dict(dataset=icdar2017_textdet_train)
-val_dataloader = dict(dataset=icdar2017_textdet_test)
-test_dataloader = val_dataloader
-
-auto_scale_lr = dict(base_batch_size=64 * 4)
diff --git a/spaces/Nee001/bing0/src/components/markdown.tsx b/spaces/Nee001/bing0/src/components/markdown.tsx
deleted file mode 100644
index d4491467a1f14d1d72e535caac9c40636054e5df..0000000000000000000000000000000000000000
--- a/spaces/Nee001/bing0/src/components/markdown.tsx
+++ /dev/null
@@ -1,9 +0,0 @@
-import { FC, memo } from 'react'
-import ReactMarkdown, { Options } from 'react-markdown'
-
-export const MemoizedReactMarkdown: FC = memo(
- ReactMarkdown,
- (prevProps, nextProps) =>
- prevProps.children === nextProps.children &&
- prevProps.className === nextProps.className
-)
diff --git a/spaces/Nexxt/MagicPrompt-Stable-Diffusion/app.py b/spaces/Nexxt/MagicPrompt-Stable-Diffusion/app.py
deleted file mode 100644
index 4ef904995708514c1b101049af73529e23c1a3ab..0000000000000000000000000000000000000000
--- a/spaces/Nexxt/MagicPrompt-Stable-Diffusion/app.py
+++ /dev/null
@@ -1,54 +0,0 @@
-from transformers import pipeline, set_seed
-import gradio as grad, random, re
-
-
-gpt2_pipe = pipeline('text-generation', model='Gustavosta/MagicPrompt-Stable-Diffusion', tokenizer='gpt2')
-with open("ideas.txt", "r") as f:
- line = f.readlines()
-
-
-def generate(starting_text):
- seed = random.randint(100, 1000000)
- set_seed(seed)
-
- if starting_text == "":
- starting_text: str = line[random.randrange(0, len(line))].replace("\n", "").lower().capitalize()
- starting_text: str = re.sub(r"[,:\-–.!;?_]", '', starting_text)
-
- response = gpt2_pipe(starting_text, max_length=(len(starting_text) + random.randint(60, 90)), num_return_sequences=4)
- response_list = []
- for x in response:
- resp = x['generated_text'].strip()
- if resp != starting_text and len(resp) > (len(starting_text) + 4) and resp.endswith((":", "-", "—")) is False:
- response_list.append(resp+'\n')
-
- response_end = "\n".join(response_list)
- response_end = re.sub('[^ ]+\.[^ ]+','', response_end)
- response_end = response_end.replace("<", "").replace(">", "")
-
- if response_end != "":
- return response_end
-
-
-txt = grad.Textbox(lines=1, label="Initial Text", placeholder="English Text here")
-out = grad.Textbox(lines=4, label="Generated Prompts")
-
-examples = []
-for x in range(8):
- examples.append(line[random.randrange(0, len(line))].replace("\n", "").lower().capitalize())
-
-title = "Stable Diffusion Prompt Generator"
-description = 'This is a demo of the model series: "MagicPrompt", in this case, aimed at: "Stable Diffusion". To use it, simply submit your text or click on one of the examples. To learn more about the model, [click here](https://huggingface.co/Gustavosta/MagicPrompt-Stable-Diffusion). '
-
-grad.Interface(fn=generate,
- inputs=txt,
- outputs=out,
- examples=examples,
- title=title,
- description=description,
- article='',
- allow_flagging='never',
- cache_examples=False,
- theme="default").launch(enable_queue=True, debug=True)
-
-
diff --git a/spaces/Nick1/rvc-models/lib/infer_pack/models.py b/spaces/Nick1/rvc-models/lib/infer_pack/models.py
deleted file mode 100644
index 3665d03bc0514a6ed07d3372ea24717dae1e0a65..0000000000000000000000000000000000000000
--- a/spaces/Nick1/rvc-models/lib/infer_pack/models.py
+++ /dev/null
@@ -1,1142 +0,0 @@
-import math, pdb, os
-from time import time as ttime
-import torch
-from torch import nn
-from torch.nn import functional as F
-from lib.infer_pack import modules
-from lib.infer_pack import attentions
-from lib.infer_pack import commons
-from lib.infer_pack.commons import init_weights, get_padding
-from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
-from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
-from lib.infer_pack.commons import init_weights
-import numpy as np
-from lib.infer_pack import commons
-
-
-class TextEncoder256(nn.Module):
- def __init__(
- self,
- out_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- f0=True,
- ):
- super().__init__()
- self.out_channels = out_channels
- self.hidden_channels = hidden_channels
- self.filter_channels = filter_channels
- self.n_heads = n_heads
- self.n_layers = n_layers
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.emb_phone = nn.Linear(256, hidden_channels)
- self.lrelu = nn.LeakyReLU(0.1, inplace=True)
- if f0 == True:
- self.emb_pitch = nn.Embedding(256, hidden_channels) # pitch 256
- self.encoder = attentions.Encoder(
- hidden_channels, filter_channels, n_heads, n_layers, kernel_size, p_dropout
- )
- self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
- def forward(self, phone, pitch, lengths):
- if pitch == None:
- x = self.emb_phone(phone)
- else:
- x = self.emb_phone(phone) + self.emb_pitch(pitch)
- x = x * math.sqrt(self.hidden_channels) # [b, t, h]
- x = self.lrelu(x)
- x = torch.transpose(x, 1, -1) # [b, h, t]
- x_mask = torch.unsqueeze(commons.sequence_mask(lengths, x.size(2)), 1).to(
- x.dtype
- )
- x = self.encoder(x * x_mask, x_mask)
- stats = self.proj(x) * x_mask
-
- m, logs = torch.split(stats, self.out_channels, dim=1)
- return m, logs, x_mask
-
-
-class TextEncoder768(nn.Module):
- def __init__(
- self,
- out_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- f0=True,
- ):
- super().__init__()
- self.out_channels = out_channels
- self.hidden_channels = hidden_channels
- self.filter_channels = filter_channels
- self.n_heads = n_heads
- self.n_layers = n_layers
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.emb_phone = nn.Linear(768, hidden_channels)
- self.lrelu = nn.LeakyReLU(0.1, inplace=True)
- if f0 == True:
- self.emb_pitch = nn.Embedding(256, hidden_channels) # pitch 256
- self.encoder = attentions.Encoder(
- hidden_channels, filter_channels, n_heads, n_layers, kernel_size, p_dropout
- )
- self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
- def forward(self, phone, pitch, lengths):
- if pitch == None:
- x = self.emb_phone(phone)
- else:
- x = self.emb_phone(phone) + self.emb_pitch(pitch)
- x = x * math.sqrt(self.hidden_channels) # [b, t, h]
- x = self.lrelu(x)
- x = torch.transpose(x, 1, -1) # [b, h, t]
- x_mask = torch.unsqueeze(commons.sequence_mask(lengths, x.size(2)), 1).to(
- x.dtype
- )
- x = self.encoder(x * x_mask, x_mask)
- stats = self.proj(x) * x_mask
-
- m, logs = torch.split(stats, self.out_channels, dim=1)
- return m, logs, x_mask
-
-
-class ResidualCouplingBlock(nn.Module):
- def __init__(
- self,
- channels,
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- n_flows=4,
- gin_channels=0,
- ):
- super().__init__()
- self.channels = channels
- self.hidden_channels = hidden_channels
- self.kernel_size = kernel_size
- self.dilation_rate = dilation_rate
- self.n_layers = n_layers
- self.n_flows = n_flows
- self.gin_channels = gin_channels
-
- self.flows = nn.ModuleList()
- for i in range(n_flows):
- self.flows.append(
- modules.ResidualCouplingLayer(
- channels,
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- gin_channels=gin_channels,
- mean_only=True,
- )
- )
- self.flows.append(modules.Flip())
-
- def forward(self, x, x_mask, g=None, reverse=False):
- if not reverse:
- for flow in self.flows:
- x, _ = flow(x, x_mask, g=g, reverse=reverse)
- else:
- for flow in reversed(self.flows):
- x = flow(x, x_mask, g=g, reverse=reverse)
- return x
-
- def remove_weight_norm(self):
- for i in range(self.n_flows):
- self.flows[i * 2].remove_weight_norm()
-
-
-class PosteriorEncoder(nn.Module):
- def __init__(
- self,
- in_channels,
- out_channels,
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- gin_channels=0,
- ):
- super().__init__()
- self.in_channels = in_channels
- self.out_channels = out_channels
- self.hidden_channels = hidden_channels
- self.kernel_size = kernel_size
- self.dilation_rate = dilation_rate
- self.n_layers = n_layers
- self.gin_channels = gin_channels
-
- self.pre = nn.Conv1d(in_channels, hidden_channels, 1)
- self.enc = modules.WN(
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- gin_channels=gin_channels,
- )
- self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
- def forward(self, x, x_lengths, g=None):
- x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(
- x.dtype
- )
- x = self.pre(x) * x_mask
- x = self.enc(x, x_mask, g=g)
- stats = self.proj(x) * x_mask
- m, logs = torch.split(stats, self.out_channels, dim=1)
- z = (m + torch.randn_like(m) * torch.exp(logs)) * x_mask
- return z, m, logs, x_mask
-
- def remove_weight_norm(self):
- self.enc.remove_weight_norm()
-
-
-class Generator(torch.nn.Module):
- def __init__(
- self,
- initial_channel,
- resblock,
- resblock_kernel_sizes,
- resblock_dilation_sizes,
- upsample_rates,
- upsample_initial_channel,
- upsample_kernel_sizes,
- gin_channels=0,
- ):
- super(Generator, self).__init__()
- self.num_kernels = len(resblock_kernel_sizes)
- self.num_upsamples = len(upsample_rates)
- self.conv_pre = Conv1d(
- initial_channel, upsample_initial_channel, 7, 1, padding=3
- )
- resblock = modules.ResBlock1 if resblock == "1" else modules.ResBlock2
-
- self.ups = nn.ModuleList()
- for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
- self.ups.append(
- weight_norm(
- ConvTranspose1d(
- upsample_initial_channel // (2**i),
- upsample_initial_channel // (2 ** (i + 1)),
- k,
- u,
- padding=(k - u) // 2,
- )
- )
- )
-
- self.resblocks = nn.ModuleList()
- for i in range(len(self.ups)):
- ch = upsample_initial_channel // (2 ** (i + 1))
- for j, (k, d) in enumerate(
- zip(resblock_kernel_sizes, resblock_dilation_sizes)
- ):
- self.resblocks.append(resblock(ch, k, d))
-
- self.conv_post = Conv1d(ch, 1, 7, 1, padding=3, bias=False)
- self.ups.apply(init_weights)
-
- if gin_channels != 0:
- self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1)
-
- def forward(self, x, g=None):
- x = self.conv_pre(x)
- if g is not None:
- x = x + self.cond(g)
-
- for i in range(self.num_upsamples):
- x = F.leaky_relu(x, modules.LRELU_SLOPE)
- x = self.ups[i](x)
- xs = None
- for j in range(self.num_kernels):
- if xs is None:
- xs = self.resblocks[i * self.num_kernels + j](x)
- else:
- xs += self.resblocks[i * self.num_kernels + j](x)
- x = xs / self.num_kernels
- x = F.leaky_relu(x)
- x = self.conv_post(x)
- x = torch.tanh(x)
-
- return x
-
- def remove_weight_norm(self):
- for l in self.ups:
- remove_weight_norm(l)
- for l in self.resblocks:
- l.remove_weight_norm()
-
-
-class SineGen(torch.nn.Module):
- """Definition of sine generator
- SineGen(samp_rate, harmonic_num = 0,
- sine_amp = 0.1, noise_std = 0.003,
- voiced_threshold = 0,
- flag_for_pulse=False)
- samp_rate: sampling rate in Hz
- harmonic_num: number of harmonic overtones (default 0)
- sine_amp: amplitude of sine-wavefrom (default 0.1)
- noise_std: std of Gaussian noise (default 0.003)
- voiced_thoreshold: F0 threshold for U/V classification (default 0)
- flag_for_pulse: this SinGen is used inside PulseGen (default False)
- Note: when flag_for_pulse is True, the first time step of a voiced
- segment is always sin(np.pi) or cos(0)
- """
-
- def __init__(
- self,
- samp_rate,
- harmonic_num=0,
- sine_amp=0.1,
- noise_std=0.003,
- voiced_threshold=0,
- flag_for_pulse=False,
- ):
- super(SineGen, self).__init__()
- self.sine_amp = sine_amp
- self.noise_std = noise_std
- self.harmonic_num = harmonic_num
- self.dim = self.harmonic_num + 1
- self.sampling_rate = samp_rate
- self.voiced_threshold = voiced_threshold
-
- def _f02uv(self, f0):
- # generate uv signal
- uv = torch.ones_like(f0)
- uv = uv * (f0 > self.voiced_threshold)
- return uv
-
- def forward(self, f0, upp):
- """sine_tensor, uv = forward(f0)
- input F0: tensor(batchsize=1, length, dim=1)
- f0 for unvoiced steps should be 0
- output sine_tensor: tensor(batchsize=1, length, dim)
- output uv: tensor(batchsize=1, length, 1)
- """
- with torch.no_grad():
- f0 = f0[:, None].transpose(1, 2)
- f0_buf = torch.zeros(f0.shape[0], f0.shape[1], self.dim, device=f0.device)
- # fundamental component
- f0_buf[:, :, 0] = f0[:, :, 0]
- for idx in np.arange(self.harmonic_num):
- f0_buf[:, :, idx + 1] = f0_buf[:, :, 0] * (
- idx + 2
- ) # idx + 2: the (idx+1)-th overtone, (idx+2)-th harmonic
- rad_values = (f0_buf / self.sampling_rate) % 1 ###%1意味着n_har的乘积无法后处理优化
- rand_ini = torch.rand(
- f0_buf.shape[0], f0_buf.shape[2], device=f0_buf.device
- )
- rand_ini[:, 0] = 0
- rad_values[:, 0, :] = rad_values[:, 0, :] + rand_ini
- tmp_over_one = torch.cumsum(rad_values, 1) # % 1 #####%1意味着后面的cumsum无法再优化
- tmp_over_one *= upp
- tmp_over_one = F.interpolate(
- tmp_over_one.transpose(2, 1),
- scale_factor=upp,
- mode="linear",
- align_corners=True,
- ).transpose(2, 1)
- rad_values = F.interpolate(
- rad_values.transpose(2, 1), scale_factor=upp, mode="nearest"
- ).transpose(
- 2, 1
- ) #######
- tmp_over_one %= 1
- tmp_over_one_idx = (tmp_over_one[:, 1:, :] - tmp_over_one[:, :-1, :]) < 0
- cumsum_shift = torch.zeros_like(rad_values)
- cumsum_shift[:, 1:, :] = tmp_over_one_idx * -1.0
- sine_waves = torch.sin(
- torch.cumsum(rad_values + cumsum_shift, dim=1) * 2 * np.pi
- )
- sine_waves = sine_waves * self.sine_amp
- uv = self._f02uv(f0)
- uv = F.interpolate(
- uv.transpose(2, 1), scale_factor=upp, mode="nearest"
- ).transpose(2, 1)
- noise_amp = uv * self.noise_std + (1 - uv) * self.sine_amp / 3
- noise = noise_amp * torch.randn_like(sine_waves)
- sine_waves = sine_waves * uv + noise
- return sine_waves, uv, noise
-
-
-class SourceModuleHnNSF(torch.nn.Module):
- """SourceModule for hn-nsf
- SourceModule(sampling_rate, harmonic_num=0, sine_amp=0.1,
- add_noise_std=0.003, voiced_threshod=0)
- sampling_rate: sampling_rate in Hz
- harmonic_num: number of harmonic above F0 (default: 0)
- sine_amp: amplitude of sine source signal (default: 0.1)
- add_noise_std: std of additive Gaussian noise (default: 0.003)
- note that amplitude of noise in unvoiced is decided
- by sine_amp
- voiced_threshold: threhold to set U/V given F0 (default: 0)
- Sine_source, noise_source = SourceModuleHnNSF(F0_sampled)
- F0_sampled (batchsize, length, 1)
- Sine_source (batchsize, length, 1)
- noise_source (batchsize, length 1)
- uv (batchsize, length, 1)
- """
-
- def __init__(
- self,
- sampling_rate,
- harmonic_num=0,
- sine_amp=0.1,
- add_noise_std=0.003,
- voiced_threshod=0,
- is_half=True,
- ):
- super(SourceModuleHnNSF, self).__init__()
-
- self.sine_amp = sine_amp
- self.noise_std = add_noise_std
- self.is_half = is_half
- # to produce sine waveforms
- self.l_sin_gen = SineGen(
- sampling_rate, harmonic_num, sine_amp, add_noise_std, voiced_threshod
- )
-
- # to merge source harmonics into a single excitation
- self.l_linear = torch.nn.Linear(harmonic_num + 1, 1)
- self.l_tanh = torch.nn.Tanh()
-
- def forward(self, x, upp=None):
- sine_wavs, uv, _ = self.l_sin_gen(x, upp)
- if self.is_half:
- sine_wavs = sine_wavs.half()
- sine_merge = self.l_tanh(self.l_linear(sine_wavs))
- return sine_merge, None, None # noise, uv
-
-
-class GeneratorNSF(torch.nn.Module):
- def __init__(
- self,
- initial_channel,
- resblock,
- resblock_kernel_sizes,
- resblock_dilation_sizes,
- upsample_rates,
- upsample_initial_channel,
- upsample_kernel_sizes,
- gin_channels,
- sr,
- is_half=False,
- ):
- super(GeneratorNSF, self).__init__()
- self.num_kernels = len(resblock_kernel_sizes)
- self.num_upsamples = len(upsample_rates)
-
- self.f0_upsamp = torch.nn.Upsample(scale_factor=np.prod(upsample_rates))
- self.m_source = SourceModuleHnNSF(
- sampling_rate=sr, harmonic_num=0, is_half=is_half
- )
- self.noise_convs = nn.ModuleList()
- self.conv_pre = Conv1d(
- initial_channel, upsample_initial_channel, 7, 1, padding=3
- )
- resblock = modules.ResBlock1 if resblock == "1" else modules.ResBlock2
-
- self.ups = nn.ModuleList()
- for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
- c_cur = upsample_initial_channel // (2 ** (i + 1))
- self.ups.append(
- weight_norm(
- ConvTranspose1d(
- upsample_initial_channel // (2**i),
- upsample_initial_channel // (2 ** (i + 1)),
- k,
- u,
- padding=(k - u) // 2,
- )
- )
- )
- if i + 1 < len(upsample_rates):
- stride_f0 = np.prod(upsample_rates[i + 1 :])
- self.noise_convs.append(
- Conv1d(
- 1,
- c_cur,
- kernel_size=stride_f0 * 2,
- stride=stride_f0,
- padding=stride_f0 // 2,
- )
- )
- else:
- self.noise_convs.append(Conv1d(1, c_cur, kernel_size=1))
-
- self.resblocks = nn.ModuleList()
- for i in range(len(self.ups)):
- ch = upsample_initial_channel // (2 ** (i + 1))
- for j, (k, d) in enumerate(
- zip(resblock_kernel_sizes, resblock_dilation_sizes)
- ):
- self.resblocks.append(resblock(ch, k, d))
-
- self.conv_post = Conv1d(ch, 1, 7, 1, padding=3, bias=False)
- self.ups.apply(init_weights)
-
- if gin_channels != 0:
- self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1)
-
- self.upp = np.prod(upsample_rates)
-
- def forward(self, x, f0, g=None):
- har_source, noi_source, uv = self.m_source(f0, self.upp)
- har_source = har_source.transpose(1, 2)
- x = self.conv_pre(x)
- if g is not None:
- x = x + self.cond(g)
-
- for i in range(self.num_upsamples):
- x = F.leaky_relu(x, modules.LRELU_SLOPE)
- x = self.ups[i](x)
- x_source = self.noise_convs[i](har_source)
- x = x + x_source
- xs = None
- for j in range(self.num_kernels):
- if xs is None:
- xs = self.resblocks[i * self.num_kernels + j](x)
- else:
- xs += self.resblocks[i * self.num_kernels + j](x)
- x = xs / self.num_kernels
- x = F.leaky_relu(x)
- x = self.conv_post(x)
- x = torch.tanh(x)
- return x
-
- def remove_weight_norm(self):
- for l in self.ups:
- remove_weight_norm(l)
- for l in self.resblocks:
- l.remove_weight_norm()
-
-
-sr2sr = {
- "32k": 32000,
- "40k": 40000,
- "48k": 48000,
-}
-
-
-class SynthesizerTrnMs256NSFsid(nn.Module):
- def __init__(
- self,
- spec_channels,
- segment_size,
- inter_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- resblock,
- resblock_kernel_sizes,
- resblock_dilation_sizes,
- upsample_rates,
- upsample_initial_channel,
- upsample_kernel_sizes,
- spk_embed_dim,
- gin_channels,
- sr,
- **kwargs
- ):
- super().__init__()
- if type(sr) == type("strr"):
- sr = sr2sr[sr]
- self.spec_channels = spec_channels
- self.inter_channels = inter_channels
- self.hidden_channels = hidden_channels
- self.filter_channels = filter_channels
- self.n_heads = n_heads
- self.n_layers = n_layers
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.resblock = resblock
- self.resblock_kernel_sizes = resblock_kernel_sizes
- self.resblock_dilation_sizes = resblock_dilation_sizes
- self.upsample_rates = upsample_rates
- self.upsample_initial_channel = upsample_initial_channel
- self.upsample_kernel_sizes = upsample_kernel_sizes
- self.segment_size = segment_size
- self.gin_channels = gin_channels
- # self.hop_length = hop_length#
- self.spk_embed_dim = spk_embed_dim
- self.enc_p = TextEncoder256(
- inter_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- )
- self.dec = GeneratorNSF(
- inter_channels,
- resblock,
- resblock_kernel_sizes,
- resblock_dilation_sizes,
- upsample_rates,
- upsample_initial_channel,
- upsample_kernel_sizes,
- gin_channels=gin_channels,
- sr=sr,
- is_half=kwargs["is_half"],
- )
- self.enc_q = PosteriorEncoder(
- spec_channels,
- inter_channels,
- hidden_channels,
- 5,
- 1,
- 16,
- gin_channels=gin_channels,
- )
- self.flow = ResidualCouplingBlock(
- inter_channels, hidden_channels, 5, 1, 3, gin_channels=gin_channels
- )
- self.emb_g = nn.Embedding(self.spk_embed_dim, gin_channels)
- print("gin_channels:", gin_channels, "self.spk_embed_dim:", self.spk_embed_dim)
-
- def remove_weight_norm(self):
- self.dec.remove_weight_norm()
- self.flow.remove_weight_norm()
- self.enc_q.remove_weight_norm()
-
- def forward(
- self, phone, phone_lengths, pitch, pitchf, y, y_lengths, ds
- ): # 这里ds是id，[bs,1]
- # print(1,pitch.shape)#[bs,t]
- g = self.emb_g(ds).unsqueeze(-1) # [b, 256, 1]##1是t，广播的
- m_p, logs_p, x_mask = self.enc_p(phone, pitch, phone_lengths)
- z, m_q, logs_q, y_mask = self.enc_q(y, y_lengths, g=g)
- z_p = self.flow(z, y_mask, g=g)
- z_slice, ids_slice = commons.rand_slice_segments(
- z, y_lengths, self.segment_size
- )
- # print(-1,pitchf.shape,ids_slice,self.segment_size,self.hop_length,self.segment_size//self.hop_length)
- pitchf = commons.slice_segments2(pitchf, ids_slice, self.segment_size)
- # print(-2,pitchf.shape,z_slice.shape)
- o = self.dec(z_slice, pitchf, g=g)
- return o, ids_slice, x_mask, y_mask, (z, z_p, m_p, logs_p, m_q, logs_q)
-
- def infer(self, phone, phone_lengths, pitch, nsff0, sid, rate=None):
- g = self.emb_g(sid).unsqueeze(-1)
- m_p, logs_p, x_mask = self.enc_p(phone, pitch, phone_lengths)
- z_p = (m_p + torch.exp(logs_p) * torch.randn_like(m_p) * 0.66666) * x_mask
- if rate:
- head = int(z_p.shape[2] * rate)
- z_p = z_p[:, :, -head:]
- x_mask = x_mask[:, :, -head:]
- nsff0 = nsff0[:, -head:]
- z = self.flow(z_p, x_mask, g=g, reverse=True)
- o = self.dec(z * x_mask, nsff0, g=g)
- return o, x_mask, (z, z_p, m_p, logs_p)
-
-
-class SynthesizerTrnMs768NSFsid(nn.Module):
- def __init__(
- self,
- spec_channels,
- segment_size,
- inter_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- resblock,
- resblock_kernel_sizes,
- resblock_dilation_sizes,
- upsample_rates,
- upsample_initial_channel,
- upsample_kernel_sizes,
- spk_embed_dim,
- gin_channels,
- sr,
- **kwargs
- ):
- super().__init__()
- if type(sr) == type("strr"):
- sr = sr2sr[sr]
- self.spec_channels = spec_channels
- self.inter_channels = inter_channels
- self.hidden_channels = hidden_channels
- self.filter_channels = filter_channels
- self.n_heads = n_heads
- self.n_layers = n_layers
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.resblock = resblock
- self.resblock_kernel_sizes = resblock_kernel_sizes
- self.resblock_dilation_sizes = resblock_dilation_sizes
- self.upsample_rates = upsample_rates
- self.upsample_initial_channel = upsample_initial_channel
- self.upsample_kernel_sizes = upsample_kernel_sizes
- self.segment_size = segment_size
- self.gin_channels = gin_channels
- # self.hop_length = hop_length#
- self.spk_embed_dim = spk_embed_dim
- self.enc_p = TextEncoder768(
- inter_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- )
- self.dec = GeneratorNSF(
- inter_channels,
- resblock,
- resblock_kernel_sizes,
- resblock_dilation_sizes,
- upsample_rates,
- upsample_initial_channel,
- upsample_kernel_sizes,
- gin_channels=gin_channels,
- sr=sr,
- is_half=kwargs["is_half"],
- )
- self.enc_q = PosteriorEncoder(
- spec_channels,
- inter_channels,
- hidden_channels,
- 5,
- 1,
- 16,
- gin_channels=gin_channels,
- )
- self.flow = ResidualCouplingBlock(
- inter_channels, hidden_channels, 5, 1, 3, gin_channels=gin_channels
- )
- self.emb_g = nn.Embedding(self.spk_embed_dim, gin_channels)
- print("gin_channels:", gin_channels, "self.spk_embed_dim:", self.spk_embed_dim)
-
- def remove_weight_norm(self):
- self.dec.remove_weight_norm()
- self.flow.remove_weight_norm()
- self.enc_q.remove_weight_norm()
-
- def forward(
- self, phone, phone_lengths, pitch, pitchf, y, y_lengths, ds
- ): # 这里ds是id，[bs,1]
- # print(1,pitch.shape)#[bs,t]
- g = self.emb_g(ds).unsqueeze(-1) # [b, 256, 1]##1是t，广播的
- m_p, logs_p, x_mask = self.enc_p(phone, pitch, phone_lengths)
- z, m_q, logs_q, y_mask = self.enc_q(y, y_lengths, g=g)
- z_p = self.flow(z, y_mask, g=g)
- z_slice, ids_slice = commons.rand_slice_segments(
- z, y_lengths, self.segment_size
- )
- # print(-1,pitchf.shape,ids_slice,self.segment_size,self.hop_length,self.segment_size//self.hop_length)
- pitchf = commons.slice_segments2(pitchf, ids_slice, self.segment_size)
- # print(-2,pitchf.shape,z_slice.shape)
- o = self.dec(z_slice, pitchf, g=g)
- return o, ids_slice, x_mask, y_mask, (z, z_p, m_p, logs_p, m_q, logs_q)
-
- def infer(self, phone, phone_lengths, pitch, nsff0, sid, rate=None):
- g = self.emb_g(sid).unsqueeze(-1)
- m_p, logs_p, x_mask = self.enc_p(phone, pitch, phone_lengths)
- z_p = (m_p + torch.exp(logs_p) * torch.randn_like(m_p) * 0.66666) * x_mask
- if rate:
- head = int(z_p.shape[2] * rate)
- z_p = z_p[:, :, -head:]
- x_mask = x_mask[:, :, -head:]
- nsff0 = nsff0[:, -head:]
- z = self.flow(z_p, x_mask, g=g, reverse=True)
- o = self.dec(z * x_mask, nsff0, g=g)
- return o, x_mask, (z, z_p, m_p, logs_p)
-
-
-class SynthesizerTrnMs256NSFsid_nono(nn.Module):
- def __init__(
- self,
- spec_channels,
- segment_size,
- inter_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- resblock,
- resblock_kernel_sizes,
- resblock_dilation_sizes,
- upsample_rates,
- upsample_initial_channel,
- upsample_kernel_sizes,
- spk_embed_dim,
- gin_channels,
- sr=None,
- **kwargs
- ):
- super().__init__()
- self.spec_channels = spec_channels
- self.inter_channels = inter_channels
- self.hidden_channels = hidden_channels
- self.filter_channels = filter_channels
- self.n_heads = n_heads
- self.n_layers = n_layers
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.resblock = resblock
- self.resblock_kernel_sizes = resblock_kernel_sizes
- self.resblock_dilation_sizes = resblock_dilation_sizes
- self.upsample_rates = upsample_rates
- self.upsample_initial_channel = upsample_initial_channel
- self.upsample_kernel_sizes = upsample_kernel_sizes
- self.segment_size = segment_size
- self.gin_channels = gin_channels
- # self.hop_length = hop_length#
- self.spk_embed_dim = spk_embed_dim
- self.enc_p = TextEncoder256(
- inter_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- f0=False,
- )
- self.dec = Generator(
- inter_channels,
- resblock,
- resblock_kernel_sizes,
- resblock_dilation_sizes,
- upsample_rates,
- upsample_initial_channel,
- upsample_kernel_sizes,
- gin_channels=gin_channels,
- )
- self.enc_q = PosteriorEncoder(
- spec_channels,
- inter_channels,
- hidden_channels,
- 5,
- 1,
- 16,
- gin_channels=gin_channels,
- )
- self.flow = ResidualCouplingBlock(
- inter_channels, hidden_channels, 5, 1, 3, gin_channels=gin_channels
- )
- self.emb_g = nn.Embedding(self.spk_embed_dim, gin_channels)
- print("gin_channels:", gin_channels, "self.spk_embed_dim:", self.spk_embed_dim)
-
- def remove_weight_norm(self):
- self.dec.remove_weight_norm()
- self.flow.remove_weight_norm()
- self.enc_q.remove_weight_norm()
-
- def forward(self, phone, phone_lengths, y, y_lengths, ds): # 这里ds是id，[bs,1]
- g = self.emb_g(ds).unsqueeze(-1) # [b, 256, 1]##1是t，广播的
- m_p, logs_p, x_mask = self.enc_p(phone, None, phone_lengths)
- z, m_q, logs_q, y_mask = self.enc_q(y, y_lengths, g=g)
- z_p = self.flow(z, y_mask, g=g)
- z_slice, ids_slice = commons.rand_slice_segments(
- z, y_lengths, self.segment_size
- )
- o = self.dec(z_slice, g=g)
- return o, ids_slice, x_mask, y_mask, (z, z_p, m_p, logs_p, m_q, logs_q)
-
- def infer(self, phone, phone_lengths, sid, rate=None):
- g = self.emb_g(sid).unsqueeze(-1)
- m_p, logs_p, x_mask = self.enc_p(phone, None, phone_lengths)
- z_p = (m_p + torch.exp(logs_p) * torch.randn_like(m_p) * 0.66666) * x_mask
- if rate:
- head = int(z_p.shape[2] * rate)
- z_p = z_p[:, :, -head:]
- x_mask = x_mask[:, :, -head:]
- z = self.flow(z_p, x_mask, g=g, reverse=True)
- o = self.dec(z * x_mask, g=g)
- return o, x_mask, (z, z_p, m_p, logs_p)
-
-
-class SynthesizerTrnMs768NSFsid_nono(nn.Module):
- def __init__(
- self,
- spec_channels,
- segment_size,
- inter_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- resblock,
- resblock_kernel_sizes,
- resblock_dilation_sizes,
- upsample_rates,
- upsample_initial_channel,
- upsample_kernel_sizes,
- spk_embed_dim,
- gin_channels,
- sr=None,
- **kwargs
- ):
- super().__init__()
- self.spec_channels = spec_channels
- self.inter_channels = inter_channels
- self.hidden_channels = hidden_channels
- self.filter_channels = filter_channels
- self.n_heads = n_heads
- self.n_layers = n_layers
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.resblock = resblock
- self.resblock_kernel_sizes = resblock_kernel_sizes
- self.resblock_dilation_sizes = resblock_dilation_sizes
- self.upsample_rates = upsample_rates
- self.upsample_initial_channel = upsample_initial_channel
- self.upsample_kernel_sizes = upsample_kernel_sizes
- self.segment_size = segment_size
- self.gin_channels = gin_channels
- # self.hop_length = hop_length#
- self.spk_embed_dim = spk_embed_dim
- self.enc_p = TextEncoder768(
- inter_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- f0=False,
- )
- self.dec = Generator(
- inter_channels,
- resblock,
- resblock_kernel_sizes,
- resblock_dilation_sizes,
- upsample_rates,
- upsample_initial_channel,
- upsample_kernel_sizes,
- gin_channels=gin_channels,
- )
- self.enc_q = PosteriorEncoder(
- spec_channels,
- inter_channels,
- hidden_channels,
- 5,
- 1,
- 16,
- gin_channels=gin_channels,
- )
- self.flow = ResidualCouplingBlock(
- inter_channels, hidden_channels, 5, 1, 3, gin_channels=gin_channels
- )
- self.emb_g = nn.Embedding(self.spk_embed_dim, gin_channels)
- print("gin_channels:", gin_channels, "self.spk_embed_dim:", self.spk_embed_dim)
-
- def remove_weight_norm(self):
- self.dec.remove_weight_norm()
- self.flow.remove_weight_norm()
- self.enc_q.remove_weight_norm()
-
- def forward(self, phone, phone_lengths, y, y_lengths, ds): # 这里ds是id，[bs,1]
- g = self.emb_g(ds).unsqueeze(-1) # [b, 256, 1]##1是t，广播的
- m_p, logs_p, x_mask = self.enc_p(phone, None, phone_lengths)
- z, m_q, logs_q, y_mask = self.enc_q(y, y_lengths, g=g)
- z_p = self.flow(z, y_mask, g=g)
- z_slice, ids_slice = commons.rand_slice_segments(
- z, y_lengths, self.segment_size
- )
- o = self.dec(z_slice, g=g)
- return o, ids_slice, x_mask, y_mask, (z, z_p, m_p, logs_p, m_q, logs_q)
-
- def infer(self, phone, phone_lengths, sid, rate=None):
- g = self.emb_g(sid).unsqueeze(-1)
- m_p, logs_p, x_mask = self.enc_p(phone, None, phone_lengths)
- z_p = (m_p + torch.exp(logs_p) * torch.randn_like(m_p) * 0.66666) * x_mask
- if rate:
- head = int(z_p.shape[2] * rate)
- z_p = z_p[:, :, -head:]
- x_mask = x_mask[:, :, -head:]
- z = self.flow(z_p, x_mask, g=g, reverse=True)
- o = self.dec(z * x_mask, g=g)
- return o, x_mask, (z, z_p, m_p, logs_p)
-
-
-class MultiPeriodDiscriminator(torch.nn.Module):
- def __init__(self, use_spectral_norm=False):
- super(MultiPeriodDiscriminator, self).__init__()
- periods = [2, 3, 5, 7, 11, 17]
- # periods = [3, 5, 7, 11, 17, 23, 37]
-
- discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
- discs = discs + [
- DiscriminatorP(i, use_spectral_norm=use_spectral_norm) for i in periods
- ]
- self.discriminators = nn.ModuleList(discs)
-
- def forward(self, y, y_hat):
- y_d_rs = [] #
- y_d_gs = []
- fmap_rs = []
- fmap_gs = []
- for i, d in enumerate(self.discriminators):
- y_d_r, fmap_r = d(y)
- y_d_g, fmap_g = d(y_hat)
- # for j in range(len(fmap_r)):
- # print(i,j,y.shape,y_hat.shape,fmap_r[j].shape,fmap_g[j].shape)
- y_d_rs.append(y_d_r)
- y_d_gs.append(y_d_g)
- fmap_rs.append(fmap_r)
- fmap_gs.append(fmap_g)
-
- return y_d_rs, y_d_gs, fmap_rs, fmap_gs
-
-
-class MultiPeriodDiscriminatorV2(torch.nn.Module):
- def __init__(self, use_spectral_norm=False):
- super(MultiPeriodDiscriminatorV2, self).__init__()
- # periods = [2, 3, 5, 7, 11, 17]
- periods = [2, 3, 5, 7, 11, 17, 23, 37]
-
- discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
- discs = discs + [
- DiscriminatorP(i, use_spectral_norm=use_spectral_norm) for i in periods
- ]
- self.discriminators = nn.ModuleList(discs)
-
- def forward(self, y, y_hat):
- y_d_rs = [] #
- y_d_gs = []
- fmap_rs = []
- fmap_gs = []
- for i, d in enumerate(self.discriminators):
- y_d_r, fmap_r = d(y)
- y_d_g, fmap_g = d(y_hat)
- # for j in range(len(fmap_r)):
- # print(i,j,y.shape,y_hat.shape,fmap_r[j].shape,fmap_g[j].shape)
- y_d_rs.append(y_d_r)
- y_d_gs.append(y_d_g)
- fmap_rs.append(fmap_r)
- fmap_gs.append(fmap_g)
-
- return y_d_rs, y_d_gs, fmap_rs, fmap_gs
-
-
-class DiscriminatorS(torch.nn.Module):
- def __init__(self, use_spectral_norm=False):
- super(DiscriminatorS, self).__init__()
- norm_f = weight_norm if use_spectral_norm == False else spectral_norm
- self.convs = nn.ModuleList(
- [
- norm_f(Conv1d(1, 16, 15, 1, padding=7)),
- norm_f(Conv1d(16, 64, 41, 4, groups=4, padding=20)),
- norm_f(Conv1d(64, 256, 41, 4, groups=16, padding=20)),
- norm_f(Conv1d(256, 1024, 41, 4, groups=64, padding=20)),
- norm_f(Conv1d(1024, 1024, 41, 4, groups=256, padding=20)),
- norm_f(Conv1d(1024, 1024, 5, 1, padding=2)),
- ]
- )
- self.conv_post = norm_f(Conv1d(1024, 1, 3, 1, padding=1))
-
- def forward(self, x):
- fmap = []
-
- for l in self.convs:
- x = l(x)
- x = F.leaky_relu(x, modules.LRELU_SLOPE)
- fmap.append(x)
- x = self.conv_post(x)
- fmap.append(x)
- x = torch.flatten(x, 1, -1)
-
- return x, fmap
-
-
-class DiscriminatorP(torch.nn.Module):
- def __init__(self, period, kernel_size=5, stride=3, use_spectral_norm=False):
- super(DiscriminatorP, self).__init__()
- self.period = period
- self.use_spectral_norm = use_spectral_norm
- norm_f = weight_norm if use_spectral_norm == False else spectral_norm
- self.convs = nn.ModuleList(
- [
- norm_f(
- Conv2d(
- 1,
- 32,
- (kernel_size, 1),
- (stride, 1),
- padding=(get_padding(kernel_size, 1), 0),
- )
- ),
- norm_f(
- Conv2d(
- 32,
- 128,
- (kernel_size, 1),
- (stride, 1),
- padding=(get_padding(kernel_size, 1), 0),
- )
- ),
- norm_f(
- Conv2d(
- 128,
- 512,
- (kernel_size, 1),
- (stride, 1),
- padding=(get_padding(kernel_size, 1), 0),
- )
- ),
- norm_f(
- Conv2d(
- 512,
- 1024,
- (kernel_size, 1),
- (stride, 1),
- padding=(get_padding(kernel_size, 1), 0),
- )
- ),
- norm_f(
- Conv2d(
- 1024,
- 1024,
- (kernel_size, 1),
- 1,
- padding=(get_padding(kernel_size, 1), 0),
- )
- ),
- ]
- )
- self.conv_post = norm_f(Conv2d(1024, 1, (3, 1), 1, padding=(1, 0)))
-
- def forward(self, x):
- fmap = []
-
- # 1d to 2d
- b, c, t = x.shape
- if t % self.period != 0: # pad first
- n_pad = self.period - (t % self.period)
- x = F.pad(x, (0, n_pad), "reflect")
- t = t + n_pad
- x = x.view(b, c, t // self.period, self.period)
-
- for l in self.convs:
- x = l(x)
- x = F.leaky_relu(x, modules.LRELU_SLOPE)
- fmap.append(x)
- x = self.conv_post(x)
- fmap.append(x)
- x = torch.flatten(x, 1, -1)
-
- return x, fmap
diff --git a/spaces/Noahfinncee/Test02/README.md b/spaces/Noahfinncee/Test02/README.md
deleted file mode 100644
index 0d589a3f06d19d5c3e4a91be3385a09c0dde807d..0000000000000000000000000000000000000000
--- a/spaces/Noahfinncee/Test02/README.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: Test02
-emoji: 👀
-colorFrom: purple
-colorTo: red
-sdk: docker
-pinned: false
----
-
-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/textless_nlp/gslm/unit2speech/README.md b/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/examples/textless_nlp/gslm/unit2speech/README.md
deleted file mode 100644
index 57104230655c7c517d25904e634c53b6159ee60f..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/examples/textless_nlp/gslm/unit2speech/README.md
+++ /dev/null
@@ -1,42 +0,0 @@
-# Unit to Speech Model (unit2speech)
-
-Unit to speech model is modified Tacotron2 model that learns to synthesize speech from discrete speech units. All models are trained on quantized [LJSpeech](https://keithito.com/LJ-Speech-Dataset/).
-
-Upstream Units | Download Link
-|-|-
-Log Mel Filterbank + KM50 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/logmel/tts_km50/tts_checkpoint_best.pt)
-Log Mel Filterbank + KM100 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/logmel/tts_km100/tts_checkpoint_best.pt)
-Log Mel Filterbank + KM200 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/logmel/tts_km200/tts_checkpoint_best.pt)
-Log Mel Filterbank + KM500 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/logmel/tts_km500/tts_checkpoint_best.pt)
-Modified CPC + KM50 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/cpc/tts_km50/tts_checkpoint_best.pt)
-Modified CPC + KM100 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/cpc/tts_km100/tts_checkpoint_best.pt)
-Modified CPC + KM200 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/cpc/tts_km200/tts_checkpoint_best.pt)
-Modified CPC + KM500 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/cpc/tts_km500/tts_checkpoint_best.pt)
-HuBERT Base + KM50 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/hubert/tts_km50/tts_checkpoint_best.pt)
-HuBERT Base + KM100 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/hubert/tts_km100/tts_checkpoint_best.pt)
-HuBERT Base + KM200 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/hubert/tts_km200/tts_checkpoint_best.pt)
-HuBERT Base + KM500 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/hubert/tts_km500/tts_checkpoint_best.pt)
-wav2vec 2.0 Large + KM50 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/w2v2/tts_km50/tts_checkpoint_best.pt)
-wav2vec 2.0 Large + KM100 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/w2v2/tts_km100/tts_checkpoint_best.pt)
-wav2vec 2.0 Large + KM200 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/w2v2/tts_km200/tts_checkpoint_best.pt)
-wav2vec 2.0 Large + KM500 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/w2v2/tts_km500/tts_checkpoint_best.pt)
-
-## Run inference using a unit2speech model
-* Install librosa, unidecode and inflect using `pip install librosa, unidecode, inflect`
-* Download [Waveglow checkpoint](https://dl.fbaipublicfiles.com/textless_nlp/gslm/waveglow_256channels_new.pt). This is the vocoder.
-
-Sample commnd to run inference using trained unit2speech models. Please note that the quantized audio to synthesized should be using the same units as the unit2speech model was trained with.
-```
-FAIRSEQ_ROOT=
-TTS_MODEL_PATH=
-QUANTIZED_UNIT_PATH=
-OUT_DIR=
-WAVEGLOW_PATH=
-
-PYTHONPATH=${FAIRSEQ_ROOT}:${FAIRSEQ_ROOT}/examples/textless_nlp/gslm/unit2speech python ${FAIRSEQ_ROOT}/examples/textless_nlp/gslm/unit2speech/synthesize_audio_from_units.py \
- --tts_model_path $TTS_MODEL_PATH \
- --quantized_unit_path $QUANTIZED_UNIT_PATH \
- --out_audio_dir $OUT_DIR \
- --waveglow_path $WAVEGLOW_PATH \
- --max_decoder_steps 2000
-```
\ No newline at end of file
diff --git a/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/fairseq/model_parallel/models/transformer_lm.py b/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/fairseq/model_parallel/models/transformer_lm.py
deleted file mode 100644
index dc52f6e8dd3899b6bf9bebae7415cee20baf9884..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/fairseq/model_parallel/models/transformer_lm.py
+++ /dev/null
@@ -1,174 +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 torch.nn as nn
-from fairseq.model_parallel.models.transformer import ModelParallelTransformerDecoder
-from fairseq.models import register_model, register_model_architecture
-from fairseq.models.transformer_lm import TransformerLanguageModel
-
-
-try:
- from fairseq.model_parallel.megatron.mpu import VocabParallelEmbedding
-
- has_megatron_submodule = True
-except (ImportError, ModuleNotFoundError):
- has_megatron_submodule = False
-
-
-DEFAULT_MAX_TARGET_POSITIONS = 1024
-
-
-@register_model("model_parallel_transformer_lm")
-class ModelParallelTransformerLanguageModel(TransformerLanguageModel):
-
- @staticmethod
- def add_args(parser):
- TransformerLanguageModel.add_args(parser)
-
- @classmethod
- def build_model(cls, args, task):
- """Build a new model instance."""
- if not has_megatron_submodule:
- raise ImportError(
- "\n\nPlease install the megatron submodule:"
- "\n\n git submodule update --init "
- "fairseq/model_parallel/megatron"
- )
-
- # make sure all arguments are present in older models
- base_lm_architecture(args)
-
- task.source_dictionary.pad_to_multiple_(args.model_parallel_size * 8)
- task.target_dictionary.pad_to_multiple_(args.model_parallel_size * 8)
-
- if args.decoder_layers_to_keep:
- args.decoder_layers = len(args.decoder_layers_to_keep.split(","))
-
- if getattr(args, "max_target_positions", None) is None:
- args.max_target_positions = getattr(
- args, "tokens_per_sample", DEFAULT_MAX_TARGET_POSITIONS
- )
-
- if args.character_embeddings:
- raise NotImplementedError(
- "Character embeddings is not supported for model parallel"
- )
- elif args.adaptive_input:
- raise NotImplementedError(
- "Adaptive input is not supported for model parallel"
- )
- else:
- embed_tokens = cls.build_embedding(
- args, task.source_dictionary, args.decoder_input_dim
- )
-
- decoder = ModelParallelTransformerDecoder(
- args,
- task.target_dictionary,
- embed_tokens,
- no_encoder_attn=True,
- )
- return cls(decoder)
-
- @staticmethod
- def add_args(parser):
- TransformerLanguageModel.add_args(parser)
-
- @classmethod
- def build_embedding(cls, args, dictionary, embed_dim, path=None):
- def _vocab_init(tensor, **kwargs):
- nn.init.normal_(tensor, mean=0, std=embed_dim ** -0.5)
- nn.init.constant_(tensor[1], 0)
-
- embed_tokens = VocabParallelEmbedding(
- len(dictionary), embed_dim, dictionary.pad(), init_method=_vocab_init
- )
- return embed_tokens
-
-
-def base_lm_architecture(args):
- # backward compatibility for older model checkpoints
- if hasattr(args, "no_tie_adaptive_proj"):
- # previous models defined --no-tie-adaptive-proj, so use the existence of
- # that option to determine if this is an "old" model checkpoint
- args.no_decoder_final_norm = True # old models always set this to True
- if args.no_tie_adaptive_proj is False:
- args.tie_adaptive_proj = True
- if hasattr(args, "decoder_final_norm"):
- args.no_decoder_final_norm = not args.decoder_final_norm
-
- args.activation_fn = getattr(args, "activation_fn", "relu")
- args.dropout = getattr(args, "dropout", 0.1)
- args.attention_dropout = getattr(args, "attention_dropout", 0.0)
- args.activation_dropout = getattr(args, "activation_dropout", 0.0)
- args.relu_dropout = getattr(args, "relu_dropout", 0.0)
- args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 512)
- args.decoder_output_dim = getattr(
- args, "decoder_output_dim", args.decoder_embed_dim
- )
- args.decoder_input_dim = getattr(args, "decoder_input_dim", args.decoder_embed_dim)
- args.decoder_ffn_embed_dim = getattr(args, "decoder_ffn_embed_dim", 2048)
- args.decoder_layers = getattr(args, "decoder_layers", 6)
- args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 8)
- # Model training is not stable without this
- args.decoder_normalize_before = True
- args.no_decoder_final_norm = getattr(args, "no_decoder_final_norm", False)
- args.adaptive_softmax_cutoff = getattr(args, "adaptive_softmax_cutoff", None)
- args.adaptive_softmax_dropout = getattr(args, "adaptive_softmax_dropout", 0)
- args.adaptive_softmax_factor = getattr(args, "adaptive_softmax_factor", 4)
- args.no_token_positional_embeddings = getattr(
- args, "no_token_positional_embeddings", False
- )
- args.share_decoder_input_output_embed = getattr(
- args, "share_decoder_input_output_embed", False
- )
- args.character_embeddings = getattr(args, "character_embeddings", False)
- args.character_filters = getattr(
- args,
- "character_filters",
- "[(1, 64), (2, 128), (3, 192), (4, 256), (5, 256), (6, 256), (7, 256)]",
- )
- args.character_embedding_dim = getattr(args, "character_embedding_dim", 4)
- args.char_embedder_highway_layers = getattr(args, "char_embedder_highway_layers", 2)
- args.adaptive_input = getattr(args, "adaptive_input", False)
- args.adaptive_input_factor = getattr(args, "adaptive_input_factor", 4)
- args.adaptive_input_cutoff = getattr(args, "adaptive_input_cutoff", None)
- args.tie_adaptive_weights = getattr(args, "tie_adaptive_weights", False)
- args.tie_adaptive_proj = getattr(args, "tie_adaptive_proj", False)
- args.decoder_learned_pos = getattr(args, "decoder_learned_pos", False)
- args.decoder_layerdrop = getattr(args, "decoder_layerdrop", 0.0)
- args.decoder_layers_to_keep = getattr(args, "decoder_layers_to_keep", None)
- args.layernorm_embedding = getattr(args, "layernorm_embedding", False)
- args.no_scale_embedding = getattr(args, "no_scale_embedding", False)
- args.quant_noise_pq = getattr(args, "quant_noise_pq", 0.0)
- args.quant_noise_pq_block_size = getattr(args, "quant_noise_pq_block_size", 8)
- args.quant_noise_scalar = getattr(args, "quant_noise_scalar", 0.0)
- args.add_bos_token = getattr(args, "add_bos_token", False)
-
-
-@register_model_architecture("model_parallel_transformer_lm", "transformer_lm_megatron")
-def transformer_lm_megatron(args):
- args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 3072)
- args.decoder_ffn_embed_dim = getattr(args, "decoder_ffn_embed_dim", 3072 * 4)
- args.decoder_layers = getattr(args, "decoder_layers", 72)
- args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 32)
- args.dropout = getattr(args, "dropout", 0.1)
- args.attention_dropout = getattr(args, "attention_dropout", 0.1)
- args.activation_fn = getattr(args, "activation_fn", "gelu")
- base_lm_architecture(args)
-
-
-@register_model_architecture(
- "model_parallel_transformer_lm", "transformer_lm_megatron_11b"
-)
-def transformer_lm_megatron_11b(args):
- args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 3072)
- args.decoder_ffn_embed_dim = getattr(args, "decoder_ffn_embed_dim", 3072 * 6)
- args.decoder_layers = getattr(args, "decoder_layers", 72)
- args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 32)
- args.dropout = getattr(args, "dropout", 0.1)
- args.attention_dropout = getattr(args, "attention_dropout", 0.1)
- args.activation_fn = getattr(args, "activation_fn", "gelu")
- base_lm_architecture(args)
diff --git a/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/fairseq/models/transformer_align.py b/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/fairseq/models/transformer_align.py
deleted file mode 100644
index eaf585bd10e630ae6cd89920f197cd165f55ad58..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/fairseq/models/transformer_align.py
+++ /dev/null
@@ -1,93 +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 fairseq.models import register_model, register_model_architecture
-from fairseq.models.transformer import (
- TransformerModel,
- base_architecture,
- transformer_wmt_en_de_big,
-)
-
-
-@register_model("transformer_align")
-class TransformerAlignModel(TransformerModel):
- """
- See "Jointly Learning to Align and Translate with Transformer
- Models" (Garg et al., EMNLP 2019).
- """
-
- def __init__(self, encoder, decoder, args):
- super().__init__(args, encoder, decoder)
- self.alignment_heads = args.alignment_heads
- self.alignment_layer = args.alignment_layer
- self.full_context_alignment = args.full_context_alignment
-
- @staticmethod
- def add_args(parser):
- # fmt: off
- super(TransformerAlignModel, TransformerAlignModel).add_args(parser)
- parser.add_argument('--alignment-heads', type=int, metavar='D',
- help='Number of cross attention heads per layer to supervised with alignments')
- parser.add_argument('--alignment-layer', type=int, metavar='D',
- help='Layer number which has to be supervised. 0 corresponding to the bottommost layer.')
- parser.add_argument('--full-context-alignment', action='store_true',
- help='Whether or not alignment is supervised conditioned on the full target context.')
- # fmt: on
-
- @classmethod
- def build_model(cls, args, task):
- # set any default arguments
- transformer_align(args)
-
- transformer_model = TransformerModel.build_model(args, task)
- return TransformerAlignModel(
- transformer_model.encoder, transformer_model.decoder, args
- )
-
- def forward(self, src_tokens, src_lengths, prev_output_tokens):
- encoder_out = self.encoder(src_tokens, src_lengths)
- return self.forward_decoder(prev_output_tokens, encoder_out)
-
- def forward_decoder(
- self,
- prev_output_tokens,
- encoder_out=None,
- incremental_state=None,
- features_only=False,
- **extra_args,
- ):
- attn_args = {
- "alignment_layer": self.alignment_layer,
- "alignment_heads": self.alignment_heads,
- }
- decoder_out = self.decoder(prev_output_tokens, encoder_out, **attn_args)
-
- if self.full_context_alignment:
- attn_args["full_context_alignment"] = self.full_context_alignment
- _, alignment_out = self.decoder(
- prev_output_tokens,
- encoder_out,
- features_only=True,
- **attn_args,
- **extra_args,
- )
- decoder_out[1]["attn"] = alignment_out["attn"]
-
- return decoder_out
-
-
-@register_model_architecture("transformer_align", "transformer_align")
-def transformer_align(args):
- args.alignment_heads = getattr(args, "alignment_heads", 1)
- args.alignment_layer = getattr(args, "alignment_layer", 4)
- args.full_context_alignment = getattr(args, "full_context_alignment", False)
- base_architecture(args)
-
-
-@register_model_architecture("transformer_align", "transformer_wmt_en_de_big_align")
-def transformer_wmt_en_de_big_align(args):
- args.alignment_heads = getattr(args, "alignment_heads", 1)
- args.alignment_layer = getattr(args, "alignment_layer", 4)
- transformer_wmt_en_de_big(args)
diff --git a/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/tests/test_huffman.py b/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/tests/test_huffman.py
deleted file mode 100644
index a8cd5222b468b2dbf22f13c9dd34c484a0c30205..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/tests/test_huffman.py
+++ /dev/null
@@ -1,201 +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 os
-import random
-import string
-import typing as tp
-import unittest
-from collections import Counter
-from tempfile import NamedTemporaryFile, TemporaryDirectory
-
-from fairseq.data import Dictionary, indexed_dataset
-from fairseq.data.huffman import (
- HuffmanCodeBuilder,
- HuffmanCoder,
- HuffmanMMapIndexedDataset,
- HuffmanMMapIndexedDatasetBuilder,
-)
-
-POPULATION = string.ascii_letters + string.digits
-
-
-def make_sentence() -> tp.List[str]:
- length = random.randint(10, 50)
- return random.choices(
- population=POPULATION, k=length, weights=range(1, len(POPULATION) + 1)
- )
-
-
-def make_data(length=1000) -> tp.List[tp.List[str]]:
- return (
- [make_sentence() for _ in range(0, length)]
- # add all the symbols at least once
- + [list(string.ascii_letters), list(string.digits)]
- )
-
-
-def make_counts(data: tp.List[tp.List[str]]) -> Counter:
- return Counter([symbol for sentence in data for symbol in sentence])
-
-
-def make_code_builder(data: tp.List[tp.List[str]]) -> HuffmanCodeBuilder:
- builder = HuffmanCodeBuilder()
- for sentence in data:
- builder.add_symbols(*sentence)
- return builder
-
-
-class TestCodeBuilder(unittest.TestCase):
- def test_code_builder_can_count(self):
- data = make_data()
- counts = make_counts(data)
- builder = make_code_builder(data)
-
- self.assertEqual(builder.symbols, counts)
-
- def test_code_builder_can_add(self):
- data = make_data()
- counts = make_counts(data)
- builder = make_code_builder(data)
-
- new_builder = builder + builder
-
- self.assertEqual(new_builder.symbols, counts + counts)
-
- def test_code_builder_can_io(self):
- data = make_data()
- builder = make_code_builder(data)
-
- with NamedTemporaryFile() as tmp_fp:
- builder.to_file(tmp_fp.name)
- other_builder = HuffmanCodeBuilder.from_file(tmp_fp.name)
-
- self.assertEqual(builder.symbols, other_builder.symbols)
-
-
-class TestCoder(unittest.TestCase):
- def test_coder_can_io(self):
- data = make_data()
- builder = make_code_builder(data)
- coder = builder.build_code()
-
- with NamedTemporaryFile() as tmp_fp:
- coder.to_file(tmp_fp.name)
- other_coder = HuffmanCoder.from_file(tmp_fp.name)
-
- self.assertEqual(coder, other_coder)
-
- def test_coder_can_encode_decode(self):
- data = make_data()
- builder = make_code_builder(data)
- coder = builder.build_code()
-
- encoded = [coder.encode(sentence) for sentence in data]
- decoded = [[n.symbol for n in coder.decode(enc)] for enc in encoded]
-
- self.assertEqual(decoded, data)
-
- unseen_data = make_data()
- unseen_encoded = [coder.encode(sentence) for sentence in unseen_data]
- unseen_decoded = [
- [n.symbol for n in coder.decode(enc)] for enc in unseen_encoded
- ]
- self.assertEqual(unseen_decoded, unseen_data)
-
-
-def build_dataset(prefix, data, coder):
- with HuffmanMMapIndexedDatasetBuilder(prefix, coder) as builder:
- for sentence in data:
- builder.add_item(sentence)
-
-
-def sizes(data):
- return [len(sentence) for sentence in data]
-
-
-class TestHuffmanDataset(unittest.TestCase):
- def test_huffman_can_encode_decode(self):
- data = make_data()
- builder = make_code_builder(data)
- coder = builder.build_code()
-
- with TemporaryDirectory() as dirname:
- prefix = os.path.join(dirname, "test1")
- build_dataset(prefix, data, coder)
- dataset = HuffmanMMapIndexedDataset(prefix)
-
- self.assertEqual(len(dataset), len(data))
- decoded = [list(dataset.get_symbols(i)) for i in range(0, len(dataset))]
-
- self.assertEqual(decoded, data)
- data_sizes = [i.item() for i in dataset.sizes]
- self.assertEqual(data_sizes, sizes(data))
-
- def test_huffman_compresses(self):
- data = make_data()
- builder = make_code_builder(data)
- coder = builder.build_code()
-
- with TemporaryDirectory() as dirname:
- prefix = os.path.join(dirname, "huffman")
- build_dataset(prefix, data, coder)
-
- prefix_mmap = os.path.join(dirname, "mmap")
- mmap_builder = indexed_dataset.make_builder(
- indexed_dataset.data_file_path(prefix_mmap),
- "mmap",
- vocab_size=len(POPULATION),
- )
- dictionary = Dictionary()
- for c in POPULATION:
- dictionary.add_symbol(c)
- dictionary.finalize()
- for sentence in data:
- mmap_builder.add_item(dictionary.encode_line(" ".join(sentence)))
- mmap_builder.finalize(indexed_dataset.index_file_path(prefix_mmap))
-
- huff_size = os.stat(indexed_dataset.data_file_path(prefix)).st_size
- mmap_size = os.stat(indexed_dataset.data_file_path(prefix_mmap)).st_size
- self.assertLess(huff_size, mmap_size)
-
- def test_huffman_can_append(self):
- data1 = make_data()
- builder = make_code_builder(data1)
- coder = builder.build_code()
-
- with TemporaryDirectory() as dirname:
- prefix1 = os.path.join(dirname, "test1")
- build_dataset(prefix1, data1, coder)
-
- data2 = make_data()
- prefix2 = os.path.join(dirname, "test2")
- build_dataset(prefix2, data2, coder)
-
- prefix3 = os.path.join(dirname, "test3")
-
- with HuffmanMMapIndexedDatasetBuilder(prefix3, coder) as builder:
- builder.append(prefix1)
- builder.append(prefix2)
-
- dataset = HuffmanMMapIndexedDataset(prefix3)
-
- self.assertEqual(len(dataset), len(data1) + len(data2))
-
- decoded1 = [list(dataset.get_symbols(i)) for i in range(0, len(data1))]
- self.assertEqual(decoded1, data1)
-
- decoded2 = [
- list(dataset.get_symbols(i)) for i in range(len(data1), len(dataset))
- ]
- self.assertEqual(decoded2, data2)
-
- data_sizes = [i.item() for i in dataset.sizes]
- self.assertEqual(data_sizes[: len(data1)], sizes(data1))
- self.assertEqual(data_sizes[len(data1) : len(dataset)], sizes(data2))
-
-
-if __name__ == "__main__":
- unittest.main()
diff --git a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/examples/pointer_generator/pointer_generator_src/__init__.py b/spaces/OFA-Sys/OFA-Image_Caption/fairseq/examples/pointer_generator/pointer_generator_src/__init__.py
deleted file mode 100644
index c361ff6bd616512fe2521387665de1ad1aff66d0..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/examples/pointer_generator/pointer_generator_src/__init__.py
+++ /dev/null
@@ -1,6 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-from . import transformer_pg # noqa
diff --git a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/examples/wav2vec/unsupervised/tasks/unpaired_audio_text.py b/spaces/OFA-Sys/OFA-Image_Caption/fairseq/examples/wav2vec/unsupervised/tasks/unpaired_audio_text.py
deleted file mode 100644
index 5f292528f80d6bb51f16a4324d97342d28fce942..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/examples/wav2vec/unsupervised/tasks/unpaired_audio_text.py
+++ /dev/null
@@ -1,447 +0,0 @@
-# Copyright (c) 2017-present, Facebook, Inc.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the LICENSE file in
-# the root directory of this source tree. An additional grant of patent rights
-# can be found in the PATENTS file in the same directory.
-
-from dataclasses import dataclass, field
-import logging
-import math
-import os
-from typing import Optional
-import torch
-
-from fairseq.logging import metrics
-from fairseq.tasks import FairseqTask, register_task
-from ..data import ExtractedFeaturesDataset, RandomInputDataset
-
-from fairseq.data import (
- Dictionary,
- data_utils,
- StripTokenDataset,
-)
-from fairseq.dataclass import FairseqDataclass
-from fairseq.distributed.utils import get_data_parallel_world_size
-from omegaconf import MISSING
-
-from examples.speech_recognition.kaldi.kaldi_decoder import (
- KaldiDecoder,
- KaldiDecoderConfig,
-)
-
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class DecodingConfig(FairseqDataclass):
- kenlm_path: Optional[str] = None
- lm_weight: float = 0
- blank_weight: float = 0
-
-
-@dataclass
-class UnpairedAudioTextConfig(FairseqDataclass):
- data: str = field(
- default=MISSING, metadata={"help": "path to data directory containing audio"}
- )
- text_data: str = field(
- default=MISSING, metadata={"help": "path to data directory containing text"}
- )
- max_length: Optional[int] = None
- labels: Optional[str] = field(
- default=None,
- metadata={"help": "extension of the label file to load, used for fine-tuning"},
- )
- unfiltered: bool = field(
- default=False, metadata={"help": "load data with _unfiltered suffix"}
- )
- ctc_eval: bool = field(
- default=False, metadata={"help": "eval UER as if computed by CTC"}
- )
- sort_by_length: bool = field(
- default=True, metadata={"help": "sort examples by length of audio timesteps"}
- )
- shuffle: bool = field(default=True, metadata={"help": "shuffle examples"})
- append_eos: bool = field(default=False, metadata={"help": "append eos"})
- uppercase: Optional[bool] = field(
- default=False, metadata={"help": "uppercase for LM score computation"}
- )
- skipwords: Optional[str] = field(
- default="",
- metadata={
- "help": "comma-separated words to be removed for LM score computation"
- },
- )
- kenlm_path: Optional[str] = None
- vocab_usage_power: float = 2
-
- word_decoder_config: Optional[KaldiDecoderConfig] = None
- word_kenlm_path: Optional[str] = None
-
- decoding_config: DecodingConfig = DecodingConfig()
-
-
-@register_task("unpaired_audio_text", dataclass=UnpairedAudioTextConfig)
-class UnpairedAudioText(FairseqTask):
- """ """
-
- cfg: UnpairedAudioTextConfig
-
- def __init__(
- self,
- cfg: UnpairedAudioTextConfig,
- source_dictionary=None,
- target_dictionary=None,
- ):
- super().__init__(cfg)
-
- self._target_dictionary = target_dictionary
- self._source_dictionary = source_dictionary
- self.num_symbols = (
- len([s for s in target_dictionary.symbols if not s.startswith("madeup")])
- - target_dictionary.nspecial
- )
- self.sil_id = (
- target_dictionary.index("") if "" in target_dictionary else -1
- )
- self.kenlm = None
- if cfg.kenlm_path is not None:
- import kenlm
-
- self.kenlm = kenlm.Model(cfg.kenlm_path)
-
- self.word_kenlm = None
- if cfg.word_kenlm_path is not None:
- import kenlm
-
- self.word_kenlm = kenlm.Model(cfg.word_kenlm_path)
-
- self.uppercase = cfg.uppercase
- self.skipwords = set(cfg.skipwords.split(","))
-
- def str_postprocess(s):
- s = " ".join(w for w in s.split() if w not in self.skipwords)
- s = s.upper() if self.uppercase else s
- return s
-
- self.str_postprocess = str_postprocess
- self.compute_lm_score = lambda s: self.kenlm.score(self.str_postprocess(s))
-
- self.compute_word_score = None
- if cfg.word_decoder_config is not None:
- self.kaldi_decoder = KaldiDecoder(cfg.word_decoder_config, beam=10)
-
- def compute_word_score(logits, padding):
- res = self.kaldi_decoder.decode(logits, padding)
- for r in res:
- r = r.result()
- assert len(r) == 1
- r = r[0]
- yield r["score"], r["words"]
-
- self.compute_word_score = compute_word_score
-
- @classmethod
- def setup_task(cls, cfg: UnpairedAudioTextConfig, **kwargs):
- """Setup the task (e.g., load dictionaries).
-
- Args:
- cfg (AudioPretrainingConfig): configuration of this task
- """
-
- dict_path = os.path.join(cfg.text_data, "dict.txt")
- if os.path.exists(dict_path):
- target_dictionary = Dictionary.load(dict_path)
- else:
- dict_path = os.path.join(cfg.data, f"dict.{cfg.labels}.txt")
- target_dictionary = Dictionary.load(dict_path)
-
- return cls(cfg, target_dictionary=target_dictionary)
-
- def optimizer_step(self, optimizer, model, update_num):
- if hasattr(model, "get_groups_for_update"):
- groups = model.get_groups_for_update(update_num)
- optimizer.step(groups={groups})
- else:
- optimizer.step()
-
- def valid_step(self, sample, model, criterion):
- res = model(
- **sample["net_input"],
- dense_x_only=True,
- )
-
- dense_x = res["logits"]
- padding_mask = res["padding_mask"]
-
- word_scores = None
- if self.compute_word_score is not None:
- word_scores = self.compute_word_score(dense_x.cpu(), padding_mask.cpu())
-
- z = dense_x.argmax(-1)
- z[padding_mask] = self.target_dictionary.pad()
-
- vocab_seen = torch.zeros(self.num_symbols, dtype=torch.bool)
-
- import editdistance
-
- c_err = 0
- c_len = 0
- pred_c_len = 0
- lm_score_sum = 0
- for i, (x, t, id) in enumerate(
- zip(
- z,
- sample["target"] if "target" in sample else [None] * len(z),
- sample["id"],
- )
- ):
-
- if t is not None:
- t = t[(t >= self.target_dictionary.nspecial)]
- x = x[
- (x >= self.target_dictionary.nspecial)
- & (x < (self.num_symbols + self.target_dictionary.nspecial))
- ]
- if self.sil_id >= 0:
- x = x[x != self.sil_id]
-
- vocab_seen[x - self.target_dictionary.nspecial] = True
-
- pred_units_arr = x
- if self.cfg.ctc_eval:
- pred_units_arr = pred_units_arr.unique_consecutive()
- pred_units_arr = pred_units_arr[pred_units_arr != 0]
-
- if id == 0:
- if t is not None:
- logger.info(f"REF: {self.target_dictionary.string(t)}")
- logger.info(f"HYP: {self.target_dictionary.string(pred_units_arr)}")
-
- if self.kenlm is not None:
- if t is not None:
- ref_lm_s = self.compute_lm_score(
- self.target_dictionary.string(t)
- )
- logger.info(
- f"LM [REF]: {ref_lm_s}, {math.pow(10, -ref_lm_s / (len(t) + 1))}"
- )
-
- hyp_lm_s = self.compute_lm_score(
- self.target_dictionary.string(pred_units_arr)
- )
- logger.info(
- f"LM [HYP]: {hyp_lm_s}, {math.pow(10, -hyp_lm_s / (len(pred_units_arr) + 1))}"
- )
-
- pred_units_arr = pred_units_arr.tolist()
-
- pred_c_len += len(pred_units_arr)
-
- if t is not None:
- t = t.tolist()
- c_err += editdistance.eval(pred_units_arr, t)
- c_len += len(t)
- else:
- c_len = pred_c_len
-
- if self.kenlm is not None:
- pred_str = self.target_dictionary.string(pred_units_arr)
- lm_score = self.compute_lm_score(pred_str)
- lm_score_sum += lm_score
-
- kaldi_score_sum = 0
- word_lm_sum = 0
- num_words = 0
- if word_scores is not None:
- for score, words in word_scores:
- kaldi_score_sum += score
- num_words += len(words)
- if self.word_kenlm is not None:
- word_lm_sum += self.kenlm.score(" ".join(words))
-
- try:
- world_size = get_data_parallel_world_size()
- except:
- world_size = 1
-
- logging_output = {
- "loss": c_err,
- "_num_char_errors": c_err,
- "_num_chars": c_len,
- "_num_pred_chars": pred_c_len,
- "ntokens": c_len,
- "nsentences": z.size(0),
- "sample_size": c_len,
- "_world_size": world_size,
- "_lm_score_sum": lm_score_sum,
- "_kaldi_score_sum": kaldi_score_sum,
- "_word_lm_sum": word_lm_sum,
- "_num_words": num_words,
- "_vocab_seen": vocab_seen,
- }
-
- return c_err, c_len, logging_output
-
- def load_dataset(self, split: str, task_cfg: FairseqDataclass = None, **kwargs):
- data_path = self.cfg.data
- task_cfg = task_cfg or self.cfg
-
- has_unpaired_text = os.path.exists(
- os.path.join(self.cfg.text_data, f"{split}.idx")
- )
-
- self.datasets[split] = ExtractedFeaturesDataset(
- path=data_path,
- split=split,
- min_length=3,
- max_length=task_cfg.max_length,
- labels=None if has_unpaired_text else task_cfg.labels,
- label_dict=self.target_dictionary,
- shuffle=getattr(task_cfg, "shuffle", True),
- sort_by_length=task_cfg.sort_by_length,
- )
-
- logger.info(f"split {split} has unpaired text? {has_unpaired_text}")
- if has_unpaired_text:
- text_dataset = data_utils.load_indexed_dataset(
- os.path.join(self.cfg.text_data, split), self.target_dictionary
- )
- text_dataset = StripTokenDataset(text_dataset, self.target_dictionary.eos())
- self.datasets[split] = RandomInputDataset(
- self.datasets[split],
- text_dataset,
- ["random_label"],
- add_to_input=True,
- pad_idx=self.target_dictionary.pad(),
- )
-
- @property
- def source_dictionary(self):
- return self._source_dictionary
-
- @property
- def target_dictionary(self):
- """Return the :class:`~fairseq.data.Dictionary` for the language
- model."""
- return self._target_dictionary
-
- def max_positions(self):
- """Maximum input length supported by the encoder."""
- return None
-
- def reduce_metrics(self, logging_outputs, criterion):
- super().reduce_metrics(logging_outputs, criterion)
-
- zero = torch.scalar_tensor(0.0)
- num_char_errors = sum(
- log.get("_num_char_errors", zero) for log in logging_outputs
- )
- num_chars = sum(log.get("_num_chars", zero) for log in logging_outputs)
- num_word_errors = sum(
- log.get("_num_word_errors", zero) for log in logging_outputs
- )
- num_words = sum(log.get("_num_words", zero) for log in logging_outputs)
- num_pred_chars = sum(
- log.get("_num_pred_chars", zero) for log in logging_outputs
- )
-
- lm_score_sum = sum(log.get("_lm_score_sum", zero) for log in logging_outputs)
- vocab_seen = (
- sum(log.get("_vocab_seen", zero) for log in logging_outputs)
- .bool()
- .sum()
- .item()
- )
- kaldi_score_sum = sum(
- log.get("_kaldi_score_sum", zero) for log in logging_outputs
- )
- word_lm_sum = sum(log.get("_word_lm_sum", zero) for log in logging_outputs)
-
- metrics.log_scalar_sum("_num_char_errors", num_char_errors)
- metrics.log_scalar_sum("_num_chars", num_chars)
- metrics.log_scalar_sum("_num_word_errors", num_word_errors)
- metrics.log_scalar_sum("_num_words", num_words)
-
- metrics.log_scalar_sum("lm_score_sum", lm_score_sum)
- metrics.log_scalar_sum("num_pred_chars", num_pred_chars)
-
- if self.cfg.word_kenlm_path is not None:
- metrics.log_scalar_sum("kaldi_score_sum", kaldi_score_sum)
- metrics.log_scalar_sum("word_lm_sum", word_lm_sum)
-
- if num_chars > 0:
- metrics.log_derived(
- "uer",
- lambda meters: meters["_num_char_errors"].sum
- * 100.0
- / meters["_num_chars"].sum
- if meters["_num_chars"].sum > 0
- else float("nan"),
- )
-
- if lm_score_sum < 0 and vocab_seen > 0:
- metrics.log_scalar("vocab_seen_pct", vocab_seen / self.num_symbols)
-
- metrics.log_derived(
- "weighted_lm_ppl",
- lambda meters: math.pow(
- 10,
- -meters["lm_score_sum"].sum
- / (
- meters["num_pred_chars"].sum + meters["nsentences"].sum
- ), # account for
- )
- / meters["vocab_seen_pct"].avg ** self.cfg.vocab_usage_power,
- )
-
- metrics.log_derived(
- "lm_ppl",
- lambda meters: math.pow(
- 10,
- -meters["lm_score_sum"].sum
- / (
- meters["num_pred_chars"].sum + meters["nsentences"].sum
- ), # account for
- ),
- )
- else:
- metrics.log_derived("weighted_lm_ppl", lambda meters: float("inf"))
-
- if num_words > 0:
- if word_lm_sum != 0:
- metrics.log_derived(
- "word_lm_ppl",
- lambda meters: math.pow(
- 10,
- -meters["word_lm_sum"].sum
- / (
- meters["_num_words"].sum + meters["nsentences"].sum
- ), # account for
- ),
- )
- metrics.log_derived(
- "weighted_word_lm_ppl",
- lambda meters: math.pow(
- 10,
- -meters["word_lm_sum"].sum
- / (
- meters["_num_words"].sum + meters["nsentences"].sum
- ), # account for
- )
- / meters["vocab_seen_pct"].avg ** self.cfg.vocab_usage_power,
- )
-
- if self.cfg.word_kenlm_path is not None:
- metrics.log_derived(
- "kaldi_score",
- lambda meters: meters["kaldi_score_sum"].sum
- / meters["nsentences"].sum,
- )
-
- def build_model(self, cfg: FairseqDataclass):
- model = super().build_model(cfg)
-
- return model
diff --git a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/fairseq/data/backtranslation_dataset.py b/spaces/OFA-Sys/OFA-Image_Caption/fairseq/fairseq/data/backtranslation_dataset.py
deleted file mode 100644
index 8f70c90df3d237077537993e125d366c95292f1a..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/fairseq/data/backtranslation_dataset.py
+++ /dev/null
@@ -1,165 +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 torch
-from fairseq import utils
-
-from . import FairseqDataset
-
-
-def backtranslate_samples(samples, collate_fn, generate_fn, cuda=True):
- """Backtranslate a list of samples.
-
- Given an input (*samples*) of the form:
-
- [{'id': 1, 'source': 'hallo welt'}]
-
- this will return:
-
- [{'id': 1, 'source': 'hello world', 'target': 'hallo welt'}]
-
- Args:
- samples (List[dict]): samples to backtranslate. Individual samples are
- expected to have a 'source' key, which will become the 'target'
- after backtranslation.
- collate_fn (callable): function to collate samples into a mini-batch
- generate_fn (callable): function to generate backtranslations
- cuda (bool): use GPU for generation (default: ``True``)
-
- Returns:
- List[dict]: an updated list of samples with a backtranslated source
- """
- collated_samples = collate_fn(samples)
- s = utils.move_to_cuda(collated_samples) if cuda else collated_samples
- generated_sources = generate_fn(s)
-
- id_to_src = {sample["id"]: sample["source"] for sample in samples}
-
- # Go through each tgt sentence in batch and its corresponding best
- # generated hypothesis and create a backtranslation data pair
- # {id: id, source: generated backtranslation, target: original tgt}
- return [
- {
- "id": id.item(),
- "target": id_to_src[id.item()],
- "source": hypos[0]["tokens"].cpu(),
- }
- for id, hypos in zip(collated_samples["id"], generated_sources)
- ]
-
-
-class BacktranslationDataset(FairseqDataset):
- """
- Sets up a backtranslation dataset which takes a tgt batch, generates
- a src using a tgt-src backtranslation function (*backtranslation_fn*),
- and returns the corresponding `{generated src, input tgt}` batch.
-
- Args:
- tgt_dataset (~fairseq.data.FairseqDataset): the dataset to be
- backtranslated. Only the source side of this dataset will be used.
- After backtranslation, the source sentences in this dataset will be
- returned as the targets.
- src_dict (~fairseq.data.Dictionary): the dictionary of backtranslated
- sentences.
- tgt_dict (~fairseq.data.Dictionary, optional): the dictionary of
- sentences to be backtranslated.
- backtranslation_fn (callable, optional): function to call to generate
- backtranslations. This is typically the `generate` method of a
- :class:`~fairseq.sequence_generator.SequenceGenerator` object.
- Pass in None when it is not available at initialization time, and
- use set_backtranslation_fn function to set it when available.
- output_collater (callable, optional): function to call on the
- backtranslated samples to create the final batch
- (default: ``tgt_dataset.collater``).
- cuda: use GPU for generation
- """
-
- def __init__(
- self,
- tgt_dataset,
- src_dict,
- tgt_dict=None,
- backtranslation_fn=None,
- output_collater=None,
- cuda=True,
- **kwargs
- ):
- self.tgt_dataset = tgt_dataset
- self.backtranslation_fn = backtranslation_fn
- self.output_collater = (
- output_collater if output_collater is not None else tgt_dataset.collater
- )
- self.cuda = cuda if torch.cuda.is_available() else False
- self.src_dict = src_dict
- self.tgt_dict = tgt_dict
-
- def __getitem__(self, index):
- """
- Returns a single sample from *tgt_dataset*. Note that backtranslation is
- not applied in this step; use :func:`collater` instead to backtranslate
- a batch of samples.
- """
- return self.tgt_dataset[index]
-
- def __len__(self):
- return len(self.tgt_dataset)
-
- def set_backtranslation_fn(self, backtranslation_fn):
- self.backtranslation_fn = backtranslation_fn
-
- def collater(self, samples):
- """Merge and backtranslate a list of samples to form a mini-batch.
-
- Using the samples from *tgt_dataset*, load a collated target sample to
- feed to the backtranslation model. Then take the backtranslation with
- the best score as the source and the original input as the target.
-
- Note: we expect *tgt_dataset* to provide a function `collater()` that
- will collate samples into the format expected by *backtranslation_fn*.
- After backtranslation, we will feed the new list of samples (i.e., the
- `(backtranslated source, original source)` pairs) to *output_collater*
- and return the result.
-
- Args:
- samples (List[dict]): samples to backtranslate and collate
-
- Returns:
- dict: a mini-batch with keys coming from *output_collater*
- """
- if samples[0].get("is_dummy", False):
- return samples
- samples = backtranslate_samples(
- samples=samples,
- collate_fn=self.tgt_dataset.collater,
- generate_fn=(lambda net_input: self.backtranslation_fn(net_input)),
- cuda=self.cuda,
- )
- return self.output_collater(samples)
-
- def num_tokens(self, index):
- """Just use the tgt dataset num_tokens"""
- return self.tgt_dataset.num_tokens(index)
-
- def ordered_indices(self):
- """Just use the tgt dataset ordered_indices"""
- return self.tgt_dataset.ordered_indices()
-
- def size(self, index):
- """Return an example's size as a float or tuple. This value is used
- when filtering a dataset with ``--max-positions``.
-
- Note: we use *tgt_dataset* to approximate the length of the source
- sentence, since we do not know the actual length until after
- backtranslation.
- """
- tgt_size = self.tgt_dataset.size(index)[0]
- return (tgt_size, tgt_size)
-
- @property
- def supports_prefetch(self):
- return getattr(self.tgt_dataset, "supports_prefetch", False)
-
- def prefetch(self, indices):
- return self.tgt_dataset.prefetch(indices)
diff --git a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/fairseq/dataclass/initialize.py b/spaces/OFA-Sys/OFA-Image_Caption/fairseq/fairseq/dataclass/initialize.py
deleted file mode 100644
index 8f6cbafb805b293611e2175721132078123b81d0..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/fairseq/dataclass/initialize.py
+++ /dev/null
@@ -1,61 +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.
-"""isort:skip_file"""
-
-import logging
-from hydra.core.config_store import ConfigStore
-from fairseq.dataclass.configs import FairseqConfig
-from omegaconf import DictConfig, OmegaConf
-
-
-logger = logging.getLogger(__name__)
-
-
-def hydra_init(cfg_name="config") -> None:
-
- cs = ConfigStore.instance()
- cs.store(name=f"{cfg_name}", node=FairseqConfig)
-
- for k in FairseqConfig.__dataclass_fields__:
- v = FairseqConfig.__dataclass_fields__[k].default
- try:
- cs.store(name=k, node=v)
- except BaseException:
- logger.error(f"{k} - {v}")
- raise
-
-
-def add_defaults(cfg: DictConfig) -> None:
- """This function adds default values that are stored in dataclasses that hydra doesn't know about """
-
- from fairseq.registry import REGISTRIES
- from fairseq.tasks import TASK_DATACLASS_REGISTRY
- from fairseq.models import ARCH_MODEL_NAME_REGISTRY, MODEL_DATACLASS_REGISTRY
- from fairseq.dataclass.utils import merge_with_parent
- from typing import Any
-
- OmegaConf.set_struct(cfg, False)
-
- for k, v in FairseqConfig.__dataclass_fields__.items():
- field_cfg = cfg.get(k)
- if field_cfg is not None and v.type == Any:
- dc = None
-
- if isinstance(field_cfg, str):
- field_cfg = DictConfig({"_name": field_cfg})
- field_cfg.__dict__["_parent"] = field_cfg.__dict__["_parent"]
-
- name = getattr(field_cfg, "_name", None)
-
- if k == "task":
- dc = TASK_DATACLASS_REGISTRY.get(name)
- elif k == "model":
- name = ARCH_MODEL_NAME_REGISTRY.get(name, name)
- dc = MODEL_DATACLASS_REGISTRY.get(name)
- elif k in REGISTRIES:
- dc = REGISTRIES[k]["dataclass_registry"].get(name)
-
- if dc is not None:
- cfg[k] = merge_with_parent(dc, field_cfg)
diff --git a/spaces/OFA-Sys/OFA-vqa/fairseq/fairseq/criterions/__init__.py b/spaces/OFA-Sys/OFA-vqa/fairseq/fairseq/criterions/__init__.py
deleted file mode 100644
index 4dbf46a1cb31ce65c4224ae79cbc2d7cf9e4d111..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-vqa/fairseq/fairseq/criterions/__init__.py
+++ /dev/null
@@ -1,36 +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.
-"""isort:skip_file"""
-
-import importlib
-import os
-
-from fairseq import registry
-from fairseq.criterions.fairseq_criterion import ( # noqa
- FairseqCriterion,
- LegacyFairseqCriterion,
-)
-from omegaconf import DictConfig
-
-
-(
- build_criterion_,
- register_criterion,
- CRITERION_REGISTRY,
- CRITERION_DATACLASS_REGISTRY,
-) = registry.setup_registry(
- "--criterion", base_class=FairseqCriterion, default="cross_entropy"
-)
-
-
-def build_criterion(cfg: DictConfig, task):
- return build_criterion_(cfg, task)
-
-
-# automatically import any Python files in the criterions/ directory
-for file in sorted(os.listdir(os.path.dirname(__file__))):
- if file.endswith(".py") and not file.startswith("_"):
- file_name = file[: file.find(".py")]
- importlib.import_module("fairseq.criterions." + file_name)
diff --git a/spaces/OFA-Sys/OFA-vqa/fairseq/fairseq/data/language_pair_dataset.py b/spaces/OFA-Sys/OFA-vqa/fairseq/fairseq/data/language_pair_dataset.py
deleted file mode 100644
index ff3e14bf14770638524ef6067b558e455dbe5f2b..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-vqa/fairseq/fairseq/data/language_pair_dataset.py
+++ /dev/null
@@ -1,471 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import logging
-
-import numpy as np
-import torch
-from fairseq.data import FairseqDataset, data_utils
-
-
-logger = logging.getLogger(__name__)
-
-
-def collate(
- samples,
- pad_idx,
- eos_idx,
- left_pad_source=True,
- left_pad_target=False,
- input_feeding=True,
- pad_to_length=None,
- pad_to_multiple=1,
-):
- if len(samples) == 0:
- return {}
-
- def merge(key, left_pad, move_eos_to_beginning=False, pad_to_length=None):
- return data_utils.collate_tokens(
- [s[key] for s in samples],
- pad_idx,
- eos_idx,
- left_pad,
- move_eos_to_beginning,
- pad_to_length=pad_to_length,
- pad_to_multiple=pad_to_multiple,
- )
-
- def check_alignment(alignment, src_len, tgt_len):
- if alignment is None or len(alignment) == 0:
- return False
- if (
- alignment[:, 0].max().item() >= src_len - 1
- or alignment[:, 1].max().item() >= tgt_len - 1
- ):
- logger.warning("alignment size mismatch found, skipping alignment!")
- return False
- return True
-
- def compute_alignment_weights(alignments):
- """
- Given a tensor of shape [:, 2] containing the source-target indices
- corresponding to the alignments, a weight vector containing the
- inverse frequency of each target index is computed.
- For e.g. if alignments = [[5, 7], [2, 3], [1, 3], [4, 2]], then
- a tensor containing [1., 0.5, 0.5, 1] should be returned (since target
- index 3 is repeated twice)
- """
- align_tgt = alignments[:, 1]
- _, align_tgt_i, align_tgt_c = torch.unique(
- align_tgt, return_inverse=True, return_counts=True
- )
- align_weights = align_tgt_c[align_tgt_i[np.arange(len(align_tgt))]]
- return 1.0 / align_weights.float()
-
- id = torch.LongTensor([s["id"] for s in samples])
- src_tokens = merge(
- "source",
- left_pad=left_pad_source,
- pad_to_length=pad_to_length["source"] if pad_to_length is not None else None,
- )
- # sort by descending source length
- src_lengths = torch.LongTensor(
- [s["source"].ne(pad_idx).long().sum() for s in samples]
- )
- src_lengths, sort_order = src_lengths.sort(descending=True)
- id = id.index_select(0, sort_order)
- src_tokens = src_tokens.index_select(0, sort_order)
-
- prev_output_tokens = None
- target = None
- if samples[0].get("target", None) is not None:
- target = merge(
- "target",
- left_pad=left_pad_target,
- pad_to_length=pad_to_length["target"]
- if pad_to_length is not None
- else None,
- )
- target = target.index_select(0, sort_order)
- tgt_lengths = torch.LongTensor(
- [s["target"].ne(pad_idx).long().sum() for s in samples]
- ).index_select(0, sort_order)
- ntokens = tgt_lengths.sum().item()
-
- if samples[0].get("prev_output_tokens", None) is not None:
- prev_output_tokens = merge("prev_output_tokens", left_pad=left_pad_target)
- elif input_feeding:
- # we create a shifted version of targets for feeding the
- # previous output token(s) into the next decoder step
- prev_output_tokens = merge(
- "target",
- left_pad=left_pad_target,
- move_eos_to_beginning=True,
- pad_to_length=pad_to_length["target"]
- if pad_to_length is not None
- else None,
- )
- else:
- ntokens = src_lengths.sum().item()
-
- batch = {
- "id": id,
- "nsentences": len(samples),
- "ntokens": ntokens,
- "net_input": {"src_tokens": src_tokens, "src_lengths": src_lengths,},
- "target": target,
- }
- if prev_output_tokens is not None:
- batch["net_input"]["prev_output_tokens"] = prev_output_tokens.index_select(
- 0, sort_order
- )
-
- if samples[0].get("alignment", None) is not None:
- bsz, tgt_sz = batch["target"].shape
- src_sz = batch["net_input"]["src_tokens"].shape[1]
-
- offsets = torch.zeros((len(sort_order), 2), dtype=torch.long)
- offsets[:, 1] += torch.arange(len(sort_order), dtype=torch.long) * tgt_sz
- if left_pad_source:
- offsets[:, 0] += src_sz - src_lengths
- if left_pad_target:
- offsets[:, 1] += tgt_sz - tgt_lengths
-
- alignments = [
- alignment + offset
- for align_idx, offset, src_len, tgt_len in zip(
- sort_order, offsets, src_lengths, tgt_lengths
- )
- for alignment in [samples[align_idx]["alignment"].view(-1, 2)]
- if check_alignment(alignment, src_len, tgt_len)
- ]
-
- if len(alignments) > 0:
- alignments = torch.cat(alignments, dim=0)
- align_weights = compute_alignment_weights(alignments)
-
- batch["alignments"] = alignments
- batch["align_weights"] = align_weights
-
- if samples[0].get("constraints", None) is not None:
- # Collate the packed constraints across the samples, padding to
- # the length of the longest sample.
- lens = [sample.get("constraints").size(0) for sample in samples]
- max_len = max(lens)
- constraints = torch.zeros((len(samples), max(lens))).long()
- for i, sample in enumerate(samples):
- constraints[i, 0 : lens[i]] = samples[i].get("constraints")
- batch["constraints"] = constraints.index_select(0, sort_order)
-
- return batch
-
-
-class LanguagePairDataset(FairseqDataset):
- """
- A pair of torch.utils.data.Datasets.
-
- Args:
- src (torch.utils.data.Dataset): source dataset to wrap
- src_sizes (List[int]): source sentence lengths
- src_dict (~fairseq.data.Dictionary): source vocabulary
- tgt (torch.utils.data.Dataset, optional): target dataset to wrap
- tgt_sizes (List[int], optional): target sentence lengths
- tgt_dict (~fairseq.data.Dictionary, optional): target vocabulary
- left_pad_source (bool, optional): pad source tensors on the left side
- (default: True).
- left_pad_target (bool, optional): pad target tensors on the left side
- (default: False).
- shuffle (bool, optional): shuffle dataset elements before batching
- (default: True).
- input_feeding (bool, optional): create a shifted version of the targets
- to be passed into the model for teacher forcing (default: True).
- remove_eos_from_source (bool, optional): if set, removes eos from end
- of source if it's present (default: False).
- append_eos_to_target (bool, optional): if set, appends eos to end of
- target if it's absent (default: False).
- align_dataset (torch.utils.data.Dataset, optional): dataset
- containing alignments.
- constraints (Tensor, optional): 2d tensor with a concatenated, zero-
- delimited list of constraints for each sentence.
- append_bos (bool, optional): if set, appends bos to the beginning of
- source/target sentence.
- num_buckets (int, optional): if set to a value greater than 0, then
- batches will be bucketed into the given number of batch shapes.
- src_lang_id (int, optional): source language ID, if set, the collated batch
- will contain a field 'src_lang_id' in 'net_input' which indicates the
- source language of the samples.
- tgt_lang_id (int, optional): target language ID, if set, the collated batch
- will contain a field 'tgt_lang_id' which indicates the target language
- of the samples.
- """
-
- def __init__(
- self,
- src,
- src_sizes,
- src_dict,
- tgt=None,
- tgt_sizes=None,
- tgt_dict=None,
- left_pad_source=True,
- left_pad_target=False,
- shuffle=True,
- input_feeding=True,
- remove_eos_from_source=False,
- append_eos_to_target=False,
- align_dataset=None,
- constraints=None,
- append_bos=False,
- eos=None,
- num_buckets=0,
- src_lang_id=None,
- tgt_lang_id=None,
- pad_to_multiple=1,
- ):
- if tgt_dict is not None:
- assert src_dict.pad() == tgt_dict.pad()
- assert src_dict.eos() == tgt_dict.eos()
- assert src_dict.unk() == tgt_dict.unk()
- if tgt is not None:
- assert len(src) == len(
- tgt
- ), "Source and target must contain the same number of examples"
- self.src = src
- self.tgt = tgt
- self.src_sizes = np.array(src_sizes)
- self.tgt_sizes = np.array(tgt_sizes) if tgt_sizes is not None else None
- self.sizes = (
- np.vstack((self.src_sizes, self.tgt_sizes)).T
- if self.tgt_sizes is not None
- else self.src_sizes
- )
- self.src_dict = src_dict
- self.tgt_dict = tgt_dict
- self.left_pad_source = left_pad_source
- self.left_pad_target = left_pad_target
- self.shuffle = shuffle
- self.input_feeding = input_feeding
- self.remove_eos_from_source = remove_eos_from_source
- self.append_eos_to_target = append_eos_to_target
- self.align_dataset = align_dataset
- if self.align_dataset is not None:
- assert (
- self.tgt_sizes is not None
- ), "Both source and target needed when alignments are provided"
- self.constraints = constraints
- self.append_bos = append_bos
- self.eos = eos if eos is not None else src_dict.eos()
- self.src_lang_id = src_lang_id
- self.tgt_lang_id = tgt_lang_id
- if num_buckets > 0:
- from fairseq.data import BucketPadLengthDataset
-
- self.src = BucketPadLengthDataset(
- self.src,
- sizes=self.src_sizes,
- num_buckets=num_buckets,
- pad_idx=self.src_dict.pad(),
- left_pad=self.left_pad_source,
- )
- self.src_sizes = self.src.sizes
- logger.info("bucketing source lengths: {}".format(list(self.src.buckets)))
- if self.tgt is not None:
- self.tgt = BucketPadLengthDataset(
- self.tgt,
- sizes=self.tgt_sizes,
- num_buckets=num_buckets,
- pad_idx=self.tgt_dict.pad(),
- left_pad=self.left_pad_target,
- )
- self.tgt_sizes = self.tgt.sizes
- logger.info(
- "bucketing target lengths: {}".format(list(self.tgt.buckets))
- )
-
- # determine bucket sizes using self.num_tokens, which will return
- # the padded lengths (thanks to BucketPadLengthDataset)
- num_tokens = np.vectorize(self.num_tokens, otypes=[np.compat.long])
- self.bucketed_num_tokens = num_tokens(np.arange(len(self.src)))
- self.buckets = [
- (None, num_tokens) for num_tokens in np.unique(self.bucketed_num_tokens)
- ]
- else:
- self.buckets = None
- self.pad_to_multiple = pad_to_multiple
-
- def get_batch_shapes(self):
- return self.buckets
-
- def __getitem__(self, index):
- tgt_item = self.tgt[index] if self.tgt is not None else None
- src_item = self.src[index]
- # Append EOS to end of tgt sentence if it does not have an EOS and remove
- # EOS from end of src sentence if it exists. This is useful when we use
- # use existing datasets for opposite directions i.e., when we want to
- # use tgt_dataset as src_dataset and vice versa
- if self.append_eos_to_target:
- eos = self.tgt_dict.eos() if self.tgt_dict else self.src_dict.eos()
- if self.tgt and self.tgt[index][-1] != eos:
- tgt_item = torch.cat([self.tgt[index], torch.LongTensor([eos])])
-
- if self.append_bos:
- bos = self.tgt_dict.bos() if self.tgt_dict else self.src_dict.bos()
- if self.tgt and self.tgt[index][0] != bos:
- tgt_item = torch.cat([torch.LongTensor([bos]), self.tgt[index]])
-
- bos = self.src_dict.bos()
- if self.src[index][0] != bos:
- src_item = torch.cat([torch.LongTensor([bos]), self.src[index]])
-
- if self.remove_eos_from_source:
- eos = self.src_dict.eos()
- if self.src[index][-1] == eos:
- src_item = self.src[index][:-1]
-
- example = {
- "id": index,
- "source": src_item,
- "target": tgt_item,
- }
- if self.align_dataset is not None:
- example["alignment"] = self.align_dataset[index]
- if self.constraints is not None:
- example["constraints"] = self.constraints[index]
- return example
-
- def __len__(self):
- return len(self.src)
-
- def collater(self, samples, pad_to_length=None):
- """Merge a list of samples to form a mini-batch.
-
- Args:
- samples (List[dict]): samples to collate
- pad_to_length (dict, optional): a dictionary of
- {'source': source_pad_to_length, 'target': target_pad_to_length}
- to indicate the max length to pad to in source and target respectively.
-
- Returns:
- dict: a mini-batch with the following keys:
-
- - `id` (LongTensor): example IDs in the original input order
- - `ntokens` (int): total number of tokens in the batch
- - `net_input` (dict): the input to the Model, containing keys:
-
- - `src_tokens` (LongTensor): a padded 2D Tensor of tokens in
- the source sentence of shape `(bsz, src_len)`. Padding will
- appear on the left if *left_pad_source* is ``True``.
- - `src_lengths` (LongTensor): 1D Tensor of the unpadded
- lengths of each source sentence of shape `(bsz)`
- - `prev_output_tokens` (LongTensor): a padded 2D Tensor of
- tokens in the target sentence, shifted right by one
- position for teacher forcing, of shape `(bsz, tgt_len)`.
- This key will not be present if *input_feeding* is
- ``False``. Padding will appear on the left if
- *left_pad_target* is ``True``.
- - `src_lang_id` (LongTensor): a long Tensor which contains source
- language IDs of each sample in the batch
-
- - `target` (LongTensor): a padded 2D Tensor of tokens in the
- target sentence of shape `(bsz, tgt_len)`. Padding will appear
- on the left if *left_pad_target* is ``True``.
- - `tgt_lang_id` (LongTensor): a long Tensor which contains target language
- IDs of each sample in the batch
- """
- res = collate(
- samples,
- pad_idx=self.src_dict.pad(),
- eos_idx=self.eos,
- left_pad_source=self.left_pad_source,
- left_pad_target=self.left_pad_target,
- input_feeding=self.input_feeding,
- pad_to_length=pad_to_length,
- pad_to_multiple=self.pad_to_multiple,
- )
- if self.src_lang_id is not None or self.tgt_lang_id is not None:
- src_tokens = res["net_input"]["src_tokens"]
- bsz = src_tokens.size(0)
- if self.src_lang_id is not None:
- res["net_input"]["src_lang_id"] = (
- torch.LongTensor([[self.src_lang_id]]).expand(bsz, 1).to(src_tokens)
- )
- if self.tgt_lang_id is not None:
- res["tgt_lang_id"] = (
- torch.LongTensor([[self.tgt_lang_id]]).expand(bsz, 1).to(src_tokens)
- )
- return res
-
- def num_tokens(self, index):
- """Return the number of tokens in a sample. This value is used to
- enforce ``--max-tokens`` during batching."""
- return max(
- self.src_sizes[index],
- self.tgt_sizes[index] if self.tgt_sizes is not None else 0,
- )
-
- def num_tokens_vec(self, indices):
- """Return the number of tokens for a set of positions defined by indices.
- This value is used to enforce ``--max-tokens`` during batching."""
- sizes = self.src_sizes[indices]
- if self.tgt_sizes is not None:
- sizes = np.maximum(sizes, self.tgt_sizes[indices])
- return sizes
-
- def size(self, index):
- """Return an example's size as a float or tuple. This value is used when
- filtering a dataset with ``--max-positions``."""
- return (
- self.src_sizes[index],
- self.tgt_sizes[index] if self.tgt_sizes is not None else 0,
- )
-
- def ordered_indices(self):
- """Return an ordered list of indices. Batches will be constructed based
- on this order."""
- if self.shuffle:
- indices = np.random.permutation(len(self)).astype(np.int64)
- else:
- indices = np.arange(len(self), dtype=np.int64)
- if self.buckets is None:
- # sort by target length, then source length
- if self.tgt_sizes is not None:
- indices = indices[np.argsort(self.tgt_sizes[indices], kind="mergesort")]
- return indices[np.argsort(self.src_sizes[indices], kind="mergesort")]
- else:
- # sort by bucketed_num_tokens, which is:
- # max(padded_src_len, padded_tgt_len)
- return indices[
- np.argsort(self.bucketed_num_tokens[indices], kind="mergesort")
- ]
-
- @property
- def supports_prefetch(self):
- return getattr(self.src, "supports_prefetch", False) and (
- getattr(self.tgt, "supports_prefetch", False) or self.tgt is None
- )
-
- def prefetch(self, indices):
- self.src.prefetch(indices)
- if self.tgt is not None:
- self.tgt.prefetch(indices)
- if self.align_dataset is not None:
- self.align_dataset.prefetch(indices)
-
- def filter_indices_by_size(self, indices, max_sizes):
- """Filter a list of sample indices. Remove those that are longer
- than specified in max_sizes.
-
- Args:
- indices (np.array): original array of sample indices
- max_sizes (int or list[int] or tuple[int]): max sample size,
- can be defined separately for src and tgt (then list or tuple)
-
- Returns:
- np.array: filtered sample array
- list: list of removed indices
- """
- return data_utils.filter_paired_dataset_indices_by_size(
- self.src_sizes, self.tgt_sizes, indices, max_sizes,
- )
diff --git a/spaces/OldP1ng/QQsign/README.md b/spaces/OldP1ng/QQsign/README.md
deleted file mode 100644
index 3042be806844c4b6d92719e8afaa17d09c970d46..0000000000000000000000000000000000000000
--- a/spaces/OldP1ng/QQsign/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: QQsign
-emoji: 🦀
-colorFrom: blue
-colorTo: purple
-sdk: docker
-pinned: false
-license: mit
-duplicated_from: CikeyQI/QQsign
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
\ No newline at end of file
diff --git a/spaces/Omnibus/MusicGen/audiocraft/models/loaders.py b/spaces/Omnibus/MusicGen/audiocraft/models/loaders.py
deleted file mode 100644
index 97c662c3212b7695669cbfc5214ff2f099c3f319..0000000000000000000000000000000000000000
--- a/spaces/Omnibus/MusicGen/audiocraft/models/loaders.py
+++ /dev/null
@@ -1,94 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-"""
-Utility functions to load from the checkpoints.
-Each checkpoint is a torch.saved dict with the following keys:
-- 'xp.cfg': the hydra config as dumped during training. This should be used
- to rebuild the object using the audiocraft.models.builders functions,
-- 'model_best_state': a readily loadable best state for the model, including
- the conditioner. The model obtained from `xp.cfg` should be compatible
- with this state dict. In the case of a LM, the encodec model would not be
- bundled along but instead provided separately.
-
-Those functions also support loading from a remote location with the Torch Hub API.
-They also support overriding some parameters, in particular the device and dtype
-of the returned model.
-"""
-
-from pathlib import Path
-from huggingface_hub import hf_hub_download
-import typing as tp
-import os
-
-from omegaconf import OmegaConf
-import torch
-
-from . import builders
-
-
-HF_MODEL_CHECKPOINTS_MAP = {
- "small": "facebook/musicgen-small",
- "medium": "facebook/musicgen-medium",
- "large": "facebook/musicgen-large",
- "melody": "facebook/musicgen-melody",
-}
-
-
-def _get_state_dict(
- file_or_url_or_id: tp.Union[Path, str],
- filename: tp.Optional[str] = None,
- device='cpu',
- cache_dir: tp.Optional[str] = None,
-):
- # Return the state dict either from a file or url
- file_or_url_or_id = str(file_or_url_or_id)
- assert isinstance(file_or_url_or_id, str)
-
- if os.path.isfile(file_or_url_or_id):
- return torch.load(file_or_url_or_id, map_location=device)
-
- if os.path.isdir(file_or_url_or_id):
- file = f"{file_or_url_or_id}/{filename}"
- return torch.load(file, map_location=device)
-
- elif file_or_url_or_id.startswith('https://'):
- return torch.hub.load_state_dict_from_url(file_or_url_or_id, map_location=device, check_hash=True)
-
- elif file_or_url_or_id in HF_MODEL_CHECKPOINTS_MAP:
- assert filename is not None, "filename needs to be defined if using HF checkpoints"
-
- repo_id = HF_MODEL_CHECKPOINTS_MAP[file_or_url_or_id]
- file = hf_hub_download(repo_id=repo_id, filename=filename, cache_dir=cache_dir)
- return torch.load(file, map_location=device)
-
- else:
- raise ValueError(f"{file_or_url_or_id} is not a valid name, path or link that can be loaded.")
-
-
-def load_compression_model(file_or_url_or_id: tp.Union[Path, str], device='cpu', cache_dir: tp.Optional[str] = None):
- pkg = _get_state_dict(file_or_url_or_id, filename="compression_state_dict.bin", cache_dir=cache_dir)
- cfg = OmegaConf.create(pkg['xp.cfg'])
- cfg.device = str(device)
- model = builders.get_compression_model(cfg)
- model.load_state_dict(pkg['best_state'])
- model.eval()
- return model
-
-
-def load_lm_model(file_or_url_or_id: tp.Union[Path, str], device='cpu', cache_dir: tp.Optional[str] = None):
- pkg = _get_state_dict(file_or_url_or_id, filename="state_dict.bin", cache_dir=cache_dir)
- cfg = OmegaConf.create(pkg['xp.cfg'])
- cfg.device = str(device)
- if cfg.device == 'cpu':
- cfg.dtype = 'float32'
- else:
- cfg.dtype = 'float16'
- model = builders.get_lm_model(cfg)
- model.load_state_dict(pkg['best_state'])
- model.eval()
- model.cfg = cfg
- return model
diff --git a/spaces/Omnibus/Video-Diffusion-WebUI/video_diffusion/tuneavideo/tuneavideo_text2video.py b/spaces/Omnibus/Video-Diffusion-WebUI/video_diffusion/tuneavideo/tuneavideo_text2video.py
deleted file mode 100644
index 774f7ee6d259953ea8716b05b1f6b99c92b0e9bb..0000000000000000000000000000000000000000
--- a/spaces/Omnibus/Video-Diffusion-WebUI/video_diffusion/tuneavideo/tuneavideo_text2video.py
+++ /dev/null
@@ -1,153 +0,0 @@
-import gradio as gr
-import torch
-
-from video_diffusion.tuneavideo.models.unet import UNet3DConditionModel
-from video_diffusion.tuneavideo.pipelines.pipeline_tuneavideo import TuneAVideoPipeline
-from video_diffusion.tuneavideo.util import save_videos_grid
-from video_diffusion.utils.model_list import stable_model_list
-
-video_diffusion_model_list = [
- "Tune-A-Video-library/a-man-is-surfing",
- "Tune-A-Video-library/mo-di-bear-guitar",
- "Tune-A-Video-library/redshift-man-skiing",
-]
-
-
-class TunaVideoText2VideoGenerator:
- def __init__(self):
- self.pipe = None
- self.unet = None
-
- def load_model(self, video_diffusion_model_list, stable_model_list):
- if self.pipe is None:
- if self.unet is None:
- self.unet = UNet3DConditionModel.from_pretrained(
- video_diffusion_model_list, subfolder="unet", torch_dtype=torch.float16
- ).to("cuda")
-
- self.pipe = TuneAVideoPipeline.from_pretrained(
- stable_model_list, unet=self.unet, torch_dtype=torch.float16
- )
- self.pipe.to("cuda")
- self.pipe.enable_xformers_memory_efficient_attention()
-
- return self.pipe
-
- def generate_video(
- self,
- video_diffusion_model: str,
- stable_model_list: str,
- prompt: str,
- negative_prompt: str,
- video_length: int,
- height: int,
- width: int,
- num_inference_steps: int,
- guidance_scale: int,
- fps: int,
- ):
- pipe = self.load_model(video_diffusion_model, stable_model_list)
- video = pipe(
- prompt,
- negative_prompt=negative_prompt,
- video_length=video_length,
- height=height,
- width=width,
- num_inference_steps=num_inference_steps,
- guidance_scale=guidance_scale,
- ).videos
-
- save_videos_grid(videos=video, path="output.gif", fps=fps)
- return "output.gif"
-
- def app():
- with gr.Blocks():
- with gr.Row():
- with gr.Column():
- tunevideo_video_diffusion_model_list = gr.Dropdown(
- choices=video_diffusion_model_list,
- label="Video Diffusion Model",
- value=video_diffusion_model_list[0],
- )
- tunevideo_stable_model_list = gr.Dropdown(
- choices=stable_model_list,
- label="Stable Model List",
- value=stable_model_list[0],
- )
- with gr.Row():
- with gr.Column():
- tunevideo_prompt = gr.Textbox(
- lines=1,
- placeholder="Prompt",
- show_label=False,
- )
- tunevideo_video_length = gr.Slider(
- minimum=1,
- maximum=100,
- step=1,
- value=10,
- label="Video Length",
- )
- tunevideo_num_inference_steps = gr.Slider(
- minimum=1,
- maximum=100,
- step=1,
- value=50,
- label="Num Inference Steps",
- )
- tunevideo_fps = gr.Slider(
- minimum=1,
- maximum=60,
- step=1,
- value=5,
- label="Fps",
- )
- with gr.Row():
- with gr.Column():
- tunevideo_negative_prompt = gr.Textbox(
- lines=1,
- placeholder="Negative Prompt",
- show_label=False,
- )
- tunevideo_guidance_scale = gr.Slider(
- minimum=1,
- maximum=15,
- step=1,
- value=7.5,
- label="Guidance Scale",
- )
- tunevideo_height = gr.Slider(
- minimum=1,
- maximum=1280,
- step=32,
- value=512,
- label="Height",
- )
- tunevideo_width = gr.Slider(
- minimum=1,
- maximum=1280,
- step=32,
- value=512,
- label="Width",
- )
- tunevideo_generate = gr.Button(value="Generator")
-
- with gr.Column():
- tunevideo_output = gr.Video(label="Output")
-
- tunevideo_generate.click(
- fn=TunaVideoText2VideoGenerator().generate_video,
- inputs=[
- tunevideo_video_diffusion_model_list,
- tunevideo_stable_model_list,
- tunevideo_prompt,
- tunevideo_negative_prompt,
- tunevideo_video_length,
- tunevideo_height,
- tunevideo_width,
- tunevideo_num_inference_steps,
- tunevideo_guidance_scale,
- tunevideo_fps,
- ],
- outputs=tunevideo_output,
- )
diff --git a/spaces/One-2-3-45/One-2-3-45/README.md b/spaces/One-2-3-45/One-2-3-45/README.md
deleted file mode 100644
index 8de795c7b728591c7035291d0dbfa202b4249f5f..0000000000000000000000000000000000000000
--- a/spaces/One-2-3-45/One-2-3-45/README.md
+++ /dev/null
@@ -1,37 +0,0 @@
----
-title: One-2-3-45
-emoji: 📸🚀🌟
-colorFrom: red
-colorTo: yellow
-sdk: gradio
-sdk_version: 3.44.0
-app_file: app.py
-pinned: true
-license: mit
----
-
-# One-2-3-45: Any Single Image to 3D Mesh in 45 Seconds without Per-Shape Optimization
-
-
-
-
-
-
-
-
-This space hosts the demo for [One-2-3-45](http://One-2-3-45.com), powered by the [inference model](https://huggingface.co/One-2-3-45/code).
-
-Please refer to our [GitHub repo](https://github.com/One-2-3-45/One-2-3-45) for full code release and local deployment of the demo.
-
-## Citation
-
-```bibtex
-@misc{liu2023one2345,
- title={One-2-3-45: Any Single Image to 3D Mesh in 45 Seconds without Per-Shape Optimization},
- author={Minghua Liu and Chao Xu and Haian Jin and Linghao Chen and Mukund Varma T and Zexiang Xu and Hao Su},
- year={2023},
- eprint={2306.16928},
- archivePrefix={arXiv},
- primaryClass={cs.CV}
-}
-```
\ No newline at end of file
diff --git a/spaces/OpenGVLab/InternGPT/third-party/lama/bin/make_checkpoint.py b/spaces/OpenGVLab/InternGPT/third-party/lama/bin/make_checkpoint.py
deleted file mode 100644
index 322147483915bef758770ae931e705e56083fa8d..0000000000000000000000000000000000000000
--- a/spaces/OpenGVLab/InternGPT/third-party/lama/bin/make_checkpoint.py
+++ /dev/null
@@ -1,79 +0,0 @@
-#!/usr/bin/env python3
-
-import os
-import shutil
-
-import torch
-
-
-def get_checkpoint_files(s):
- s = s.strip()
- if ',' in s:
- return [get_checkpoint_files(chunk) for chunk in s.split(',')]
- return 'last.ckpt' if s == 'last' else f'{s}.ckpt'
-
-
-def main(args):
- checkpoint_fnames = get_checkpoint_files(args.epochs)
- if isinstance(checkpoint_fnames, str):
- checkpoint_fnames = [checkpoint_fnames]
- assert len(checkpoint_fnames) >= 1
-
- checkpoint_path = os.path.join(args.indir, 'models', checkpoint_fnames[0])
- checkpoint = torch.load(checkpoint_path, map_location='cpu')
- del checkpoint['optimizer_states']
-
- if len(checkpoint_fnames) > 1:
- for fname in checkpoint_fnames[1:]:
- print('sum', fname)
- sum_tensors_cnt = 0
- other_cp = torch.load(os.path.join(args.indir, 'models', fname), map_location='cpu')
- for k in checkpoint['state_dict'].keys():
- if checkpoint['state_dict'][k].dtype is torch.float:
- checkpoint['state_dict'][k].data.add_(other_cp['state_dict'][k].data)
- sum_tensors_cnt += 1
- print('summed', sum_tensors_cnt, 'tensors')
-
- for k in checkpoint['state_dict'].keys():
- if checkpoint['state_dict'][k].dtype is torch.float:
- checkpoint['state_dict'][k].data.mul_(1 / float(len(checkpoint_fnames)))
-
- state_dict = checkpoint['state_dict']
-
- if not args.leave_discriminators:
- for k in list(state_dict.keys()):
- if k.startswith('discriminator.'):
- del state_dict[k]
-
- if not args.leave_losses:
- for k in list(state_dict.keys()):
- if k.startswith('loss_'):
- del state_dict[k]
-
- out_checkpoint_path = os.path.join(args.outdir, 'models', 'best.ckpt')
- os.makedirs(os.path.dirname(out_checkpoint_path), exist_ok=True)
-
- torch.save(checkpoint, out_checkpoint_path)
-
- shutil.copy2(os.path.join(args.indir, 'config.yaml'),
- os.path.join(args.outdir, 'config.yaml'))
-
-
-if __name__ == '__main__':
- import argparse
-
- aparser = argparse.ArgumentParser()
- aparser.add_argument('indir',
- help='Path to directory with output of training '
- '(i.e. directory, which has samples, modules, config.yaml and train.log')
- aparser.add_argument('outdir',
- help='Where to put minimal checkpoint, which can be consumed by "bin/predict.py"')
- aparser.add_argument('--epochs', type=str, default='last',
- help='Which checkpoint to take. '
- 'Can be "last" or integer - number of epoch')
- aparser.add_argument('--leave-discriminators', action='store_true',
- help='If enabled, the state of discriminators will not be removed from the checkpoint')
- aparser.add_argument('--leave-losses', action='store_true',
- help='If enabled, weights of nn-based losses (e.g. perceptual) will not be removed')
-
- main(aparser.parse_args())
diff --git a/spaces/OpenGVLab/InternGPT/third-party/lama/saicinpainting/training/modules/squeeze_excitation.py b/spaces/OpenGVLab/InternGPT/third-party/lama/saicinpainting/training/modules/squeeze_excitation.py
deleted file mode 100644
index d1d902bb30c071acbc0fa919a134c80fed86bd6c..0000000000000000000000000000000000000000
--- a/spaces/OpenGVLab/InternGPT/third-party/lama/saicinpainting/training/modules/squeeze_excitation.py
+++ /dev/null
@@ -1,20 +0,0 @@
-import torch.nn as nn
-
-
-class SELayer(nn.Module):
- def __init__(self, channel, reduction=16):
- super(SELayer, self).__init__()
- self.avg_pool = nn.AdaptiveAvgPool2d(1)
- self.fc = nn.Sequential(
- nn.Linear(channel, channel // reduction, bias=False),
- nn.ReLU(inplace=True),
- nn.Linear(channel // reduction, channel, bias=False),
- nn.Sigmoid()
- )
-
- def forward(self, x):
- b, c, _, _ = x.size()
- y = self.avg_pool(x).view(b, c)
- y = self.fc(y).view(b, c, 1, 1)
- res = x * y.expand_as(x)
- return res
diff --git a/spaces/PAIR/Text2Video-Zero/annotator/openpose/model.py b/spaces/PAIR/Text2Video-Zero/annotator/openpose/model.py
deleted file mode 100644
index 5dfc80de827a17beccb9b0f3f7588545be78c9de..0000000000000000000000000000000000000000
--- a/spaces/PAIR/Text2Video-Zero/annotator/openpose/model.py
+++ /dev/null
@@ -1,219 +0,0 @@
-import torch
-from collections import OrderedDict
-
-import torch
-import torch.nn as nn
-
-def make_layers(block, no_relu_layers):
- layers = []
- for layer_name, v in block.items():
- if 'pool' in layer_name:
- layer = nn.MaxPool2d(kernel_size=v[0], stride=v[1],
- padding=v[2])
- layers.append((layer_name, layer))
- else:
- conv2d = nn.Conv2d(in_channels=v[0], out_channels=v[1],
- kernel_size=v[2], stride=v[3],
- padding=v[4])
- layers.append((layer_name, conv2d))
- if layer_name not in no_relu_layers:
- layers.append(('relu_'+layer_name, nn.ReLU(inplace=True)))
-
- return nn.Sequential(OrderedDict(layers))
-
-class bodypose_model(nn.Module):
- def __init__(self):
- super(bodypose_model, self).__init__()
-
- # these layers have no relu layer
- no_relu_layers = ['conv5_5_CPM_L1', 'conv5_5_CPM_L2', 'Mconv7_stage2_L1',\
- 'Mconv7_stage2_L2', 'Mconv7_stage3_L1', 'Mconv7_stage3_L2',\
- 'Mconv7_stage4_L1', 'Mconv7_stage4_L2', 'Mconv7_stage5_L1',\
- 'Mconv7_stage5_L2', 'Mconv7_stage6_L1', 'Mconv7_stage6_L1']
- blocks = {}
- block0 = OrderedDict([
- ('conv1_1', [3, 64, 3, 1, 1]),
- ('conv1_2', [64, 64, 3, 1, 1]),
- ('pool1_stage1', [2, 2, 0]),
- ('conv2_1', [64, 128, 3, 1, 1]),
- ('conv2_2', [128, 128, 3, 1, 1]),
- ('pool2_stage1', [2, 2, 0]),
- ('conv3_1', [128, 256, 3, 1, 1]),
- ('conv3_2', [256, 256, 3, 1, 1]),
- ('conv3_3', [256, 256, 3, 1, 1]),
- ('conv3_4', [256, 256, 3, 1, 1]),
- ('pool3_stage1', [2, 2, 0]),
- ('conv4_1', [256, 512, 3, 1, 1]),
- ('conv4_2', [512, 512, 3, 1, 1]),
- ('conv4_3_CPM', [512, 256, 3, 1, 1]),
- ('conv4_4_CPM', [256, 128, 3, 1, 1])
- ])
-
-
- # Stage 1
- block1_1 = OrderedDict([
- ('conv5_1_CPM_L1', [128, 128, 3, 1, 1]),
- ('conv5_2_CPM_L1', [128, 128, 3, 1, 1]),
- ('conv5_3_CPM_L1', [128, 128, 3, 1, 1]),
- ('conv5_4_CPM_L1', [128, 512, 1, 1, 0]),
- ('conv5_5_CPM_L1', [512, 38, 1, 1, 0])
- ])
-
- block1_2 = OrderedDict([
- ('conv5_1_CPM_L2', [128, 128, 3, 1, 1]),
- ('conv5_2_CPM_L2', [128, 128, 3, 1, 1]),
- ('conv5_3_CPM_L2', [128, 128, 3, 1, 1]),
- ('conv5_4_CPM_L2', [128, 512, 1, 1, 0]),
- ('conv5_5_CPM_L2', [512, 19, 1, 1, 0])
- ])
- blocks['block1_1'] = block1_1
- blocks['block1_2'] = block1_2
-
- self.model0 = make_layers(block0, no_relu_layers)
-
- # Stages 2 - 6
- for i in range(2, 7):
- blocks['block%d_1' % i] = OrderedDict([
- ('Mconv1_stage%d_L1' % i, [185, 128, 7, 1, 3]),
- ('Mconv2_stage%d_L1' % i, [128, 128, 7, 1, 3]),
- ('Mconv3_stage%d_L1' % i, [128, 128, 7, 1, 3]),
- ('Mconv4_stage%d_L1' % i, [128, 128, 7, 1, 3]),
- ('Mconv5_stage%d_L1' % i, [128, 128, 7, 1, 3]),
- ('Mconv6_stage%d_L1' % i, [128, 128, 1, 1, 0]),
- ('Mconv7_stage%d_L1' % i, [128, 38, 1, 1, 0])
- ])
-
- blocks['block%d_2' % i] = OrderedDict([
- ('Mconv1_stage%d_L2' % i, [185, 128, 7, 1, 3]),
- ('Mconv2_stage%d_L2' % i, [128, 128, 7, 1, 3]),
- ('Mconv3_stage%d_L2' % i, [128, 128, 7, 1, 3]),
- ('Mconv4_stage%d_L2' % i, [128, 128, 7, 1, 3]),
- ('Mconv5_stage%d_L2' % i, [128, 128, 7, 1, 3]),
- ('Mconv6_stage%d_L2' % i, [128, 128, 1, 1, 0]),
- ('Mconv7_stage%d_L2' % i, [128, 19, 1, 1, 0])
- ])
-
- for k in blocks.keys():
- blocks[k] = make_layers(blocks[k], no_relu_layers)
-
- self.model1_1 = blocks['block1_1']
- self.model2_1 = blocks['block2_1']
- self.model3_1 = blocks['block3_1']
- self.model4_1 = blocks['block4_1']
- self.model5_1 = blocks['block5_1']
- self.model6_1 = blocks['block6_1']
-
- self.model1_2 = blocks['block1_2']
- self.model2_2 = blocks['block2_2']
- self.model3_2 = blocks['block3_2']
- self.model4_2 = blocks['block4_2']
- self.model5_2 = blocks['block5_2']
- self.model6_2 = blocks['block6_2']
-
-
- def forward(self, x):
-
- out1 = self.model0(x)
-
- out1_1 = self.model1_1(out1)
- out1_2 = self.model1_2(out1)
- out2 = torch.cat([out1_1, out1_2, out1], 1)
-
- out2_1 = self.model2_1(out2)
- out2_2 = self.model2_2(out2)
- out3 = torch.cat([out2_1, out2_2, out1], 1)
-
- out3_1 = self.model3_1(out3)
- out3_2 = self.model3_2(out3)
- out4 = torch.cat([out3_1, out3_2, out1], 1)
-
- out4_1 = self.model4_1(out4)
- out4_2 = self.model4_2(out4)
- out5 = torch.cat([out4_1, out4_2, out1], 1)
-
- out5_1 = self.model5_1(out5)
- out5_2 = self.model5_2(out5)
- out6 = torch.cat([out5_1, out5_2, out1], 1)
-
- out6_1 = self.model6_1(out6)
- out6_2 = self.model6_2(out6)
-
- return out6_1, out6_2
-
-class handpose_model(nn.Module):
- def __init__(self):
- super(handpose_model, self).__init__()
-
- # these layers have no relu layer
- no_relu_layers = ['conv6_2_CPM', 'Mconv7_stage2', 'Mconv7_stage3',\
- 'Mconv7_stage4', 'Mconv7_stage5', 'Mconv7_stage6']
- # stage 1
- block1_0 = OrderedDict([
- ('conv1_1', [3, 64, 3, 1, 1]),
- ('conv1_2', [64, 64, 3, 1, 1]),
- ('pool1_stage1', [2, 2, 0]),
- ('conv2_1', [64, 128, 3, 1, 1]),
- ('conv2_2', [128, 128, 3, 1, 1]),
- ('pool2_stage1', [2, 2, 0]),
- ('conv3_1', [128, 256, 3, 1, 1]),
- ('conv3_2', [256, 256, 3, 1, 1]),
- ('conv3_3', [256, 256, 3, 1, 1]),
- ('conv3_4', [256, 256, 3, 1, 1]),
- ('pool3_stage1', [2, 2, 0]),
- ('conv4_1', [256, 512, 3, 1, 1]),
- ('conv4_2', [512, 512, 3, 1, 1]),
- ('conv4_3', [512, 512, 3, 1, 1]),
- ('conv4_4', [512, 512, 3, 1, 1]),
- ('conv5_1', [512, 512, 3, 1, 1]),
- ('conv5_2', [512, 512, 3, 1, 1]),
- ('conv5_3_CPM', [512, 128, 3, 1, 1])
- ])
-
- block1_1 = OrderedDict([
- ('conv6_1_CPM', [128, 512, 1, 1, 0]),
- ('conv6_2_CPM', [512, 22, 1, 1, 0])
- ])
-
- blocks = {}
- blocks['block1_0'] = block1_0
- blocks['block1_1'] = block1_1
-
- # stage 2-6
- for i in range(2, 7):
- blocks['block%d' % i] = OrderedDict([
- ('Mconv1_stage%d' % i, [150, 128, 7, 1, 3]),
- ('Mconv2_stage%d' % i, [128, 128, 7, 1, 3]),
- ('Mconv3_stage%d' % i, [128, 128, 7, 1, 3]),
- ('Mconv4_stage%d' % i, [128, 128, 7, 1, 3]),
- ('Mconv5_stage%d' % i, [128, 128, 7, 1, 3]),
- ('Mconv6_stage%d' % i, [128, 128, 1, 1, 0]),
- ('Mconv7_stage%d' % i, [128, 22, 1, 1, 0])
- ])
-
- for k in blocks.keys():
- blocks[k] = make_layers(blocks[k], no_relu_layers)
-
- self.model1_0 = blocks['block1_0']
- self.model1_1 = blocks['block1_1']
- self.model2 = blocks['block2']
- self.model3 = blocks['block3']
- self.model4 = blocks['block4']
- self.model5 = blocks['block5']
- self.model6 = blocks['block6']
-
- def forward(self, x):
- out1_0 = self.model1_0(x)
- out1_1 = self.model1_1(out1_0)
- concat_stage2 = torch.cat([out1_1, out1_0], 1)
- out_stage2 = self.model2(concat_stage2)
- concat_stage3 = torch.cat([out_stage2, out1_0], 1)
- out_stage3 = self.model3(concat_stage3)
- concat_stage4 = torch.cat([out_stage3, out1_0], 1)
- out_stage4 = self.model4(concat_stage4)
- concat_stage5 = torch.cat([out_stage4, out1_0], 1)
- out_stage5 = self.model5(concat_stage5)
- concat_stage6 = torch.cat([out_stage5, out1_0], 1)
- out_stage6 = self.model6(concat_stage6)
- return out_stage6
-
-
diff --git a/spaces/PKUWilliamYang/VToonify/vtoonify/model/raft/train_mixed.sh b/spaces/PKUWilliamYang/VToonify/vtoonify/model/raft/train_mixed.sh
deleted file mode 100644
index d9b979f143902a17a0ba7b0a8f960598b7096e0b..0000000000000000000000000000000000000000
--- a/spaces/PKUWilliamYang/VToonify/vtoonify/model/raft/train_mixed.sh
+++ /dev/null
@@ -1,6 +0,0 @@
-#!/bin/bash
-mkdir -p checkpoints
-python -u train.py --name raft-chairs --stage chairs --validation chairs --gpus 0 --num_steps 120000 --batch_size 8 --lr 0.00025 --image_size 368 496 --wdecay 0.0001 --mixed_precision
-python -u train.py --name raft-things --stage things --validation sintel --restore_ckpt checkpoints/raft-chairs.pth --gpus 0 --num_steps 120000 --batch_size 5 --lr 0.0001 --image_size 400 720 --wdecay 0.0001 --mixed_precision
-python -u train.py --name raft-sintel --stage sintel --validation sintel --restore_ckpt checkpoints/raft-things.pth --gpus 0 --num_steps 120000 --batch_size 5 --lr 0.0001 --image_size 368 768 --wdecay 0.00001 --gamma=0.85 --mixed_precision
-python -u train.py --name raft-kitti --stage kitti --validation kitti --restore_ckpt checkpoints/raft-sintel.pth --gpus 0 --num_steps 50000 --batch_size 5 --lr 0.0001 --image_size 288 960 --wdecay 0.00001 --gamma=0.85 --mixed_precision
diff --git a/spaces/PSLD/PSLD/diffusion-posterior-sampling/bkse/models/arch_util.py b/spaces/PSLD/PSLD/diffusion-posterior-sampling/bkse/models/arch_util.py
deleted file mode 100644
index 88e1d60d658bf413887d4c34977e47917ff1d4e2..0000000000000000000000000000000000000000
--- a/spaces/PSLD/PSLD/diffusion-posterior-sampling/bkse/models/arch_util.py
+++ /dev/null
@@ -1,58 +0,0 @@
-import functools
-
-import torch.nn as nn
-import torch.nn.init as init
-
-
-class Identity(nn.Module):
- def forward(self, x):
- return x
-
-
-def get_norm_layer(norm_type="instance"):
- """Return a normalization layer
- Parameters:
- norm_type (str) -- the name of the normalization
- layer: batch | instance | none
-
- For BatchNorm, we use learnable affine parameters and
- track running statistics (mean/stddev).
-
- For InstanceNorm, we do not use learnable affine
- parameters. We do not track running statistics.
- """
- if norm_type == "batch":
- norm_layer = functools.partial(nn.BatchNorm2d, affine=True, track_running_stats=True)
- elif norm_type == "instance":
- norm_layer = functools.partial(nn.InstanceNorm2d, affine=False, track_running_stats=False)
- elif norm_type == "none":
-
- def norm_layer(x):
- return Identity()
-
- else:
- raise NotImplementedError(
- f"normalization layer {norm_type}\
- is not found"
- )
- return norm_layer
-
-
-def initialize_weights(net_l, scale=1):
- if not isinstance(net_l, list):
- net_l = [net_l]
- for net in net_l:
- for m in net.modules():
- if isinstance(m, nn.Conv2d):
- init.kaiming_normal_(m.weight, a=0, mode="fan_in")
- m.weight.data *= scale # for residual block
- if m.bias is not None:
- m.bias.data.zero_()
- elif isinstance(m, nn.Linear):
- init.kaiming_normal_(m.weight, a=0, mode="fan_in")
- m.weight.data *= scale
- if m.bias is not None:
- m.bias.data.zero_()
- elif isinstance(m, nn.BatchNorm2d):
- init.constant_(m.weight, 1)
- init.constant_(m.bias.data, 0.0)
diff --git a/spaces/Parthjain9925/DigitRecognizer/app1.py b/spaces/Parthjain9925/DigitRecognizer/app1.py
deleted file mode 100644
index b6c349e918690bffea5466147308a667a74fc0b7..0000000000000000000000000000000000000000
--- a/spaces/Parthjain9925/DigitRecognizer/app1.py
+++ /dev/null
@@ -1,148 +0,0 @@
-from keras.models import load_model
-import numpy as np # linear algebra
-import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
-import matplotlib.pyplot as plt
-import seaborn as sns
-from numpy import load
-import cv2
-
-
-import numpy.random as nr
-
-import warnings
-warnings.simplefilter(action='ignore')
-from PIL import Image, ImageFilter
-
-%matplotlib inline
-from google.colab import drive
-drive.mount('/content/drive')
-from google.colab.patches import cv2_imshow
-from PIL import Image
-from skimage.io import imread
-from skimage.morphology import convex_hull_image
-from skimage.color import rgb2gray
-import cv2
-nn = load_model('my_model-2.h5')
-def imageprepare(argv,Single):
- """
- This function returns the pixel values.
- The input is a png file location.
- """
- img_gray=cv2.imread(argv,cv2.IMREAD_GRAYSCALE) # read image, image size is 180x180
- (thresh, img_bin) = cv2.threshold(img_gray, 128, 255, cv2.THRESH_BINARY)
- im=Image.fromarray(img_bin)
- if Single==True:
- rgb_im = im.convert("RGB")
- rgb_im.save("ok.jpg")
- im=crop_to_content('/content/ok.jpg')
- width = float(im.size[0])
- height = float(im.size[1])
- newImage = Image.new('L', (28, 28), (255)) # creates white canvas of 28x28 pixels
-
- if width > height: # check which dimension is bigger
- # Width is bigger. Width becomes 20 pixels.
- nheight = int(round((20.0 / width * height), 0)) # resize height according to ratio width
- if (nheight == 0): # rare case but minimum is 1 pixel
- nheight = 1
- # resize and sharpen
- img = im.resize((20, nheight), Image.ANTIALIAS).filter(ImageFilter.SHARPEN)
- wtop = int(round(((28 - nheight) / 2), 0)) # calculate horizontal position
- newImage.paste(img, (4, wtop)) # paste resized image on white canvas
- else:
- # Height is bigger. Heigth becomes 20 pixels.
- nwidth = int(round((20.0 / height * width), 0)) # resize width according to ratio height
- if (nwidth == 0): # rare case but minimum is 1 pixel
- nwidth = 1
- # resize and sharpen
- img = im.resize((nwidth, 20), Image.ANTIALIAS).filter(ImageFilter.SHARPEN)
- wleft = int(round(((28 - nwidth) / 2), 0)) # caculate vertical pozition
- newImage.paste(img, (wleft, 4)) # paste resized image on white canvas
-
- # newImage.save("sample.png)
-
- tv = list(newImage.getdata()) # get pixel values
-
- # normalize pixels to 0 and 1. 0 is pure white, 1 is pure black.
- tva = [(255 - x) * 1.0 / 255.0 for x in tv]
- return tva
-
-def show(path):
- img_gray=cv2.imread(path,cv2.IMREAD_GRAYSCALE) # read image, image size is 180x180
- (thresh, img_bin) = cv2.threshold(img_gray, 140, 255, cv2.THRESH_BINARY)
- im=Image.fromarray(img_bin)
- rgb_im = im.convert("RGB")
- rgb_im.save("ok.jpg")
- # plt.imshow(rgb_im)
- # plt.show()
- # im=crop_to_content('/content/ok.jpg')
- image = cv2.imread('/content/ok.jpg')
- grey = cv2.cvtColor(image.copy(), cv2.COLOR_BGR2GRAY)
- ret, thresh = cv2.threshold(grey.copy(), 130, 255, cv2.THRESH_BINARY_INV)
- contours, t = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
- preprocessed_digits=[]
- for _, c in enumerate(contours):
-
- # Get the bounding rectangle of the current contour:
- boundRect = cv2.boundingRect(c)
-
- # Get the bounding rectangle data:
- rectX = boundRect[0]
- rectY = boundRect[1]
- rectWidth = boundRect[2]
- rectHeight = boundRect[3]
-
- # Estimate the bounding rect area:
- rectArea = rectWidth * rectHeight
-
- # Set a min area threshold
- minArea = 1000
- # Filter blobs by area:
- if rectArea > minArea:
-
- # Draw bounding box:
- color = (0, 255, 0)
- cv2.rectangle(image, (int(rectX), int(rectY)),
- (int(rectX + rectWidth), int(rectY + rectHeight)), color, 2)
- # Crop bounding box:
- currentCrop = image[rectY:rectY+rectHeight,rectX:rectX+rectWidth]
- # cv2_imshow(currentCrop)
- # cv2.waitKey(0)
- cv2.imwrite("image.jpg", currentCrop)
- x=imageprepare("image.jpg",False)
- digit=np.array(x)
- prediction = nn.predict(digit.reshape(1, 28, 28, 1))
- print(np.argmax(prediction))
- cv2.putText(image,str(np.argmax(prediction)),(rectX,rectHeight+rectY+50),cv2.FONT_HERSHEY_COMPLEX,2,(50,50,225),2)
- status = cv2.imwrite('/content/kok.jpg',image)
- return "/content/kok.jpg"
-import numpy as np
-import gradio as gr
-
-def predict_sketch(img):
- img_3d=img.reshape(-1,28,28)
- im_resize=img_3d/255.0
- prediction=nn.predict(im_resize).tolist()[0]
- return {str(i):prediction[i] for i in range(10)}
-
-def predict_upload(image):
- im1 = image.save("/content/geeks.jpg")
- k=show("/content/geeks.jpg")
- return k
-
-with gr.Blocks() as demo:
- gr.Markdown("Flip text or image files using this demo.")
- with gr.Tabs():
- with gr.TabItem("Sketch"):
- with gr.Row():
- text_input = gr.Sketchpad()
- text_output = gr.Label(num_top_classes=3)
- text_button = gr.Button("Submit")
- with gr.TabItem("Upload Image"):
- with gr.Row():
- image_input = gr.Image(type="pil",)
- image_output = gr.Image(type="pil",)
- image_button = gr.Button("Submit")
- image_button.click(predict_upload,image_input, image_output)
- text_button.click(predict_sketch,text_input,outputs=text_output)
-
-demo.launch(debug=True)
\ No newline at end of file
diff --git a/spaces/Pattr/DrumClassification/lilypond-2.24.2/lib/guile/2.2/ccache/web/server/http.go b/spaces/Pattr/DrumClassification/lilypond-2.24.2/lib/guile/2.2/ccache/web/server/http.go
deleted file mode 100644
index 6123a00324e3caf381e8121f93394abe25933513..0000000000000000000000000000000000000000
Binary files a/spaces/Pattr/DrumClassification/lilypond-2.24.2/lib/guile/2.2/ccache/web/server/http.go and /dev/null differ
diff --git a/spaces/PeepDaSlan9/Bark-Voice-Cloning/README.md b/spaces/PeepDaSlan9/Bark-Voice-Cloning/README.md
deleted file mode 100644
index 7c3a9a7514ef9f36f54404adca8b0b168e305fe2..0000000000000000000000000000000000000000
--- a/spaces/PeepDaSlan9/Bark-Voice-Cloning/README.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-title: Bark Voice Cloning
-emoji: 🎶
-colorFrom: yellow
-colorTo: pink
-sdk: gradio
-sdk_version: 3.34.0
-app_file: app.py
-pinned: false
-license: mit
-duplicated_from: marker22/Bark-Voice-Cloning
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/Pie31415/control-animation/annotator/openpose/body.py b/spaces/Pie31415/control-animation/annotator/openpose/body.py
deleted file mode 100644
index 7c3cf7a388b4ac81004524e64125e383bdd455bd..0000000000000000000000000000000000000000
--- a/spaces/Pie31415/control-animation/annotator/openpose/body.py
+++ /dev/null
@@ -1,219 +0,0 @@
-import cv2
-import numpy as np
-import math
-import time
-from scipy.ndimage.filters import gaussian_filter
-import matplotlib.pyplot as plt
-import matplotlib
-import torch
-from torchvision import transforms
-
-from . import util
-from .model import bodypose_model
-
-class Body(object):
- def __init__(self, model_path):
- self.model = bodypose_model()
- if torch.cuda.is_available():
- self.model = self.model.cuda()
- print('cuda')
- model_dict = util.transfer(self.model, torch.load(model_path))
- self.model.load_state_dict(model_dict)
- self.model.eval()
-
- def __call__(self, oriImg):
- # scale_search = [0.5, 1.0, 1.5, 2.0]
- scale_search = [0.5]
- boxsize = 368
- stride = 8
- padValue = 128
- thre1 = 0.1
- thre2 = 0.05
- multiplier = [x * boxsize / oriImg.shape[0] for x in scale_search]
- heatmap_avg = np.zeros((oriImg.shape[0], oriImg.shape[1], 19))
- paf_avg = np.zeros((oriImg.shape[0], oriImg.shape[1], 38))
-
- for m in range(len(multiplier)):
- scale = multiplier[m]
- imageToTest = cv2.resize(oriImg, (0, 0), fx=scale, fy=scale, interpolation=cv2.INTER_CUBIC)
- imageToTest_padded, pad = util.padRightDownCorner(imageToTest, stride, padValue)
- im = np.transpose(np.float32(imageToTest_padded[:, :, :, np.newaxis]), (3, 2, 0, 1)) / 256 - 0.5
- im = np.ascontiguousarray(im)
-
- data = torch.from_numpy(im).float()
- if torch.cuda.is_available():
- data = data.cuda()
- # data = data.permute([2, 0, 1]).unsqueeze(0).float()
- with torch.no_grad():
- Mconv7_stage6_L1, Mconv7_stage6_L2 = self.model(data)
- Mconv7_stage6_L1 = Mconv7_stage6_L1.cpu().numpy()
- Mconv7_stage6_L2 = Mconv7_stage6_L2.cpu().numpy()
-
- # extract outputs, resize, and remove padding
- # heatmap = np.transpose(np.squeeze(net.blobs[output_blobs.keys()[1]].data), (1, 2, 0)) # output 1 is heatmaps
- heatmap = np.transpose(np.squeeze(Mconv7_stage6_L2), (1, 2, 0)) # output 1 is heatmaps
- heatmap = cv2.resize(heatmap, (0, 0), fx=stride, fy=stride, interpolation=cv2.INTER_CUBIC)
- heatmap = heatmap[:imageToTest_padded.shape[0] - pad[2], :imageToTest_padded.shape[1] - pad[3], :]
- heatmap = cv2.resize(heatmap, (oriImg.shape[1], oriImg.shape[0]), interpolation=cv2.INTER_CUBIC)
-
- # paf = np.transpose(np.squeeze(net.blobs[output_blobs.keys()[0]].data), (1, 2, 0)) # output 0 is PAFs
- paf = np.transpose(np.squeeze(Mconv7_stage6_L1), (1, 2, 0)) # output 0 is PAFs
- paf = cv2.resize(paf, (0, 0), fx=stride, fy=stride, interpolation=cv2.INTER_CUBIC)
- paf = paf[:imageToTest_padded.shape[0] - pad[2], :imageToTest_padded.shape[1] - pad[3], :]
- paf = cv2.resize(paf, (oriImg.shape[1], oriImg.shape[0]), interpolation=cv2.INTER_CUBIC)
-
- heatmap_avg += heatmap_avg + heatmap / len(multiplier)
- paf_avg += + paf / len(multiplier)
-
- all_peaks = []
- peak_counter = 0
-
- for part in range(18):
- map_ori = heatmap_avg[:, :, part]
- one_heatmap = gaussian_filter(map_ori, sigma=3)
-
- map_left = np.zeros(one_heatmap.shape)
- map_left[1:, :] = one_heatmap[:-1, :]
- map_right = np.zeros(one_heatmap.shape)
- map_right[:-1, :] = one_heatmap[1:, :]
- map_up = np.zeros(one_heatmap.shape)
- map_up[:, 1:] = one_heatmap[:, :-1]
- map_down = np.zeros(one_heatmap.shape)
- map_down[:, :-1] = one_heatmap[:, 1:]
-
- peaks_binary = np.logical_and.reduce(
- (one_heatmap >= map_left, one_heatmap >= map_right, one_heatmap >= map_up, one_heatmap >= map_down, one_heatmap > thre1))
- peaks = list(zip(np.nonzero(peaks_binary)[1], np.nonzero(peaks_binary)[0])) # note reverse
- peaks_with_score = [x + (map_ori[x[1], x[0]],) for x in peaks]
- peak_id = range(peak_counter, peak_counter + len(peaks))
- peaks_with_score_and_id = [peaks_with_score[i] + (peak_id[i],) for i in range(len(peak_id))]
-
- all_peaks.append(peaks_with_score_and_id)
- peak_counter += len(peaks)
-
- # find connection in the specified sequence, center 29 is in the position 15
- limbSeq = [[2, 3], [2, 6], [3, 4], [4, 5], [6, 7], [7, 8], [2, 9], [9, 10], \
- [10, 11], [2, 12], [12, 13], [13, 14], [2, 1], [1, 15], [15, 17], \
- [1, 16], [16, 18], [3, 17], [6, 18]]
- # the middle joints heatmap correpondence
- mapIdx = [[31, 32], [39, 40], [33, 34], [35, 36], [41, 42], [43, 44], [19, 20], [21, 22], \
- [23, 24], [25, 26], [27, 28], [29, 30], [47, 48], [49, 50], [53, 54], [51, 52], \
- [55, 56], [37, 38], [45, 46]]
-
- connection_all = []
- special_k = []
- mid_num = 10
-
- for k in range(len(mapIdx)):
- score_mid = paf_avg[:, :, [x - 19 for x in mapIdx[k]]]
- candA = all_peaks[limbSeq[k][0] - 1]
- candB = all_peaks[limbSeq[k][1] - 1]
- nA = len(candA)
- nB = len(candB)
- indexA, indexB = limbSeq[k]
- if (nA != 0 and nB != 0):
- connection_candidate = []
- for i in range(nA):
- for j in range(nB):
- vec = np.subtract(candB[j][:2], candA[i][:2])
- norm = math.sqrt(vec[0] * vec[0] + vec[1] * vec[1])
- norm = max(0.001, norm)
- vec = np.divide(vec, norm)
-
- startend = list(zip(np.linspace(candA[i][0], candB[j][0], num=mid_num), \
- np.linspace(candA[i][1], candB[j][1], num=mid_num)))
-
- vec_x = np.array([score_mid[int(round(startend[I][1])), int(round(startend[I][0])), 0] \
- for I in range(len(startend))])
- vec_y = np.array([score_mid[int(round(startend[I][1])), int(round(startend[I][0])), 1] \
- for I in range(len(startend))])
-
- score_midpts = np.multiply(vec_x, vec[0]) + np.multiply(vec_y, vec[1])
- score_with_dist_prior = sum(score_midpts) / len(score_midpts) + min(
- 0.5 * oriImg.shape[0] / norm - 1, 0)
- criterion1 = len(np.nonzero(score_midpts > thre2)[0]) > 0.8 * len(score_midpts)
- criterion2 = score_with_dist_prior > 0
- if criterion1 and criterion2:
- connection_candidate.append(
- [i, j, score_with_dist_prior, score_with_dist_prior + candA[i][2] + candB[j][2]])
-
- connection_candidate = sorted(connection_candidate, key=lambda x: x[2], reverse=True)
- connection = np.zeros((0, 5))
- for c in range(len(connection_candidate)):
- i, j, s = connection_candidate[c][0:3]
- if (i not in connection[:, 3] and j not in connection[:, 4]):
- connection = np.vstack([connection, [candA[i][3], candB[j][3], s, i, j]])
- if (len(connection) >= min(nA, nB)):
- break
-
- connection_all.append(connection)
- else:
- special_k.append(k)
- connection_all.append([])
-
- # last number in each row is the total parts number of that person
- # the second last number in each row is the score of the overall configuration
- subset = -1 * np.ones((0, 20))
- candidate = np.array([item for sublist in all_peaks for item in sublist])
-
- for k in range(len(mapIdx)):
- if k not in special_k:
- partAs = connection_all[k][:, 0]
- partBs = connection_all[k][:, 1]
- indexA, indexB = np.array(limbSeq[k]) - 1
-
- for i in range(len(connection_all[k])): # = 1:size(temp,1)
- found = 0
- subset_idx = [-1, -1]
- for j in range(len(subset)): # 1:size(subset,1):
- if subset[j][indexA] == partAs[i] or subset[j][indexB] == partBs[i]:
- subset_idx[found] = j
- found += 1
-
- if found == 1:
- j = subset_idx[0]
- if subset[j][indexB] != partBs[i]:
- subset[j][indexB] = partBs[i]
- subset[j][-1] += 1
- subset[j][-2] += candidate[partBs[i].astype(int), 2] + connection_all[k][i][2]
- elif found == 2: # if found 2 and disjoint, merge them
- j1, j2 = subset_idx
- membership = ((subset[j1] >= 0).astype(int) + (subset[j2] >= 0).astype(int))[:-2]
- if len(np.nonzero(membership == 2)[0]) == 0: # merge
- subset[j1][:-2] += (subset[j2][:-2] + 1)
- subset[j1][-2:] += subset[j2][-2:]
- subset[j1][-2] += connection_all[k][i][2]
- subset = np.delete(subset, j2, 0)
- else: # as like found == 1
- subset[j1][indexB] = partBs[i]
- subset[j1][-1] += 1
- subset[j1][-2] += candidate[partBs[i].astype(int), 2] + connection_all[k][i][2]
-
- # if find no partA in the subset, create a new subset
- elif not found and k < 17:
- row = -1 * np.ones(20)
- row[indexA] = partAs[i]
- row[indexB] = partBs[i]
- row[-1] = 2
- row[-2] = sum(candidate[connection_all[k][i, :2].astype(int), 2]) + connection_all[k][i][2]
- subset = np.vstack([subset, row])
- # delete some rows of subset which has few parts occur
- deleteIdx = []
- for i in range(len(subset)):
- if subset[i][-1] < 4 or subset[i][-2] / subset[i][-1] < 0.4:
- deleteIdx.append(i)
- subset = np.delete(subset, deleteIdx, axis=0)
-
- # subset: n*20 array, 0-17 is the index in candidate, 18 is the total score, 19 is the total parts
- # candidate: x, y, score, id
- return candidate, subset
-
-if __name__ == "__main__":
- body_estimation = Body('../model/body_pose_model.pth')
-
- test_image = '../images/ski.jpg'
- oriImg = cv2.imread(test_image) # B,G,R order
- candidate, subset = body_estimation(oriImg)
- canvas = util.draw_bodypose(oriImg, candidate, subset)
- plt.imshow(canvas[:, :, [2, 1, 0]])
- plt.show()
diff --git a/spaces/Pie31415/control-animation/annotator/uniformer/mmcv/cnn/bricks/transformer.py b/spaces/Pie31415/control-animation/annotator/uniformer/mmcv/cnn/bricks/transformer.py
deleted file mode 100644
index e61ae0dd941a7be00b3e41a3de833ec50470a45f..0000000000000000000000000000000000000000
--- a/spaces/Pie31415/control-animation/annotator/uniformer/mmcv/cnn/bricks/transformer.py
+++ /dev/null
@@ -1,595 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import copy
-import warnings
-
-import torch
-import torch.nn as nn
-
-from annotator.uniformer.mmcv import ConfigDict, deprecated_api_warning
-from annotator.uniformer.mmcv.cnn import Linear, build_activation_layer, build_norm_layer
-from annotator.uniformer.mmcv.runner.base_module import BaseModule, ModuleList, Sequential
-from annotator.uniformer.mmcv.utils import build_from_cfg
-from .drop import build_dropout
-from .registry import (ATTENTION, FEEDFORWARD_NETWORK, POSITIONAL_ENCODING,
- TRANSFORMER_LAYER, TRANSFORMER_LAYER_SEQUENCE)
-
-# Avoid BC-breaking of importing MultiScaleDeformableAttention from this file
-try:
- from annotator.uniformer.mmcv.ops.multi_scale_deform_attn import MultiScaleDeformableAttention # noqa F401
- warnings.warn(
- ImportWarning(
- '``MultiScaleDeformableAttention`` has been moved to '
- '``mmcv.ops.multi_scale_deform_attn``, please change original path ' # noqa E501
- '``from annotator.uniformer.mmcv.cnn.bricks.transformer import MultiScaleDeformableAttention`` ' # noqa E501
- 'to ``from annotator.uniformer.mmcv.ops.multi_scale_deform_attn import MultiScaleDeformableAttention`` ' # noqa E501
- ))
-
-except ImportError:
- warnings.warn('Fail to import ``MultiScaleDeformableAttention`` from '
- '``mmcv.ops.multi_scale_deform_attn``, '
- 'You should install ``mmcv-full`` if you need this module. ')
-
-
-def build_positional_encoding(cfg, default_args=None):
- """Builder for Position Encoding."""
- return build_from_cfg(cfg, POSITIONAL_ENCODING, default_args)
-
-
-def build_attention(cfg, default_args=None):
- """Builder for attention."""
- return build_from_cfg(cfg, ATTENTION, default_args)
-
-
-def build_feedforward_network(cfg, default_args=None):
- """Builder for feed-forward network (FFN)."""
- return build_from_cfg(cfg, FEEDFORWARD_NETWORK, default_args)
-
-
-def build_transformer_layer(cfg, default_args=None):
- """Builder for transformer layer."""
- return build_from_cfg(cfg, TRANSFORMER_LAYER, default_args)
-
-
-def build_transformer_layer_sequence(cfg, default_args=None):
- """Builder for transformer encoder and transformer decoder."""
- return build_from_cfg(cfg, TRANSFORMER_LAYER_SEQUENCE, default_args)
-
-
-@ATTENTION.register_module()
-class MultiheadAttention(BaseModule):
- """A wrapper for ``torch.nn.MultiheadAttention``.
-
- This module implements MultiheadAttention with identity connection,
- and positional encoding is also passed as input.
-
- Args:
- embed_dims (int): The embedding dimension.
- num_heads (int): Parallel attention heads.
- attn_drop (float): A Dropout layer on attn_output_weights.
- Default: 0.0.
- proj_drop (float): A Dropout layer after `nn.MultiheadAttention`.
- Default: 0.0.
- dropout_layer (obj:`ConfigDict`): The dropout_layer used
- when adding the shortcut.
- init_cfg (obj:`mmcv.ConfigDict`): The Config for initialization.
- Default: None.
- batch_first (bool): When it is True, Key, Query and Value are shape of
- (batch, n, embed_dim), otherwise (n, batch, embed_dim).
- Default to False.
- """
-
- def __init__(self,
- embed_dims,
- num_heads,
- attn_drop=0.,
- proj_drop=0.,
- dropout_layer=dict(type='Dropout', drop_prob=0.),
- init_cfg=None,
- batch_first=False,
- **kwargs):
- super(MultiheadAttention, self).__init__(init_cfg)
- if 'dropout' in kwargs:
- warnings.warn('The arguments `dropout` in MultiheadAttention '
- 'has been deprecated, now you can separately '
- 'set `attn_drop`(float), proj_drop(float), '
- 'and `dropout_layer`(dict) ')
- attn_drop = kwargs['dropout']
- dropout_layer['drop_prob'] = kwargs.pop('dropout')
-
- self.embed_dims = embed_dims
- self.num_heads = num_heads
- self.batch_first = batch_first
-
- self.attn = nn.MultiheadAttention(embed_dims, num_heads, attn_drop,
- **kwargs)
-
- self.proj_drop = nn.Dropout(proj_drop)
- self.dropout_layer = build_dropout(
- dropout_layer) if dropout_layer else nn.Identity()
-
- @deprecated_api_warning({'residual': 'identity'},
- cls_name='MultiheadAttention')
- def forward(self,
- query,
- key=None,
- value=None,
- identity=None,
- query_pos=None,
- key_pos=None,
- attn_mask=None,
- key_padding_mask=None,
- **kwargs):
- """Forward function for `MultiheadAttention`.
-
- **kwargs allow passing a more general data flow when combining
- with other operations in `transformerlayer`.
-
- Args:
- query (Tensor): The input query with shape [num_queries, bs,
- embed_dims] if self.batch_first is False, else
- [bs, num_queries embed_dims].
- key (Tensor): The key tensor with shape [num_keys, bs,
- embed_dims] if self.batch_first is False, else
- [bs, num_keys, embed_dims] .
- If None, the ``query`` will be used. Defaults to None.
- value (Tensor): The value tensor with same shape as `key`.
- Same in `nn.MultiheadAttention.forward`. Defaults to None.
- If None, the `key` will be used.
- identity (Tensor): This tensor, with the same shape as x,
- will be used for the identity link.
- If None, `x` will be used. Defaults to None.
- query_pos (Tensor): The positional encoding for query, with
- the same shape as `x`. If not None, it will
- be added to `x` before forward function. Defaults to None.
- key_pos (Tensor): The positional encoding for `key`, with the
- same shape as `key`. Defaults to None. If not None, it will
- be added to `key` before forward function. If None, and
- `query_pos` has the same shape as `key`, then `query_pos`
- will be used for `key_pos`. Defaults to None.
- attn_mask (Tensor): ByteTensor mask with shape [num_queries,
- num_keys]. Same in `nn.MultiheadAttention.forward`.
- Defaults to None.
- key_padding_mask (Tensor): ByteTensor with shape [bs, num_keys].
- Defaults to None.
-
- Returns:
- Tensor: forwarded results with shape
- [num_queries, bs, embed_dims]
- if self.batch_first is False, else
- [bs, num_queries embed_dims].
- """
-
- if key is None:
- key = query
- if value is None:
- value = key
- if identity is None:
- identity = query
- if key_pos is None:
- if query_pos is not None:
- # use query_pos if key_pos is not available
- if query_pos.shape == key.shape:
- key_pos = query_pos
- else:
- warnings.warn(f'position encoding of key is'
- f'missing in {self.__class__.__name__}.')
- if query_pos is not None:
- query = query + query_pos
- if key_pos is not None:
- key = key + key_pos
-
- # Because the dataflow('key', 'query', 'value') of
- # ``torch.nn.MultiheadAttention`` is (num_query, batch,
- # embed_dims), We should adjust the shape of dataflow from
- # batch_first (batch, num_query, embed_dims) to num_query_first
- # (num_query ,batch, embed_dims), and recover ``attn_output``
- # from num_query_first to batch_first.
- if self.batch_first:
- query = query.transpose(0, 1)
- key = key.transpose(0, 1)
- value = value.transpose(0, 1)
-
- out = self.attn(
- query=query,
- key=key,
- value=value,
- attn_mask=attn_mask,
- key_padding_mask=key_padding_mask)[0]
-
- if self.batch_first:
- out = out.transpose(0, 1)
-
- return identity + self.dropout_layer(self.proj_drop(out))
-
-
-@FEEDFORWARD_NETWORK.register_module()
-class FFN(BaseModule):
- """Implements feed-forward networks (FFNs) with identity connection.
-
- Args:
- embed_dims (int): The feature dimension. Same as
- `MultiheadAttention`. Defaults: 256.
- feedforward_channels (int): The hidden dimension of FFNs.
- Defaults: 1024.
- num_fcs (int, optional): The number of fully-connected layers in
- FFNs. Default: 2.
- act_cfg (dict, optional): The activation config for FFNs.
- Default: dict(type='ReLU')
- ffn_drop (float, optional): Probability of an element to be
- zeroed in FFN. Default 0.0.
- add_identity (bool, optional): Whether to add the
- identity connection. Default: `True`.
- dropout_layer (obj:`ConfigDict`): The dropout_layer used
- when adding the shortcut.
- init_cfg (obj:`mmcv.ConfigDict`): The Config for initialization.
- Default: None.
- """
-
- @deprecated_api_warning(
- {
- 'dropout': 'ffn_drop',
- 'add_residual': 'add_identity'
- },
- cls_name='FFN')
- def __init__(self,
- embed_dims=256,
- feedforward_channels=1024,
- num_fcs=2,
- act_cfg=dict(type='ReLU', inplace=True),
- ffn_drop=0.,
- dropout_layer=None,
- add_identity=True,
- init_cfg=None,
- **kwargs):
- super(FFN, self).__init__(init_cfg)
- assert num_fcs >= 2, 'num_fcs should be no less ' \
- f'than 2. got {num_fcs}.'
- self.embed_dims = embed_dims
- self.feedforward_channels = feedforward_channels
- self.num_fcs = num_fcs
- self.act_cfg = act_cfg
- self.activate = build_activation_layer(act_cfg)
-
- layers = []
- in_channels = embed_dims
- for _ in range(num_fcs - 1):
- layers.append(
- Sequential(
- Linear(in_channels, feedforward_channels), self.activate,
- nn.Dropout(ffn_drop)))
- in_channels = feedforward_channels
- layers.append(Linear(feedforward_channels, embed_dims))
- layers.append(nn.Dropout(ffn_drop))
- self.layers = Sequential(*layers)
- self.dropout_layer = build_dropout(
- dropout_layer) if dropout_layer else torch.nn.Identity()
- self.add_identity = add_identity
-
- @deprecated_api_warning({'residual': 'identity'}, cls_name='FFN')
- def forward(self, x, identity=None):
- """Forward function for `FFN`.
-
- The function would add x to the output tensor if residue is None.
- """
- out = self.layers(x)
- if not self.add_identity:
- return self.dropout_layer(out)
- if identity is None:
- identity = x
- return identity + self.dropout_layer(out)
-
-
-@TRANSFORMER_LAYER.register_module()
-class BaseTransformerLayer(BaseModule):
- """Base `TransformerLayer` for vision transformer.
-
- It can be built from `mmcv.ConfigDict` and support more flexible
- customization, for example, using any number of `FFN or LN ` and
- use different kinds of `attention` by specifying a list of `ConfigDict`
- named `attn_cfgs`. It is worth mentioning that it supports `prenorm`
- when you specifying `norm` as the first element of `operation_order`.
- More details about the `prenorm`: `On Layer Normalization in the
- Transformer Architecture `_ .
-
- Args:
- attn_cfgs (list[`mmcv.ConfigDict`] | obj:`mmcv.ConfigDict` | None )):
- Configs for `self_attention` or `cross_attention` modules,
- The order of the configs in the list should be consistent with
- corresponding attentions in operation_order.
- If it is a dict, all of the attention modules in operation_order
- will be built with this config. Default: None.
- ffn_cfgs (list[`mmcv.ConfigDict`] | obj:`mmcv.ConfigDict` | None )):
- Configs for FFN, The order of the configs in the list should be
- consistent with corresponding ffn in operation_order.
- If it is a dict, all of the attention modules in operation_order
- will be built with this config.
- operation_order (tuple[str]): The execution order of operation
- in transformer. Such as ('self_attn', 'norm', 'ffn', 'norm').
- Support `prenorm` when you specifying first element as `norm`.
- Default：None.
- norm_cfg (dict): Config dict for normalization layer.
- Default: dict(type='LN').
- init_cfg (obj:`mmcv.ConfigDict`): The Config for initialization.
- Default: None.
- batch_first (bool): Key, Query and Value are shape
- of (batch, n, embed_dim)
- or (n, batch, embed_dim). Default to False.
- """
-
- def __init__(self,
- attn_cfgs=None,
- ffn_cfgs=dict(
- type='FFN',
- embed_dims=256,
- feedforward_channels=1024,
- num_fcs=2,
- ffn_drop=0.,
- act_cfg=dict(type='ReLU', inplace=True),
- ),
- operation_order=None,
- norm_cfg=dict(type='LN'),
- init_cfg=None,
- batch_first=False,
- **kwargs):
-
- deprecated_args = dict(
- feedforward_channels='feedforward_channels',
- ffn_dropout='ffn_drop',
- ffn_num_fcs='num_fcs')
- for ori_name, new_name in deprecated_args.items():
- if ori_name in kwargs:
- warnings.warn(
- f'The arguments `{ori_name}` in BaseTransformerLayer '
- f'has been deprecated, now you should set `{new_name}` '
- f'and other FFN related arguments '
- f'to a dict named `ffn_cfgs`. ')
- ffn_cfgs[new_name] = kwargs[ori_name]
-
- super(BaseTransformerLayer, self).__init__(init_cfg)
-
- self.batch_first = batch_first
-
- assert set(operation_order) & set(
- ['self_attn', 'norm', 'ffn', 'cross_attn']) == \
- set(operation_order), f'The operation_order of' \
- f' {self.__class__.__name__} should ' \
- f'contains all four operation type ' \
- f"{['self_attn', 'norm', 'ffn', 'cross_attn']}"
-
- num_attn = operation_order.count('self_attn') + operation_order.count(
- 'cross_attn')
- if isinstance(attn_cfgs, dict):
- attn_cfgs = [copy.deepcopy(attn_cfgs) for _ in range(num_attn)]
- else:
- assert num_attn == len(attn_cfgs), f'The length ' \
- f'of attn_cfg {num_attn} is ' \
- f'not consistent with the number of attention' \
- f'in operation_order {operation_order}.'
-
- self.num_attn = num_attn
- self.operation_order = operation_order
- self.norm_cfg = norm_cfg
- self.pre_norm = operation_order[0] == 'norm'
- self.attentions = ModuleList()
-
- index = 0
- for operation_name in operation_order:
- if operation_name in ['self_attn', 'cross_attn']:
- if 'batch_first' in attn_cfgs[index]:
- assert self.batch_first == attn_cfgs[index]['batch_first']
- else:
- attn_cfgs[index]['batch_first'] = self.batch_first
- attention = build_attention(attn_cfgs[index])
- # Some custom attentions used as `self_attn`
- # or `cross_attn` can have different behavior.
- attention.operation_name = operation_name
- self.attentions.append(attention)
- index += 1
-
- self.embed_dims = self.attentions[0].embed_dims
-
- self.ffns = ModuleList()
- num_ffns = operation_order.count('ffn')
- if isinstance(ffn_cfgs, dict):
- ffn_cfgs = ConfigDict(ffn_cfgs)
- if isinstance(ffn_cfgs, dict):
- ffn_cfgs = [copy.deepcopy(ffn_cfgs) for _ in range(num_ffns)]
- assert len(ffn_cfgs) == num_ffns
- for ffn_index in range(num_ffns):
- if 'embed_dims' not in ffn_cfgs[ffn_index]:
- ffn_cfgs['embed_dims'] = self.embed_dims
- else:
- assert ffn_cfgs[ffn_index]['embed_dims'] == self.embed_dims
- self.ffns.append(
- build_feedforward_network(ffn_cfgs[ffn_index],
- dict(type='FFN')))
-
- self.norms = ModuleList()
- num_norms = operation_order.count('norm')
- for _ in range(num_norms):
- self.norms.append(build_norm_layer(norm_cfg, self.embed_dims)[1])
-
- def forward(self,
- query,
- key=None,
- value=None,
- query_pos=None,
- key_pos=None,
- attn_masks=None,
- query_key_padding_mask=None,
- key_padding_mask=None,
- **kwargs):
- """Forward function for `TransformerDecoderLayer`.
-
- **kwargs contains some specific arguments of attentions.
-
- Args:
- query (Tensor): The input query with shape
- [num_queries, bs, embed_dims] if
- self.batch_first is False, else
- [bs, num_queries embed_dims].
- key (Tensor): The key tensor with shape [num_keys, bs,
- embed_dims] if self.batch_first is False, else
- [bs, num_keys, embed_dims] .
- value (Tensor): The value tensor with same shape as `key`.
- query_pos (Tensor): The positional encoding for `query`.
- Default: None.
- key_pos (Tensor): The positional encoding for `key`.
- Default: None.
- attn_masks (List[Tensor] | None): 2D Tensor used in
- calculation of corresponding attention. The length of
- it should equal to the number of `attention` in
- `operation_order`. Default: None.
- query_key_padding_mask (Tensor): ByteTensor for `query`, with
- shape [bs, num_queries]. Only used in `self_attn` layer.
- Defaults to None.
- key_padding_mask (Tensor): ByteTensor for `query`, with
- shape [bs, num_keys]. Default: None.
-
- Returns:
- Tensor: forwarded results with shape [num_queries, bs, embed_dims].
- """
-
- norm_index = 0
- attn_index = 0
- ffn_index = 0
- identity = query
- if attn_masks is None:
- attn_masks = [None for _ in range(self.num_attn)]
- elif isinstance(attn_masks, torch.Tensor):
- attn_masks = [
- copy.deepcopy(attn_masks) for _ in range(self.num_attn)
- ]
- warnings.warn(f'Use same attn_mask in all attentions in '
- f'{self.__class__.__name__} ')
- else:
- assert len(attn_masks) == self.num_attn, f'The length of ' \
- f'attn_masks {len(attn_masks)} must be equal ' \
- f'to the number of attention in ' \
- f'operation_order {self.num_attn}'
-
- for layer in self.operation_order:
- if layer == 'self_attn':
- temp_key = temp_value = query
- query = self.attentions[attn_index](
- query,
- temp_key,
- temp_value,
- identity if self.pre_norm else None,
- query_pos=query_pos,
- key_pos=query_pos,
- attn_mask=attn_masks[attn_index],
- key_padding_mask=query_key_padding_mask,
- **kwargs)
- attn_index += 1
- identity = query
-
- elif layer == 'norm':
- query = self.norms[norm_index](query)
- norm_index += 1
-
- elif layer == 'cross_attn':
- query = self.attentions[attn_index](
- query,
- key,
- value,
- identity if self.pre_norm else None,
- query_pos=query_pos,
- key_pos=key_pos,
- attn_mask=attn_masks[attn_index],
- key_padding_mask=key_padding_mask,
- **kwargs)
- attn_index += 1
- identity = query
-
- elif layer == 'ffn':
- query = self.ffns[ffn_index](
- query, identity if self.pre_norm else None)
- ffn_index += 1
-
- return query
-
-
-@TRANSFORMER_LAYER_SEQUENCE.register_module()
-class TransformerLayerSequence(BaseModule):
- """Base class for TransformerEncoder and TransformerDecoder in vision
- transformer.
-
- As base-class of Encoder and Decoder in vision transformer.
- Support customization such as specifying different kind
- of `transformer_layer` in `transformer_coder`.
-
- Args:
- transformerlayer (list[obj:`mmcv.ConfigDict`] |
- obj:`mmcv.ConfigDict`): Config of transformerlayer
- in TransformerCoder. If it is obj:`mmcv.ConfigDict`,
- it would be repeated `num_layer` times to a
- list[`mmcv.ConfigDict`]. Default: None.
- num_layers (int): The number of `TransformerLayer`. Default: None.
- init_cfg (obj:`mmcv.ConfigDict`): The Config for initialization.
- Default: None.
- """
-
- def __init__(self, transformerlayers=None, num_layers=None, init_cfg=None):
- super(TransformerLayerSequence, self).__init__(init_cfg)
- if isinstance(transformerlayers, dict):
- transformerlayers = [
- copy.deepcopy(transformerlayers) for _ in range(num_layers)
- ]
- else:
- assert isinstance(transformerlayers, list) and \
- len(transformerlayers) == num_layers
- self.num_layers = num_layers
- self.layers = ModuleList()
- for i in range(num_layers):
- self.layers.append(build_transformer_layer(transformerlayers[i]))
- self.embed_dims = self.layers[0].embed_dims
- self.pre_norm = self.layers[0].pre_norm
-
- def forward(self,
- query,
- key,
- value,
- query_pos=None,
- key_pos=None,
- attn_masks=None,
- query_key_padding_mask=None,
- key_padding_mask=None,
- **kwargs):
- """Forward function for `TransformerCoder`.
-
- Args:
- query (Tensor): Input query with shape
- `(num_queries, bs, embed_dims)`.
- key (Tensor): The key tensor with shape
- `(num_keys, bs, embed_dims)`.
- value (Tensor): The value tensor with shape
- `(num_keys, bs, embed_dims)`.
- query_pos (Tensor): The positional encoding for `query`.
- Default: None.
- key_pos (Tensor): The positional encoding for `key`.
- Default: None.
- attn_masks (List[Tensor], optional): Each element is 2D Tensor
- which is used in calculation of corresponding attention in
- operation_order. Default: None.
- query_key_padding_mask (Tensor): ByteTensor for `query`, with
- shape [bs, num_queries]. Only used in self-attention
- Default: None.
- key_padding_mask (Tensor): ByteTensor for `query`, with
- shape [bs, num_keys]. Default: None.
-
- Returns:
- Tensor: results with shape [num_queries, bs, embed_dims].
- """
- for layer in self.layers:
- query = layer(
- query,
- key,
- value,
- query_pos=query_pos,
- key_pos=key_pos,
- attn_masks=attn_masks,
- query_key_padding_mask=query_key_padding_mask,
- key_padding_mask=key_padding_mask,
- **kwargs)
- return query
diff --git a/spaces/Pie31415/control-animation/annotator/uniformer/mmcv/runner/hooks/logger/wandb.py b/spaces/Pie31415/control-animation/annotator/uniformer/mmcv/runner/hooks/logger/wandb.py
deleted file mode 100644
index 9f6808462eb79ab2b04806a5d9f0d3dd079b5ea9..0000000000000000000000000000000000000000
--- a/spaces/Pie31415/control-animation/annotator/uniformer/mmcv/runner/hooks/logger/wandb.py
+++ /dev/null
@@ -1,56 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from ...dist_utils import master_only
-from ..hook import HOOKS
-from .base import LoggerHook
-
-
-@HOOKS.register_module()
-class WandbLoggerHook(LoggerHook):
-
- def __init__(self,
- init_kwargs=None,
- interval=10,
- ignore_last=True,
- reset_flag=False,
- commit=True,
- by_epoch=True,
- with_step=True):
- super(WandbLoggerHook, self).__init__(interval, ignore_last,
- reset_flag, by_epoch)
- self.import_wandb()
- self.init_kwargs = init_kwargs
- self.commit = commit
- self.with_step = with_step
-
- def import_wandb(self):
- try:
- import wandb
- except ImportError:
- raise ImportError(
- 'Please run "pip install wandb" to install wandb')
- self.wandb = wandb
-
- @master_only
- def before_run(self, runner):
- super(WandbLoggerHook, self).before_run(runner)
- if self.wandb is None:
- self.import_wandb()
- if self.init_kwargs:
- self.wandb.init(**self.init_kwargs)
- else:
- self.wandb.init()
-
- @master_only
- def log(self, runner):
- tags = self.get_loggable_tags(runner)
- if tags:
- if self.with_step:
- self.wandb.log(
- tags, step=self.get_iter(runner), commit=self.commit)
- else:
- tags['global_step'] = self.get_iter(runner)
- self.wandb.log(tags, commit=self.commit)
-
- @master_only
- def after_run(self, runner):
- self.wandb.join()
diff --git a/spaces/Pie31415/control-animation/annotator/uniformer/mmseg/apis/test.py b/spaces/Pie31415/control-animation/annotator/uniformer/mmseg/apis/test.py
deleted file mode 100644
index e574eb7da04f09a59cf99ff953c36468ae87a326..0000000000000000000000000000000000000000
--- a/spaces/Pie31415/control-animation/annotator/uniformer/mmseg/apis/test.py
+++ /dev/null
@@ -1,238 +0,0 @@
-import os.path as osp
-import pickle
-import shutil
-import tempfile
-
-import annotator.uniformer.mmcv as mmcv
-import numpy as np
-import torch
-import torch.distributed as dist
-from annotator.uniformer.mmcv.image import tensor2imgs
-from annotator.uniformer.mmcv.runner import get_dist_info
-
-
-def np2tmp(array, temp_file_name=None):
- """Save ndarray to local numpy file.
-
- Args:
- array (ndarray): Ndarray to save.
- temp_file_name (str): Numpy file name. If 'temp_file_name=None', this
- function will generate a file name with tempfile.NamedTemporaryFile
- to save ndarray. Default: None.
-
- Returns:
- str: The numpy file name.
- """
-
- if temp_file_name is None:
- temp_file_name = tempfile.NamedTemporaryFile(
- suffix='.npy', delete=False).name
- np.save(temp_file_name, array)
- return temp_file_name
-
-
-def single_gpu_test(model,
- data_loader,
- show=False,
- out_dir=None,
- efficient_test=False,
- opacity=0.5):
- """Test with single GPU.
-
- Args:
- model (nn.Module): Model to be tested.
- data_loader (utils.data.Dataloader): Pytorch data loader.
- show (bool): Whether show results during inference. Default: False.
- out_dir (str, optional): If specified, the results will be dumped into
- the directory to save output results.
- efficient_test (bool): Whether save the results as local numpy files to
- save CPU memory during evaluation. Default: False.
- opacity(float): Opacity of painted segmentation map.
- Default 0.5.
- Must be in (0, 1] range.
- Returns:
- list: The prediction results.
- """
-
- 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, **data)
-
- if show or out_dir:
- img_tensor = data['img'][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 img, img_meta in 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,
- palette=dataset.PALETTE,
- show=show,
- out_file=out_file,
- opacity=opacity)
-
- if isinstance(result, list):
- if efficient_test:
- result = [np2tmp(_) for _ in result]
- results.extend(result)
- else:
- if efficient_test:
- result = np2tmp(result)
- results.append(result)
-
- batch_size = len(result)
- for _ in range(batch_size):
- prog_bar.update()
- return results
-
-
-def multi_gpu_test(model,
- data_loader,
- tmpdir=None,
- gpu_collect=False,
- efficient_test=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 (utils.data.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.
- efficient_test (bool): Whether save the results as local numpy files to
- save CPU memory during evaluation. Default: False.
-
- 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))
- for i, data in enumerate(data_loader):
- with torch.no_grad():
- result = model(return_loss=False, rescale=True, **data)
-
- if isinstance(result, list):
- if efficient_test:
- result = [np2tmp(_) for _ in result]
- results.extend(result)
- else:
- if efficient_test:
- result = np2tmp(result)
- results.append(result)
-
- if rank == 0:
- batch_size = data['img'][0].size(0)
- 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):
- """Collect results with CPU."""
- 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:
- tmpdir = tempfile.mkdtemp()
- 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, 'part_{}.pkl'.format(rank)))
- 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, 'part_{}.pkl'.format(i))
- 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):
- """Collect results with GPU."""
- 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/PixelistStudio/3dart-Models/index.html b/spaces/PixelistStudio/3dart-Models/index.html
deleted file mode 100644
index 6a0444b125aa12a8dc563cf78b6cf266564c8db1..0000000000000000000000000000000000000000
--- a/spaces/PixelistStudio/3dart-Models/index.html
+++ /dev/null
@@ -1,305 +0,0 @@
-import gradio as gr
-import os
-import sys
-from pathlib import Path
-
-models = [
- {"name": "Deliberate", "url": "Masagin/Deliberate"},
- {"name": "Dreamlike Anime", "url": "dreamlike-art/dreamlike-anime-1.0"},
- {"name": "Dreamlike Diffusion", "url": "dreamlike-art/dreamlike-diffusion-1.0"},
- {"name": "Dreamlike Photoreal", "url": "dreamlike-art/dreamlike-photoreal-2.0"},
- {"name": "Dreamshaper", "url": "Lykon/DreamShaper"},
- {"name": "Lyriel 1.3", "url": "sakistriker/Lyriel_V1.3"},
- {"name": "Never Ending Dream 2", "url": "luongphamit/NeverEnding-Dream2"},
- {"name": "Protogen X 5.8", "url": "darkstorm2150/Protogen_x5.8_Official_Release"},
- {"name": "❤ ART MODELS ==========", "url": "dreamlike-art/dreamlike-diffusion-1.0"},
- {"name": "Alice in Diffusion Land", "url": "Guizmus/SDArt_AliceInDiffusionLand"},
- {"name": "Alt Clip", "url": "BAAI/AltCLIP"},
- {"name": "Anything Midjourney 4.1", "url": "Joeythemonster/anything-midjourney-v-4-1"},
- {"name": "Chaos and Order", "url": "Guizmus/SDArt_ChaosAndOrder768"},
- {"name": "Chilloutclara", "url": "Fred99774/chilloutvlara"},
- {"name": "Comic Diffusion", "url": "ogkalu/Comic-Diffusion"},
- {"name": "Cosmic Horros 768", "url": "Guizmus/SDArt_cosmichorrors768"},
- {"name": "Cosmic Horros", "url": "Guizmus/SDArt_cosmichorrors"},
- {"name": "DGSpitzer", "url": "DGSpitzer/DGSpitzer-Art-Diffusion"},
- {"name": "Dungeons and Diffusion", "url": "0xJustin/Dungeons-and-Diffusion"},
- {"name": "Elden Ring", "url": "nitrosocke/elden-ring-diffusion"},
- {"name": "Epic Diffusion 1.1", "url": "johnslegers/epic-diffusion-v1.1"},
- {"name": "Epic Diffusion", "url": "johnslegers/epic-diffusion"},
- {"name": "EpicMix Realism", "url": "Duskfallcrew/EpicMix_Realism"},
- {"name": "Fantasy Mix", "url": "theintuitiveye/FantasyMix"},
- {"name": "Girl New 1", "url": "Fred99774/girlnew1"},
- {"name": "Lit 6B", "url": "hakurei/lit-6B"},
- {"name": "Luna Diffusion", "url": "proximasanfinetuning/luna-diffusion"},
- {"name": "Midjourney 4.0", "url": "flax/midjourney-v4-diffusion"},
- {"name": "Midjourney 4.1", "url": "Joeythemonster/anything-midjourney-v-4-1"},
- {"name": "Mo-Di Diffusion", "url": "nitrosocke/mo-di-diffusion"},
- {"name": "Nitro Diffusion", "url": "nitrosocke/Nitro-Diffusion"},
- {"name": "Openjourney V2", "url": "prompthero/openjourney-v2"},
- {"name": "Openjourney", "url": "prompthero/openjourney"},
- {"name": "Seek Art Mega", "url": "coreco/seek.art_MEGA"},
- {"name": "Something", "url": "Guizmus/SDArt_something"},
- {"name": "Spider Verse diffusion", "url": "nitrosocke/spider-verse-diffusion"},
- {"name": "Vintedois 1.0", "url": "22h/vintedois-diffusion-v0-1"},
- {"name": "Vintedois 2.0", "url": "22h/vintedois-diffusion-v0-2"},
- {"name": "❤ ART STYLES ==========", "url": "joachimsallstrom/Double-Exposure-Diffusion"},
- {"name": "Balloon Art", "url": "Fictiverse/Stable_Diffusion_BalloonArt_Model"},
- {"name": "Double Exposure Diffusion", "url": "joachimsallstrom/Double-Exposure-Diffusion"},
- {"name": "Fluid Art", "url": "Fictiverse/Stable_Diffusion_FluidArt_Model"},
- {"name": "GTA5 Artwork Diffusion", "url": "ItsJayQz/GTA5_Artwork_Diffusion"},
- {"name": "Marvel WhatIf Diffusion", "url": "ItsJayQz/Marvel_WhatIf_Diffusion"},
- {"name": "Naruto Diffuser", "url": "lambdalabs/sd-naruto-diffusers"},
- {"name": "Papercut", "url": "Fictiverse/Stable_Diffusion_PaperCut_Model"},
- {"name": "Pokemon Diffuser", "url": "lambdalabs/sd-pokemon-diffusers"},
- {"name": "Synthwave Punk 2", "url": "ItsJayQz/SynthwavePunk-v2"},
- {"name": "Valorant Diffusion", "url": "ItsJayQz/Valorant_Diffusion"},
- {"name": "Van Gogh Diffusion", "url": "dallinmackay/Van-Gogh-diffusion"},
- {"name": "Vectorartz Diffusion", "url": "coder119/Vectorartz_Diffusion"},
- {"name": "VoxelArt", "url": "Fictiverse/Stable_Diffusion_VoxelArt_Model"},
- {"name": "❤ ANIME MODELS ==========", "url": "dreamlike-art/dreamlike-anime-1.0"},
- {"name": "7 Pa", "url": "AIARTCHAN/7pa"},
- {"name": "A Certain Model", "url": "JosephusCheung/ACertainModel"},
- {"name": "A Certain Thing", "url": "JosephusCheung/ACertainThing"},
- {"name": "A Certainity", "url": "JosephusCheung/ACertainty"},
- {"name": "Abyss Hell Hero", "url": "AIARTCHAN/AbyssHellHero"},
- {"name": "Abyss Maple 3", "url": "AIARTCHAN/AbyssMapleVer3"},
- {"name": "Abyss Orange Mix 2", "url": "WarriorMama777/AbyssOrangeMix2"},
- {"name": "Abyss Orange Mix 4", "url": "sakistriker/AbyssOrangeMix3"},
- {"name": "Abyss Orange Mix", "url": "WarriorMama777/AbyssOrangeMix"},
- {"name": "AbyssHell 3", "url": "AIARTCHAN/AbyssHellVer3"},
- {"name": "All 526 Animated", "url": "stablediffusionapi/all-526-animated"},
- {"name": "Anidosmix 3", "url": "AIARTCHAN/anidosmixV2"},
- {"name": "Anime Kawai Diffusion", "url": "Ojimi/anime-kawai-diffusion"},
- {"name": "Anireal 3D V2", "url": "circulus/sd-anireal-3d-v2"},
- {"name": "AnyLORA", "url": "kubanemil/AnyLORA"},
- {"name": "Anything 2.1", "url": "swl-models/anything-v2.1"},
- {"name": "Anything 3.0 Light", "url": "mm00/anything-v3.0-light"},
- {"name": "Anything 3.0", "url": "Linaqruf/anything-v3.0"},
- {"name": "Anything 3.1", "url": "cag/anything-v3-1"},
- {"name": "Anything 3X", "url": "iZELX1/Anything-V3-X"},
- {"name": "Anything 4.0", "url": "andite/anything-v4.0"},
- {"name": "Anything 5", "url": "sakistriker/Anything_V5_PrtRE"},
- {"name": "Anything 5.0", "url": "stablediffusionapi/anything-v5"},
- {"name": "Anything Else 4", "url": "stablediffusionapi/anythingelse-v4"},
- {"name": "Anything Else 5", "url": "stablediffusionapi/anything-v5"},
- {"name": "Arcane Diffusion", "url": "nitrosocke/Arcane-Diffusion"},
- {"name": "Archer Diffusion", "url": "nitrosocke/archer-diffusion"},
- {"name": "Asian Mix", "url": "D1b4l4p/AsianMix"},
- {"name": "Blood Orange Mix", "url": "WarriorMama777/BloodOrangeMix"},
- {"name": "CamelliaMix 2.5D","url": "stablediffusionapi/camelliamix25d"},
- {"name": "CamelliaMix Line","url": "stablediffusionapi/camelliamixline"},
- {"name": "CamelliaMix","url": "Powidl43/CamelliaMix"},
- {"name": "Cetusmix", "url": "stablediffusionapi/cetusmix"},
- {"name": "Chik Mix", "url": "stablediffusionapi/chikmix"},
- {"name": "Chikmix", "url": "stablediffusionapi/chikmix"},
- {"name": "Chillout App Factory","url": "stablediffusionapi/chillout-app-factory"},
- {"name": "Classic Anime", "url": "nitrosocke/classic-anim-diffusion"},
- {"name": "Cool Japan Diffusion 2.1.2", "url": "aipicasso/cool-japan-diffusion-2-1-2"},
- {"name": "Cosmic Babes", "url": "stablediffusionapi/cosmic-babes"},
- {"name": "Counterfeit 1.0", "url": "gsdf/counterfeit-v1.0"},
- {"name": "Counterfeit 2", "url": "gsdf/Counterfeit-V2.0"},
- {"name": "Counterfeit 2.0", "url": "gsdf/Counterfeit-V2.0"},
- {"name": "Counterfeit 3.0", "url": "stablediffusionapi/counterfeit-v30"},
- {"name": "CuteSexyRobutts", "url": "andite/cutesexyrobutts-diffusion"},
- {"name": "CyberPunk Anime", "url": "DGSpitzer/Cyberpunk-Anime-Diffusion"},
- {"name": "Dark Sushi Mix", "url": "stablediffusionapi/dark-sushi-mix"},
- {"name": "Dash Sushi 25d", "url": "stablediffusionapi/dark-sushi-25d"},
- {"name": "DucHaiten Anime", "url": "DucHaiten/DucHaitenAnime"},
- {"name": "Eerie Orange Mix", "url": "WarriorMama777/EerieOrangeMix"},
- {"name": "Eimis Anime Diffusion", "url": "eimiss/EimisAnimeDiffusion_1.0v"},
- {"name": "Ghibli Diffusion", "url": "nitrosocke/Ghibli-Diffusion"},
- {"name": "GrapeFruit", "url": "iZELX1/Grapefruit"},
- {"name": "GuoFeng 3", "url": "xiaolxl/GuoFeng3"},
- {"name": "Guweiz Diffusion", "url": "andite/guweiz-diffusion"},
- {"name": "Hiten Diffusion", "url": "andite/hiten-diffusion"},
- {"name": "Icomix 2", "url": "stablediffusionapi/icomix-2"},
- {"name": "InkPunk Diffusion", "url": "Envvi/Inkpunk-Diffusion"},
- {"name": "Mama Orange Mixs", "url": "WarriorMama777/OrangeMixs"},
- {"name": "Mashuu Diffusion", "url": "andite/mashuu-diffusion"},
- {"name": "Meainamis 8", "url": "sakistriker/MeinaMix_V8"},
- {"name": "Meina Alter", "url": "stablediffusionapi/meinaalter"},
- {"name": "Meina Pastel", "url": "stablediffusionapi/meinapastel"},
- {"name": "MeinaMix 7", "url": "Nacholmo/meinamixv7-diffusers"},
- {"name": "Mignon Diffusion", "url": "andite/mignon-diffusion"},
- {"name": "MikaPikazo Diffusion", "url": "andite/mikapikazo-diffusion"},
- {"name": "Mikapikazo", "url": "andite/mikapikazo-diffusion"},
- {"name": "Mix Pro V4", "url": "AIARTCHAN/MIX-Pro-V4"},
- {"name": "NeverEnding-Dream", "url": "Lykon/NeverEnding-Dream"},
- {"name": "Niji V5 Style 1", "url": "sakistriker/NijiV5style_V1"},
- {"name": "Openjourney 4", "url": "prompthero/openjourney-v4"},
- {"name": "OpenNiji", "url": "Korakoe/OpenNiji"},
- {"name": "Pastel Mix", "url": "andite/pastel-mix"},
- {"name": "Picasso Diffusion 1.1", "url": "aipicasso/picasso-diffusion-1-1"},
- {"name": "Piromizu Diffusion", "url": "andite/piromizu-diffusion"},
- {"name": "Protogen 2.2", "url": "darkstorm2150/Protogen_v2.2_Official_Release"},
- {"name": "Protogen Infinity", "url": "darkstorm2150/Protogen_Infinity_Official_Release"},
- {"name": "Protogen X 3.4", "url": "darkstorm2150/Protogen_x3.4_Official_Release"},
- {"name": "Rev Anim", "url": "stablediffusionapi/rev-anim"},
- {"name": "Rev Animated", "url": "coreml/coreml-ReV-Animated"},
- {"name": "Rev Animated", "url": "LottePeisch/RevAnimated-Diffusers"},
- {"name": "Something V 2.2","url": "NoCrypt/SomethingV2_2"},
- {"name": "Something V2","url": "NoCrypt/SomethingV2"},
- {"name": "Three Delicacy", "url": "stablediffusionapi/three-delicacy"},
- {"name": "Three Delicacy wonto", "url": "stablediffusionapi/three-delicacy-wonto"},
- {"name": "TMND mix", "url": "stablediffusionapi/tmnd-mix"},
- {"name": "Waifu Diffusion", "url": "hakurei/waifu-diffusion"},
- {"name": "❤ REALISTIC PHOTO MODELS ==========", "url": "dreamlike-art/dreamlike-photoreal-2.0"},
- {"name": "AmiIReal", "url": "stablediffusionapi/amireal"},
- {"name": "Analog Diffusion", "url": "wavymulder/Analog-Diffusion"},
- {"name": "Circulus 2.8", "url": "circulus/sd-photoreal-v2.8"},
- {"name": "Circulus Photoreal V2", "url": "circulus/sd-photoreal-real-v2"},
- {"name": "Claudfuen 1", "url": "claudfuen/photorealistic-fuen-v1"},
- {"name": "Collage Diffusion", "url": "wavymulder/collage-diffusion"},
- {"name": "Cyberrealistic", "url": "stablediffusionapi/cyberrealistic"},
- {"name": "Dreamful 2", "url": "Hius/DreamFul-V2"},
- {"name": "GakkiMix768", "url": "Sa1i/gakki-mix-768"},
- {"name": "Grimoeresigils", "url": "ECarbenia/grimoiresigils"},
- {"name": "HARDBlend", "url": "theintuitiveye/HARDblend"},
- {"name": "HassanBlend 1.4", "url": "hassanblend/hassanblend1.4"},
- {"name": "HassanBlend 1.5.1.2", "url": "hassanblend/HassanBlend1.5.1.2"},
- {"name": "Lomo Diffusion", "url": "wavymulder/lomo-diffusion"},
- {"name": "Model Shoot", "url": "wavymulder/modelshoot"},
- {"name": "Portrait Plus", "url": "wavymulder/portraitplus"},
- {"name": "QuinceMix", "url": "Hemlok/QuinceMix"},
- {"name": "Realistic Vision 1.4", "url": "SG161222/Realistic_Vision_V1.4"},
- {"name": "The Ally", "url": "stablediffusionapi/the-ally"},
- {"name": "Timeless Diffusion", "url": "wavymulder/timeless-diffusion"},
- {"name": "UltraSkin", "url": "VegaKH/Ultraskin"},
- {"name": "Wavyfusion", "url": "wavymulder/wavyfusion"},
- {"name": "❤ SEMI-REALISTIC MODELS ==========", "url": "stablediffusionapi/all-526"},
- {"name": "All 526", "url": "stablediffusionapi/all-526"},
- {"name": "All 526 animated", "url": "stablediffusionapi/all-526-animated"},
- {"name": "Circulus Semi Real 2", "url": "circulus/sd-photoreal-semi-v2"},
- {"name": "Semi Real Mix", "url": "robotjung/SemiRealMix"},
- {"name": "SpyBG", "url": "stablediffusionapi/spybg"},
- {"name": "❤ STABLE DIFFUSION MODELS ==========", "url": "stabilityai/stable-diffusion-2-1"},
- {"name": "Stable Diffusion 1.4","url": "CompVis/stable-diffusion-v1-4"},
- {"name": "Stable Diffusion 1.5","url": "runwayml/stable-diffusion-v1-5"},
- {"name": "Stable Diffusion 2.1","url": "stabilityai/stable-diffusion-2-1"},
- {"name": "Stable Diffusion 2.1 Base","url": "stabilityai/stable-diffusion-2-1-base"},
- {"name": "Stable Diffusion 2.1 Unclip","url": "stabilityai/stable-diffusion-2-1-unclip"},
- {"name": "❤ SCI FI MODELS ==========", "url": "nitrosocke/Future-Diffusion"},
- {"name": "Future Diffusion", "url": "nitrosocke/Future-Diffusion"},
- {"name": "JWST Deep Space Diffusion", "url": "dallinmackay/JWST-Deep-Space-diffusion"},
- {"name": "Robo Diffusion 3 Base", "url": "nousr/robo-diffusion-2-base"},
- {"name": "Robo Diffusion", "url": "nousr/robo-diffusion"},
- {"name": "Tron Legacy Diffusion", "url": "dallinmackay/Tron-Legacy-diffusion"},
- {"name": "❤ 3D ART MODELS ==========", "url": "DucHaiten/DucHaitenAIart"},
- {"name": "DucHaiten Art", "url": "DucHaiten/DucHaitenAIart"},
- {"name": "DucHaiten ClassicAnime", "url": "DucHaiten/DH_ClassicAnime"},
- {"name": "DucHaiten DreamWorld", "url": "DucHaiten/DucHaitenDreamWorld"},
- {"name": "DucHaiten Journey", "url": "DucHaiten/DucHaitenJourney"},
- {"name": "DucHaiten StyleLikeMe", "url": "DucHaiten/DucHaiten-StyleLikeMe"},
- {"name": "DucHaiten SuperCute", "url": "DucHaiten/DucHaitenSuperCute"},
- {"name": "Redshift Diffusion 768", "url": "nitrosocke/redshift-diffusion-768"},
- {"name": "Redshift Diffusion", "url": "nitrosocke/redshift-diffusion"},
-]
-
-current_model = models[0]
-
-text_gen = gr.Interface.load("spaces/Omnibus/MagicPrompt-Stable-Diffusion_link")
-
-models2 = []
-for model in models:
- model_url = f"models/{model['url']}"
- loaded_model = gr.Interface.load(model_url, live=True, preprocess=True)
- models2.append(loaded_model)
-
-
-def text_it(inputs, text_gen=text_gen):
- return text_gen(inputs)
-
-
-def set_model(current_model_index):
- global current_model
- current_model = models[current_model_index]
- return gr.update(label=f"{current_model['name']}")
-
-
-def send_it(inputs, model_choice):
- proc = models2[model_choice]
- return proc(inputs)
-
-
-css = """"""
-
-with gr.Blocks(css=css) as myface:
- gr.HTML(
- """
-
-
-
-
-
-
-
-
-
-
-
-
- Pixelist Ai
-
-
-"""
- )
-
- with gr.Row():
- with gr.Row():
- input_text = gr.Textbox(label="Prompt idea", lines=1)
- # Model selection dropdown
- model_name1 = gr.Dropdown(
- label="Choose Model",
- choices=[m["name"] for m in models],
- type="index",
- value=current_model["name"],
- interactive=True,
- )
- with gr.Row():
- see_prompts = gr.Button("Generate Prompts")
- run = gr.Button("Generate Images", variant="primary")
- with gr.Tab("Main"):
- with gr.Row():
- output1 = gr.Image(label=f"{current_model['name']}")
- output2 = gr.Image(label=f"{current_model['name']}")
- output3 = gr.Image(label=f"{current_model['name']}")
- output4 = gr.Image(label=f"{current_model['name']}")
- with gr.Row():
- magic1 = gr.Textbox(lines=4)
- magic2 = gr.Textbox(lines=4)
- magic3 = gr.Textbox(lines=4)
- magic4 = gr.Textbox(lines=4)
-
- with gr.Row():
- output5 = gr.Image(label=f"{current_model['name']}")
- output6 = gr.Image(label=f"{current_model['name']}")
- output7 = gr.Image(label=f"{current_model['name']}")
- output8 = gr.Image(label=f"{current_model['name']}")
- with gr.Row():
- magic5 = gr.Textbox(lines=4)
- magic6 = gr.Textbox(lines=4)
- magic7 = gr.Textbox(lines=4)
- magic8 = gr.Textbox(lines=4)
-
- model_name1.change(set_model, inputs=model_name1, outputs=[output1, output2, output3, output4, output5, output6, output7, output8])
-
- run.click(send_it, inputs=[magic1, model_name1], outputs=[output1])
- run.click(send_it, inputs=[magic2, model_name1], outputs=[output2])
- run.click(send_it, inputs=[magic3, model_name1], outputs=[output3])
- run.click(send_it, inputs=[magic4, model_name1], outputs=[output4])
- run.click(send_it, inputs=[magic5, model_name1], outputs=[output5])
- run.click(send_it, inputs=[magic6, model_name1], outputs=[output6])
- run.click(send_it, inputs=[magic7, model_name1], outputs=[output7])
- run.click(send_it, inputs=[magic8, model_name1], outputs=[output8])
-
- see_prompts.click(text_it, inputs=[input_text], outputs=[magic1])
- see_prompts.click(text_it, inputs=[input_text], outputs=[magic2])
- see_prompts.click(text_it, inputs=[input_text], outputs=[magic3])
- see_prompts.click(text_it, inputs=[input_text], outputs=[magic4])
- see_prompts.click(text_it, inputs=[input_text], outputs=[magic5])
- see_prompts.click(text_it, inputs=[input_text], outputs=[magic6])
- see_prompts.click(text_it, inputs=[input_text], outputs=[magic7])
- see_prompts.click(text_it, inputs=[input_text], outputs=[magic8])
-
-myface.queue(concurrency_count=200)
-myface.launch(inline=True, show_api=False, max_threads=400)
\ No newline at end of file
diff --git a/spaces/Plurigrid/LifeSim/src/app/agents/types.ts b/spaces/Plurigrid/LifeSim/src/app/agents/types.ts
deleted file mode 100644
index 57c82a06435c6768328166c9aef6c6c0ef595e4f..0000000000000000000000000000000000000000
--- a/spaces/Plurigrid/LifeSim/src/app/agents/types.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-export type AgentType = 'ant' | 'fish' | 'fox' | 'smith'
-
-export interface Scene {
- action: string
- position: string
- prompt: string
-}
-
-export interface Agent {
- title: string
- type: AgentType
- simulate: () => Scene
-}
diff --git a/spaces/ProteinDesignLab/protpardelle/sampling.py b/spaces/ProteinDesignLab/protpardelle/sampling.py
deleted file mode 100644
index 367345eef56a75e92e62cd37ce908d04df37def8..0000000000000000000000000000000000000000
--- a/spaces/ProteinDesignLab/protpardelle/sampling.py
+++ /dev/null
@@ -1,213 +0,0 @@
-"""
-https://github.com/ProteinDesignLab/protpardelle
-License: MIT
-Author: Alex Chu
-
-Configs and convenience functions for wrapping the model sample() function.
-"""
-import argparse
-import time
-from typing import Optional, Tuple
-
-import torch
-from torchtyping import TensorType
-
-from core import residue_constants
-from core import utils
-import diffusion
-
-
-def default_backbone_sampling_config():
- config = argparse.Namespace(
- n_steps=500,
- s_churn=200,
- step_scale=1.2,
- sidechain_mode=False,
- noise_schedule=lambda t: diffusion.noise_schedule(t, s_max=80, s_min=0.001),
- )
- return config
-
-
-def default_allatom_sampling_config():
- noise_schedule = lambda t: diffusion.noise_schedule(t, s_max=80, s_min=0.001)
- stage2 = argparse.Namespace(
- apply_cond_proportion=1.0,
- n_steps=200,
- s_churn=100,
- step_scale=1.2,
- sidechain_mode=True,
- skip_mpnn_proportion=1.0,
- noise_schedule=noise_schedule,
- )
- config = argparse.Namespace(
- n_steps=500,
- s_churn=200,
- step_scale=1.2,
- sidechain_mode=True,
- skip_mpnn_proportion=0.6,
- use_fullmpnn=False,
- use_fullmpnn_for_final=True,
- anneal_seq_resampling_rate="linear",
- noise_schedule=noise_schedule,
- stage_2=stage2,
- )
- return config
-
-
-def draw_backbone_samples(
- model: torch.nn.Module,
- seq_mask: TensorType["b n", float] = None,
- n_samples: int = None,
- sample_length_range: Tuple[int] = (50, 512),
- pdb_save_path: Optional[str] = None,
- return_aux: bool = False,
- return_sampling_runtime: bool = False,
- **sampling_kwargs,
-):
- device = model.device
- if seq_mask is None:
- assert n_samples is not None
- seq_mask = model.make_seq_mask_for_sampling(
- n_samples=n_samples,
- min_len=sample_length_range[0],
- max_len=sample_length_range[1],
- )
-
- start = time.time()
- aux = model.sample(
- seq_mask=seq_mask, return_last=False, return_aux=True, **sampling_kwargs
- )
- aux["runtime"] = time.time() - start
- seq_lens = seq_mask.sum(-1).long()
- cropped_samp_coords = [
- s[: seq_lens[i], model.bb_idxs] for i, s in enumerate(aux["xt_traj"][-1])
- ]
-
- if pdb_save_path is not None:
- gly_aatype = (seq_mask * residue_constants.restype_order["G"]).long()
- trimmed_aatype = [a[: seq_lens[i]] for i, a in enumerate(gly_aatype)]
- atom_mask = utils.atom37_mask_from_aatype(gly_aatype, seq_mask).cpu()
- for i in range(len(cropped_samp_coords)):
- utils.write_coords_to_pdb(
- cropped_samp_coords[i],
- f"{pdb_save_path}{i}.pdb",
- batched=False,
- aatype=trimmed_aatype[i],
- atom_mask=atom_mask[i],
- )
-
- if return_aux:
- return aux
- else:
- if return_sampling_runtime:
- return cropped_samp_coords, seq_mask, aux["runtime"]
- else:
- return cropped_samp_coords, seq_mask
-
-
-def draw_allatom_samples(
- model: torch.nn.Module,
- seq_mask: TensorType["b n", float] = None,
- n_samples: int = None,
- sample_length_range: Tuple[int] = (50, 512),
- two_stage_sampling: bool = True,
- pdb_save_path: Optional[str] = None,
- return_aux: bool = False,
- return_sampling_runtime: bool = False,
- **sampling_kwargs,
-):
- """Implement the default 2-stage all-atom sampling routine."""
-
- def save_allatom_samples(aux, path):
- seq_lens = aux["seq_mask"].sum(-1).long()
- cropped_samp_coords = [
- c[: seq_lens[i]] for i, c in enumerate(aux["xt_traj"][-1])
- ]
- cropped_samp_aatypes = [
- s[: seq_lens[i]] for i, s in enumerate(aux["st_traj"][-1])
- ]
- samp_atom_mask = utils.atom37_mask_from_aatype(
- aux["st_traj"][-1].to(device), seq_mask
- )
- samp_atom_mask = [m[: seq_lens[i]] for i, m in enumerate(samp_atom_mask)]
- for i, c in enumerate(cropped_samp_coords):
- utils.write_coords_to_pdb(
- c,
- f"{path}{i}.pdb",
- batched=False,
- aatype=cropped_samp_aatypes[i],
- atom_mask=samp_atom_mask[i],
- conect=True,
- )
-
- device = model.device
- if seq_mask is None:
- assert n_samples is not None
- seq_mask = model.make_seq_mask_for_sampling(
- n_samples=n_samples,
- min_len=sample_length_range[0],
- max_len=sample_length_range[1],
- )
- sampling_runtime = 0.0
-
- # Stage 1 sampling
- start = time.time()
- if "stage_2" in sampling_kwargs:
- stage_2_kwargs = vars(sampling_kwargs.pop("stage_2"))
- aux = model.sample(
- seq_mask=seq_mask,
- return_last=False,
- return_aux=True,
- **sampling_kwargs,
- )
- sampling_runtime = time.time() - start
- if pdb_save_path is not None and two_stage_sampling:
- save_allatom_samples(aux, pdb_save_path + "_init")
-
- # Stage 2 sampling (sidechain refinement only)
- if two_stage_sampling:
- samp_seq = aux["st_traj"][-1]
- samp_coords = aux["xt_traj"][-1]
- cond_atom_mask = utils.atom37_mask_from_aatype((seq_mask * 7).long(), seq_mask)
- aux = {f"stage1_{k}": v for k, v in aux.items()}
- start = time.time()
- stage2_aux = model.sample(
- gt_cond_atom_mask=cond_atom_mask.to(device), # condition on backbone
- gt_cond_seq_mask=seq_mask.to(device),
- gt_coords=samp_coords.to(device),
- gt_aatype=samp_seq.to(device),
- seq_mask=seq_mask,
- return_last=False,
- return_aux=True,
- **stage_2_kwargs,
- )
- sampling_runtime += time.time() - start
- aux = {**aux, **stage2_aux}
- if pdb_save_path is not None:
- save_allatom_samples(aux, pdb_save_path + "_samp")
- aux["runtime"] = sampling_runtime
-
- # Process outputs, crop to correct length
- if return_aux:
- return aux
- else:
- xt_traj = aux["xt_traj"]
- st_traj = aux["st_traj"]
- seq_mask = aux["seq_mask"]
- seq_lens = seq_mask.sum(-1).long()
- cropped_samp_coords = [c[: seq_lens[i]] for i, c in enumerate(xt_traj[-1])]
- cropped_samp_aatypes = [s[: seq_lens[i]] for i, s in enumerate(st_traj[-1])]
- samp_atom_mask = utils.atom37_mask_from_aatype(st_traj[-1].to(device), seq_mask)
- samp_atom_mask = [m[: seq_lens[i]] for i, m in enumerate(samp_atom_mask)]
- orig_xt_traj = aux["stage1_xt_traj"]
- stage1_coords = [c[: seq_lens[i]] for i, c in enumerate(orig_xt_traj[-1])]
- ret = (
- cropped_samp_coords,
- cropped_samp_aatypes,
- samp_atom_mask,
- stage1_coords,
- seq_mask,
- )
- if return_sampling_runtime:
- ret = ret + (sampling_runtime,)
- return ret
diff --git a/spaces/Qilex/ColorpAI/README.md b/spaces/Qilex/ColorpAI/README.md
deleted file mode 100644
index 12f11e70488295de0ef131418f79c8b019473aa6..0000000000000000000000000000000000000000
--- a/spaces/Qilex/ColorpAI/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Color pAI
-emoji: 🎨
-colorFrom: yellow
-colorTo: gray
-sdk: gradio
-sdk_version: 3.1.4
-app_file: app.py
-license: other
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pip/_vendor/platformdirs/macos.py b/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pip/_vendor/platformdirs/macos.py
deleted file mode 100644
index a01337c7764e1e1aba1f3ba378a1c9241f31806d..0000000000000000000000000000000000000000
--- a/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pip/_vendor/platformdirs/macos.py
+++ /dev/null
@@ -1,64 +0,0 @@
-from __future__ import annotations
-
-import os
-
-from .api import PlatformDirsABC
-
-
-class MacOS(PlatformDirsABC):
- """
- Platform directories for the macOS operating system. Follows the guidance from `Apple documentation
- `_.
- Makes use of the `appname ` and
- `version `.
- """
-
- @property
- def user_data_dir(self) -> str:
- """:return: data directory tied to the user, e.g. ``~/Library/Application Support/$appname/$version``"""
- return self._append_app_name_and_version(os.path.expanduser("~/Library/Application Support/"))
-
- @property
- def site_data_dir(self) -> str:
- """:return: data directory shared by users, e.g. ``/Library/Application Support/$appname/$version``"""
- return self._append_app_name_and_version("/Library/Application Support")
-
- @property
- def user_config_dir(self) -> str:
- """:return: config directory tied to the user, e.g. ``~/Library/Preferences/$appname/$version``"""
- return self._append_app_name_and_version(os.path.expanduser("~/Library/Preferences/"))
-
- @property
- def site_config_dir(self) -> str:
- """:return: config directory shared by the users, e.g. ``/Library/Preferences/$appname``"""
- return self._append_app_name_and_version("/Library/Preferences")
-
- @property
- def user_cache_dir(self) -> str:
- """:return: cache directory tied to the user, e.g. ``~/Library/Caches/$appname/$version``"""
- return self._append_app_name_and_version(os.path.expanduser("~/Library/Caches"))
-
- @property
- def user_state_dir(self) -> str:
- """:return: state directory tied to the user, same as `user_data_dir`"""
- return self.user_data_dir
-
- @property
- def user_log_dir(self) -> str:
- """:return: log directory tied to the user, e.g. ``~/Library/Logs/$appname/$version``"""
- return self._append_app_name_and_version(os.path.expanduser("~/Library/Logs"))
-
- @property
- def user_documents_dir(self) -> str:
- """:return: documents directory tied to the user, e.g. ``~/Documents``"""
- return os.path.expanduser("~/Documents")
-
- @property
- def user_runtime_dir(self) -> str:
- """:return: runtime directory tied to the user, e.g. ``~/Library/Caches/TemporaryItems/$appname/$version``"""
- return self._append_app_name_and_version(os.path.expanduser("~/Library/Caches/TemporaryItems"))
-
-
-__all__ = [
- "MacOS",
-]
diff --git a/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pip/_vendor/pyparsing/helpers.py b/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pip/_vendor/pyparsing/helpers.py
deleted file mode 100644
index 9588b3b780159a2a2d23c7f84a4404ec350e2b65..0000000000000000000000000000000000000000
--- a/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pip/_vendor/pyparsing/helpers.py
+++ /dev/null
@@ -1,1088 +0,0 @@
-# helpers.py
-import html.entities
-import re
-import typing
-
-from . import __diag__
-from .core import *
-from .util import _bslash, _flatten, _escape_regex_range_chars
-
-
-#
-# global helpers
-#
-def delimited_list(
- expr: Union[str, ParserElement],
- delim: Union[str, ParserElement] = ",",
- combine: bool = False,
- min: typing.Optional[int] = None,
- max: typing.Optional[int] = None,
- *,
- allow_trailing_delim: bool = False,
-) -> ParserElement:
- """Helper to define a delimited list of expressions - the delimiter
- defaults to ','. By default, the list elements and delimiters can
- have intervening whitespace, and comments, but this can be
- overridden by passing ``combine=True`` in the constructor. If
- ``combine`` is set to ``True``, the matching tokens are
- returned as a single token string, with the delimiters included;
- otherwise, the matching tokens are returned as a list of tokens,
- with the delimiters suppressed.
-
- If ``allow_trailing_delim`` is set to True, then the list may end with
- a delimiter.
-
- Example::
-
- delimited_list(Word(alphas)).parse_string("aa,bb,cc") # -> ['aa', 'bb', 'cc']
- delimited_list(Word(hexnums), delim=':', combine=True).parse_string("AA:BB:CC:DD:EE") # -> ['AA:BB:CC:DD:EE']
- """
- if isinstance(expr, str_type):
- expr = ParserElement._literalStringClass(expr)
-
- dlName = "{expr} [{delim} {expr}]...{end}".format(
- expr=str(expr.copy().streamline()),
- delim=str(delim),
- end=" [{}]".format(str(delim)) if allow_trailing_delim else "",
- )
-
- if not combine:
- delim = Suppress(delim)
-
- if min is not None:
- if min < 1:
- raise ValueError("min must be greater than 0")
- min -= 1
- if max is not None:
- if min is not None and max <= min:
- raise ValueError("max must be greater than, or equal to min")
- max -= 1
- delimited_list_expr = expr + (delim + expr)[min, max]
-
- if allow_trailing_delim:
- delimited_list_expr += Opt(delim)
-
- if combine:
- return Combine(delimited_list_expr).set_name(dlName)
- else:
- return delimited_list_expr.set_name(dlName)
-
-
-def counted_array(
- expr: ParserElement,
- int_expr: typing.Optional[ParserElement] = None,
- *,
- intExpr: typing.Optional[ParserElement] = None,
-) -> ParserElement:
- """Helper to define a counted list of expressions.
-
- This helper defines a pattern of the form::
-
- integer expr expr expr...
-
- where the leading integer tells how many expr expressions follow.
- The matched tokens returns the array of expr tokens as a list - the
- leading count token is suppressed.
-
- If ``int_expr`` is specified, it should be a pyparsing expression
- that produces an integer value.
-
- Example::
-
- counted_array(Word(alphas)).parse_string('2 ab cd ef') # -> ['ab', 'cd']
-
- # in this parser, the leading integer value is given in binary,
- # '10' indicating that 2 values are in the array
- binary_constant = Word('01').set_parse_action(lambda t: int(t[0], 2))
- counted_array(Word(alphas), int_expr=binary_constant).parse_string('10 ab cd ef') # -> ['ab', 'cd']
-
- # if other fields must be parsed after the count but before the
- # list items, give the fields results names and they will
- # be preserved in the returned ParseResults:
- count_with_metadata = integer + Word(alphas)("type")
- typed_array = counted_array(Word(alphanums), int_expr=count_with_metadata)("items")
- result = typed_array.parse_string("3 bool True True False")
- print(result.dump())
-
- # prints
- # ['True', 'True', 'False']
- # - items: ['True', 'True', 'False']
- # - type: 'bool'
- """
- intExpr = intExpr or int_expr
- array_expr = Forward()
-
- def count_field_parse_action(s, l, t):
- nonlocal array_expr
- n = t[0]
- array_expr <<= (expr * n) if n else Empty()
- # clear list contents, but keep any named results
- del t[:]
-
- if intExpr is None:
- intExpr = Word(nums).set_parse_action(lambda t: int(t[0]))
- else:
- intExpr = intExpr.copy()
- intExpr.set_name("arrayLen")
- intExpr.add_parse_action(count_field_parse_action, call_during_try=True)
- return (intExpr + array_expr).set_name("(len) " + str(expr) + "...")
-
-
-def match_previous_literal(expr: ParserElement) -> ParserElement:
- """Helper to define an expression that is indirectly defined from
- the tokens matched in a previous expression, that is, it looks for
- a 'repeat' of a previous expression. For example::
-
- first = Word(nums)
- second = match_previous_literal(first)
- match_expr = first + ":" + second
-
- will match ``"1:1"``, but not ``"1:2"``. Because this
- matches a previous literal, will also match the leading
- ``"1:1"`` in ``"1:10"``. If this is not desired, use
- :class:`match_previous_expr`. Do *not* use with packrat parsing
- enabled.
- """
- rep = Forward()
-
- def copy_token_to_repeater(s, l, t):
- if t:
- if len(t) == 1:
- rep << t[0]
- else:
- # flatten t tokens
- tflat = _flatten(t.as_list())
- rep << And(Literal(tt) for tt in tflat)
- else:
- rep << Empty()
-
- expr.add_parse_action(copy_token_to_repeater, callDuringTry=True)
- rep.set_name("(prev) " + str(expr))
- return rep
-
-
-def match_previous_expr(expr: ParserElement) -> ParserElement:
- """Helper to define an expression that is indirectly defined from
- the tokens matched in a previous expression, that is, it looks for
- a 'repeat' of a previous expression. For example::
-
- first = Word(nums)
- second = match_previous_expr(first)
- match_expr = first + ":" + second
-
- will match ``"1:1"``, but not ``"1:2"``. Because this
- matches by expressions, will *not* match the leading ``"1:1"``
- in ``"1:10"``; the expressions are evaluated first, and then
- compared, so ``"1"`` is compared with ``"10"``. Do *not* use
- with packrat parsing enabled.
- """
- rep = Forward()
- e2 = expr.copy()
- rep <<= e2
-
- def copy_token_to_repeater(s, l, t):
- matchTokens = _flatten(t.as_list())
-
- def must_match_these_tokens(s, l, t):
- theseTokens = _flatten(t.as_list())
- if theseTokens != matchTokens:
- raise ParseException(
- s, l, "Expected {}, found{}".format(matchTokens, theseTokens)
- )
-
- rep.set_parse_action(must_match_these_tokens, callDuringTry=True)
-
- expr.add_parse_action(copy_token_to_repeater, callDuringTry=True)
- rep.set_name("(prev) " + str(expr))
- return rep
-
-
-def one_of(
- strs: Union[typing.Iterable[str], str],
- caseless: bool = False,
- use_regex: bool = True,
- as_keyword: bool = False,
- *,
- useRegex: bool = True,
- asKeyword: bool = False,
-) -> ParserElement:
- """Helper to quickly define a set of alternative :class:`Literal` s,
- and makes sure to do longest-first testing when there is a conflict,
- regardless of the input order, but returns
- a :class:`MatchFirst` for best performance.
-
- Parameters:
-
- - ``strs`` - a string of space-delimited literals, or a collection of
- string literals
- - ``caseless`` - treat all literals as caseless - (default= ``False``)
- - ``use_regex`` - as an optimization, will
- generate a :class:`Regex` object; otherwise, will generate
- a :class:`MatchFirst` object (if ``caseless=True`` or ``asKeyword=True``, or if
- creating a :class:`Regex` raises an exception) - (default= ``True``)
- - ``as_keyword`` - enforce :class:`Keyword`-style matching on the
- generated expressions - (default= ``False``)
- - ``asKeyword`` and ``useRegex`` are retained for pre-PEP8 compatibility,
- but will be removed in a future release
-
- Example::
-
- comp_oper = one_of("< = > <= >= !=")
- var = Word(alphas)
- number = Word(nums)
- term = var | number
- comparison_expr = term + comp_oper + term
- print(comparison_expr.search_string("B = 12 AA=23 B<=AA AA>12"))
-
- prints::
-
- [['B', '=', '12'], ['AA', '=', '23'], ['B', '<=', 'AA'], ['AA', '>', '12']]
- """
- asKeyword = asKeyword or as_keyword
- useRegex = useRegex and use_regex
-
- if (
- isinstance(caseless, str_type)
- and __diag__.warn_on_multiple_string_args_to_oneof
- ):
- warnings.warn(
- "More than one string argument passed to one_of, pass"
- " choices as a list or space-delimited string",
- stacklevel=2,
- )
-
- if caseless:
- isequal = lambda a, b: a.upper() == b.upper()
- masks = lambda a, b: b.upper().startswith(a.upper())
- parseElementClass = CaselessKeyword if asKeyword else CaselessLiteral
- else:
- isequal = lambda a, b: a == b
- masks = lambda a, b: b.startswith(a)
- parseElementClass = Keyword if asKeyword else Literal
-
- symbols: List[str] = []
- if isinstance(strs, str_type):
- symbols = strs.split()
- elif isinstance(strs, Iterable):
- symbols = list(strs)
- else:
- raise TypeError("Invalid argument to one_of, expected string or iterable")
- if not symbols:
- return NoMatch()
-
- # reorder given symbols to take care to avoid masking longer choices with shorter ones
- # (but only if the given symbols are not just single characters)
- if any(len(sym) > 1 for sym in symbols):
- i = 0
- while i < len(symbols) - 1:
- cur = symbols[i]
- for j, other in enumerate(symbols[i + 1 :]):
- if isequal(other, cur):
- del symbols[i + j + 1]
- break
- elif masks(cur, other):
- del symbols[i + j + 1]
- symbols.insert(i, other)
- break
- else:
- i += 1
-
- if useRegex:
- re_flags: int = re.IGNORECASE if caseless else 0
-
- try:
- if all(len(sym) == 1 for sym in symbols):
- # symbols are just single characters, create range regex pattern
- patt = "[{}]".format(
- "".join(_escape_regex_range_chars(sym) for sym in symbols)
- )
- else:
- patt = "|".join(re.escape(sym) for sym in symbols)
-
- # wrap with \b word break markers if defining as keywords
- if asKeyword:
- patt = r"\b(?:{})\b".format(patt)
-
- ret = Regex(patt, flags=re_flags).set_name(" | ".join(symbols))
-
- if caseless:
- # add parse action to return symbols as specified, not in random
- # casing as found in input string
- symbol_map = {sym.lower(): sym for sym in symbols}
- ret.add_parse_action(lambda s, l, t: symbol_map[t[0].lower()])
-
- return ret
-
- except re.error:
- warnings.warn(
- "Exception creating Regex for one_of, building MatchFirst", stacklevel=2
- )
-
- # last resort, just use MatchFirst
- return MatchFirst(parseElementClass(sym) for sym in symbols).set_name(
- " | ".join(symbols)
- )
-
-
-def dict_of(key: ParserElement, value: ParserElement) -> ParserElement:
- """Helper to easily and clearly define a dictionary by specifying
- the respective patterns for the key and value. Takes care of
- defining the :class:`Dict`, :class:`ZeroOrMore`, and
- :class:`Group` tokens in the proper order. The key pattern
- can include delimiting markers or punctuation, as long as they are
- suppressed, thereby leaving the significant key text. The value
- pattern can include named results, so that the :class:`Dict` results
- can include named token fields.
-
- Example::
-
- text = "shape: SQUARE posn: upper left color: light blue texture: burlap"
- attr_expr = (label + Suppress(':') + OneOrMore(data_word, stop_on=label).set_parse_action(' '.join))
- print(attr_expr[1, ...].parse_string(text).dump())
-
- attr_label = label
- attr_value = Suppress(':') + OneOrMore(data_word, stop_on=label).set_parse_action(' '.join)
-
- # similar to Dict, but simpler call format
- result = dict_of(attr_label, attr_value).parse_string(text)
- print(result.dump())
- print(result['shape'])
- print(result.shape) # object attribute access works too
- print(result.as_dict())
-
- prints::
-
- [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']]
- - color: 'light blue'
- - posn: 'upper left'
- - shape: 'SQUARE'
- - texture: 'burlap'
- SQUARE
- SQUARE
- {'color': 'light blue', 'shape': 'SQUARE', 'posn': 'upper left', 'texture': 'burlap'}
- """
- return Dict(OneOrMore(Group(key + value)))
-
-
-def original_text_for(
- expr: ParserElement, as_string: bool = True, *, asString: bool = True
-) -> ParserElement:
- """Helper to return the original, untokenized text for a given
- expression. Useful to restore the parsed fields of an HTML start
- tag into the raw tag text itself, or to revert separate tokens with
- intervening whitespace back to the original matching input text. By
- default, returns astring containing the original parsed text.
-
- If the optional ``as_string`` argument is passed as
- ``False``, then the return value is
- a :class:`ParseResults` containing any results names that
- were originally matched, and a single token containing the original
- matched text from the input string. So if the expression passed to
- :class:`original_text_for` contains expressions with defined
- results names, you must set ``as_string`` to ``False`` if you
- want to preserve those results name values.
-
- The ``asString`` pre-PEP8 argument is retained for compatibility,
- but will be removed in a future release.
-
- Example::
-
- src = "this is test bold text normal text "
- for tag in ("b", "i"):
- opener, closer = make_html_tags(tag)
- patt = original_text_for(opener + SkipTo(closer) + closer)
- print(patt.search_string(src)[0])
-
- prints::
-
- [' bold text']
- ['text']
- """
- asString = asString and as_string
-
- locMarker = Empty().set_parse_action(lambda s, loc, t: loc)
- endlocMarker = locMarker.copy()
- endlocMarker.callPreparse = False
- matchExpr = locMarker("_original_start") + expr + endlocMarker("_original_end")
- if asString:
- extractText = lambda s, l, t: s[t._original_start : t._original_end]
- else:
-
- def extractText(s, l, t):
- t[:] = [s[t.pop("_original_start") : t.pop("_original_end")]]
-
- matchExpr.set_parse_action(extractText)
- matchExpr.ignoreExprs = expr.ignoreExprs
- matchExpr.suppress_warning(Diagnostics.warn_ungrouped_named_tokens_in_collection)
- return matchExpr
-
-
-def ungroup(expr: ParserElement) -> ParserElement:
- """Helper to undo pyparsing's default grouping of And expressions,
- even if all but one are non-empty.
- """
- return TokenConverter(expr).add_parse_action(lambda t: t[0])
-
-
-def locatedExpr(expr: ParserElement) -> ParserElement:
- """
- (DEPRECATED - future code should use the Located class)
- Helper to decorate a returned token with its starting and ending
- locations in the input string.
-
- This helper adds the following results names:
-
- - ``locn_start`` - location where matched expression begins
- - ``locn_end`` - location where matched expression ends
- - ``value`` - the actual parsed results
-
- Be careful if the input text contains ```` characters, you
- may want to call :class:`ParserElement.parseWithTabs`
-
- Example::
-
- wd = Word(alphas)
- for match in locatedExpr(wd).searchString("ljsdf123lksdjjf123lkkjj1222"):
- print(match)
-
- prints::
-
- [[0, 'ljsdf', 5]]
- [[8, 'lksdjjf', 15]]
- [[18, 'lkkjj', 23]]
- """
- locator = Empty().set_parse_action(lambda ss, ll, tt: ll)
- return Group(
- locator("locn_start")
- + expr("value")
- + locator.copy().leaveWhitespace()("locn_end")
- )
-
-
-def nested_expr(
- opener: Union[str, ParserElement] = "(",
- closer: Union[str, ParserElement] = ")",
- content: typing.Optional[ParserElement] = None,
- ignore_expr: ParserElement = quoted_string(),
- *,
- ignoreExpr: ParserElement = quoted_string(),
-) -> ParserElement:
- """Helper method for defining nested lists enclosed in opening and
- closing delimiters (``"("`` and ``")"`` are the default).
-
- Parameters:
- - ``opener`` - opening character for a nested list
- (default= ``"("``); can also be a pyparsing expression
- - ``closer`` - closing character for a nested list
- (default= ``")"``); can also be a pyparsing expression
- - ``content`` - expression for items within the nested lists
- (default= ``None``)
- - ``ignore_expr`` - expression for ignoring opening and closing delimiters
- (default= :class:`quoted_string`)
- - ``ignoreExpr`` - this pre-PEP8 argument is retained for compatibility
- but will be removed in a future release
-
- If an expression is not provided for the content argument, the
- nested expression will capture all whitespace-delimited content
- between delimiters as a list of separate values.
-
- Use the ``ignore_expr`` argument to define expressions that may
- contain opening or closing characters that should not be treated as
- opening or closing characters for nesting, such as quoted_string or
- a comment expression. Specify multiple expressions using an
- :class:`Or` or :class:`MatchFirst`. The default is
- :class:`quoted_string`, but if no expressions are to be ignored, then
- pass ``None`` for this argument.
-
- Example::
-
- data_type = one_of("void int short long char float double")
- decl_data_type = Combine(data_type + Opt(Word('*')))
- ident = Word(alphas+'_', alphanums+'_')
- number = pyparsing_common.number
- arg = Group(decl_data_type + ident)
- LPAR, RPAR = map(Suppress, "()")
-
- code_body = nested_expr('{', '}', ignore_expr=(quoted_string | c_style_comment))
-
- c_function = (decl_data_type("type")
- + ident("name")
- + LPAR + Opt(delimited_list(arg), [])("args") + RPAR
- + code_body("body"))
- c_function.ignore(c_style_comment)
-
- source_code = '''
- int is_odd(int x) {
- return (x%2);
- }
-
- int dec_to_hex(char hchar) {
- if (hchar >= '0' && hchar <= '9') {
- return (ord(hchar)-ord('0'));
- } else {
- return (10+ord(hchar)-ord('A'));
- }
- }
- '''
- for func in c_function.search_string(source_code):
- print("%(name)s (%(type)s) args: %(args)s" % func)
-
-
- prints::
-
- is_odd (int) args: [['int', 'x']]
- dec_to_hex (int) args: [['char', 'hchar']]
- """
- if ignoreExpr != ignore_expr:
- ignoreExpr = ignore_expr if ignoreExpr == quoted_string() else ignoreExpr
- if opener == closer:
- raise ValueError("opening and closing strings cannot be the same")
- if content is None:
- if isinstance(opener, str_type) and isinstance(closer, str_type):
- if len(opener) == 1 and len(closer) == 1:
- if ignoreExpr is not None:
- content = Combine(
- OneOrMore(
- ~ignoreExpr
- + CharsNotIn(
- opener + closer + ParserElement.DEFAULT_WHITE_CHARS,
- exact=1,
- )
- )
- ).set_parse_action(lambda t: t[0].strip())
- else:
- content = empty.copy() + CharsNotIn(
- opener + closer + ParserElement.DEFAULT_WHITE_CHARS
- ).set_parse_action(lambda t: t[0].strip())
- else:
- if ignoreExpr is not None:
- content = Combine(
- OneOrMore(
- ~ignoreExpr
- + ~Literal(opener)
- + ~Literal(closer)
- + CharsNotIn(ParserElement.DEFAULT_WHITE_CHARS, exact=1)
- )
- ).set_parse_action(lambda t: t[0].strip())
- else:
- content = Combine(
- OneOrMore(
- ~Literal(opener)
- + ~Literal(closer)
- + CharsNotIn(ParserElement.DEFAULT_WHITE_CHARS, exact=1)
- )
- ).set_parse_action(lambda t: t[0].strip())
- else:
- raise ValueError(
- "opening and closing arguments must be strings if no content expression is given"
- )
- ret = Forward()
- if ignoreExpr is not None:
- ret <<= Group(
- Suppress(opener) + ZeroOrMore(ignoreExpr | ret | content) + Suppress(closer)
- )
- else:
- ret <<= Group(Suppress(opener) + ZeroOrMore(ret | content) + Suppress(closer))
- ret.set_name("nested %s%s expression" % (opener, closer))
- return ret
-
-
-def _makeTags(tagStr, xml, suppress_LT=Suppress("<"), suppress_GT=Suppress(">")):
- """Internal helper to construct opening and closing tag expressions, given a tag name"""
- if isinstance(tagStr, str_type):
- resname = tagStr
- tagStr = Keyword(tagStr, caseless=not xml)
- else:
- resname = tagStr.name
-
- tagAttrName = Word(alphas, alphanums + "_-:")
- if xml:
- tagAttrValue = dbl_quoted_string.copy().set_parse_action(remove_quotes)
- openTag = (
- suppress_LT
- + tagStr("tag")
- + Dict(ZeroOrMore(Group(tagAttrName + Suppress("=") + tagAttrValue)))
- + Opt("/", default=[False])("empty").set_parse_action(
- lambda s, l, t: t[0] == "/"
- )
- + suppress_GT
- )
- else:
- tagAttrValue = quoted_string.copy().set_parse_action(remove_quotes) | Word(
- printables, exclude_chars=">"
- )
- openTag = (
- suppress_LT
- + tagStr("tag")
- + Dict(
- ZeroOrMore(
- Group(
- tagAttrName.set_parse_action(lambda t: t[0].lower())
- + Opt(Suppress("=") + tagAttrValue)
- )
- )
- )
- + Opt("/", default=[False])("empty").set_parse_action(
- lambda s, l, t: t[0] == "/"
- )
- + suppress_GT
- )
- closeTag = Combine(Literal("", adjacent=False)
-
- openTag.set_name("<%s>" % resname)
- # add start results name in parse action now that ungrouped names are not reported at two levels
- openTag.add_parse_action(
- lambda t: t.__setitem__(
- "start" + "".join(resname.replace(":", " ").title().split()), t.copy()
- )
- )
- closeTag = closeTag(
- "end" + "".join(resname.replace(":", " ").title().split())
- ).set_name("" % resname)
- openTag.tag = resname
- closeTag.tag = resname
- openTag.tag_body = SkipTo(closeTag())
- return openTag, closeTag
-
-
-def make_html_tags(
- tag_str: Union[str, ParserElement]
-) -> Tuple[ParserElement, ParserElement]:
- """Helper to construct opening and closing tag expressions for HTML,
- given a tag name. Matches tags in either upper or lower case,
- attributes with namespaces and with quoted or unquoted values.
-
- Example::
-
- text = '
"""
-# st.markdown(pagetile, unsafe_allow_html=True)
-st.subheader('To begin using the app, load your LAS file using the file upload option below.')
-st.subheader("1. LAS File Loading:")
-#------------------------------------------------------------------------------
-#Streamlit Dashboard------------------------------------------------------------------------------------------
-
-# set_page_config(page='custom')
-hide_menu_button()
-condense_layout()
-#-----------------------------------------------------------------------------
-@st.cache_data() #allow_output_mutation=True, suppress_st_warning=True
-def upload_las(uploaded_files):
- dataframes = {}
- las_data_list = []
- las_data = []
- if uploaded_files is not None:
- for file in uploaded_files:
- try:
- bytes_data = file.read()
- str_io = StringIO(bytes_data.decode('Windows-1252'))
- las_data = lasio.read(str_io)
- well_data = las_data.df()
- well_data['WELL'] = las_data.well.WELL.value
- if well_data.index.name == 'DEPT':
- well_data.reset_index('DEPT', inplace=True) # Set 'DEPT' as the new index
- well_data.index.name = 'DEPT'
- if len(well_data) > 0: # Kiểm tra xem dataframe có dữ liệu không
- dataframes[file.name] = well_data
- las_data_list.append(las_data)
- else:
- st.warning(f"No data in file {file.name}")
- else:
- well_data.index.name == 'DEPTH'
- well_data.reset_index('DEPTH', inplace=True) # Set 'DEPTH' as the new index
- well_data.index.name = 'DEPTH'
- if len(well_data) > 0: # Kiểm tra xem dataframe có dữ liệu không
- dataframes[file.name] = well_data
- las_data_list.append(las_data)
- except Exception as e:
- st.error(f"Error loading {file.name}: {e}")
- return dataframes, las_data_list, las_data
-
-# Sidebar Options & File Upload
-uploaded_files = st.file_uploader(label='Upload LAS files:', accept_multiple_files=True, type='las')
-
-dataframes, las_data_list, las_data = upload_las(uploaded_files)
-# print("print las data", las_data_list)
-well_names = {}
-if dataframes:
- merged_df = []
- for file_name, df in dataframes.items():
- well_name = file_name.split(".")[0]
- # Lấy danh sách các tên giếng
- well_names = list(dataframes.keys())
-
- # Cho phép người dùng chọn giếng và hiển thị DataFrame tương ứng
- selected_well = st.selectbox("Select Well", well_names, key = "selected_well_1")
-
- # st.write(f"Data for {selected_well}:")
- st.write(dataframes[selected_well])
- # Tạo một danh sách các DataFrame
- dfs = [df for _, df in dataframes.items()]
- merged_df = pd.concat([df for df in dfs])
- # Hiển thị DataFrame tổng thể
- st.write("Merged DataFrame:")
- st.write(merged_df)
-else:
- print ("Please select LAS files for uploading ")
- st.warning('No valid LAS files were uploaded.')
-
-curves = []
-wellname = []
-las = las_data
-list_well = []
-if las:
-
- for las_data in las_data_list:
- well_name = las_data.well['WELL'].value
- list_well.append(well_name)
- # print(list_well)
-
- st.success('File Uploaded Successfully')
- st.write(f'Well Name: {list_well}', unsafe_allow_html=True)
- # 2_CURVES_INFOMATION-----------------------------------------------------------------
- if las:
-
- st.subheader("2. Curve logs details:")
- selected_well = st.selectbox("Select Well", well_names, key = "selected_well_2")
- st.caption("All curve logs in data:")
-
- curves = []
-
- for well, las_file in zip(well_names, las_data_list):
- if well == selected_well:
- las = las_file
- break
-
-
- # print("in ra las:", las)
- for curve in las.curves:
- st.write(curve.mnemonic)
- curves.append(curve.mnemonic)
-
- for count, curve in enumerate(las.curves):
- st.write("---")
- st.write(f"Curve: {curve.mnemonic}, \t Units: {curve.unit}, \t Description: {curve.descr}")
- st.write(f"There are a total of: {count+1} curves present within this file")
-
- #3_DATAFRAME-----------------------------------------------------------------
- if "selected_well" not in st.session_state:
- st.session_state.selected_well = None
- st.session_state.selected_well_multi = None
- st.subheader("3. Converting LAS to DataFrame:")
- st.caption("3.1 Preview of all Dataframe")
-
- selected_well = st.selectbox("Select Well", well_names, key = "selected_well_5")
- # print("Well_name", well_names)
- # print("las_data_list", las_data_list)
- for well, las_file in zip(well_names, las_data_list):
- if well == selected_well:
- las = las_file
- break
- # break
- well = las.df()
- well['WELL'] = las.well.WELL.value
- well['DEPTH'] = well.index
- well = well.reset_index(drop=True)
- well = well.reindex(columns=['DEPTH'] + [col for col in well.columns if col != 'DEPTH'])
- st.write(well.head())
- st.caption("3.2 Well curves Statistics")
- st.write(well.describe())
- # print("in ra danh sách giếng", list_well)
- # create a selectbox to choose the well
-
- selected_well_multi = st.multiselect(" 3.3 Select well for download", list_well)
- st.session_state.changename = st.button("Create", key="create_curve")
- if st.session_state.changename:
- dataframes_df = pd.concat(dataframes.values(), ignore_index=True)
- st.session_state.selected_well_multi = dataframes_df.loc[dataframes_df['WELL'].isin(selected_well_multi)].reset_index(drop=True)
- st.dataframe(st.session_state.selected_well_multi)
- st.write(" Download DataFrame")
- st.download_button(label='Download CSV File',
- data = st.session_state.selected_well_multi.to_csv(),
- file_name=f"{selected_well_multi}.csv",
- mime='text/csv')
-
- #4_Data Preprocessing-----------------------------------------------------------------
- st.subheader("4. Data Preprocessing:")
- st.session_state.old_name:str
- st.session_state.new_name:str
- st.session_state.changename:bool
- st.session_state.well = None
-
- st.write("4.1 Rename curves")
-
- st.session_state.selected_well_rename = None
- selected_well_rename = st.selectbox("Select Well", list_well, key="well_selectbox")
-
- well_to_las = {}
- well = []
- data_rename_1 =[]
- df_all_full = pd.DataFrame()
- st.session_state.selected_well_rename = None
- for i in range(len(well_names)):
- well_to_las[well_names[i]] = las_data_list[i]
- # print("key: ",well_names[i][:len(selected_well_rename)], " value: ",las_data_list[i])
- if selected_well_rename == well_names[i][:len(selected_well_rename)]:
- las = las_data_list[i]
- break
- # print("In ra las:", las)
- well = las.df()
- well['WELL'] = las.well.WELL.value
- # print("In ra well2:", well)
- curves = well.columns.tolist()
- # print ("print ra cuvers:", curves) # save the number of curves for the selected well in session state
- st.session_state.num_curves = len(curves)
- df_rename = pd.DataFrame()
- st.session_state.selected_well_rename = df_rename
- st.session_state.selected_well_rename = well
-
-import pandas as pd
-
-# Khởi tạo DataFrame từ dữ liệu có sẵn
-# Khởi tạo thuộc tính selected_well_rename trong st.session_state
-st.session_state.setdefault('selected_well_rename', 'Default value')
-# Truy cập thuộc tính selected_well_rename
-
-data = st.session_state.selected_well_rename
-if 'columns' in data:
- n_cols = 4
- n_rows = -(-len(data.columns) // n_cols) # Round up division
- for i in range(n_rows):
- cols = st.columns(n_cols)
- for j in range(n_cols):
- idx = i * n_cols + (j-1)
- if idx < len(data.columns):
- col = data.columns[idx]
- # Lưu trữ tên cũ trong biến old_col
- old_col = col
- # new_col == well_names[i][:len(col)]
- new_col = cols[j-1].text_input(f"Enter new name for '{col}'", key=f"input_{cols}")
- # Kiểm tra nếu người dùng không nhập tên mới
- if not new_col:
- # Sử dụng tên cũ thay thế
- new_col = old_col
- data = data.rename(columns={col: new_col})
- data["DEPTH"] = well.index
- data.insert(0, 'DEPTH', data.pop('DEPTH'))
- data = data.reset_index(drop=True)
- st.dataframe(data)
-else:
- print ("Please select LAS files for input data")
-# Hiển thị lại bảng
-
-def my_function(data):
- # Lưu trữ DataFrame khi người dùng nhấn vào nút "Lưu"
- if st.button("Lưu", key="saved_rename"):
- # Tạo tên file CSV dựa trên biến selected_well_rename
- file_name = f"/work/2022_VPIMLogs_WebApp/data/change_name_logs/{selected_well_rename}.csv"
- # Lưu trữ DataFrame vào tệp CSV với tên file tương ứng
- data.to_csv(file_name, index=False)
- # Trả về giá trị của biến result
- return data
-result = my_function(data)
-
-# for name in selected_well_multi:
-# # dataframe_merged_df = pd.DataFrame()
-# merged_df = pd.read_csv("data/change_name_logs/merged_df.csv")
-# dataframe_merged_df.append(merged_df[merged_df.WELL==name])
-# dataframe_merged_df.to_csv("data/change_name_logs/merged_df.csv")
-# st.dataframe(dataframe_merged_df, width=1400)
-
-
-selected_well_multi= st.multiselect(" 4.3 Select well for download", list_well, key = 'selected_well_multi_lasts')
-# dowload_dataframes_df = pd.DataFrame()
-st.session_state.changename_download = st.button("Create", key="selected_well_multi_rename_curve_111")
-# Đường dẫn đến thư mục chứa các file csv
-dir_path = '/work/2022_VPIMLogs_WebApp/data/change_name_logs/'
-if st.session_state.changename_download:
- # Tạo một DataFrame rỗng để chứa dữ liệu
- merged_df = pd.DataFrame()
- dataframe_merged_df = pd.DataFrame()
- # Duyệt qua tất cả các file trong thư mục và gộp chúng vào DataFrame
- for filename in os.listdir(dir_path):
- if filename.endswith('.csv'):
- filepath = os.path.join(dir_path, filename)
- df = pd.read_csv(filepath)
- merged_df = pd.concat([merged_df, df], ignore_index=True).reset_index(drop=True)
- merged_df.to_csv(f"/work/2022_VPIMLogs_WebApp/data/merged/{selected_well_multi}_merged_df.csv")
- dataframes_df = pd.read_csv(f"/work/2022_VPIMLogs_WebApp/data/merged/{selected_well_multi}_merged_df.csv")
- st.session_state.selected_well_multi = dataframes_df.loc[dataframes_df['WELL'].isin(selected_well_multi)].reset_index(drop=True).drop('Unnamed: 0', axis = 1)
-
- st.dataframe(st.session_state.selected_well_multi , width=1400)
- # 4.3_DOWNLOAD-----------------------------------------------------------------
- st.write("4.3 Download well curves with renamed names")
- st.download_button(label='Download CSV File',
- data = st.session_state.selected_well_multi.to_csv(),
- file_name=f"{selected_well_multi}.csv",
- mime='text/csv')
- for filename in os.listdir(dir_path):
- if filename.endswith('.csv'):
- os.remove(os.path.join(dir_path, filename))
-#'''Adding the ‘download’ tag attribute as shown below allows you to provide a file name and extension.
-#f'Download csv file'''
-
-hide_menu_button()
-condense_layout()
\ No newline at end of file
diff --git "a/spaces/SouthCity/ShuruiXu/crazy_functions/\350\257\273\346\226\207\347\253\240\345\206\231\346\221\230\350\246\201.py" "b/spaces/SouthCity/ShuruiXu/crazy_functions/\350\257\273\346\226\207\347\253\240\345\206\231\346\221\230\350\246\201.py"
deleted file mode 100644
index b7c508e17f82a91952be672f2c92034ce40f8445..0000000000000000000000000000000000000000
--- "a/spaces/SouthCity/ShuruiXu/crazy_functions/\350\257\273\346\226\207\347\253\240\345\206\231\346\221\230\350\246\201.py"
+++ /dev/null
@@ -1,70 +0,0 @@
-from predict import predict_no_ui
-from toolbox import CatchException, report_execption, write_results_to_file, predict_no_ui_but_counting_down
-fast_debug = False
-
-
-def 解析Paper(file_manifest, project_folder, top_p, api_key, temperature, chatbot, history, systemPromptTxt):
- import time, glob, os
- print('begin analysis on:', file_manifest)
- for index, fp in enumerate(file_manifest):
- with open(fp, 'r', encoding='utf-8') as f:
- file_content = f.read()
-
- prefix = "接下来请你逐文件分析下面的论文文件，概括其内容" if index==0 else ""
- i_say = prefix + f'请对下面的文章片段用中文做一个概述，文件名是{os.path.relpath(fp, project_folder)}，文章内容是 ```{file_content}```'
- i_say_show_user = prefix + f'[{index}/{len(file_manifest)}] 请对下面的文章片段做一个概述: {os.path.abspath(fp)}'
- chatbot.append((i_say_show_user, "[Local Message] waiting gpt response."))
- print('[1] yield chatbot, history')
- yield chatbot, history, '正常'
-
- if not fast_debug:
- msg = '正常'
- # ** gpt request **
- gpt_say = yield from predict_no_ui_but_counting_down(i_say, i_say_show_user, chatbot, top_p, api_key, temperature, history=[]) # 带超时倒计时
-
- print('[2] end gpt req')
- chatbot[-1] = (i_say_show_user, gpt_say)
- history.append(i_say_show_user); history.append(gpt_say)
- print('[3] yield chatbot, history')
- yield chatbot, history, msg
- print('[4] next')
- if not fast_debug: time.sleep(2)
-
- all_file = ', '.join([os.path.relpath(fp, project_folder) for index, fp in enumerate(file_manifest)])
- i_say = f'根据以上你自己的分析，对全文进行概括，用学术性语言写一段中文摘要，然后再写一段英文摘要（包括{all_file}）。'
- chatbot.append((i_say, "[Local Message] waiting gpt response."))
- yield chatbot, history, '正常'
-
- if not fast_debug:
- msg = '正常'
- # ** gpt request **
- gpt_say = yield from predict_no_ui_but_counting_down(i_say, i_say, chatbot, top_p, api_key, temperature, history=history) # 带超时倒计时
-
- chatbot[-1] = (i_say, gpt_say)
- history.append(i_say); history.append(gpt_say)
- yield chatbot, history, msg
- res = write_results_to_file(history)
- chatbot.append(("完成了吗？", res))
- yield chatbot, history, msg
-
-
-
-@CatchException
-def 读文章写摘要(txt, top_p, api_key, temperature, chatbot, history, systemPromptTxt, WEB_PORT):
- history = [] # 清空历史，以免输入溢出
- import glob, os
- if os.path.exists(txt):
- project_folder = txt
- else:
- if txt == "": txt = '空空如也的输入栏'
- report_execption(chatbot, history, a = f"解析项目: {txt}", b = f"找不到本地项目或无权访问: {txt}")
- yield chatbot, history, '正常'
- return
- file_manifest = [f for f in glob.glob(f'{project_folder}/**/*.tex', recursive=True)] # + \
- # [f for f in glob.glob(f'{project_folder}/**/*.cpp', recursive=True)] + \
- # [f for f in glob.glob(f'{project_folder}/**/*.c', recursive=True)]
- if len(file_manifest) == 0:
- report_execption(chatbot, history, a = f"解析项目: {txt}", b = f"找不到任何.tex文件: {txt}")
- yield chatbot, history, '正常'
- return
- yield from 解析Paper(file_manifest, project_folder, top_p, api_key, temperature, chatbot, history, systemPromptTxt)
diff --git a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/IPython/utils/timing.py b/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/IPython/utils/timing.py
deleted file mode 100644
index 3a181ae7288f4c33f96f29596019b63fe9796c0b..0000000000000000000000000000000000000000
--- a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/IPython/utils/timing.py
+++ /dev/null
@@ -1,123 +0,0 @@
-# encoding: utf-8
-"""
-Utilities for timing code execution.
-"""
-
-#-----------------------------------------------------------------------------
-# Copyright (C) 2008-2011 The IPython Development Team
-#
-# Distributed under the terms of the BSD License. The full license is in
-# the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import time
-
-#-----------------------------------------------------------------------------
-# Code
-#-----------------------------------------------------------------------------
-
-# If possible (Unix), use the resource module instead of time.clock()
-try:
- import resource
-except ImportError:
- resource = None
-
-# Some implementations (like jyputerlite) don't have getrusage
-if resource is not None and hasattr(resource, "getrusage"):
- def clocku():
- """clocku() -> floating point number
-
- Return the *USER* CPU time in seconds since the start of the process.
- This is done via a call to resource.getrusage, so it avoids the
- wraparound problems in time.clock()."""
-
- return resource.getrusage(resource.RUSAGE_SELF)[0]
-
- def clocks():
- """clocks() -> floating point number
-
- Return the *SYSTEM* CPU time in seconds since the start of the process.
- This is done via a call to resource.getrusage, so it avoids the
- wraparound problems in time.clock()."""
-
- return resource.getrusage(resource.RUSAGE_SELF)[1]
-
- def clock():
- """clock() -> floating point number
-
- Return the *TOTAL USER+SYSTEM* CPU time in seconds since the start of
- the process. This is done via a call to resource.getrusage, so it
- avoids the wraparound problems in time.clock()."""
-
- u,s = resource.getrusage(resource.RUSAGE_SELF)[:2]
- return u+s
-
- def clock2():
- """clock2() -> (t_user,t_system)
-
- Similar to clock(), but return a tuple of user/system times."""
- return resource.getrusage(resource.RUSAGE_SELF)[:2]
-
-else:
- # There is no distinction of user/system time under windows, so we just use
- # time.process_time() for everything...
- clocku = clocks = clock = time.process_time
-
- def clock2():
- """Under windows, system CPU time can't be measured.
-
- This just returns process_time() and zero."""
- return time.process_time(), 0.0
-
-
-def timings_out(reps,func,*args,**kw):
- """timings_out(reps,func,*args,**kw) -> (t_total,t_per_call,output)
-
- Execute a function reps times, return a tuple with the elapsed total
- CPU time in seconds, the time per call and the function's output.
-
- Under Unix, the return value is the sum of user+system time consumed by
- the process, computed via the resource module. This prevents problems
- related to the wraparound effect which the time.clock() function has.
-
- Under Windows the return value is in wall clock seconds. See the
- documentation for the time module for more details."""
-
- reps = int(reps)
- assert reps >=1, 'reps must be >= 1'
- if reps==1:
- start = clock()
- out = func(*args,**kw)
- tot_time = clock()-start
- else:
- rng = range(reps-1) # the last time is executed separately to store output
- start = clock()
- for dummy in rng: func(*args,**kw)
- out = func(*args,**kw) # one last time
- tot_time = clock()-start
- av_time = tot_time / reps
- return tot_time,av_time,out
-
-
-def timings(reps,func,*args,**kw):
- """timings(reps,func,*args,**kw) -> (t_total,t_per_call)
-
- Execute a function reps times, return a tuple with the elapsed total CPU
- time in seconds and the time per call. These are just the first two values
- in timings_out()."""
-
- return timings_out(reps,func,*args,**kw)[0:2]
-
-
-def timing(func,*args,**kw):
- """timing(func,*args,**kw) -> t_total
-
- Execute a function once, return the elapsed total CPU time in
- seconds. This is just the first value in timings_out()."""
-
- return timings_out(1,func,*args,**kw)[0]
-
diff --git a/spaces/Superlang/ImageProcessor/annotator/uniformer/configs/_base_/models/apcnet_r50-d8.py b/spaces/Superlang/ImageProcessor/annotator/uniformer/configs/_base_/models/apcnet_r50-d8.py
deleted file mode 100644
index c8f5316cbcf3896ba9de7ca2c801eba512f01d5e..0000000000000000000000000000000000000000
--- a/spaces/Superlang/ImageProcessor/annotator/uniformer/configs/_base_/models/apcnet_r50-d8.py
+++ /dev/null
@@ -1,44 +0,0 @@
-# model settings
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
- type='EncoderDecoder',
- pretrained='open-mmlab://resnet50_v1c',
- backbone=dict(
- type='ResNetV1c',
- depth=50,
- num_stages=4,
- out_indices=(0, 1, 2, 3),
- dilations=(1, 1, 2, 4),
- strides=(1, 2, 1, 1),
- norm_cfg=norm_cfg,
- norm_eval=False,
- style='pytorch',
- contract_dilation=True),
- decode_head=dict(
- type='APCHead',
- in_channels=2048,
- in_index=3,
- channels=512,
- pool_scales=(1, 2, 3, 6),
- dropout_ratio=0.1,
- num_classes=19,
- norm_cfg=dict(type='SyncBN', requires_grad=True),
- align_corners=False,
- loss_decode=dict(
- type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
- auxiliary_head=dict(
- type='FCNHead',
- in_channels=1024,
- in_index=2,
- channels=256,
- num_convs=1,
- concat_input=False,
- dropout_ratio=0.1,
- num_classes=19,
- norm_cfg=norm_cfg,
- align_corners=False,
- loss_decode=dict(
- type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
- # model training and testing settings
- train_cfg=dict(),
- test_cfg=dict(mode='whole'))
diff --git a/spaces/Superlang/ImageProcessor/annotator/uniformer/mmcv/runner/checkpoint.py b/spaces/Superlang/ImageProcessor/annotator/uniformer/mmcv/runner/checkpoint.py
deleted file mode 100644
index b29ca320679164432f446adad893e33fb2b4b29e..0000000000000000000000000000000000000000
--- a/spaces/Superlang/ImageProcessor/annotator/uniformer/mmcv/runner/checkpoint.py
+++ /dev/null
@@ -1,707 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import io
-import os
-import os.path as osp
-import pkgutil
-import re
-import time
-import warnings
-from collections import OrderedDict
-from importlib import import_module
-from tempfile import TemporaryDirectory
-
-import torch
-import torchvision
-from torch.optim import Optimizer
-from torch.utils import model_zoo
-
-import annotator.uniformer.mmcv as mmcv
-from ..fileio import FileClient
-from ..fileio import load as load_file
-from ..parallel import is_module_wrapper
-from ..utils import mkdir_or_exist
-from .dist_utils import get_dist_info
-
-ENV_MMCV_HOME = 'MMCV_HOME'
-ENV_XDG_CACHE_HOME = 'XDG_CACHE_HOME'
-DEFAULT_CACHE_DIR = '~/.cache'
-
-
-def _get_mmcv_home():
- mmcv_home = os.path.expanduser(
- os.getenv(
- ENV_MMCV_HOME,
- os.path.join(
- os.getenv(ENV_XDG_CACHE_HOME, DEFAULT_CACHE_DIR), 'mmcv')))
-
- mkdir_or_exist(mmcv_home)
- return mmcv_home
-
-
-def load_state_dict(module, state_dict, strict=False, logger=None):
- """Load state_dict to a module.
-
- This method is modified from :meth:`torch.nn.Module.load_state_dict`.
- Default value for ``strict`` is set to ``False`` and the message for
- param mismatch will be shown even if strict is False.
-
- Args:
- module (Module): Module that receives the state_dict.
- state_dict (OrderedDict): Weights.
- strict (bool): whether to strictly enforce that the keys
- in :attr:`state_dict` match the keys returned by this module's
- :meth:`~torch.nn.Module.state_dict` function. Default: ``False``.
- logger (:obj:`logging.Logger`, optional): Logger to log the error
- message. If not specified, print function will be used.
- """
- unexpected_keys = []
- all_missing_keys = []
- err_msg = []
-
- metadata = getattr(state_dict, '_metadata', None)
- state_dict = state_dict.copy()
- if metadata is not None:
- state_dict._metadata = metadata
-
- # use _load_from_state_dict to enable checkpoint version control
- def load(module, prefix=''):
- # recursively check parallel module in case that the model has a
- # complicated structure, e.g., nn.Module(nn.Module(DDP))
- if is_module_wrapper(module):
- module = module.module
- local_metadata = {} if metadata is None else metadata.get(
- prefix[:-1], {})
- module._load_from_state_dict(state_dict, prefix, local_metadata, True,
- all_missing_keys, unexpected_keys,
- err_msg)
- for name, child in module._modules.items():
- if child is not None:
- load(child, prefix + name + '.')
-
- load(module)
- load = None # break load->load reference cycle
-
- # ignore "num_batches_tracked" of BN layers
- missing_keys = [
- key for key in all_missing_keys if 'num_batches_tracked' not in key
- ]
-
- if unexpected_keys:
- err_msg.append('unexpected key in source '
- f'state_dict: {", ".join(unexpected_keys)}\n')
- if missing_keys:
- err_msg.append(
- f'missing keys in source state_dict: {", ".join(missing_keys)}\n')
-
- rank, _ = get_dist_info()
- if len(err_msg) > 0 and rank == 0:
- err_msg.insert(
- 0, 'The model and loaded state dict do not match exactly\n')
- err_msg = '\n'.join(err_msg)
- if strict:
- raise RuntimeError(err_msg)
- elif logger is not None:
- logger.warning(err_msg)
- else:
- print(err_msg)
-
-
-def get_torchvision_models():
- model_urls = dict()
- for _, name, ispkg in pkgutil.walk_packages(torchvision.models.__path__):
- if ispkg:
- continue
- _zoo = import_module(f'torchvision.models.{name}')
- if hasattr(_zoo, 'model_urls'):
- _urls = getattr(_zoo, 'model_urls')
- model_urls.update(_urls)
- return model_urls
-
-
-def get_external_models():
- mmcv_home = _get_mmcv_home()
- default_json_path = osp.join(mmcv.__path__[0], 'model_zoo/open_mmlab.json')
- default_urls = load_file(default_json_path)
- assert isinstance(default_urls, dict)
- external_json_path = osp.join(mmcv_home, 'open_mmlab.json')
- if osp.exists(external_json_path):
- external_urls = load_file(external_json_path)
- assert isinstance(external_urls, dict)
- default_urls.update(external_urls)
-
- return default_urls
-
-
-def get_mmcls_models():
- mmcls_json_path = osp.join(mmcv.__path__[0], 'model_zoo/mmcls.json')
- mmcls_urls = load_file(mmcls_json_path)
-
- return mmcls_urls
-
-
-def get_deprecated_model_names():
- deprecate_json_path = osp.join(mmcv.__path__[0],
- 'model_zoo/deprecated.json')
- deprecate_urls = load_file(deprecate_json_path)
- assert isinstance(deprecate_urls, dict)
-
- return deprecate_urls
-
-
-def _process_mmcls_checkpoint(checkpoint):
- state_dict = checkpoint['state_dict']
- new_state_dict = OrderedDict()
- for k, v in state_dict.items():
- if k.startswith('backbone.'):
- new_state_dict[k[9:]] = v
- new_checkpoint = dict(state_dict=new_state_dict)
-
- return new_checkpoint
-
-
-class CheckpointLoader:
- """A general checkpoint loader to manage all schemes."""
-
- _schemes = {}
-
- @classmethod
- def _register_scheme(cls, prefixes, loader, force=False):
- if isinstance(prefixes, str):
- prefixes = [prefixes]
- else:
- assert isinstance(prefixes, (list, tuple))
- for prefix in prefixes:
- if (prefix not in cls._schemes) or force:
- cls._schemes[prefix] = loader
- else:
- raise KeyError(
- f'{prefix} is already registered as a loader backend, '
- 'add "force=True" if you want to override it')
- # sort, longer prefixes take priority
- cls._schemes = OrderedDict(
- sorted(cls._schemes.items(), key=lambda t: t[0], reverse=True))
-
- @classmethod
- def register_scheme(cls, prefixes, loader=None, force=False):
- """Register a loader to CheckpointLoader.
-
- This method can be used as a normal class method or a decorator.
-
- Args:
- prefixes (str or list[str] or tuple[str]):
- The prefix of the registered loader.
- loader (function, optional): The loader function to be registered.
- When this method is used as a decorator, loader is None.
- Defaults to None.
- force (bool, optional): Whether to override the loader
- if the prefix has already been registered. Defaults to False.
- """
-
- if loader is not None:
- cls._register_scheme(prefixes, loader, force=force)
- return
-
- def _register(loader_cls):
- cls._register_scheme(prefixes, loader_cls, force=force)
- return loader_cls
-
- return _register
-
- @classmethod
- def _get_checkpoint_loader(cls, path):
- """Finds a loader that supports the given path. Falls back to the local
- loader if no other loader is found.
-
- Args:
- path (str): checkpoint path
-
- Returns:
- loader (function): checkpoint loader
- """
-
- for p in cls._schemes:
- if path.startswith(p):
- return cls._schemes[p]
-
- @classmethod
- def load_checkpoint(cls, filename, map_location=None, logger=None):
- """load checkpoint through URL scheme path.
-
- Args:
- filename (str): checkpoint file name with given prefix
- map_location (str, optional): Same as :func:`torch.load`.
- Default: None
- logger (:mod:`logging.Logger`, optional): The logger for message.
- Default: None
-
- Returns:
- dict or OrderedDict: The loaded checkpoint.
- """
-
- checkpoint_loader = cls._get_checkpoint_loader(filename)
- class_name = checkpoint_loader.__name__
- mmcv.print_log(
- f'load checkpoint from {class_name[10:]} path: {filename}', logger)
- return checkpoint_loader(filename, map_location)
-
-
-@CheckpointLoader.register_scheme(prefixes='')
-def load_from_local(filename, map_location):
- """load checkpoint by local file path.
-
- Args:
- filename (str): local checkpoint file path
- map_location (str, optional): Same as :func:`torch.load`.
-
- Returns:
- dict or OrderedDict: The loaded checkpoint.
- """
-
- if not osp.isfile(filename):
- raise IOError(f'{filename} is not a checkpoint file')
- checkpoint = torch.load(filename, map_location=map_location)
- return checkpoint
-
-
-@CheckpointLoader.register_scheme(prefixes=('http://', 'https://'))
-def load_from_http(filename, map_location=None, model_dir=None):
- """load checkpoint through HTTP or HTTPS scheme path. In distributed
- setting, this function only download checkpoint at local rank 0.
-
- Args:
- filename (str): checkpoint file path with modelzoo or
- torchvision prefix
- map_location (str, optional): Same as :func:`torch.load`.
- model_dir (string, optional): directory in which to save the object,
- Default: None
-
- Returns:
- dict or OrderedDict: The loaded checkpoint.
- """
- rank, world_size = get_dist_info()
- rank = int(os.environ.get('LOCAL_RANK', rank))
- if rank == 0:
- checkpoint = model_zoo.load_url(
- filename, model_dir=model_dir, map_location=map_location)
- if world_size > 1:
- torch.distributed.barrier()
- if rank > 0:
- checkpoint = model_zoo.load_url(
- filename, model_dir=model_dir, map_location=map_location)
- return checkpoint
-
-
-@CheckpointLoader.register_scheme(prefixes='pavi://')
-def load_from_pavi(filename, map_location=None):
- """load checkpoint through the file path prefixed with pavi. In distributed
- setting, this function download ckpt at all ranks to different temporary
- directories.
-
- Args:
- filename (str): checkpoint file path with pavi prefix
- map_location (str, optional): Same as :func:`torch.load`.
- Default: None
-
- Returns:
- dict or OrderedDict: The loaded checkpoint.
- """
- assert filename.startswith('pavi://'), \
- f'Expected filename startswith `pavi://`, but get {filename}'
- model_path = filename[7:]
-
- try:
- from pavi import modelcloud
- except ImportError:
- raise ImportError(
- 'Please install pavi to load checkpoint from modelcloud.')
-
- model = modelcloud.get(model_path)
- with TemporaryDirectory() as tmp_dir:
- downloaded_file = osp.join(tmp_dir, model.name)
- model.download(downloaded_file)
- checkpoint = torch.load(downloaded_file, map_location=map_location)
- return checkpoint
-
-
-@CheckpointLoader.register_scheme(prefixes='s3://')
-def load_from_ceph(filename, map_location=None, backend='petrel'):
- """load checkpoint through the file path prefixed with s3. In distributed
- setting, this function download ckpt at all ranks to different temporary
- directories.
-
- Args:
- filename (str): checkpoint file path with s3 prefix
- map_location (str, optional): Same as :func:`torch.load`.
- backend (str, optional): The storage backend type. Options are 'ceph',
- 'petrel'. Default: 'petrel'.
-
- .. warning::
- :class:`mmcv.fileio.file_client.CephBackend` will be deprecated,
- please use :class:`mmcv.fileio.file_client.PetrelBackend` instead.
-
- Returns:
- dict or OrderedDict: The loaded checkpoint.
- """
- allowed_backends = ['ceph', 'petrel']
- if backend not in allowed_backends:
- raise ValueError(f'Load from Backend {backend} is not supported.')
-
- if backend == 'ceph':
- warnings.warn(
- 'CephBackend will be deprecated, please use PetrelBackend instead')
-
- # CephClient and PetrelBackend have the same prefix 's3://' and the latter
- # will be chosen as default. If PetrelBackend can not be instantiated
- # successfully, the CephClient will be chosen.
- try:
- file_client = FileClient(backend=backend)
- except ImportError:
- allowed_backends.remove(backend)
- file_client = FileClient(backend=allowed_backends[0])
-
- with io.BytesIO(file_client.get(filename)) as buffer:
- checkpoint = torch.load(buffer, map_location=map_location)
- return checkpoint
-
-
-@CheckpointLoader.register_scheme(prefixes=('modelzoo://', 'torchvision://'))
-def load_from_torchvision(filename, map_location=None):
- """load checkpoint through the file path prefixed with modelzoo or
- torchvision.
-
- Args:
- filename (str): checkpoint file path with modelzoo or
- torchvision prefix
- map_location (str, optional): Same as :func:`torch.load`.
-
- Returns:
- dict or OrderedDict: The loaded checkpoint.
- """
- model_urls = get_torchvision_models()
- if filename.startswith('modelzoo://'):
- warnings.warn('The URL scheme of "modelzoo://" is deprecated, please '
- 'use "torchvision://" instead')
- model_name = filename[11:]
- else:
- model_name = filename[14:]
- return load_from_http(model_urls[model_name], map_location=map_location)
-
-
-@CheckpointLoader.register_scheme(prefixes=('open-mmlab://', 'openmmlab://'))
-def load_from_openmmlab(filename, map_location=None):
- """load checkpoint through the file path prefixed with open-mmlab or
- openmmlab.
-
- Args:
- filename (str): checkpoint file path with open-mmlab or
- openmmlab prefix
- map_location (str, optional): Same as :func:`torch.load`.
- Default: None
-
- Returns:
- dict or OrderedDict: The loaded checkpoint.
- """
-
- model_urls = get_external_models()
- prefix_str = 'open-mmlab://'
- if filename.startswith(prefix_str):
- model_name = filename[13:]
- else:
- model_name = filename[12:]
- prefix_str = 'openmmlab://'
-
- deprecated_urls = get_deprecated_model_names()
- if model_name in deprecated_urls:
- warnings.warn(f'{prefix_str}{model_name} is deprecated in favor '
- f'of {prefix_str}{deprecated_urls[model_name]}')
- model_name = deprecated_urls[model_name]
- model_url = model_urls[model_name]
- # check if is url
- if model_url.startswith(('http://', 'https://')):
- checkpoint = load_from_http(model_url, map_location=map_location)
- else:
- filename = osp.join(_get_mmcv_home(), model_url)
- if not osp.isfile(filename):
- raise IOError(f'{filename} is not a checkpoint file')
- checkpoint = torch.load(filename, map_location=map_location)
- return checkpoint
-
-
-@CheckpointLoader.register_scheme(prefixes='mmcls://')
-def load_from_mmcls(filename, map_location=None):
- """load checkpoint through the file path prefixed with mmcls.
-
- Args:
- filename (str): checkpoint file path with mmcls prefix
- map_location (str, optional): Same as :func:`torch.load`.
-
- Returns:
- dict or OrderedDict: The loaded checkpoint.
- """
-
- model_urls = get_mmcls_models()
- model_name = filename[8:]
- checkpoint = load_from_http(
- model_urls[model_name], map_location=map_location)
- checkpoint = _process_mmcls_checkpoint(checkpoint)
- return checkpoint
-
-
-def _load_checkpoint(filename, map_location=None, logger=None):
- """Load checkpoint from somewhere (modelzoo, file, url).
-
- Args:
- filename (str): Accept local filepath, URL, ``torchvision://xxx``,
- ``open-mmlab://xxx``. Please refer to ``docs/model_zoo.md`` for
- details.
- map_location (str, optional): Same as :func:`torch.load`.
- Default: None.
- logger (:mod:`logging.Logger`, optional): The logger for error message.
- Default: None
-
- Returns:
- dict or OrderedDict: The loaded checkpoint. It can be either an
- OrderedDict storing model weights or a dict containing other
- information, which depends on the checkpoint.
- """
- return CheckpointLoader.load_checkpoint(filename, map_location, logger)
-
-
-def _load_checkpoint_with_prefix(prefix, filename, map_location=None):
- """Load partial pretrained model with specific prefix.
-
- Args:
- prefix (str): The prefix of sub-module.
- filename (str): Accept local filepath, URL, ``torchvision://xxx``,
- ``open-mmlab://xxx``. Please refer to ``docs/model_zoo.md`` for
- details.
- map_location (str | None): Same as :func:`torch.load`. Default: None.
-
- Returns:
- dict or OrderedDict: The loaded checkpoint.
- """
-
- checkpoint = _load_checkpoint(filename, map_location=map_location)
-
- if 'state_dict' in checkpoint:
- state_dict = checkpoint['state_dict']
- else:
- state_dict = checkpoint
- if not prefix.endswith('.'):
- prefix += '.'
- prefix_len = len(prefix)
-
- state_dict = {
- k[prefix_len:]: v
- for k, v in state_dict.items() if k.startswith(prefix)
- }
-
- assert state_dict, f'{prefix} is not in the pretrained model'
- return state_dict
-
-
-def load_checkpoint(model,
- filename,
- map_location=None,
- strict=False,
- logger=None,
- revise_keys=[(r'^module\.', '')]):
- """Load checkpoint from a file or URI.
-
- Args:
- model (Module): Module to load checkpoint.
- filename (str): Accept local filepath, URL, ``torchvision://xxx``,
- ``open-mmlab://xxx``. Please refer to ``docs/model_zoo.md`` for
- details.
- map_location (str): Same as :func:`torch.load`.
- strict (bool): Whether to allow different params for the model and
- checkpoint.
- logger (:mod:`logging.Logger` or None): The logger for error message.
- revise_keys (list): A list of customized keywords to modify the
- state_dict in checkpoint. Each item is a (pattern, replacement)
- pair of the regular expression operations. Default: strip
- the prefix 'module.' by [(r'^module\\.', '')].
-
- Returns:
- dict or OrderedDict: The loaded checkpoint.
- """
- checkpoint = _load_checkpoint(filename, map_location, logger)
- # OrderedDict is a subclass of dict
- if not isinstance(checkpoint, dict):
- raise RuntimeError(
- f'No state_dict found in checkpoint file {filename}')
- # get state_dict from checkpoint
- if 'state_dict' in checkpoint:
- state_dict = checkpoint['state_dict']
- else:
- state_dict = checkpoint
-
- # strip prefix of state_dict
- metadata = getattr(state_dict, '_metadata', OrderedDict())
- for p, r in revise_keys:
- state_dict = OrderedDict(
- {re.sub(p, r, k): v
- for k, v in state_dict.items()})
- # Keep metadata in state_dict
- state_dict._metadata = metadata
-
- # load state_dict
- load_state_dict(model, state_dict, strict, logger)
- return checkpoint
-
-
-def weights_to_cpu(state_dict):
- """Copy a model state_dict to cpu.
-
- Args:
- state_dict (OrderedDict): Model weights on GPU.
-
- Returns:
- OrderedDict: Model weights on GPU.
- """
- state_dict_cpu = OrderedDict()
- for key, val in state_dict.items():
- state_dict_cpu[key] = val.cpu()
- # Keep metadata in state_dict
- state_dict_cpu._metadata = getattr(state_dict, '_metadata', OrderedDict())
- return state_dict_cpu
-
-
-def _save_to_state_dict(module, destination, prefix, keep_vars):
- """Saves module state to `destination` dictionary.
-
- This method is modified from :meth:`torch.nn.Module._save_to_state_dict`.
-
- Args:
- module (nn.Module): The module to generate state_dict.
- destination (dict): A dict where state will be stored.
- prefix (str): The prefix for parameters and buffers used in this
- module.
- """
- for name, param in module._parameters.items():
- if param is not None:
- destination[prefix + name] = param if keep_vars else param.detach()
- for name, buf in module._buffers.items():
- # remove check of _non_persistent_buffers_set to allow nn.BatchNorm2d
- if buf is not None:
- destination[prefix + name] = buf if keep_vars else buf.detach()
-
-
-def get_state_dict(module, destination=None, prefix='', keep_vars=False):
- """Returns a dictionary containing a whole state of the module.
-
- Both parameters and persistent buffers (e.g. running averages) are
- included. Keys are corresponding parameter and buffer names.
-
- This method is modified from :meth:`torch.nn.Module.state_dict` to
- recursively check parallel module in case that the model has a complicated
- structure, e.g., nn.Module(nn.Module(DDP)).
-
- Args:
- module (nn.Module): The module to generate state_dict.
- destination (OrderedDict): Returned dict for the state of the
- module.
- prefix (str): Prefix of the key.
- keep_vars (bool): Whether to keep the variable property of the
- parameters. Default: False.
-
- Returns:
- dict: A dictionary containing a whole state of the module.
- """
- # recursively check parallel module in case that the model has a
- # complicated structure, e.g., nn.Module(nn.Module(DDP))
- if is_module_wrapper(module):
- module = module.module
-
- # below is the same as torch.nn.Module.state_dict()
- if destination is None:
- destination = OrderedDict()
- destination._metadata = OrderedDict()
- destination._metadata[prefix[:-1]] = local_metadata = dict(
- version=module._version)
- _save_to_state_dict(module, destination, prefix, keep_vars)
- for name, child in module._modules.items():
- if child is not None:
- get_state_dict(
- child, destination, prefix + name + '.', keep_vars=keep_vars)
- for hook in module._state_dict_hooks.values():
- hook_result = hook(module, destination, prefix, local_metadata)
- if hook_result is not None:
- destination = hook_result
- return destination
-
-
-def save_checkpoint(model,
- filename,
- optimizer=None,
- meta=None,
- file_client_args=None):
- """Save checkpoint to file.
-
- The checkpoint will have 3 fields: ``meta``, ``state_dict`` and
- ``optimizer``. By default ``meta`` will contain version and time info.
-
- Args:
- model (Module): Module whose params are to be saved.
- filename (str): Checkpoint filename.
- optimizer (:obj:`Optimizer`, optional): Optimizer to be saved.
- meta (dict, optional): Metadata to be saved in checkpoint.
- file_client_args (dict, optional): Arguments to instantiate a
- FileClient. See :class:`mmcv.fileio.FileClient` for details.
- Default: None.
- `New in version 1.3.16.`
- """
- if meta is None:
- meta = {}
- elif not isinstance(meta, dict):
- raise TypeError(f'meta must be a dict or None, but got {type(meta)}')
- meta.update(mmcv_version=mmcv.__version__, time=time.asctime())
-
- if is_module_wrapper(model):
- model = model.module
-
- if hasattr(model, 'CLASSES') and model.CLASSES is not None:
- # save class name to the meta
- meta.update(CLASSES=model.CLASSES)
-
- checkpoint = {
- 'meta': meta,
- 'state_dict': weights_to_cpu(get_state_dict(model))
- }
- # save optimizer state dict in the checkpoint
- if isinstance(optimizer, Optimizer):
- checkpoint['optimizer'] = optimizer.state_dict()
- elif isinstance(optimizer, dict):
- checkpoint['optimizer'] = {}
- for name, optim in optimizer.items():
- checkpoint['optimizer'][name] = optim.state_dict()
-
- if filename.startswith('pavi://'):
- if file_client_args is not None:
- raise ValueError(
- 'file_client_args should be "None" if filename starts with'
- f'"pavi://", but got {file_client_args}')
- try:
- from pavi import modelcloud
- from pavi import exception
- except ImportError:
- raise ImportError(
- 'Please install pavi to load checkpoint from modelcloud.')
- model_path = filename[7:]
- root = modelcloud.Folder()
- model_dir, model_name = osp.split(model_path)
- try:
- model = modelcloud.get(model_dir)
- except exception.NodeNotFoundError:
- model = root.create_training_model(model_dir)
- with TemporaryDirectory() as tmp_dir:
- checkpoint_file = osp.join(tmp_dir, model_name)
- with open(checkpoint_file, 'wb') as f:
- torch.save(checkpoint, f)
- f.flush()
- model.create_file(checkpoint_file, name=model_name)
- else:
- file_client = FileClient.infer_client(file_client_args, filename)
- with io.BytesIO() as f:
- torch.save(checkpoint, f)
- file_client.put(f.getvalue(), filename)
diff --git a/spaces/TNR-5/semantic-image-search.img/README.md b/spaces/TNR-5/semantic-image-search.img/README.md
deleted file mode 100644
index 2dc5f872cd6136820ef584467b1c9985ca0e634d..0000000000000000000000000000000000000000
--- a/spaces/TNR-5/semantic-image-search.img/README.md
+++ /dev/null
@@ -1,45 +0,0 @@
----
-title: Semantic Image Search
-emoji: 🔍
-colorFrom: green
-colorTo: indigo
-sdk: docker
-pinned: false
-app_port: 3000
-duplicated_from: Xenova/semantic-image-search
----
-
-This is a [Next.js](https://nextjs.org/) project bootstrapped with [`create-next-app`](https://github.com/vercel/next.js/tree/canary/packages/create-next-app).
-
-## Getting Started
-
-First, run the development server:
-
-```bash
-npm run dev
-# or
-yarn dev
-# or
-pnpm dev
-```
-
-Open [http://localhost:3000](http://localhost:3000) with your browser to see the result.
-
-You can start editing the page by modifying `app/page.js`. The page auto-updates as you edit the file.
-
-This project uses [`next/font`](https://nextjs.org/docs/basic-features/font-optimization) to automatically optimize and load Inter, a custom Google Font.
-
-## Learn More
-
-To learn more about Next.js, take a look at the following resources:
-
-- [Next.js Documentation](https://nextjs.org/docs) - learn about Next.js features and API.
-- [Learn Next.js](https://nextjs.org/learn) - an interactive Next.js tutorial.
-
-You can check out [the Next.js GitHub repository](https://github.com/vercel/next.js/) - your feedback and contributions are welcome!
-
-## Deploy on Vercel
-
-The easiest way to deploy your Next.js app is to use the [Vercel Platform](https://vercel.com/new?utm_medium=default-template&filter=next.js&utm_source=create-next-app&utm_campaign=create-next-app-readme) from the creators of Next.js.
-
-Check out our [Next.js deployment documentation](https://nextjs.org/docs/deployment) for more details.
diff --git a/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/wheel/cli/__init__.py b/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/wheel/cli/__init__.py
deleted file mode 100644
index c09f839546b0bd9e44d602e127c41b085085d262..0000000000000000000000000000000000000000
--- a/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/wheel/cli/__init__.py
+++ /dev/null
@@ -1,155 +0,0 @@
-"""
-Wheel command-line utility.
-"""
-
-from __future__ import annotations
-
-import argparse
-import os
-import sys
-from argparse import ArgumentTypeError
-
-
-class WheelError(Exception):
- pass
-
-
-def unpack_f(args):
- from .unpack import unpack
-
- unpack(args.wheelfile, args.dest)
-
-
-def pack_f(args):
- from .pack import pack
-
- pack(args.directory, args.dest_dir, args.build_number)
-
-
-def convert_f(args):
- from .convert import convert
-
- convert(args.files, args.dest_dir, args.verbose)
-
-
-def tags_f(args):
- from .tags import tags
-
- names = (
- tags(
- wheel,
- args.python_tag,
- args.abi_tag,
- args.platform_tag,
- args.build,
- args.remove,
- )
- for wheel in args.wheel
- )
-
- for name in names:
- print(name)
-
-
-def version_f(args):
- from .. import __version__
-
- print("wheel %s" % __version__)
-
-
-def parse_build_tag(build_tag: str) -> str:
- if not build_tag[0].isdigit():
- raise ArgumentTypeError("build tag must begin with a digit")
- elif "-" in build_tag:
- raise ArgumentTypeError("invalid character ('-') in build tag")
-
- return build_tag
-
-
-TAGS_HELP = """\
-Make a new wheel with given tags. Any tags unspecified will remain the same.
-Starting the tags with a "+" will append to the existing tags. Starting with a
-"-" will remove a tag (use --option=-TAG syntax). Multiple tags can be
-separated by ".". The original file will remain unless --remove is given. The
-output filename(s) will be displayed on stdout for further processing.
-"""
-
-
-def parser():
- p = argparse.ArgumentParser()
- s = p.add_subparsers(help="commands")
-
- unpack_parser = s.add_parser("unpack", help="Unpack wheel")
- unpack_parser.add_argument(
- "--dest", "-d", help="Destination directory", default="."
- )
- unpack_parser.add_argument("wheelfile", help="Wheel file")
- unpack_parser.set_defaults(func=unpack_f)
-
- repack_parser = s.add_parser("pack", help="Repack wheel")
- repack_parser.add_argument("directory", help="Root directory of the unpacked wheel")
- repack_parser.add_argument(
- "--dest-dir",
- "-d",
- default=os.path.curdir,
- help="Directory to store the wheel (default %(default)s)",
- )
- repack_parser.add_argument(
- "--build-number", help="Build tag to use in the wheel name"
- )
- repack_parser.set_defaults(func=pack_f)
-
- convert_parser = s.add_parser("convert", help="Convert egg or wininst to wheel")
- convert_parser.add_argument("files", nargs="*", help="Files to convert")
- convert_parser.add_argument(
- "--dest-dir",
- "-d",
- default=os.path.curdir,
- help="Directory to store wheels (default %(default)s)",
- )
- convert_parser.add_argument("--verbose", "-v", action="store_true")
- convert_parser.set_defaults(func=convert_f)
-
- tags_parser = s.add_parser(
- "tags", help="Add or replace the tags on a wheel", description=TAGS_HELP
- )
- tags_parser.add_argument("wheel", nargs="*", help="Existing wheel(s) to retag")
- tags_parser.add_argument(
- "--remove",
- action="store_true",
- help="Remove the original files, keeping only the renamed ones",
- )
- tags_parser.add_argument(
- "--python-tag", metavar="TAG", help="Specify an interpreter tag(s)"
- )
- tags_parser.add_argument("--abi-tag", metavar="TAG", help="Specify an ABI tag(s)")
- tags_parser.add_argument(
- "--platform-tag", metavar="TAG", help="Specify a platform tag(s)"
- )
- tags_parser.add_argument(
- "--build", type=parse_build_tag, metavar="BUILD", help="Specify a build tag"
- )
- tags_parser.set_defaults(func=tags_f)
-
- version_parser = s.add_parser("version", help="Print version and exit")
- version_parser.set_defaults(func=version_f)
-
- help_parser = s.add_parser("help", help="Show this help")
- help_parser.set_defaults(func=lambda args: p.print_help())
-
- return p
-
-
-def main():
- p = parser()
- args = p.parse_args()
- if not hasattr(args, "func"):
- p.print_help()
- else:
- try:
- args.func(args)
- return 0
- except WheelError as e:
- print(e, file=sys.stderr)
-
- return 1
diff --git a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/GETTING_STARTED.md b/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/GETTING_STARTED.md
deleted file mode 100644
index 404b0c8f467264d1adf61e8274e5f864e24018e8..0000000000000000000000000000000000000000
--- a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/GETTING_STARTED.md
+++ /dev/null
@@ -1,79 +0,0 @@
-## Getting Started with Detectron2
-
-This document provides a brief intro of the usage of builtin command-line tools in detectron2.
-
-For a tutorial that involves actual coding with the API,
-see our [Colab Notebook](https://colab.research.google.com/drive/16jcaJoc6bCFAQ96jDe2HwtXj7BMD_-m5)
-which covers how to run inference with an
-existing model, and how to train a builtin model on a custom dataset.
-
-
-### Inference Demo with Pre-trained Models
-
-1. Pick a model and its config file from
- [model zoo](MODEL_ZOO.md),
- for example, `mask_rcnn_R_50_FPN_3x.yaml`.
-2. We provide `demo.py` that is able to demo builtin configs. Run it with:
-```
-cd demo/
-python demo.py --config-file ../configs/COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml \
- --input input1.jpg input2.jpg \
- [--other-options]
- --opts MODEL.WEIGHTS detectron2://COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x/137849600/model_final_f10217.pkl
-```
-The configs are made for training, therefore we need to specify `MODEL.WEIGHTS` to a model from model zoo for evaluation.
-This command will run the inference and show visualizations in an OpenCV window.
-
-For details of the command line arguments, see `demo.py -h` or look at its source code
-to understand its behavior. Some common arguments are:
-* To run __on your webcam__, replace `--input files` with `--webcam`.
-* To run __on a video__, replace `--input files` with `--video-input video.mp4`.
-* To run __on cpu__, add `MODEL.DEVICE cpu` after `--opts`.
-* To save outputs to a directory (for images) or a file (for webcam or video), use `--output`.
-
-
-### Training & Evaluation in Command Line
-
-We provide two scripts in "tools/plain_train_net.py" and "tools/train_net.py",
-that are made to train all the configs provided in detectron2. You may want to
-use it as a reference to write your own training script.
-
-Compared to "train_net.py", "plain_train_net.py" supports fewer default
-features. It also includes fewer abstraction, therefore is easier to add custom
-logic.
-
-To train a model with "train_net.py", first
-setup the corresponding datasets following
-[datasets/README.md](./datasets/README.md),
-then run:
-```
-cd tools/
-./train_net.py --num-gpus 8 \
- --config-file ../configs/COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_1x.yaml
-```
-
-The configs are made for 8-GPU training.
-To train on 1 GPU, you may need to [change some parameters](https://arxiv.org/abs/1706.02677), e.g.:
-```
-./train_net.py \
- --config-file ../configs/COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_1x.yaml \
- --num-gpus 1 SOLVER.IMS_PER_BATCH 2 SOLVER.BASE_LR 0.0025
-```
-
-To evaluate a model's performance, use
-```
-./train_net.py \
- --config-file ../configs/COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_1x.yaml \
- --eval-only MODEL.WEIGHTS /path/to/checkpoint_file
-```
-For more options, see `./train_net.py -h`.
-
-### Use Detectron2 APIs in Your Code
-
-See our [Colab Notebook](https://colab.research.google.com/drive/16jcaJoc6bCFAQ96jDe2HwtXj7BMD_-m5)
-to learn how to use detectron2 APIs to:
-1. run inference with an existing model
-2. train a builtin model on a custom dataset
-
-See [detectron2/projects](https://github.com/facebookresearch/detectron2/tree/main/projects)
-for more ways to build your project on detectron2.
diff --git a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/detectron2/config/lazy.py b/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/detectron2/config/lazy.py
deleted file mode 100644
index fa5d86b427ab53ecbe992842cce71d12c5e3a141..0000000000000000000000000000000000000000
--- a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/detectron2/config/lazy.py
+++ /dev/null
@@ -1,399 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import ast
-import builtins
-import importlib
-import inspect
-import logging
-import os
-import uuid
-from collections import abc
-from contextlib import contextmanager
-from copy import deepcopy
-from dataclasses import is_dataclass
-from typing import List, Tuple, Union
-import cloudpickle
-import yaml
-from omegaconf import DictConfig, ListConfig, OmegaConf
-
-from detectron2.utils.file_io import PathManager
-from detectron2.utils.registry import _convert_target_to_string
-
-__all__ = ["LazyCall", "LazyConfig"]
-
-
-class LazyCall:
- """
- Wrap a callable so that when it's called, the call will not be executed,
- but returns a dict that describes the call.
-
- LazyCall object has to be called with only keyword arguments. Positional
- arguments are not yet supported.
-
- Examples:
- ::
- from detectron2.config import instantiate, LazyCall
-
- layer_cfg = LazyCall(nn.Conv2d)(in_channels=32, out_channels=32)
- layer_cfg.out_channels = 64 # can edit it afterwards
- layer = instantiate(layer_cfg)
- """
-
- def __init__(self, target):
- if not (callable(target) or isinstance(target, (str, abc.Mapping))):
- raise TypeError(
- f"target of LazyCall must be a callable or defines a callable! Got {target}"
- )
- self._target = target
-
- def __call__(self, **kwargs):
- if is_dataclass(self._target):
- # omegaconf object cannot hold dataclass type
- # https://github.com/omry/omegaconf/issues/784
- target = _convert_target_to_string(self._target)
- else:
- target = self._target
- kwargs["_target_"] = target
-
- return DictConfig(content=kwargs, flags={"allow_objects": True})
-
-
-def _visit_dict_config(cfg, func):
- """
- Apply func recursively to all DictConfig in cfg.
- """
- if isinstance(cfg, DictConfig):
- func(cfg)
- for v in cfg.values():
- _visit_dict_config(v, func)
- elif isinstance(cfg, ListConfig):
- for v in cfg:
- _visit_dict_config(v, func)
-
-
-def _validate_py_syntax(filename):
- # see also https://github.com/open-mmlab/mmcv/blob/master/mmcv/utils/config.py
- with PathManager.open(filename, "r") as f:
- content = f.read()
- try:
- ast.parse(content)
- except SyntaxError as e:
- raise SyntaxError(f"Config file {filename} has syntax error!") from e
-
-
-def _cast_to_config(obj):
- # if given a dict, return DictConfig instead
- if isinstance(obj, dict):
- return DictConfig(obj, flags={"allow_objects": True})
- return obj
-
-
-_CFG_PACKAGE_NAME = "detectron2._cfg_loader"
-"""
-A namespace to put all imported config into.
-"""
-
-
-def _random_package_name(filename):
- # generate a random package name when loading config files
- return _CFG_PACKAGE_NAME + str(uuid.uuid4())[:4] + "." + os.path.basename(filename)
-
-
-@contextmanager
-def _patch_import():
- """
- Enhance relative import statements in config files, so that they:
- 1. locate files purely based on relative location, regardless of packages.
- e.g. you can import file without having __init__
- 2. do not cache modules globally; modifications of module states has no side effect
- 3. support other storage system through PathManager
- 4. imported dict are turned into omegaconf.DictConfig automatically
- """
- old_import = builtins.__import__
-
- def find_relative_file(original_file, relative_import_path, level):
- cur_file = os.path.dirname(original_file)
- for _ in range(level - 1):
- cur_file = os.path.dirname(cur_file)
- cur_name = relative_import_path.lstrip(".")
- for part in cur_name.split("."):
- cur_file = os.path.join(cur_file, part)
- # NOTE: directory import is not handled. Because then it's unclear
- # if such import should produce python module or DictConfig. This can
- # be discussed further if needed.
- if not cur_file.endswith(".py"):
- cur_file += ".py"
- if not PathManager.isfile(cur_file):
- raise ImportError(
- f"Cannot import name {relative_import_path} from "
- f"{original_file}: {cur_file} has to exist."
- )
- return cur_file
-
- def new_import(name, globals=None, locals=None, fromlist=(), level=0):
- if (
- # Only deal with relative imports inside config files
- level != 0
- and globals is not None
- and (globals.get("__package__", "") or "").startswith(_CFG_PACKAGE_NAME)
- ):
- cur_file = find_relative_file(globals["__file__"], name, level)
- _validate_py_syntax(cur_file)
- spec = importlib.machinery.ModuleSpec(
- _random_package_name(cur_file), None, origin=cur_file
- )
- module = importlib.util.module_from_spec(spec)
- module.__file__ = cur_file
- with PathManager.open(cur_file) as f:
- content = f.read()
- exec(compile(content, cur_file, "exec"), module.__dict__)
- for name in fromlist: # turn imported dict into DictConfig automatically
- val = _cast_to_config(module.__dict__[name])
- module.__dict__[name] = val
- return module
- return old_import(name, globals, locals, fromlist=fromlist, level=level)
-
- builtins.__import__ = new_import
- yield new_import
- builtins.__import__ = old_import
-
-
-class LazyConfig:
- """
- Provide methods to save, load, and overrides an omegaconf config object
- which may contain definition of lazily-constructed objects.
- """
-
- @staticmethod
- def load_rel(filename: str, keys: Union[None, str, Tuple[str, ...]] = None):
- """
- Similar to :meth:`load()`, but load path relative to the caller's
- source file.
-
- This has the same functionality as a relative import, except that this method
- accepts filename as a string, so more characters are allowed in the filename.
- """
- caller_frame = inspect.stack()[1]
- caller_fname = caller_frame[0].f_code.co_filename
- assert caller_fname != "", "load_rel Unable to find caller"
- caller_dir = os.path.dirname(caller_fname)
- filename = os.path.join(caller_dir, filename)
- return LazyConfig.load(filename, keys)
-
- @staticmethod
- def load(filename: str, keys: Union[None, str, Tuple[str, ...]] = None):
- """
- Load a config file.
-
- Args:
- filename: absolute path or relative path w.r.t. the current working directory
- keys: keys to load and return. If not given, return all keys
- (whose values are config objects) in a dict.
- """
- has_keys = keys is not None
- filename = filename.replace("/./", "/") # redundant
- if os.path.splitext(filename)[1] not in [".py", ".yaml", ".yml"]:
- raise ValueError(f"Config file {filename} has to be a python or yaml file.")
- if filename.endswith(".py"):
- _validate_py_syntax(filename)
-
- with _patch_import():
- # Record the filename
- module_namespace = {
- "__file__": filename,
- "__package__": _random_package_name(filename),
- }
- with PathManager.open(filename) as f:
- content = f.read()
- # Compile first with filename to:
- # 1. make filename appears in stacktrace
- # 2. make load_rel able to find its parent's (possibly remote) location
- exec(compile(content, filename, "exec"), module_namespace)
-
- ret = module_namespace
- else:
- with PathManager.open(filename) as f:
- obj = yaml.unsafe_load(f)
- ret = OmegaConf.create(obj, flags={"allow_objects": True})
-
- if has_keys:
- if isinstance(keys, str):
- return _cast_to_config(ret[keys])
- else:
- return tuple(_cast_to_config(ret[a]) for a in keys)
- else:
- if filename.endswith(".py"):
- # when not specified, only load those that are config objects
- ret = DictConfig(
- {
- name: _cast_to_config(value)
- for name, value in ret.items()
- if isinstance(value, (DictConfig, ListConfig, dict))
- and not name.startswith("_")
- },
- flags={"allow_objects": True},
- )
- return ret
-
- @staticmethod
- def save(cfg, filename: str):
- """
- Save a config object to a yaml file.
- Note that when the config dictionary contains complex objects (e.g. lambda),
- it can't be saved to yaml. In that case we will print an error and
- attempt to save to a pkl file instead.
-
- Args:
- cfg: an omegaconf config object
- filename: yaml file name to save the config file
- """
- logger = logging.getLogger(__name__)
- try:
- cfg = deepcopy(cfg)
- except Exception:
- pass
- else:
- # if it's deep-copyable, then...
- def _replace_type_by_name(x):
- if "_target_" in x and callable(x._target_):
- try:
- x._target_ = _convert_target_to_string(x._target_)
- except AttributeError:
- pass
-
- # not necessary, but makes yaml looks nicer
- _visit_dict_config(cfg, _replace_type_by_name)
-
- save_pkl = False
- try:
- dict = OmegaConf.to_container(cfg, resolve=False)
- dumped = yaml.dump(dict, default_flow_style=None, allow_unicode=True, width=9999)
- with PathManager.open(filename, "w") as f:
- f.write(dumped)
-
- try:
- _ = yaml.unsafe_load(dumped) # test that it is loadable
- except Exception:
- logger.warning(
- "The config contains objects that cannot serialize to a valid yaml. "
- f"{filename} is human-readable but cannot be loaded."
- )
- save_pkl = True
- except Exception:
- logger.exception("Unable to serialize the config to yaml. Error:")
- save_pkl = True
-
- if save_pkl:
- new_filename = filename + ".pkl"
- try:
- # retry by pickle
- with PathManager.open(new_filename, "wb") as f:
- cloudpickle.dump(cfg, f)
- logger.warning(f"Config is saved using cloudpickle at {new_filename}.")
- except Exception:
- pass
-
- @staticmethod
- def apply_overrides(cfg, overrides: List[str]):
- """
- In-place override contents of cfg.
-
- Args:
- cfg: an omegaconf config object
- overrides: list of strings in the format of "a=b" to override configs.
- See https://hydra.cc/docs/next/advanced/override_grammar/basic/
- for syntax.
-
- Returns:
- the cfg object
- """
-
- def safe_update(cfg, key, value):
- parts = key.split(".")
- for idx in range(1, len(parts)):
- prefix = ".".join(parts[:idx])
- v = OmegaConf.select(cfg, prefix, default=None)
- if v is None:
- break
- if not OmegaConf.is_config(v):
- raise KeyError(
- f"Trying to update key {key}, but {prefix} "
- f"is not a config, but has type {type(v)}."
- )
- OmegaConf.update(cfg, key, value, merge=True)
-
- from hydra.core.override_parser.overrides_parser import OverridesParser
-
- parser = OverridesParser.create()
- overrides = parser.parse_overrides(overrides)
- for o in overrides:
- key = o.key_or_group
- value = o.value()
- if o.is_delete():
- # TODO support this
- raise NotImplementedError("deletion is not yet a supported override")
- safe_update(cfg, key, value)
- return cfg
-
- @staticmethod
- def to_py(cfg, prefix: str = "cfg."):
- """
- Try to convert a config object into Python-like psuedo code.
-
- Note that perfect conversion is not always possible. So the returned
- results are mainly meant to be human-readable, and not meant to be executed.
-
- Args:
- cfg: an omegaconf config object
- prefix: root name for the resulting code (default: "cfg.")
-
-
- Returns:
- str of formatted Python code
- """
- import black
-
- cfg = OmegaConf.to_container(cfg, resolve=True)
-
- def _to_str(obj, prefix=None, inside_call=False):
- if prefix is None:
- prefix = []
- if isinstance(obj, abc.Mapping) and "_target_" in obj:
- # Dict representing a function call
- target = _convert_target_to_string(obj.pop("_target_"))
- args = []
- for k, v in sorted(obj.items()):
- args.append(f"{k}={_to_str(v, inside_call=True)}")
- args = ", ".join(args)
- call = f"{target}({args})"
- return "".join(prefix) + call
- elif isinstance(obj, abc.Mapping) and not inside_call:
- # Dict that is not inside a call is a list of top-level config objects that we
- # render as one object per line with dot separated prefixes
- key_list = []
- for k, v in sorted(obj.items()):
- if isinstance(v, abc.Mapping) and "_target_" not in v:
- key_list.append(_to_str(v, prefix=prefix + [k + "."]))
- else:
- key = "".join(prefix) + k
- key_list.append(f"{key}={_to_str(v)}")
- return "\n".join(key_list)
- elif isinstance(obj, abc.Mapping):
- # Dict that is inside a call is rendered as a regular dict
- return (
- "{"
- + ",".join(
- f"{repr(k)}: {_to_str(v, inside_call=inside_call)}"
- for k, v in sorted(obj.items())
- )
- + "}"
- )
- elif isinstance(obj, list):
- return "[" + ",".join(_to_str(x, inside_call=inside_call) for x in obj) + "]"
- else:
- return repr(obj)
-
- py_str = _to_str(cfg, prefix=[prefix])
- try:
- return black.format_str(py_str, mode=black.Mode())
- except black.InvalidInput:
- return py_str
diff --git a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/detectron2/export/caffe2_export.py b/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/detectron2/export/caffe2_export.py
deleted file mode 100644
index 74ac123a7aed6cd77d6d833446a831d9048745b2..0000000000000000000000000000000000000000
--- a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/detectron2/export/caffe2_export.py
+++ /dev/null
@@ -1,207 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-
-import copy
-import io
-import logging
-import numpy as np
-from typing import List
-import onnx
-import torch
-from caffe2.proto import caffe2_pb2
-from caffe2.python import core
-from caffe2.python.onnx.backend import Caffe2Backend
-from tabulate import tabulate
-from termcolor import colored
-from torch.onnx import OperatorExportTypes
-
-from .shared import (
- ScopedWS,
- construct_init_net_from_params,
- fuse_alias_placeholder,
- fuse_copy_between_cpu_and_gpu,
- get_params_from_init_net,
- group_norm_replace_aten_with_caffe2,
- infer_device_type,
- remove_dead_end_ops,
- remove_reshape_for_fc,
- save_graph,
-)
-
-logger = logging.getLogger(__name__)
-
-
-def export_onnx_model(model, inputs):
- """
- Trace and export a model to onnx format.
-
- Args:
- model (nn.Module):
- inputs (tuple[args]): the model will be called by `model(*inputs)`
-
- Returns:
- an onnx model
- """
- assert isinstance(model, torch.nn.Module)
-
- # make sure all modules are in eval mode, onnx may change the training state
- # of the module if the states are not consistent
- def _check_eval(module):
- assert not module.training
-
- model.apply(_check_eval)
-
- # Export the model to ONNX
- with torch.no_grad():
- with io.BytesIO() as f:
- torch.onnx.export(
- model,
- inputs,
- f,
- operator_export_type=OperatorExportTypes.ONNX_ATEN_FALLBACK,
- # verbose=True, # NOTE: uncomment this for debugging
- # export_params=True,
- )
- onnx_model = onnx.load_from_string(f.getvalue())
-
- # Apply ONNX's Optimization
- all_passes = onnx.optimizer.get_available_passes()
- passes = ["fuse_bn_into_conv"]
- assert all(p in all_passes for p in passes)
- onnx_model = onnx.optimizer.optimize(onnx_model, passes)
- return onnx_model
-
-
-def _op_stats(net_def):
- type_count = {}
- for t in [op.type for op in net_def.op]:
- type_count[t] = type_count.get(t, 0) + 1
- type_count_list = sorted(type_count.items(), key=lambda kv: kv[0]) # alphabet
- type_count_list = sorted(type_count_list, key=lambda kv: -kv[1]) # count
- return "\n".join("{:>4}x {}".format(count, name) for name, count in type_count_list)
-
-
-def _assign_device_option(
- predict_net: caffe2_pb2.NetDef, init_net: caffe2_pb2.NetDef, tensor_inputs: List[torch.Tensor]
-):
- """
- ONNX exported network doesn't have concept of device, assign necessary
- device option for each op in order to make it runable on GPU runtime.
- """
-
- def _get_device_type(torch_tensor):
- assert torch_tensor.device.type in ["cpu", "cuda"]
- assert torch_tensor.device.index == 0
- return torch_tensor.device.type
-
- def _assign_op_device_option(net_proto, net_ssa, blob_device_types):
- for op, ssa_i in zip(net_proto.op, net_ssa):
- if op.type in ["CopyCPUToGPU", "CopyGPUToCPU"]:
- op.device_option.CopyFrom(core.DeviceOption(caffe2_pb2.CUDA, 0))
- else:
- devices = [blob_device_types[b] for b in ssa_i[0] + ssa_i[1]]
- assert all(d == devices[0] for d in devices)
- if devices[0] == "cuda":
- op.device_option.CopyFrom(core.DeviceOption(caffe2_pb2.CUDA, 0))
-
- # update ops in predict_net
- predict_net_input_device_types = {
- (name, 0): _get_device_type(tensor)
- for name, tensor in zip(predict_net.external_input, tensor_inputs)
- }
- predict_net_device_types = infer_device_type(
- predict_net, known_status=predict_net_input_device_types, device_name_style="pytorch"
- )
- predict_net_ssa, _ = core.get_ssa(predict_net)
- _assign_op_device_option(predict_net, predict_net_ssa, predict_net_device_types)
-
- # update ops in init_net
- init_net_ssa, versions = core.get_ssa(init_net)
- init_net_output_device_types = {
- (name, versions[name]): predict_net_device_types[(name, 0)]
- for name in init_net.external_output
- }
- init_net_device_types = infer_device_type(
- init_net, known_status=init_net_output_device_types, device_name_style="pytorch"
- )
- _assign_op_device_option(init_net, init_net_ssa, init_net_device_types)
-
-
-def export_caffe2_detection_model(model: torch.nn.Module, tensor_inputs: List[torch.Tensor]):
- """
- Export a caffe2-compatible Detectron2 model to caffe2 format via ONNX.
-
- Arg:
- model: a caffe2-compatible version of detectron2 model, defined in caffe2_modeling.py
- tensor_inputs: a list of tensors that caffe2 model takes as input.
- """
- model = copy.deepcopy(model)
- assert isinstance(model, torch.nn.Module)
- assert hasattr(model, "encode_additional_info")
-
- # Export via ONNX
- logger.info(
- "Exporting a {} model via ONNX ...".format(type(model).__name__)
- + " Some warnings from ONNX are expected and are usually not to worry about."
- )
- onnx_model = export_onnx_model(model, (tensor_inputs,))
- # Convert ONNX model to Caffe2 protobuf
- init_net, predict_net = Caffe2Backend.onnx_graph_to_caffe2_net(onnx_model)
- ops_table = [[op.type, op.input, op.output] for op in predict_net.op]
- table = tabulate(ops_table, headers=["type", "input", "output"], tablefmt="pipe")
- logger.info(
- "ONNX export Done. Exported predict_net (before optimizations):\n" + colored(table, "cyan")
- )
-
- # Apply protobuf optimization
- fuse_alias_placeholder(predict_net, init_net)
- if any(t.device.type != "cpu" for t in tensor_inputs):
- fuse_copy_between_cpu_and_gpu(predict_net)
- remove_dead_end_ops(init_net)
- _assign_device_option(predict_net, init_net, tensor_inputs)
- params, device_options = get_params_from_init_net(init_net)
- predict_net, params = remove_reshape_for_fc(predict_net, params)
- init_net = construct_init_net_from_params(params, device_options)
- group_norm_replace_aten_with_caffe2(predict_net)
-
- # Record necessary information for running the pb model in Detectron2 system.
- model.encode_additional_info(predict_net, init_net)
-
- logger.info("Operators used in predict_net: \n{}".format(_op_stats(predict_net)))
- logger.info("Operators used in init_net: \n{}".format(_op_stats(init_net)))
-
- return predict_net, init_net
-
-
-def run_and_save_graph(predict_net, init_net, tensor_inputs, graph_save_path):
- """
- Run the caffe2 model on given inputs, recording the shape and draw the graph.
-
- predict_net/init_net: caffe2 model.
- tensor_inputs: a list of tensors that caffe2 model takes as input.
- graph_save_path: path for saving graph of exported model.
- """
-
- logger.info("Saving graph of ONNX exported model to {} ...".format(graph_save_path))
- save_graph(predict_net, graph_save_path, op_only=False)
-
- # Run the exported Caffe2 net
- logger.info("Running ONNX exported model ...")
- with ScopedWS("__ws_tmp__", True) as ws:
- ws.RunNetOnce(init_net)
- initialized_blobs = set(ws.Blobs())
- uninitialized = [inp for inp in predict_net.external_input if inp not in initialized_blobs]
- for name, blob in zip(uninitialized, tensor_inputs):
- ws.FeedBlob(name, blob)
-
- try:
- ws.RunNetOnce(predict_net)
- except RuntimeError as e:
- logger.warning("Encountered RuntimeError: \n{}".format(str(e)))
-
- ws_blobs = {b: ws.FetchBlob(b) for b in ws.Blobs()}
- blob_sizes = {b: ws_blobs[b].shape for b in ws_blobs if isinstance(ws_blobs[b], np.ndarray)}
-
- logger.info("Saving graph with blob shapes to {} ...".format(graph_save_path))
- save_graph(predict_net, graph_save_path, op_only=False, blob_sizes=blob_sizes)
-
- return ws_blobs
diff --git a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/docs/conf.py b/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/docs/conf.py
deleted file mode 100644
index c7232f41f7540d6d0c2e36827c9bd18d36fffac7..0000000000000000000000000000000000000000
--- a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/docs/conf.py
+++ /dev/null
@@ -1,382 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright (c) Facebook, Inc. and its affiliates.
-
-# flake8: noqa
-
-# Configuration file for the Sphinx documentation builder.
-#
-# This file does only contain a selection of the most common options. For a
-# full list see the documentation:
-# http://www.sphinx-doc.org/en/master/config
-
-# -- Path setup --------------------------------------------------------------
-
-# If extensions (or modules to document with autodoc) are in another directory,
-# add these directories to sys.path here. If the directory is relative to the
-# documentation root, use os.path.abspath to make it absolute, like shown here.
-#
-import os
-import sys
-from unittest import mock
-from sphinx.domains import Domain
-from typing import Dict, List, Tuple
-
-# The theme to use for HTML and HTML Help pages. See the documentation for
-# a list of builtin themes.
-#
-import sphinx_rtd_theme
-
-
-class GithubURLDomain(Domain):
- """
- Resolve certain links in markdown files to github source.
- """
-
- name = "githuburl"
- ROOT = "https://github.com/facebookresearch/detectron2/blob/main/"
- LINKED_DOC = ["tutorials/install", "tutorials/getting_started"]
-
- def resolve_any_xref(self, env, fromdocname, builder, target, node, contnode):
- github_url = None
- if not target.endswith("html") and target.startswith("../../"):
- url = target.replace("../", "")
- github_url = url
- if fromdocname in self.LINKED_DOC:
- # unresolved links in these docs are all github links
- github_url = target
-
- if github_url is not None:
- if github_url.endswith("MODEL_ZOO") or github_url.endswith("README"):
- # bug of recommonmark.
- # https://github.com/readthedocs/recommonmark/blob/ddd56e7717e9745f11300059e4268e204138a6b1/recommonmark/parser.py#L152-L155
- github_url += ".md"
- print("Ref {} resolved to github:{}".format(target, github_url))
- contnode["refuri"] = self.ROOT + github_url
- return [("githuburl:any", contnode)]
- else:
- return []
-
-
-# to support markdown
-from recommonmark.parser import CommonMarkParser
-
-sys.path.insert(0, os.path.abspath("../"))
-os.environ["_DOC_BUILDING"] = "True"
-DEPLOY = os.environ.get("READTHEDOCS") == "True"
-
-
-# -- Project information -----------------------------------------------------
-
-# fmt: off
-try:
- import torch # noqa
-except ImportError:
- for m in [
- "torch", "torchvision", "torch.nn", "torch.nn.parallel", "torch.distributed", "torch.multiprocessing", "torch.autograd",
- "torch.autograd.function", "torch.nn.modules", "torch.nn.modules.utils", "torch.utils", "torch.utils.data", "torch.onnx",
- "torchvision", "torchvision.ops",
- ]:
- sys.modules[m] = mock.Mock(name=m)
- sys.modules['torch'].__version__ = "1.7" # fake version
- HAS_TORCH = False
-else:
- try:
- torch.ops.detectron2 = mock.Mock(name="torch.ops.detectron2")
- except:
- pass
- HAS_TORCH = True
-
-for m in [
- "cv2", "scipy", "portalocker", "detectron2._C",
- "pycocotools", "pycocotools.mask", "pycocotools.coco", "pycocotools.cocoeval",
- "google", "google.protobuf", "google.protobuf.internal", "onnx",
- "caffe2", "caffe2.proto", "caffe2.python", "caffe2.python.utils", "caffe2.python.onnx", "caffe2.python.onnx.backend",
-]:
- sys.modules[m] = mock.Mock(name=m)
-# fmt: on
-sys.modules["cv2"].__version__ = "3.4"
-
-import detectron2 # isort: skip
-
-if HAS_TORCH:
- from detectron2.utils.env import fixup_module_metadata
-
- fixup_module_metadata("torch.nn", torch.nn.__dict__)
- fixup_module_metadata("torch.utils.data", torch.utils.data.__dict__)
-
-
-project = "detectron2"
-copyright = "2019-2020, detectron2 contributors"
-author = "detectron2 contributors"
-
-# The short X.Y version
-version = detectron2.__version__
-# The full version, including alpha/beta/rc tags
-release = version
-
-
-# -- General configuration ---------------------------------------------------
-
-# If your documentation needs a minimal Sphinx version, state it here.
-#
-needs_sphinx = "3.0"
-
-# Add any Sphinx extension module names here, as strings. They can be
-# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
-# ones.
-extensions = [
- "recommonmark",
- "sphinx.ext.autodoc",
- "sphinx.ext.napoleon",
- "sphinx.ext.intersphinx",
- "sphinx.ext.todo",
- "sphinx.ext.coverage",
- "sphinx.ext.mathjax",
- "sphinx.ext.viewcode",
- "sphinx.ext.githubpages",
-]
-
-# -- Configurations for plugins ------------
-napoleon_google_docstring = True
-napoleon_include_init_with_doc = True
-napoleon_include_special_with_doc = True
-napoleon_numpy_docstring = False
-napoleon_use_rtype = False
-autodoc_inherit_docstrings = False
-autodoc_member_order = "bysource"
-
-if DEPLOY:
- intersphinx_timeout = 10
-else:
- # skip this when building locally
- intersphinx_timeout = 0.5
-intersphinx_mapping = {
- "python": ("https://docs.python.org/3.6", None),
- "numpy": ("https://docs.scipy.org/doc/numpy/", None),
- "torch": ("https://pytorch.org/docs/master/", None),
-}
-# -------------------------
-
-
-# Add any paths that contain templates here, relative to this directory.
-templates_path = ["_templates"]
-
-source_suffix = [".rst", ".md"]
-
-# The master toctree document.
-master_doc = "index"
-
-# The language for content autogenerated by Sphinx. Refer to documentation
-# for a list of supported languages.
-#
-# This is also used if you do content translation via gettext catalogs.
-# Usually you set "language" from the command line for these cases.
-language = None
-
-# List of patterns, relative to source directory, that match files and
-# directories to ignore when looking for source files.
-# This pattern also affects html_static_path and html_extra_path.
-exclude_patterns = ["_build", "Thumbs.db", ".DS_Store", "build", "README.md", "tutorials/README.md"]
-
-# The name of the Pygments (syntax highlighting) style to use.
-pygments_style = "sphinx"
-
-
-# -- Options for HTML output -------------------------------------------------
-
-html_theme = "sphinx_rtd_theme"
-html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]
-
-# Theme options are theme-specific and customize the look and feel of a theme
-# further. For a list of options available for each theme, see the
-# documentation.
-#
-# html_theme_options = {}
-
-# Add any paths that contain custom static files (such as style sheets) here,
-# relative to this directory. They are copied after the builtin static files,
-# so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ["_static"]
-html_css_files = ["css/custom.css"]
-
-# Custom sidebar templates, must be a dictionary that maps document names
-# to template names.
-#
-# The default sidebars (for documents that don't match any pattern) are
-# defined by theme itself. Builtin themes are using these templates by
-# default: ``['localtoc.html', 'relations.html', 'sourcelink.html',
-# 'searchbox.html']``.
-#
-# html_sidebars = {}
-
-
-# -- Options for HTMLHelp output ---------------------------------------------
-
-# Output file base name for HTML help builder.
-htmlhelp_basename = "detectron2doc"
-
-
-# -- Options for LaTeX output ------------------------------------------------
-
-latex_elements = {
- # The paper size ('letterpaper' or 'a4paper').
- #
- # 'papersize': 'letterpaper',
- # The font size ('10pt', '11pt' or '12pt').
- #
- # 'pointsize': '10pt',
- # Additional stuff for the LaTeX preamble.
- #
- # 'preamble': '',
- # Latex figure (float) alignment
- #
- # 'figure_align': 'htbp',
-}
-
-# Grouping the document tree into LaTeX files. List of tuples
-# (source start file, target name, title,
-# author, documentclass [howto, manual, or own class]).
-latex_documents = [
- (master_doc, "detectron2.tex", "detectron2 Documentation", "detectron2 contributors", "manual")
-]
-
-
-# -- Options for manual page output ------------------------------------------
-
-# One entry per manual page. List of tuples
-# (source start file, name, description, authors, manual section).
-man_pages = [(master_doc, "detectron2", "detectron2 Documentation", [author], 1)]
-
-
-# -- Options for Texinfo output ----------------------------------------------
-
-# Grouping the document tree into Texinfo files. List of tuples
-# (source start file, target name, title, author,
-# dir menu entry, description, category)
-texinfo_documents = [
- (
- master_doc,
- "detectron2",
- "detectron2 Documentation",
- author,
- "detectron2",
- "One line description of project.",
- "Miscellaneous",
- )
-]
-
-
-# -- Options for todo extension ----------------------------------------------
-
-# If true, `todo` and `todoList` produce output, else they produce nothing.
-todo_include_todos = True
-
-
-def autodoc_skip_member(app, what, name, obj, skip, options):
- # we hide something deliberately
- if getattr(obj, "__HIDE_SPHINX_DOC__", False):
- return True
-
- # Hide some that are deprecated or not intended to be used
- HIDDEN = {
- "ResNetBlockBase",
- "GroupedBatchSampler",
- "build_transform_gen",
- "apply_transform_gens",
- "TransformGen",
- "apply_augmentations",
- "StandardAugInput",
- "build_batch_data_loader",
- "draw_panoptic_seg_predictions",
- "WarmupCosineLR",
- "WarmupMultiStepLR",
- "downgrade_config",
- "upgrade_config",
- "add_export_config",
- }
- try:
- if name in HIDDEN or (
- hasattr(obj, "__doc__") and obj.__doc__.lower().strip().startswith("deprecated")
- ):
- print("Skipping deprecated object: {}".format(name))
- return True
- except:
- pass
- return skip
-
-
-_PAPER_DATA = {
- "resnet": ("1512.03385", "Deep Residual Learning for Image Recognition"),
- "fpn": ("1612.03144", "Feature Pyramid Networks for Object Detection"),
- "mask r-cnn": ("1703.06870", "Mask R-CNN"),
- "faster r-cnn": (
- "1506.01497",
- "Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks",
- ),
- "deformconv": ("1703.06211", "Deformable Convolutional Networks"),
- "deformconv2": ("1811.11168", "Deformable ConvNets v2: More Deformable, Better Results"),
- "panopticfpn": ("1901.02446", "Panoptic Feature Pyramid Networks"),
- "retinanet": ("1708.02002", "Focal Loss for Dense Object Detection"),
- "cascade r-cnn": ("1712.00726", "Cascade R-CNN: Delving into High Quality Object Detection"),
- "lvis": ("1908.03195", "LVIS: A Dataset for Large Vocabulary Instance Segmentation"),
- "rrpn": ("1703.01086", "Arbitrary-Oriented Scene Text Detection via Rotation Proposals"),
- "imagenet in 1h": ("1706.02677", "Accurate, Large Minibatch SGD: Training ImageNet in 1 Hour"),
- "xception": ("1610.02357", "Xception: Deep Learning with Depthwise Separable Convolutions"),
- "mobilenet": (
- "1704.04861",
- "MobileNets: Efficient Convolutional Neural Networks for Mobile Vision Applications",
- ),
- "deeplabv3+": (
- "1802.02611",
- "Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation",
- ),
- "dds": ("2003.13678", "Designing Network Design Spaces"),
- "scaling": ("2103.06877", "Fast and Accurate Model Scaling"),
- "fcos": ("2006.09214", "FCOS: A Simple and Strong Anchor-free Object Detector"),
- "rethinking-batchnorm": ("2105.07576", 'Rethinking "Batch" in BatchNorm'),
-}
-
-
-def paper_ref_role(
- typ: str,
- rawtext: str,
- text: str,
- lineno: int,
- inliner,
- options: Dict = {},
- content: List[str] = [],
-):
- """
- Parse :paper:`xxx`. Similar to the "extlinks" sphinx extension.
- """
- from docutils import nodes, utils
- from sphinx.util.nodes import split_explicit_title
-
- text = utils.unescape(text)
- has_explicit_title, title, link = split_explicit_title(text)
- link = link.lower()
- if link not in _PAPER_DATA:
- inliner.reporter.warning("Cannot find paper " + link)
- paper_url, paper_title = "#", link
- else:
- paper_url, paper_title = _PAPER_DATA[link]
- if "/" not in paper_url:
- paper_url = "https://arxiv.org/abs/" + paper_url
- if not has_explicit_title:
- title = paper_title
- pnode = nodes.reference(title, title, internal=False, refuri=paper_url)
- return [pnode], []
-
-
-def setup(app):
- from recommonmark.transform import AutoStructify
-
- app.add_domain(GithubURLDomain)
- app.connect("autodoc-skip-member", autodoc_skip_member)
- app.add_role("paper", paper_ref_role)
- app.add_config_value(
- "recommonmark_config",
- {"enable_math": True, "enable_inline_math": True, "enable_eval_rst": True},
- True,
- )
- app.add_transform(AutoStructify)
diff --git a/spaces/UjjwalVIT/Text_analysis_and_metadata_app/Text_analysis.py b/spaces/UjjwalVIT/Text_analysis_and_metadata_app/Text_analysis.py
deleted file mode 100644
index 5622d2f541c062ad2d5002b8a9fc031ef269e92d..0000000000000000000000000000000000000000
--- a/spaces/UjjwalVIT/Text_analysis_and_metadata_app/Text_analysis.py
+++ /dev/null
@@ -1,186 +0,0 @@
-import streamlit as st
-import pandas as pd
-import streamlit.components.v1 as stc
-import docx2txt
-
-# NLP Package-used for text analysis
-import nltk
-from nltk.tokenize import word_tokenize
-from nltk.tag import pos_tag
-from nltk.stem import WordNetLemmatizer
-from nltk.corpus import stopwords
-# from nltk import ne_chunk
-from nltk.tag import StanfordNERTagger
-
-from collections import Counter
-
-from textblob import TextBlob
-import seaborn as sns
-import matplotlib.pyplot as plt
-from PIL import Image
-
-from wordcloud import WordCloud
-
-import base64
-import time
-from app_utils import *
-
-def load_image(file):
- img = Image.open(file)
- return img
-
-
-HTML_BANNER = """
-
-
Text Analysis App
-
- """
-
-def text_analysis():
- stc.html(HTML_BANNER)
- st.image(load_image('text_analysis.png'))
- menu=['Text-analysis','Upload_Files']
-
- choice=st.sidebar.selectbox('Menu',menu)
- if choice=='Text-analysis':
- st.subheader('Analyse Text')
- text=st.text_area("Enter the text to anlayze")
- if (st.button("Analyze")):
- st.success("Success")
- with st.expander('Original Text'):
- st.write(text)
- with st.expander('Text Analysis'):
- token_analysis=nlp_analysis(text)
- st.dataframe(token_analysis)
- with st.expander('Entitites'):
- entity_result=find_entities(text)
- stc.html(entity_result, height=100, scrolling=True)
-
- col1,col2=st.columns(2)
-
- with col1:
-
- with st.expander("Word Stats"):
- st.info("Word Statistics")
- docx = nt.TextFrame(text)
- st.write(docx.word_stats())
-
- with st.expander("Top keywords"):
- keywords=get_most_common_tokens(text)
- st.write(keywords)
-
- with st.expander('Tagged Keywords'):
- data= pos_tag(word_tokenize(text))
- st.dataframe(data)
- visualize_tags=tag_visualize(data)
- stc.html(visualize_tags,scrolling=True)
-
-
- with st.expander("Sentiment"):
- sent_result=get_semantics(text)
- st.write(sent_result)
-
- with col2:
-
- with st.expander("Plot word freq"):
- try:
- fig, ax = plt.subplots()
- most_common_tokens = dict(token_analysis["Token"].value_counts())
- sns.countplot(data=token_analysis[token_analysis["Token"].isin(most_common_tokens)], x="Token", ax=ax)
- ax.set_xlabel('PoS')
- ax.set_ylabel('Frequency')
- ax.tick_params(axis='x' , rotation=45)
- st.pyplot(fig)
- except:
- st.warning('Insufficient data')
-
- with st.expander("Plot part of speech"):
- try:
- fig, ax = plt.subplots()
- most_common_tokens = dict(token_analysis["Position"].value_counts())
- sns.countplot(data=token_analysis[token_analysis["Position"].isin(most_common_tokens)], x="Position", ax=ax)
- ax.set_xlabel('PoS')
- ax.set_ylabel('Frequency')
- ax.tick_params(axis='x' , rotation=45)
- st.pyplot(fig)
- except:
- st.warning('Insufficient data')
-
- with st.expander("Plot word cloud"):
- try:
- plot_wordcloud(text)
- except:
- st.warning('Insufficient data')
-
-
- with st.expander('Download Results'):
- file_download(token_analysis)
-
-
-
-
-
-
- elif choice == 'Upload_Files':
- text_file = st.file_uploader('Upload Files', type=['docx'])
- if text_file is not None:
- if text_file.type == 'text/plain':
- text = str(text_file.read(), "utf-8")
- else:
- text = docx2txt.process(text_file)
-
- if (st.button("Analyze")):
- with st.expander('Original Text'):
- st.write(text)
- with st.expander('Text Analysis'):
- token_analysis = nlp_analysis(text)
- st.dataframe(token_analysis)
- with st.expander('Entities'):
- entity_result = find_entities(text)
- stc.html(entity_result, height=100, scrolling=True)
-
- col1, col2 = st.columns(2)
-
- with col1:
- with st.expander("Word Stats"):
- st.info("Word Statistics")
- docx = nt.TextFrame(text)
- st.write(docx.word_stats())
-
- with st.expander("Top keywords"):
- keywords = get_most_common_tokens(text)
- st.write(keywords)
-
- with st.expander("Sentiment"):
- sent_result = get_semantics(text)
- st.write(sent_result)
-
- with col2:
- with st.expander("Plot word freq"):
- fig, ax = plt.subplots()
- num_tokens = 10 # Adjust the number of tokens to display as desired
- most_common_tokens = dict(token_analysis["Token"].value_counts().head(num_tokens))
- sns.countplot(data=token_analysis[token_analysis["Token"].isin(most_common_tokens)], x="Token", ax=ax)
- ax.set_xlabel('Token')
- ax.set_ylabel('Frequency')
- ax.tick_params(axis='x', rotation=45)
- st.pyplot(fig)
-
- with st.expander("Plot part of speech"):
- fig, ax = plt.subplots()
- most_common_tokens = dict(token_analysis["Position"].value_counts())
- sns.countplot(data=token_analysis[token_analysis["Position"].isin(most_common_tokens)], x="Position", ax=ax)
- ax.set_xlabel('PoS')
- ax.set_ylabel('Frequency')
- ax.tick_params(axis='x', rotation=45)
- st.pyplot(fig)
-
- with st.expander("Plot word cloud"):
- plot_wordcloud(text)
-
- with st.expander('Download Results'):
- file_download(token_analysis)
-
-
-
-
diff --git a/spaces/VincentZB/Stable-Diffusion-ControlNet-WebUI/diffusion_webui/utils/scheduler_list.py b/spaces/VincentZB/Stable-Diffusion-ControlNet-WebUI/diffusion_webui/utils/scheduler_list.py
deleted file mode 100644
index fc61731371c8e56c9afe9c4aa076eacc4b632ccd..0000000000000000000000000000000000000000
--- a/spaces/VincentZB/Stable-Diffusion-ControlNet-WebUI/diffusion_webui/utils/scheduler_list.py
+++ /dev/null
@@ -1,47 +0,0 @@
-from diffusers import (
- DDIMScheduler,
- EulerAncestralDiscreteScheduler,
- EulerDiscreteScheduler,
- HeunDiscreteScheduler,
- LMSDiscreteScheduler,
- UniPCMultistepScheduler,
-)
-
-SCHEDULER_LIST = [
- "DDIM",
- "EulerA",
- "Euler",
- "LMS",
- "Heun",
- "UniPC",
-]
-
-
-def get_scheduler_list(pipe, scheduler):
- if scheduler == SCHEDULER_LIST[0]:
- pipe.scheduler = DDIMScheduler.from_config(pipe.scheduler.config)
-
- elif scheduler == SCHEDULER_LIST[1]:
- pipe.scheduler = EulerAncestralDiscreteScheduler.from_config(
- pipe.scheduler.config
- )
-
- elif scheduler == SCHEDULER_LIST[2]:
- pipe.scheduler = EulerDiscreteScheduler.from_config(
- pipe.scheduler.config
- )
-
- elif scheduler == SCHEDULER_LIST[3]:
- pipe.scheduler = LMSDiscreteScheduler.from_config(pipe.scheduler.config)
-
- elif scheduler == SCHEDULER_LIST[4]:
- pipe.scheduler = HeunDiscreteScheduler.from_config(
- pipe.scheduler.config
- )
-
- elif scheduler == SCHEDULER_LIST[5]:
- pipe.scheduler = UniPCMultistepScheduler.from_config(
- pipe.scheduler.config
- )
-
- return pipe
diff --git a/spaces/VuAI/VN98/README.md b/spaces/VuAI/VN98/README.md
deleted file mode 100644
index 061a67386d6123fc673bd6065ed833054e5d99a8..0000000000000000000000000000000000000000
--- a/spaces/VuAI/VN98/README.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-title: VN98
-emoji: 💻
-colorFrom: gray
-colorTo: yellow
-sdk: gradio
-sdk_version: 3.29.0
-app_file: app.py
-pinned: false
-license: openrail
-duplicated_from: VuAI/VuAI-vi2vi_vn98
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
\ No newline at end of file
diff --git a/spaces/Wootang01/text_generator_gpt3/README.md b/spaces/Wootang01/text_generator_gpt3/README.md
deleted file mode 100644
index 36399f9476c823c75b0930e9df03d5abaa191b6e..0000000000000000000000000000000000000000
--- a/spaces/Wootang01/text_generator_gpt3/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Chatbot Gpt3
-emoji: 🦀
-colorFrom: red
-colorTo: purple
-sdk: gradio
-sdk_version: 3.12.0
-app_file: app.py
-pinned: false
-duplicated_from: rizam/rjgpt
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
\ No newline at end of file
diff --git a/spaces/XzJosh/Azuma-Bert-VITS2/app.py b/spaces/XzJosh/Azuma-Bert-VITS2/app.py
deleted file mode 100644
index 123c0e1faffc429eee57861fc90e4c459baaf309..0000000000000000000000000000000000000000
--- a/spaces/XzJosh/Azuma-Bert-VITS2/app.py
+++ /dev/null
@@ -1,144 +0,0 @@
-import sys, os
-
-if sys.platform == "darwin":
- os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] = "1"
-
-import logging
-
-logging.getLogger("numba").setLevel(logging.WARNING)
-logging.getLogger("markdown_it").setLevel(logging.WARNING)
-logging.getLogger("urllib3").setLevel(logging.WARNING)
-logging.getLogger("matplotlib").setLevel(logging.WARNING)
-
-logging.basicConfig(level=logging.INFO, format="| %(name)s | %(levelname)s | %(message)s")
-
-logger = logging.getLogger(__name__)
-
-import torch
-import argparse
-import commons
-import utils
-from models import SynthesizerTrn
-from text.symbols import symbols
-from text import cleaned_text_to_sequence, get_bert
-from text.cleaner import clean_text
-import gradio as gr
-import webbrowser
-
-
-net_g = None
-
-
-def get_text(text, language_str, hps):
- norm_text, phone, tone, word2ph = clean_text(text, language_str)
- phone, tone, language = cleaned_text_to_sequence(phone, tone, language_str)
-
- if hps.data.add_blank:
- phone = commons.intersperse(phone, 0)
- tone = commons.intersperse(tone, 0)
- language = commons.intersperse(language, 0)
- for i in range(len(word2ph)):
- word2ph[i] = word2ph[i] * 2
- word2ph[0] += 1
- bert = get_bert(norm_text, word2ph, language_str)
- del word2ph
-
- assert bert.shape[-1] == len(phone)
-
- phone = torch.LongTensor(phone)
- tone = torch.LongTensor(tone)
- language = torch.LongTensor(language)
-
- return bert, phone, tone, language
-
-def infer(text, sdp_ratio, noise_scale, noise_scale_w, length_scale, sid):
- global net_g
- bert, phones, tones, lang_ids = get_text(text, "ZH", hps)
- with torch.no_grad():
- x_tst=phones.to(device).unsqueeze(0)
- tones=tones.to(device).unsqueeze(0)
- lang_ids=lang_ids.to(device).unsqueeze(0)
- bert = bert.to(device).unsqueeze(0)
- x_tst_lengths = torch.LongTensor([phones.size(0)]).to(device)
- del phones
- speakers = torch.LongTensor([hps.data.spk2id[sid]]).to(device)
- audio = net_g.infer(x_tst, x_tst_lengths, speakers, tones, lang_ids, bert, sdp_ratio=sdp_ratio
- , noise_scale=noise_scale, noise_scale_w=noise_scale_w, length_scale=length_scale)[0][0,0].data.cpu().float().numpy()
- del x_tst, tones, lang_ids, bert, x_tst_lengths, speakers
- return audio
-
-def tts_fn(text, speaker, sdp_ratio, noise_scale, noise_scale_w, length_scale):
- with torch.no_grad():
- audio = infer(text, sdp_ratio=sdp_ratio, noise_scale=noise_scale, noise_scale_w=noise_scale_w, length_scale=length_scale, sid=speaker)
- return "Success", (hps.data.sampling_rate, audio)
-
-
-if __name__ == "__main__":
- parser = argparse.ArgumentParser()
- parser.add_argument("--model_dir", default="./logs/Azuma/G_17400.pth", help="path of your model")
- parser.add_argument("--config_dir", default="./configs/config.json", help="path of your config file")
- parser.add_argument("--share", default=False, help="make link public")
- parser.add_argument("-d", "--debug", action="store_true", help="enable DEBUG-LEVEL log")
-
- args = parser.parse_args()
- if args.debug:
- logger.info("Enable DEBUG-LEVEL log")
- logging.basicConfig(level=logging.DEBUG)
- hps = utils.get_hparams_from_file(args.config_dir)
- device = "cuda:0" if torch.cuda.is_available() else "cpu"
- '''
- device = (
- "cuda:0"
- if torch.cuda.is_available()
- else (
- "mps"
- if sys.platform == "darwin" and torch.backends.mps.is_available()
- else "cpu"
- )
- )
- '''
- net_g = SynthesizerTrn(
- len(symbols),
- hps.data.filter_length // 2 + 1,
- hps.train.segment_size // hps.data.hop_length,
- n_speakers=hps.data.n_speakers,
- **hps.model).to(device)
- _ = net_g.eval()
-
- _ = utils.load_checkpoint(args.model_dir, net_g, None, skip_optimizer=True)
-
- speaker_ids = hps.data.spk2id
- speakers = list(speaker_ids.keys())
- with gr.Blocks() as app:
- with gr.Row():
- with gr.Column():
- gr.Markdown(value="""
- 【AI東雪蓮】在线语音合成（Bert-Vits2）\n
- 作者：Xz乔希 https://space.bilibili.com/5859321\n
- 声音归属：東雪蓮Official https://space.bilibili.com/1437582453\n
- Bert-VITS2项目：https://github.com/Stardust-minus/Bert-VITS2\n
- 【AI塔菲】语音合成：https://huggingface.co/spaces/XzJosh/Taffy-Bert-VITS2\n
- 【AI奶绿】https://huggingface.co/spaces/XzJosh/LAPLACE-Bert-VITS2\n
- 使用本模型请严格遵守法律法规！\n
- 发布二创作品请标注本项目作者及链接、作品使用Bert-VITS2 AI生成！\n
- """)
- text = gr.TextArea(label="Text", placeholder="Input Text Here",
- value="大家好啊，我是东雪莲，今天来点大家想看的东西啊。")
- speaker = gr.Dropdown(choices=speakers, value=speakers[0], label='Speaker')
- sdp_ratio = gr.Slider(minimum=0.1, maximum=1, value=0.2, step=0.1, label='SDP/DP混合比')
- noise_scale = gr.Slider(minimum=0.1, maximum=1, value=0.5, step=0.1, label='感情调节')
- noise_scale_w = gr.Slider(minimum=0.1, maximum=1, value=0.9, step=0.1, label='音素长度')
- length_scale = gr.Slider(minimum=0.1, maximum=2, value=1, step=0.01, label='生成长度')
- btn = gr.Button("点击生成！", variant="primary")
- with gr.Column():
- text_output = gr.Textbox(label="Message")
- audio_output = gr.Audio(label="Output Audio")
-
- btn.click(tts_fn,
- inputs=[text, speaker, sdp_ratio, noise_scale, noise_scale_w, length_scale],
- outputs=[text_output, audio_output])
-
-# webbrowser.open("http://127.0.0.1:6006")
-# app.launch(server_port=6006, show_error=True)
-
- app.launch(show_error=True)
diff --git a/spaces/YeOldHermit/Super-Resolution-Anime-Diffusion/Waifu2x/train.py b/spaces/YeOldHermit/Super-Resolution-Anime-Diffusion/Waifu2x/train.py
deleted file mode 100644
index 9eaa16e3b1b02d061b898c219dad88e1b8e215d4..0000000000000000000000000000000000000000
--- a/spaces/YeOldHermit/Super-Resolution-Anime-Diffusion/Waifu2x/train.py
+++ /dev/null
@@ -1,174 +0,0 @@
-
-from torch import optim
-from torch.utils.data import DataLoader
-from torchvision.utils import save_image
-from tqdm import trange
-
-from Dataloader import *
-from .utils import image_quality
-from .utils.cls import CyclicLR
-from .utils.prepare_images import *
-
-train_folder = './dataset/train'
-test_folder = "./dataset/test"
-
-img_dataset = ImageDBData(db_file='dataset/images.db', db_table="train_images_size_128_noise_1_rgb", max_images=24)
-img_data = DataLoader(img_dataset, batch_size=6, shuffle=True, num_workers=6)
-
-total_batch = len(img_data)
-print(len(img_dataset))
-
-test_dataset = ImageDBData(db_file='dataset/test2.db', db_table="test_images_size_128_noise_1_rgb", max_images=None)
-num_test = len(test_dataset)
-test_data = DataLoader(test_dataset, batch_size=1, shuffle=False, num_workers=1)
-
-criteria = nn.L1Loss()
-
-model = CARN_V2(color_channels=3, mid_channels=64, conv=nn.Conv2d,
- single_conv_size=3, single_conv_group=1,
- scale=2, activation=nn.LeakyReLU(0.1),
- SEBlock=True, repeat_blocks=3, atrous=(1, 1, 1))
-
-model.total_parameters()
-
-
-# model.initialize_weights_xavier_uniform()
-
-# fp16 training is available in GPU only
-model = network_to_half(model)
-model = model.cuda()
-model.load_state_dict(torch.load("CARN_model_checkpoint.pt"))
-
-learning_rate = 1e-4
-weight_decay = 1e-6
-optimizer = optim.Adam(model.parameters(), lr=learning_rate, weight_decay=weight_decay, amsgrad=True)
-# optimizer = optim.SGD(model.parameters(), momentum=0.9, nesterov=True, weight_decay=weight_decay, lr=learning_rate)
-
-# optimizer = FP16_Optimizer(optimizer, static_loss_scale=128.0, verbose=False)
-# optimizer.load_state_dict(torch.load("CARN_adam_checkpoint.pt"))
-
-last_iter = -1 # torch.load("CARN_scheduler_last_iter")
-scheduler = CyclicLR(optimizer, base_lr=1e-4, max_lr=1e-4,
- step_size=3 * total_batch, mode="triangular",
- last_batch_iteration=last_iter)
-train_loss = []
-train_ssim = []
-train_psnr = []
-
-test_loss = []
-test_ssim = []
-test_psnr = []
-
-# train_loss = torch.load("train_loss.pt")
-# train_ssim = torch.load("train_ssim.pt")
-# train_psnr = torch.load("train_psnr.pt")
-#
-# test_loss = torch.load("test_loss.pt")
-# test_ssim = torch.load("test_ssim.pt")
-# test_psnr = torch.load("test_psnr.pt")
-
-
-counter = 0
-iteration = 2
-ibar = trange(iteration, ascii=True, maxinterval=1, postfix={"avg_loss": 0, "train_ssim": 0, "test_ssim": 0})
-for i in ibar:
- # batch_loss = []
- # insample_ssim = []
- # insample_psnr = []
- for index, batch in enumerate(img_data):
- scheduler.batch_step()
- lr_img, hr_img = batch
- lr_img = lr_img.cuda().half()
- hr_img = hr_img.cuda()
-
- # model.zero_grad()
- optimizer.zero_grad()
- outputs = model.forward(lr_img)
- outputs = outputs.float()
- loss = criteria(outputs, hr_img)
- # loss.backward()
- optimizer.backward(loss)
- # nn.utils.clip_grad_norm_(model.parameters(), 5)
- optimizer.step()
-
- counter += 1
- # train_loss.append(loss.item())
-
- ssim = image_quality.msssim(outputs, hr_img).item()
- psnr = image_quality.psnr(outputs, hr_img).item()
-
- ibar.set_postfix(ratio=index / total_batch, loss=loss.item(),
- ssim=ssim, batch=index,
- psnr=psnr,
- lr=scheduler.current_lr
- )
- train_loss.append(loss.item())
- train_ssim.append(ssim)
- train_psnr.append(psnr)
-
- # +++++++++++++++++++++++++++++++++++++
- # save checkpoints by iterations
- # -------------------------------------
-
- if (counter + 1) % 500 == 0:
- torch.save(model.state_dict(), 'CARN_model_checkpoint.pt')
- torch.save(optimizer.state_dict(), 'CARN_adam_checkpoint.pt')
- torch.save(train_loss, 'train_loss.pt')
- torch.save(train_ssim, "train_ssim.pt")
- torch.save(train_psnr, 'train_psnr.pt')
- torch.save(scheduler.last_batch_iteration, "CARN_scheduler_last_iter.pt")
-
- # +++++++++++++++++++++++++++++++++++++
- # End of One Epoch
- # -------------------------------------
-
- # one_ite_loss = np.mean(batch_loss)
- # one_ite_ssim = np.mean(insample_ssim)
- # one_ite_psnr = np.mean(insample_psnr)
-
- # print(f"One iteration loss {one_ite_loss}, ssim {one_ite_ssim}, psnr {one_ite_psnr}")
- # train_loss.append(one_ite_loss)
- # train_ssim.append(one_ite_ssim)
- # train_psnr.append(one_ite_psnr)
-
- torch.save(model.state_dict(), 'CARN_model_checkpoint.pt')
- # torch.save(scheduler, "CARN_scheduler_optim.pt")
- torch.save(optimizer.state_dict(), 'CARN_adam_checkpoint.pt')
- torch.save(train_loss, 'train_loss.pt')
- torch.save(train_ssim, "train_ssim.pt")
- torch.save(train_psnr, 'train_psnr.pt')
- # torch.save(scheduler.last_batch_iteration, "CARN_scheduler_last_iter.pt")
-
- # +++++++++++++++++++++++++++++++++++++
- # Test
- # -------------------------------------
-
- with torch.no_grad():
- ssim = []
- batch_loss = []
- psnr = []
- for index, test_batch in enumerate(test_data):
- lr_img, hr_img = test_batch
- lr_img = lr_img.cuda()
- hr_img = hr_img.cuda()
-
- lr_img_up = model(lr_img)
- lr_img_up = lr_img_up.float()
- loss = criteria(lr_img_up, hr_img)
-
- save_image([lr_img_up[0], hr_img[0]], f"check_test_imgs/{index}.png")
- batch_loss.append(loss.item())
- ssim.append(image_quality.msssim(lr_img_up, hr_img).item())
- psnr.append(image_quality.psnr(lr_img_up, hr_img).item())
-
- test_ssim.append(np.mean(ssim))
- test_loss.append(np.mean(batch_loss))
- test_psnr.append(np.mean(psnr))
-
- torch.save(test_loss, 'test_loss.pt')
- torch.save(test_ssim, "test_ssim.pt")
- torch.save(test_psnr, "test_psnr.pt")
-
-# import subprocess
-
-# subprocess.call(["shutdown", "/s"])
diff --git a/spaces/YeOldHermit/Super-Resolution-Anime-Diffusion/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion.py b/spaces/YeOldHermit/Super-Resolution-Anime-Diffusion/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion.py
deleted file mode 100644
index a3a8703f3ea4070337e5f55be5199277c00413ab..0000000000000000000000000000000000000000
--- a/spaces/YeOldHermit/Super-Resolution-Anime-Diffusion/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion.py
+++ /dev/null
@@ -1,578 +0,0 @@
-# Copyright 2022 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import inspect
-from typing import Callable, List, Optional, Union
-
-import torch
-
-from diffusers.utils import is_accelerate_available
-from packaging import version
-from transformers import CLIPFeatureExtractor, CLIPTextModel, CLIPTokenizer
-
-from ...configuration_utils import FrozenDict
-from ...models import AutoencoderKL, UNet2DConditionModel
-from ...pipeline_utils import DiffusionPipeline
-from ...schedulers import (
- DDIMScheduler,
- DPMSolverMultistepScheduler,
- EulerAncestralDiscreteScheduler,
- EulerDiscreteScheduler,
- LMSDiscreteScheduler,
- PNDMScheduler,
-)
-from ...utils import deprecate, logging
-from . import StableDiffusionPipelineOutput
-from .safety_checker import StableDiffusionSafetyChecker
-
-
-logger = logging.get_logger(__name__) # pylint: disable=invalid-name
-
-
-class StableDiffusionPipeline(DiffusionPipeline):
- r"""
- Pipeline for text-to-image generation using Stable Diffusion.
-
- This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods the
- library implements for all the pipelines (such as downloading or saving, running on a particular device, etc.)
-
- Args:
- vae ([`AutoencoderKL`]):
- Variational Auto-Encoder (VAE) Model to encode and decode images to and from latent representations.
- text_encoder ([`CLIPTextModel`]):
- Frozen text-encoder. Stable Diffusion uses the text portion of
- [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), specifically
- the [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14) variant.
- tokenizer (`CLIPTokenizer`):
- Tokenizer of class
- [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer).
- unet ([`UNet2DConditionModel`]): Conditional U-Net architecture to denoise the encoded image latents.
- scheduler ([`SchedulerMixin`]):
- A scheduler to be used in combination with `unet` to denoise the encoded image latents. Can be one of
- [`DDIMScheduler`], [`LMSDiscreteScheduler`], or [`PNDMScheduler`].
- safety_checker ([`StableDiffusionSafetyChecker`]):
- Classification module that estimates whether generated images could be considered offensive or harmful.
- Please, refer to the [model card](https://huggingface.co/runwayml/stable-diffusion-v1-5) for details.
- feature_extractor ([`CLIPFeatureExtractor`]):
- Model that extracts features from generated images to be used as inputs for the `safety_checker`.
- """
- _optional_components = ["safety_checker", "feature_extractor"]
-
- def __init__(
- self,
- vae: AutoencoderKL,
- text_encoder: CLIPTextModel,
- tokenizer: CLIPTokenizer,
- unet: UNet2DConditionModel,
- scheduler: Union[
- DDIMScheduler,
- PNDMScheduler,
- LMSDiscreteScheduler,
- EulerDiscreteScheduler,
- EulerAncestralDiscreteScheduler,
- DPMSolverMultistepScheduler,
- ],
- safety_checker: StableDiffusionSafetyChecker,
- feature_extractor: CLIPFeatureExtractor,
- requires_safety_checker: bool = True,
- ):
- super().__init__()
-
- if hasattr(scheduler.config, "steps_offset") and scheduler.config.steps_offset != 1:
- deprecation_message = (
- f"The configuration file of this scheduler: {scheduler} is outdated. `steps_offset`"
- f" should be set to 1 instead of {scheduler.config.steps_offset}. Please make sure "
- "to update the config accordingly as leaving `steps_offset` might led to incorrect results"
- " in future versions. If you have downloaded this checkpoint from the Hugging Face Hub,"
- " it would be very nice if you could open a Pull request for the `scheduler/scheduler_config.json`"
- " file"
- )
- deprecate("steps_offset!=1", "1.0.0", deprecation_message, standard_warn=False)
- new_config = dict(scheduler.config)
- new_config["steps_offset"] = 1
- scheduler._internal_dict = FrozenDict(new_config)
-
- if hasattr(scheduler.config, "clip_sample") and scheduler.config.clip_sample is True:
- deprecation_message = (
- f"The configuration file of this scheduler: {scheduler} has not set the configuration `clip_sample`."
- " `clip_sample` should be set to False in the configuration file. Please make sure to update the"
- " config accordingly as not setting `clip_sample` in the config might lead to incorrect results in"
- " future versions. If you have downloaded this checkpoint from the Hugging Face Hub, it would be very"
- " nice if you could open a Pull request for the `scheduler/scheduler_config.json` file"
- )
- deprecate("clip_sample not set", "1.0.0", deprecation_message, standard_warn=False)
- new_config = dict(scheduler.config)
- new_config["clip_sample"] = False
- scheduler._internal_dict = FrozenDict(new_config)
-
- 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."
- )
-
- is_unet_version_less_0_9_0 = hasattr(unet.config, "_diffusers_version") and version.parse(
- version.parse(unet.config._diffusers_version).base_version
- ) < version.parse("0.9.0.dev0")
- is_unet_sample_size_less_64 = hasattr(unet.config, "sample_size") and unet.config.sample_size < 64
- if is_unet_version_less_0_9_0 and is_unet_sample_size_less_64:
- deprecation_message = (
- "The configuration file of the unet has set the default `sample_size` to smaller than"
- " 64 which seems highly unlikely .If you're checkpoint is a fine-tuned version of any of the"
- " following: \n- CompVis/stable-diffusion-v1-4 \n- CompVis/stable-diffusion-v1-3 \n-"
- " CompVis/stable-diffusion-v1-2 \n- CompVis/stable-diffusion-v1-1 \n- runwayml/stable-diffusion-v1-5"
- " \n- runwayml/stable-diffusion-inpainting \n you should change 'sample_size' to 64 in the"
- " configuration file. Please make sure to update the config accordingly as leaving `sample_size=32`"
- " in the config might lead to incorrect results in future versions. If you have downloaded this"
- " checkpoint from the Hugging Face Hub, it would be very nice if you could open a Pull request for"
- " the `unet/config.json` file"
- )
- deprecate("sample_size<64", "1.0.0", deprecation_message, standard_warn=False)
- new_config = dict(unet.config)
- new_config["sample_size"] = 64
- unet._internal_dict = FrozenDict(new_config)
-
- 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.register_to_config(requires_safety_checker=requires_safety_checker)
-
- def enable_attention_slicing(self, slice_size: Optional[Union[str, int]] = "auto"):
- r"""
- Enable sliced attention computation.
-
- When this option is enabled, the attention module will split the input tensor in slices, to compute attention
- in several steps. This is useful to save some memory in exchange for a small speed decrease.
-
- Args:
- slice_size (`str` or `int`, *optional*, defaults to `"auto"`):
- When `"auto"`, halves the input to the attention heads, so attention will be computed in two steps. If
- a number is provided, uses as many slices as `attention_head_dim // slice_size`. In this case,
- `attention_head_dim` must be a multiple of `slice_size`.
- """
- if slice_size == "auto":
- if isinstance(self.unet.config.attention_head_dim, int):
- # half the attention head size is usually a good trade-off between
- # speed and memory
- slice_size = self.unet.config.attention_head_dim // 2
- else:
- # if `attention_head_dim` is a list, take the smallest head size
- slice_size = min(self.unet.config.attention_head_dim)
-
- self.unet.set_attention_slice(slice_size)
-
- def disable_attention_slicing(self):
- r"""
- Disable sliced attention computation. If `enable_attention_slicing` was previously invoked, this method will go
- back to computing attention in one step.
- """
- # set slice_size = `None` to disable `attention slicing`
- self.enable_attention_slicing(None)
-
- 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()
-
- def disable_vae_slicing(self):
- r"""
- Disable sliced VAE decoding. If `enable_vae_slicing` was previously invoked, this method will go back to
- computing decoding in one step.
- """
- self.vae.disable_slicing()
-
- def enable_sequential_cpu_offload(self, gpu_id=0):
- r"""
- Offloads all models to CPU using accelerate, significantly reducing memory usage. When called, unet,
- text_encoder, vae and safety checker have their state dicts saved to CPU and then are moved to a
- `torch.device('meta') and loaded to GPU only when their specific submodule has its `forward` method called.
- """
- if is_accelerate_available():
- from accelerate import cpu_offload
- else:
- raise ImportError("Please install accelerate via `pip install accelerate`")
-
- device = torch.device(f"cuda:{gpu_id}")
-
- for cpu_offloaded_model in [self.unet, self.text_encoder, self.vae]:
- if cpu_offloaded_model is not None:
- cpu_offload(cpu_offloaded_model, device)
-
- if self.safety_checker is not None:
- # TODO(Patrick) - there is currently a bug with cpu offload of nn.Parameter in accelerate
- # fix by only offloading self.safety_checker for now
- cpu_offload(self.safety_checker.vision_model, device)
-
- @property
- def _execution_device(self):
- r"""
- Returns the device on which the pipeline's models will be executed. After calling
- `pipeline.enable_sequential_cpu_offload()` the execution device can only be inferred from Accelerate's module
- hooks.
- """
- if self.device != torch.device("meta") or not hasattr(self.unet, "_hf_hook"):
- return self.device
- for module in self.unet.modules():
- if (
- hasattr(module, "_hf_hook")
- and hasattr(module._hf_hook, "execution_device")
- and module._hf_hook.execution_device is not None
- ):
- return torch.device(module._hf_hook.execution_device)
- return self.device
-
- def _encode_prompt(self, prompt, device, num_images_per_prompt, do_classifier_free_guidance, negative_prompt):
- r"""
- Encodes the prompt into text encoder hidden states.
-
- Args:
- prompt (`str` or `list(int)`):
- 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]`):
- The prompt or prompts not to guide the image generation. Ignored when not using guidance (i.e., ignored
- if `guidance_scale` is less than `1`).
- """
- batch_size = len(prompt) if isinstance(prompt, list) else 1
-
- 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="max_length", return_tensors="pt").input_ids
-
- if 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
-
- text_embeddings = self.text_encoder(
- text_input_ids.to(device),
- attention_mask=attention_mask,
- )
- text_embeddings = text_embeddings[0]
-
- # duplicate text embeddings for each generation per prompt, using mps friendly method
- bs_embed, seq_len, _ = text_embeddings.shape
- text_embeddings = text_embeddings.repeat(1, num_images_per_prompt, 1)
- text_embeddings = text_embeddings.view(bs_embed * num_images_per_prompt, seq_len, -1)
-
- # get unconditional embeddings for classifier free guidance
- if do_classifier_free_guidance:
- uncond_tokens: List[str]
- if negative_prompt is None:
- uncond_tokens = [""] * batch_size
- elif type(prompt) is not type(negative_prompt):
- raise TypeError(
- f"`negative_prompt` should be the same type to `prompt`, but got {type(negative_prompt)} !="
- f" {type(prompt)}."
- )
- elif isinstance(negative_prompt, str):
- uncond_tokens = [negative_prompt]
- elif batch_size != len(negative_prompt):
- raise ValueError(
- f"`negative_prompt`: {negative_prompt} has batch size {len(negative_prompt)}, but `prompt`:"
- f" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches"
- " the batch size of `prompt`."
- )
- else:
- uncond_tokens = negative_prompt
-
- max_length = text_input_ids.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
-
- uncond_embeddings = self.text_encoder(
- uncond_input.input_ids.to(device),
- attention_mask=attention_mask,
- )
- uncond_embeddings = uncond_embeddings[0]
-
- # duplicate unconditional embeddings for each generation per prompt, using mps friendly method
- seq_len = uncond_embeddings.shape[1]
- uncond_embeddings = uncond_embeddings.repeat(1, num_images_per_prompt, 1)
- uncond_embeddings = uncond_embeddings.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
- text_embeddings = torch.cat([uncond_embeddings, text_embeddings])
-
- return text_embeddings
-
- def run_safety_checker(self, image, device, dtype):
- if self.safety_checker is not None:
- safety_checker_input = self.feature_extractor(self.numpy_to_pil(image), return_tensors="pt").to(device)
- image, has_nsfw_concept = self.safety_checker(
- images=image, clip_input=safety_checker_input.pixel_values.to(dtype)
- )
- else:
- has_nsfw_concept = None
- return image, has_nsfw_concept
-
- def decode_latents(self, latents):
- latents = 1 / 0.18215 * latents
- image = self.vae.decode(latents).sample
- image = (image / 2 + 0.5).clamp(0, 1)
- # we always cast to float32 as this does not cause significant overhead and is compatible with bfloa16
- image = image.cpu().permute(0, 2, 3, 1).float().numpy()
- return image
-
- def prepare_extra_step_kwargs(self, generator, eta):
- # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
- # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
- # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
- # and should be between [0, 1]
-
- accepts_eta = "eta" in set(inspect.signature(self.scheduler.step).parameters.keys())
- extra_step_kwargs = {}
- if accepts_eta:
- extra_step_kwargs["eta"] = eta
-
- # check if the scheduler accepts generator
- accepts_generator = "generator" in set(inspect.signature(self.scheduler.step).parameters.keys())
- if accepts_generator:
- extra_step_kwargs["generator"] = generator
- return extra_step_kwargs
-
- def check_inputs(self, prompt, height, width, callback_steps):
- if 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 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)}."
- )
-
- 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 latents is None:
- if device.type == "mps":
- # randn does not work reproducibly on mps
- latents = torch.randn(shape, generator=generator, device="cpu", dtype=dtype).to(device)
- else:
- latents = torch.randn(shape, generator=generator, device=device, dtype=dtype)
- else:
- if latents.shape != shape:
- raise ValueError(f"Unexpected latents shape, got {latents.shape}, expected {shape}")
- 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()
- def __call__(
- self,
- prompt: Union[str, List[str]],
- height: Optional[int] = None,
- width: Optional[int] = None,
- num_inference_steps: int = 50,
- guidance_scale: float = 7.5,
- negative_prompt: Optional[Union[str, List[str]]] = None,
- num_images_per_prompt: Optional[int] = 1,
- eta: float = 0.0,
- generator: Optional[torch.Generator] = None,
- latents: Optional[torch.FloatTensor] = None,
- output_type: Optional[str] = "pil",
- return_dict: bool = True,
- callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None,
- callback_steps: Optional[int] = 1,
- ):
- r"""
- Function invoked when calling the pipeline for generation.
-
- Args:
- prompt (`str` or `List[str]`):
- The prompt or prompts to guide the image generation.
- 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 7.5):
- Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598).
- `guidance_scale` is defined as `w` of equation 2. of [Imagen
- Paper](https://arxiv.org/pdf/2205.11487.pdf). Guidance scale is enabled by setting `guidance_scale >
- 1`. Higher guidance scale encourages to generate images that are closely linked to the text `prompt`,
- usually at the expense of lower image quality.
- negative_prompt (`str` or `List[str]`, *optional*):
- The prompt or prompts not to guide the image generation. Ignored when not using guidance (i.e., ignored
- if `guidance_scale` is less than `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 (η) in the DDIM paper: https://arxiv.org/abs/2010.02502. Only applies to
- [`schedulers.DDIMScheduler`], will be ignored for others.
- generator (`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 will ge generated by sampling using the supplied random `generator`.
- output_type (`str`, *optional*, defaults to `"pil"`):
- The output format of the generate image. Choose between
- [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.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 will be called every `callback_steps` steps during inference. The function will be
- 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 will be called. If not specified, the callback will be
- called at every step.
-
- Returns:
- [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] or `tuple`:
- [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] if `return_dict` is True, otherwise a `tuple.
- When returning a tuple, the first element is a list with the generated images, and the second element is a
- list of `bool`s denoting whether the corresponding generated image likely represents "not-safe-for-work"
- (nsfw) content, according to the `safety_checker`.
- """
- # 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)
-
- # 2. Define call parameters
- batch_size = 1 if isinstance(prompt, str) else len(prompt)
- 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
- text_embeddings = self._encode_prompt(
- prompt, device, num_images_per_prompt, do_classifier_free_guidance, negative_prompt
- )
-
- # 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.in_channels
- latents = self.prepare_latents(
- batch_size * num_images_per_prompt,
- num_channels_latents,
- height,
- width,
- text_embeddings.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=text_embeddings).sample
-
- # perform guidance
- if do_classifier_free_guidance:
- noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
- noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
-
- # compute the previous noisy sample x_t -> x_t-1
- latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs).prev_sample
-
- # call the callback, if provided
- if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):
- progress_bar.update()
- if callback is not None and i % callback_steps == 0:
- callback(i, t, latents)
-
- # 8. Post-processing
- image = self.decode_latents(latents)
-
- # 9. Run safety checker
- image, has_nsfw_concept = self.run_safety_checker(image, device, text_embeddings.dtype)
-
- # 10. Convert to PIL
- if output_type == "pil":
- image = self.numpy_to_pil(image)
-
- if not return_dict:
- return (image, has_nsfw_concept)
-
- return StableDiffusionPipelineOutput(images=image, nsfw_content_detected=has_nsfw_concept)
diff --git a/spaces/Yiqin/ChatVID/model/fastchat/model/convert_fp16.py b/spaces/Yiqin/ChatVID/model/fastchat/model/convert_fp16.py
deleted file mode 100644
index efc40aa83bf3a85129a668387df86a41d925f13d..0000000000000000000000000000000000000000
--- a/spaces/Yiqin/ChatVID/model/fastchat/model/convert_fp16.py
+++ /dev/null
@@ -1,26 +0,0 @@
-"""
-Usage:
-python3 -m fastchat.model.convert_fp16 --in in-folder --out out-folder
-"""
-import argparse
-
-from transformers import AutoTokenizer, AutoModelForCausalLM
-import torch
-
-
-def convert_fp16(in_checkpoint, out_checkpoint):
- tokenizer = AutoTokenizer.from_pretrained(in_checkpoint, use_fast=False)
- model = AutoModelForCausalLM.from_pretrained(
- in_checkpoint, torch_dtype=torch.float16, low_cpu_mem_usage=True
- )
- model.save_pretrained(out_checkpoint)
- tokenizer.save_pretrained(out_checkpoint)
-
-
-if __name__ == "__main__":
- parser = argparse.ArgumentParser()
- parser.add_argument("--in-checkpoint", type=str, help="Path to the model")
- parser.add_argument("--out-checkpoint", type=str, help="Path to the output model")
- args = parser.parse_args()
-
- convert_fp16(args.in_checkpoint, args.out_checkpoint)
diff --git a/spaces/YoannLemesle/CLIPictionary/sentence.py b/spaces/YoannLemesle/CLIPictionary/sentence.py
deleted file mode 100644
index 52b8b58ef2b880678cd9c6b1c9c5e39acf7d80a5..0000000000000000000000000000000000000000
--- a/spaces/YoannLemesle/CLIPictionary/sentence.py
+++ /dev/null
@@ -1,115 +0,0 @@
-from model import encoder_text
-import torch, clip, random
-import numpy as np
-device = torch.device("cpu")
-
-from words import words
-
-########## SENTENCE PART #######################################################
-voyelles = ["a","e","i","o","u"]
-links = list(words.keys())[1:]
-
-def link_text(part,nextWord):
- ### Check if we need to write "... a", "... an", "..."
- if (len(part["link"]) > 0) and (part["link"][-1] == "a"):
- voyelleStart = (nextWord[0] in voyelles)
- plural = (nextWord[-1] == "s" and nextWord[-2] != "s") or (nextWord in ["nothing","hair","vampire teeth","something"])
- else:
- voyelleStart, plural = False, False
- return (part["link"][:-2] if plural else part["link"] + ("n" if voyelleStart else ""))
-
-def part_text(part):
- l = link_text(part,part["word"])
- return l + (" " if len(l)>0 else "") + part["word"]
-
-def compute_embeddings(part,var_dict,prefix,batch_size=64):
- target = part["word"]
- possibleWords = list(set(words[part["link"]]) - set([target]+var_dict["found_words"]))
- if len(possibleWords) > (batch_size-1): possibleWords = np.random.choice(list(possibleWords),batch_size-1,replace=False).tolist()
- possibleWords.append(target)
- ### Compute all classes & embeddings for current sentence part
- part["classes"] = [prefix + link_text(part,w) + (" " if len(link_text(part,w))>0 else "") + w for w in possibleWords]
- with torch.no_grad():
- embeddings = encoder_text(clip.tokenize(part["classes"]).to(device))
- embeddings /= embeddings.norm(dim=-1, keepdim=True)
- part["embeddings"] = embeddings.tolist()
-
-########## SENTENCE ############################################################
-def iniSentence(var_dict,input="",first_game=False):
- var_dict["found_words"] = []
- var_dict["parts"] = []
- var_dict["step"] = 0
- prefix = ""
- N = (2 if var_dict["difficulty"] == 1 else 1)
-
- if first_game:
- link = "a drawing of a"
- part = {"link":link,"word":"cat","classes":[],"embeddings":[]}
- var_dict["parts"].append(part)
- compute_embeddings(part, var_dict, prefix)
- prefix += part_text(part) + " "
-
- link = "with a"
- part = {"link":link,"word":"face","classes":[],"embeddings":[]}
- var_dict["parts"].append(part)
- compute_embeddings(part, var_dict, prefix)
- prefix += part_text(part) + " "
- else:
- ##### Generating Random Sentence
- link = "a drawing of a"
- part = {"link":link,"word":np.random.choice(words[link]),"classes":[],"embeddings":[]}
- var_dict["parts"].append(part)
- compute_embeddings(part, var_dict, prefix)
- prefix += part_text(part) + " "
-
- for i in range(N-1):
- link = np.random.choice(links)
- part = {"link":link,"word":np.random.choice(words[link][1:]),"classes":[],"embeddings":[]}
- var_dict["parts"].append(part)
- compute_embeddings(part, var_dict, prefix)
- prefix += part_text(part) + " "
-
- var_dict["target_sentence"] = prefix[:-1] # Target sentence is prefix without the last space
- setState(var_dict)
- return var_dict["target_sentence"]
-
-def prevState(var_dict):
- if len(var_dict["prev_steps"]) > 0: var_dict["step"] = var_dict["prev_steps"].pop(-1)
- else: var_dict["step"] = 0
- var_dict["revertedState"] = True
- setState(var_dict)
-
-def setState(var_dict):
- var_dict["found_words"] = var_dict["found_words"][:var_dict["step"]]
- var_dict["guessed_sentence"] = ""
- for i in range(var_dict["step"]):
- var_dict["guessed_sentence"] += part_text(var_dict["parts"][i]) + " "
-
-def updateState(var_dict, preds):
- if not var_dict["revertedState"]: var_dict["prev_steps"].append(var_dict["step"])
- else: var_dict["revertedState"] = False
-
- ### Check if the current part has been guessed
- part = var_dict["parts"][var_dict["step"]]
-
-
- idx_of_nothing = -1
- if ("nothing" in preds[0]): idx_of_nothing = 0
- elif ("nothing" in preds[1]): idx_of_nothing = 1
- elif ("nothing" in preds[2]): idx_of_nothing = 2
-
- idx_of_guess = -1
- if (part["classes"][-1] == preds[0]): idx_of_guess = 0
- elif (part["classes"][-1] == preds[1]): idx_of_guess = 1
- elif (part["classes"][-1] == preds[2]): idx_of_guess = 2
-
-
- if not var_dict["win"] and (idx_of_guess > idx_of_nothing):
- var_dict["step"] += 1
- var_dict["found_words"].append(part["word"])
- var_dict["win"] = var_dict["step"] == len(var_dict["parts"])
- setState(var_dict)
- if var_dict["win"]: return 1
- else: return 0
- elif not var_dict["win"]: return -1
- else: return 1
diff --git a/spaces/YouLiXiya/Mobile-SAM/segment_anything/segment_anything/modeling/sam.py b/spaces/YouLiXiya/Mobile-SAM/segment_anything/segment_anything/modeling/sam.py
deleted file mode 100644
index 6ec6b85406c384c9a272fe3ba689d2e2fd8509ea..0000000000000000000000000000000000000000
--- a/spaces/YouLiXiya/Mobile-SAM/segment_anything/segment_anything/modeling/sam.py
+++ /dev/null
@@ -1,176 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-from typing import Any, Dict, List, Tuple
-
-from .image_encoder import ImageEncoderViT
-from .mask_decoder import MaskDecoder
-from .prompt_encoder import PromptEncoder
-
-
-class Sam(nn.Module):
- mask_threshold: float = 0.0
- image_format: str = "RGB"
-
- def __init__(
- self,
- image_encoder: ImageEncoderViT,
- prompt_encoder: PromptEncoder,
- mask_decoder: MaskDecoder,
- adaptor: nn.Module = None,
- pixel_mean: List[float] = [123.675, 116.28, 103.53],
- pixel_std: List[float] = [58.395, 57.12, 57.375],
- ) -> None:
- """
- SAM predicts object masks from an image and input prompts.
-
- Arguments:
- image_encoder (ImageEncoderViT): The backbone used to encode the
- image into image embeddings that allow for efficient mask prediction.
- prompt_encoder (PromptEncoder): Encodes various types of input prompts.
- mask_decoder (MaskDecoder): Predicts masks from the image embeddings
- and encoded prompts.
- pixel_mean (list(float)): Mean values for normalizing pixels in the input image.
- pixel_std (list(float)): Std values for normalizing pixels in the input image.
- """
- super().__init__()
- self.image_encoder = image_encoder
- self.prompt_encoder = prompt_encoder
- self.mask_decoder = mask_decoder
- self.adaptor = adaptor
- self.register_buffer("pixel_mean", torch.Tensor(pixel_mean).view(-1, 1, 1), False)
- self.register_buffer("pixel_std", torch.Tensor(pixel_std).view(-1, 1, 1), False)
-
- @property
- def device(self) -> Any:
- return self.pixel_mean.device
-
- @torch.no_grad()
- def forward(
- self,
- batched_input: List[Dict[str, Any]],
- multimask_output: bool,
- ) -> List[Dict[str, torch.Tensor]]:
- """
- Predicts masks end-to-end from provided images and prompts.
- If prompts are not known in advance, using SamPredictor is
- recommended over calling the model directly.
-
- Arguments:
- batched_input (list(dict)): A list over input images, each a
- dictionary with the following keys. A prompt key can be
- excluded if it is not present.
- 'image': The image as a torch tensor in 3xHxW format,
- already transformed for input to the model.
- 'original_size': (tuple(int, int)) The original size of
- the image before transformation, as (H, W).
- 'point_coords': (torch.Tensor) Batched point prompts for
- this image, with shape BxNx2. Already transformed to the
- input frame of the model.
- 'point_labels': (torch.Tensor) Batched labels for point prompts,
- with shape BxN.
- 'boxes': (torch.Tensor) Batched box inputs, with shape Bx4.
- Already transformed to the input frame of the model.
- 'mask_inputs': (torch.Tensor) Batched mask inputs to the model,
- in the form Bx1xHxW.
- multimask_output (bool): Whether the model should predict multiple
- disambiguating masks, or return a single mask.
-
- Returns:
- (list(dict)): A list over input images, where each element is
- as dictionary with the following keys.
- 'masks': (torch.Tensor) Batched binary mask predictions,
- with shape BxCxHxW, where B is the number of input promts,
- C is determiend by multimask_output, and (H, W) is the
- original size of the image.
- 'iou_predictions': (torch.Tensor) The model's predictions
- of mask quality, in shape BxC.
- 'low_res_logits': (torch.Tensor) Low resolution logits with
- shape BxCxHxW, where H=W=256. Can be passed as mask input
- to subsequent iterations of prediction.
- """
- input_images = torch.stack([self.preprocess(x["image"]) for x in batched_input], dim=0)
- image_embeddings = self.image_encoder(input_images)
-
- outputs = []
- for image_record, curr_embedding in zip(batched_input, image_embeddings):
- if "point_coords" in image_record:
- points = (image_record["point_coords"], image_record["point_labels"])
- else:
- points = None
- sparse_embeddings, dense_embeddings = self.prompt_encoder(
- points=points,
- boxes=image_record.get("boxes", None),
- masks=image_record.get("mask_inputs", None),
- )
- low_res_masks, iou_predictions = self.mask_decoder(
- image_embeddings=curr_embedding.unsqueeze(0),
- image_pe=self.prompt_encoder.get_dense_pe(),
- sparse_prompt_embeddings=sparse_embeddings,
- dense_prompt_embeddings=dense_embeddings,
- multimask_output=multimask_output,
- )
- masks = self.postprocess_masks(
- low_res_masks,
- input_size=image_record["image"].shape[-2:],
- original_size=image_record["original_size"],
- )
- masks = masks > self.mask_threshold
- outputs.append(
- {
- "masks": masks,
- "iou_predictions": iou_predictions,
- "low_res_logits": low_res_masks,
- }
- )
- return outputs
-
- def postprocess_masks(
- self,
- masks: torch.Tensor,
- input_size: Tuple[int, ...],
- original_size: Tuple[int, ...],
- ) -> torch.Tensor:
- """
- Remove padding and upscale masks to the original image size.
-
- Arguments:
- masks (torch.Tensor): Batched masks from the mask_decoder,
- in BxCxHxW format.
- input_size (tuple(int, int)): The size of the image input to the
- model, in (H, W) format. Used to remove padding.
- original_size (tuple(int, int)): The original size of the image
- before resizing for input to the model, in (H, W) format.
-
- Returns:
- (torch.Tensor): Batched masks in BxCxHxW format, where (H, W)
- is given by original_size.
- """
- masks = F.interpolate(
- masks,
- (self.image_encoder.img_size, self.image_encoder.img_size),
- mode="bilinear",
- align_corners=False,
- )
- masks = masks[..., : input_size[0], : input_size[1]]
- masks = F.interpolate(masks, original_size, mode="bilinear", align_corners=False)
- return masks
-
- def preprocess(self, x: torch.Tensor) -> torch.Tensor:
- """Normalize pixel values and pad to a square input."""
- # Normalize colors
- x = (x - self.pixel_mean) / self.pixel_std
-
- # Pad
- h, w = x.shape[-2:]
- padh = self.image_encoder.img_size - h
- padw = self.image_encoder.img_size - w
- x = F.pad(x, (0, padw, 0, padh))
- return x
diff --git a/spaces/ZApkh/test/Dockerfile b/spaces/ZApkh/test/Dockerfile
deleted file mode 100644
index 6c01c09373883afcb4ea34ae2d316cd596e1737b..0000000000000000000000000000000000000000
--- a/spaces/ZApkh/test/Dockerfile
+++ /dev/null
@@ -1,21 +0,0 @@
-FROM node:18-bullseye-slim
-
-RUN apt-get update && \
-
-apt-get install -y git
-
-RUN git clone https://gitgud.io/khanon/oai-reverse-proxy.git /app
-
-WORKDIR /app
-
-RUN npm install
-
-COPY Dockerfile greeting.md* .env* ./
-
-RUN npm run build
-
-EXPOSE 7860
-
-ENV NODE_ENV=production
-
-CMD [ "npm", "start" ]
\ No newline at end of file
diff --git a/spaces/abhishek/sketch-to-image/annotator/uniformer/mmdet_null/models/dense_heads/guided_anchor_head.py b/spaces/abhishek/sketch-to-image/annotator/uniformer/mmdet_null/models/dense_heads/guided_anchor_head.py
deleted file mode 100644
index 997ebb751ade2ebae3fce335a08c46f596c60913..0000000000000000000000000000000000000000
--- a/spaces/abhishek/sketch-to-image/annotator/uniformer/mmdet_null/models/dense_heads/guided_anchor_head.py
+++ /dev/null
@@ -1,860 +0,0 @@
-import torch
-import torch.nn as nn
-from mmcv.cnn import bias_init_with_prob, normal_init
-from mmcv.ops import DeformConv2d, MaskedConv2d
-from mmcv.runner import force_fp32
-
-from mmdet.core import (anchor_inside_flags, build_anchor_generator,
- build_assigner, build_bbox_coder, build_sampler,
- calc_region, images_to_levels, multi_apply,
- multiclass_nms, unmap)
-from ..builder import HEADS, build_loss
-from .anchor_head import AnchorHead
-
-
-class FeatureAdaption(nn.Module):
- """Feature Adaption Module.
-
- Feature Adaption Module is implemented based on DCN v1.
- It uses anchor shape prediction rather than feature map to
- predict offsets of deform conv layer.
-
- Args:
- in_channels (int): Number of channels in the input feature map.
- out_channels (int): Number of channels in the output feature map.
- kernel_size (int): Deformable conv kernel size.
- deform_groups (int): Deformable conv group size.
- """
-
- def __init__(self,
- in_channels,
- out_channels,
- kernel_size=3,
- deform_groups=4):
- super(FeatureAdaption, self).__init__()
- offset_channels = kernel_size * kernel_size * 2
- self.conv_offset = nn.Conv2d(
- 2, deform_groups * offset_channels, 1, bias=False)
- self.conv_adaption = DeformConv2d(
- in_channels,
- out_channels,
- kernel_size=kernel_size,
- padding=(kernel_size - 1) // 2,
- deform_groups=deform_groups)
- self.relu = nn.ReLU(inplace=True)
-
- def init_weights(self):
- normal_init(self.conv_offset, std=0.1)
- normal_init(self.conv_adaption, std=0.01)
-
- def forward(self, x, shape):
- offset = self.conv_offset(shape.detach())
- x = self.relu(self.conv_adaption(x, offset))
- return x
-
-
-@HEADS.register_module()
-class GuidedAnchorHead(AnchorHead):
- """Guided-Anchor-based head (GA-RPN, GA-RetinaNet, etc.).
-
- This GuidedAnchorHead will predict high-quality feature guided
- anchors and locations where anchors will be kept in inference.
- There are mainly 3 categories of bounding-boxes.
-
- - Sampled 9 pairs for target assignment. (approxes)
- - The square boxes where the predicted anchors are based on. (squares)
- - Guided anchors.
-
- Please refer to https://arxiv.org/abs/1901.03278 for more details.
-
- Args:
- num_classes (int): Number of classes.
- in_channels (int): Number of channels in the input feature map.
- feat_channels (int): Number of hidden channels.
- approx_anchor_generator (dict): Config dict for approx generator
- square_anchor_generator (dict): Config dict for square generator
- anchor_coder (dict): Config dict for anchor coder
- bbox_coder (dict): Config dict for bbox coder
- reg_decoded_bbox (bool): If true, the regression loss would be
- applied directly on decoded bounding boxes, converting both
- the predicted boxes and regression targets to absolute
- coordinates format. Default False. It should be `True` when
- using `IoULoss`, `GIoULoss`, or `DIoULoss` in the bbox head.
- deform_groups: (int): Group number of DCN in
- FeatureAdaption module.
- loc_filter_thr (float): Threshold to filter out unconcerned regions.
- loss_loc (dict): Config of location loss.
- loss_shape (dict): Config of anchor shape loss.
- loss_cls (dict): Config of classification loss.
- loss_bbox (dict): Config of bbox regression loss.
- """
-
- def __init__(
- self,
- num_classes,
- in_channels,
- feat_channels=256,
- approx_anchor_generator=dict(
- type='AnchorGenerator',
- octave_base_scale=8,
- scales_per_octave=3,
- ratios=[0.5, 1.0, 2.0],
- strides=[4, 8, 16, 32, 64]),
- square_anchor_generator=dict(
- type='AnchorGenerator',
- ratios=[1.0],
- scales=[8],
- strides=[4, 8, 16, 32, 64]),
- anchor_coder=dict(
- type='DeltaXYWHBBoxCoder',
- target_means=[.0, .0, .0, .0],
- target_stds=[1.0, 1.0, 1.0, 1.0]
- ),
- bbox_coder=dict(
- type='DeltaXYWHBBoxCoder',
- target_means=[.0, .0, .0, .0],
- target_stds=[1.0, 1.0, 1.0, 1.0]
- ),
- reg_decoded_bbox=False,
- deform_groups=4,
- loc_filter_thr=0.01,
- train_cfg=None,
- test_cfg=None,
- loss_loc=dict(
- type='FocalLoss',
- use_sigmoid=True,
- gamma=2.0,
- alpha=0.25,
- loss_weight=1.0),
- loss_shape=dict(type='BoundedIoULoss', beta=0.2, loss_weight=1.0),
- loss_cls=dict(
- type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0),
- loss_bbox=dict(type='SmoothL1Loss', beta=1.0,
- loss_weight=1.0)): # yapf: disable
- super(AnchorHead, self).__init__()
- self.in_channels = in_channels
- self.num_classes = num_classes
- self.feat_channels = feat_channels
- self.deform_groups = deform_groups
- self.loc_filter_thr = loc_filter_thr
-
- # build approx_anchor_generator and square_anchor_generator
- assert (approx_anchor_generator['octave_base_scale'] ==
- square_anchor_generator['scales'][0])
- assert (approx_anchor_generator['strides'] ==
- square_anchor_generator['strides'])
- self.approx_anchor_generator = build_anchor_generator(
- approx_anchor_generator)
- self.square_anchor_generator = build_anchor_generator(
- square_anchor_generator)
- self.approxs_per_octave = self.approx_anchor_generator \
- .num_base_anchors[0]
-
- self.reg_decoded_bbox = reg_decoded_bbox
-
- # one anchor per location
- self.num_anchors = 1
- self.use_sigmoid_cls = loss_cls.get('use_sigmoid', False)
- self.loc_focal_loss = loss_loc['type'] in ['FocalLoss']
- self.sampling = loss_cls['type'] not in ['FocalLoss']
- self.ga_sampling = train_cfg is not None and hasattr(
- train_cfg, 'ga_sampler')
- if self.use_sigmoid_cls:
- self.cls_out_channels = self.num_classes
- else:
- self.cls_out_channels = self.num_classes + 1
-
- # build bbox_coder
- self.anchor_coder = build_bbox_coder(anchor_coder)
- self.bbox_coder = build_bbox_coder(bbox_coder)
-
- # build losses
- self.loss_loc = build_loss(loss_loc)
- self.loss_shape = build_loss(loss_shape)
- self.loss_cls = build_loss(loss_cls)
- self.loss_bbox = build_loss(loss_bbox)
-
- self.train_cfg = train_cfg
- self.test_cfg = test_cfg
-
- if self.train_cfg:
- self.assigner = build_assigner(self.train_cfg.assigner)
- # use PseudoSampler when sampling is False
- if self.sampling and hasattr(self.train_cfg, 'sampler'):
- sampler_cfg = self.train_cfg.sampler
- else:
- sampler_cfg = dict(type='PseudoSampler')
- self.sampler = build_sampler(sampler_cfg, context=self)
-
- self.ga_assigner = build_assigner(self.train_cfg.ga_assigner)
- if self.ga_sampling:
- ga_sampler_cfg = self.train_cfg.ga_sampler
- else:
- ga_sampler_cfg = dict(type='PseudoSampler')
- self.ga_sampler = build_sampler(ga_sampler_cfg, context=self)
-
- self.fp16_enabled = False
-
- self._init_layers()
-
- def _init_layers(self):
- self.relu = nn.ReLU(inplace=True)
- self.conv_loc = nn.Conv2d(self.in_channels, 1, 1)
- self.conv_shape = nn.Conv2d(self.in_channels, self.num_anchors * 2, 1)
- self.feature_adaption = FeatureAdaption(
- self.in_channels,
- self.feat_channels,
- kernel_size=3,
- deform_groups=self.deform_groups)
- self.conv_cls = MaskedConv2d(self.feat_channels,
- self.num_anchors * self.cls_out_channels,
- 1)
- self.conv_reg = MaskedConv2d(self.feat_channels, self.num_anchors * 4,
- 1)
-
- def init_weights(self):
- normal_init(self.conv_cls, std=0.01)
- normal_init(self.conv_reg, std=0.01)
-
- bias_cls = bias_init_with_prob(0.01)
- normal_init(self.conv_loc, std=0.01, bias=bias_cls)
- normal_init(self.conv_shape, std=0.01)
-
- self.feature_adaption.init_weights()
-
- def forward_single(self, x):
- loc_pred = self.conv_loc(x)
- shape_pred = self.conv_shape(x)
- x = self.feature_adaption(x, shape_pred)
- # masked conv is only used during inference for speed-up
- if not self.training:
- mask = loc_pred.sigmoid()[0] >= self.loc_filter_thr
- else:
- mask = None
- cls_score = self.conv_cls(x, mask)
- bbox_pred = self.conv_reg(x, mask)
- return cls_score, bbox_pred, shape_pred, loc_pred
-
- def forward(self, feats):
- return multi_apply(self.forward_single, feats)
-
- def get_sampled_approxs(self, featmap_sizes, img_metas, device='cuda'):
- """Get sampled approxs and inside flags according to feature map sizes.
-
- Args:
- featmap_sizes (list[tuple]): Multi-level feature map sizes.
- img_metas (list[dict]): Image meta info.
- device (torch.device | str): device for returned tensors
-
- Returns:
- tuple: approxes of each image, inside flags of each image
- """
- num_imgs = len(img_metas)
-
- # since feature map sizes of all images are the same, we only compute
- # approxes for one time
- multi_level_approxs = self.approx_anchor_generator.grid_anchors(
- featmap_sizes, device=device)
- approxs_list = [multi_level_approxs for _ in range(num_imgs)]
-
- # for each image, we compute inside flags of multi level approxes
- inside_flag_list = []
- for img_id, img_meta in enumerate(img_metas):
- multi_level_flags = []
- multi_level_approxs = approxs_list[img_id]
-
- # obtain valid flags for each approx first
- multi_level_approx_flags = self.approx_anchor_generator \
- .valid_flags(featmap_sizes,
- img_meta['pad_shape'],
- device=device)
-
- for i, flags in enumerate(multi_level_approx_flags):
- approxs = multi_level_approxs[i]
- inside_flags_list = []
- for i in range(self.approxs_per_octave):
- split_valid_flags = flags[i::self.approxs_per_octave]
- split_approxs = approxs[i::self.approxs_per_octave, :]
- inside_flags = anchor_inside_flags(
- split_approxs, split_valid_flags,
- img_meta['img_shape'][:2],
- self.train_cfg.allowed_border)
- inside_flags_list.append(inside_flags)
- # inside_flag for a position is true if any anchor in this
- # position is true
- inside_flags = (
- torch.stack(inside_flags_list, 0).sum(dim=0) > 0)
- multi_level_flags.append(inside_flags)
- inside_flag_list.append(multi_level_flags)
- return approxs_list, inside_flag_list
-
- def get_anchors(self,
- featmap_sizes,
- shape_preds,
- loc_preds,
- img_metas,
- use_loc_filter=False,
- device='cuda'):
- """Get squares according to feature map sizes and guided anchors.
-
- Args:
- featmap_sizes (list[tuple]): Multi-level feature map sizes.
- shape_preds (list[tensor]): Multi-level shape predictions.
- loc_preds (list[tensor]): Multi-level location predictions.
- img_metas (list[dict]): Image meta info.
- use_loc_filter (bool): Use loc filter or not.
- device (torch.device | str): device for returned tensors
-
- Returns:
- tuple: square approxs of each image, guided anchors of each image,
- loc masks of each image
- """
- num_imgs = len(img_metas)
- num_levels = len(featmap_sizes)
-
- # since feature map sizes of all images are the same, we only compute
- # squares for one time
- multi_level_squares = self.square_anchor_generator.grid_anchors(
- featmap_sizes, device=device)
- squares_list = [multi_level_squares for _ in range(num_imgs)]
-
- # for each image, we compute multi level guided anchors
- guided_anchors_list = []
- loc_mask_list = []
- for img_id, img_meta in enumerate(img_metas):
- multi_level_guided_anchors = []
- multi_level_loc_mask = []
- for i in range(num_levels):
- squares = squares_list[img_id][i]
- shape_pred = shape_preds[i][img_id]
- loc_pred = loc_preds[i][img_id]
- guided_anchors, loc_mask = self._get_guided_anchors_single(
- squares,
- shape_pred,
- loc_pred,
- use_loc_filter=use_loc_filter)
- multi_level_guided_anchors.append(guided_anchors)
- multi_level_loc_mask.append(loc_mask)
- guided_anchors_list.append(multi_level_guided_anchors)
- loc_mask_list.append(multi_level_loc_mask)
- return squares_list, guided_anchors_list, loc_mask_list
-
- def _get_guided_anchors_single(self,
- squares,
- shape_pred,
- loc_pred,
- use_loc_filter=False):
- """Get guided anchors and loc masks for a single level.
-
- Args:
- square (tensor): Squares of a single level.
- shape_pred (tensor): Shape predections of a single level.
- loc_pred (tensor): Loc predections of a single level.
- use_loc_filter (list[tensor]): Use loc filter or not.
-
- Returns:
- tuple: guided anchors, location masks
- """
- # calculate location filtering mask
- loc_pred = loc_pred.sigmoid().detach()
- if use_loc_filter:
- loc_mask = loc_pred >= self.loc_filter_thr
- else:
- loc_mask = loc_pred >= 0.0
- mask = loc_mask.permute(1, 2, 0).expand(-1, -1, self.num_anchors)
- mask = mask.contiguous().view(-1)
- # calculate guided anchors
- squares = squares[mask]
- anchor_deltas = shape_pred.permute(1, 2, 0).contiguous().view(
- -1, 2).detach()[mask]
- bbox_deltas = anchor_deltas.new_full(squares.size(), 0)
- bbox_deltas[:, 2:] = anchor_deltas
- guided_anchors = self.anchor_coder.decode(
- squares, bbox_deltas, wh_ratio_clip=1e-6)
- return guided_anchors, mask
-
- def ga_loc_targets(self, gt_bboxes_list, featmap_sizes):
- """Compute location targets for guided anchoring.
-
- Each feature map is divided into positive, negative and ignore regions.
- - positive regions: target 1, weight 1
- - ignore regions: target 0, weight 0
- - negative regions: target 0, weight 0.1
-
- Args:
- gt_bboxes_list (list[Tensor]): Gt bboxes of each image.
- featmap_sizes (list[tuple]): Multi level sizes of each feature
- maps.
-
- Returns:
- tuple
- """
- anchor_scale = self.approx_anchor_generator.octave_base_scale
- anchor_strides = self.approx_anchor_generator.strides
- # Currently only supports same stride in x and y direction.
- for stride in anchor_strides:
- assert (stride[0] == stride[1])
- anchor_strides = [stride[0] for stride in anchor_strides]
-
- center_ratio = self.train_cfg.center_ratio
- ignore_ratio = self.train_cfg.ignore_ratio
- img_per_gpu = len(gt_bboxes_list)
- num_lvls = len(featmap_sizes)
- r1 = (1 - center_ratio) / 2
- r2 = (1 - ignore_ratio) / 2
- all_loc_targets = []
- all_loc_weights = []
- all_ignore_map = []
- for lvl_id in range(num_lvls):
- h, w = featmap_sizes[lvl_id]
- loc_targets = torch.zeros(
- img_per_gpu,
- 1,
- h,
- w,
- device=gt_bboxes_list[0].device,
- dtype=torch.float32)
- loc_weights = torch.full_like(loc_targets, -1)
- ignore_map = torch.zeros_like(loc_targets)
- all_loc_targets.append(loc_targets)
- all_loc_weights.append(loc_weights)
- all_ignore_map.append(ignore_map)
- for img_id in range(img_per_gpu):
- gt_bboxes = gt_bboxes_list[img_id]
- scale = torch.sqrt((gt_bboxes[:, 2] - gt_bboxes[:, 0]) *
- (gt_bboxes[:, 3] - gt_bboxes[:, 1]))
- min_anchor_size = scale.new_full(
- (1, ), float(anchor_scale * anchor_strides[0]))
- # assign gt bboxes to different feature levels w.r.t. their scales
- target_lvls = torch.floor(
- torch.log2(scale) - torch.log2(min_anchor_size) + 0.5)
- target_lvls = target_lvls.clamp(min=0, max=num_lvls - 1).long()
- for gt_id in range(gt_bboxes.size(0)):
- lvl = target_lvls[gt_id].item()
- # rescaled to corresponding feature map
- gt_ = gt_bboxes[gt_id, :4] / anchor_strides[lvl]
- # calculate ignore regions
- ignore_x1, ignore_y1, ignore_x2, ignore_y2 = calc_region(
- gt_, r2, featmap_sizes[lvl])
- # calculate positive (center) regions
- ctr_x1, ctr_y1, ctr_x2, ctr_y2 = calc_region(
- gt_, r1, featmap_sizes[lvl])
- all_loc_targets[lvl][img_id, 0, ctr_y1:ctr_y2 + 1,
- ctr_x1:ctr_x2 + 1] = 1
- all_loc_weights[lvl][img_id, 0, ignore_y1:ignore_y2 + 1,
- ignore_x1:ignore_x2 + 1] = 0
- all_loc_weights[lvl][img_id, 0, ctr_y1:ctr_y2 + 1,
- ctr_x1:ctr_x2 + 1] = 1
- # calculate ignore map on nearby low level feature
- if lvl > 0:
- d_lvl = lvl - 1
- # rescaled to corresponding feature map
- gt_ = gt_bboxes[gt_id, :4] / anchor_strides[d_lvl]
- ignore_x1, ignore_y1, ignore_x2, ignore_y2 = calc_region(
- gt_, r2, featmap_sizes[d_lvl])
- all_ignore_map[d_lvl][img_id, 0, ignore_y1:ignore_y2 + 1,
- ignore_x1:ignore_x2 + 1] = 1
- # calculate ignore map on nearby high level feature
- if lvl < num_lvls - 1:
- u_lvl = lvl + 1
- # rescaled to corresponding feature map
- gt_ = gt_bboxes[gt_id, :4] / anchor_strides[u_lvl]
- ignore_x1, ignore_y1, ignore_x2, ignore_y2 = calc_region(
- gt_, r2, featmap_sizes[u_lvl])
- all_ignore_map[u_lvl][img_id, 0, ignore_y1:ignore_y2 + 1,
- ignore_x1:ignore_x2 + 1] = 1
- for lvl_id in range(num_lvls):
- # ignore negative regions w.r.t. ignore map
- all_loc_weights[lvl_id][(all_loc_weights[lvl_id] < 0)
- & (all_ignore_map[lvl_id] > 0)] = 0
- # set negative regions with weight 0.1
- all_loc_weights[lvl_id][all_loc_weights[lvl_id] < 0] = 0.1
- # loc average factor to balance loss
- loc_avg_factor = sum(
- [t.size(0) * t.size(-1) * t.size(-2)
- for t in all_loc_targets]) / 200
- return all_loc_targets, all_loc_weights, loc_avg_factor
-
- def _ga_shape_target_single(self,
- flat_approxs,
- inside_flags,
- flat_squares,
- gt_bboxes,
- gt_bboxes_ignore,
- img_meta,
- unmap_outputs=True):
- """Compute guided anchoring targets.
-
- This function returns sampled anchors and gt bboxes directly
- rather than calculates regression targets.
-
- Args:
- flat_approxs (Tensor): flat approxs of a single image,
- shape (n, 4)
- inside_flags (Tensor): inside flags of a single image,
- shape (n, ).
- flat_squares (Tensor): flat squares of a single image,
- shape (approxs_per_octave * n, 4)
- gt_bboxes (Tensor): Ground truth bboxes of a single image.
- img_meta (dict): Meta info of a single image.
- approxs_per_octave (int): number of approxs per octave
- cfg (dict): RPN train configs.
- unmap_outputs (bool): unmap outputs or not.
-
- Returns:
- tuple
- """
- if not inside_flags.any():
- return (None, ) * 5
- # assign gt and sample anchors
- expand_inside_flags = inside_flags[:, None].expand(
- -1, self.approxs_per_octave).reshape(-1)
- approxs = flat_approxs[expand_inside_flags, :]
- squares = flat_squares[inside_flags, :]
-
- assign_result = self.ga_assigner.assign(approxs, squares,
- self.approxs_per_octave,
- gt_bboxes, gt_bboxes_ignore)
- sampling_result = self.ga_sampler.sample(assign_result, squares,
- gt_bboxes)
-
- bbox_anchors = torch.zeros_like(squares)
- bbox_gts = torch.zeros_like(squares)
- bbox_weights = torch.zeros_like(squares)
-
- pos_inds = sampling_result.pos_inds
- neg_inds = sampling_result.neg_inds
- if len(pos_inds) > 0:
- bbox_anchors[pos_inds, :] = sampling_result.pos_bboxes
- bbox_gts[pos_inds, :] = sampling_result.pos_gt_bboxes
- bbox_weights[pos_inds, :] = 1.0
-
- # map up to original set of anchors
- if unmap_outputs:
- num_total_anchors = flat_squares.size(0)
- bbox_anchors = unmap(bbox_anchors, num_total_anchors, inside_flags)
- bbox_gts = unmap(bbox_gts, num_total_anchors, inside_flags)
- bbox_weights = unmap(bbox_weights, num_total_anchors, inside_flags)
-
- return (bbox_anchors, bbox_gts, bbox_weights, pos_inds, neg_inds)
-
- def ga_shape_targets(self,
- approx_list,
- inside_flag_list,
- square_list,
- gt_bboxes_list,
- img_metas,
- gt_bboxes_ignore_list=None,
- unmap_outputs=True):
- """Compute guided anchoring targets.
-
- Args:
- approx_list (list[list]): Multi level approxs of each image.
- inside_flag_list (list[list]): Multi level inside flags of each
- image.
- square_list (list[list]): Multi level squares of each image.
- gt_bboxes_list (list[Tensor]): Ground truth bboxes of each image.
- img_metas (list[dict]): Meta info of each image.
- gt_bboxes_ignore_list (list[Tensor]): ignore list of gt bboxes.
- unmap_outputs (bool): unmap outputs or not.
-
- Returns:
- tuple
- """
- num_imgs = len(img_metas)
- assert len(approx_list) == len(inside_flag_list) == len(
- square_list) == num_imgs
- # anchor number of multi levels
- num_level_squares = [squares.size(0) for squares in square_list[0]]
- # concat all level anchors and flags to a single tensor
- inside_flag_flat_list = []
- approx_flat_list = []
- square_flat_list = []
- for i in range(num_imgs):
- assert len(square_list[i]) == len(inside_flag_list[i])
- inside_flag_flat_list.append(torch.cat(inside_flag_list[i]))
- approx_flat_list.append(torch.cat(approx_list[i]))
- square_flat_list.append(torch.cat(square_list[i]))
-
- # compute targets for each image
- if gt_bboxes_ignore_list is None:
- gt_bboxes_ignore_list = [None for _ in range(num_imgs)]
- (all_bbox_anchors, all_bbox_gts, all_bbox_weights, pos_inds_list,
- neg_inds_list) = multi_apply(
- self._ga_shape_target_single,
- approx_flat_list,
- inside_flag_flat_list,
- square_flat_list,
- gt_bboxes_list,
- gt_bboxes_ignore_list,
- img_metas,
- unmap_outputs=unmap_outputs)
- # no valid anchors
- if any([bbox_anchors is None for bbox_anchors in all_bbox_anchors]):
- return None
- # sampled anchors of all images
- num_total_pos = sum([max(inds.numel(), 1) for inds in pos_inds_list])
- num_total_neg = sum([max(inds.numel(), 1) for inds in neg_inds_list])
- # split targets to a list w.r.t. multiple levels
- bbox_anchors_list = images_to_levels(all_bbox_anchors,
- num_level_squares)
- bbox_gts_list = images_to_levels(all_bbox_gts, num_level_squares)
- bbox_weights_list = images_to_levels(all_bbox_weights,
- num_level_squares)
- return (bbox_anchors_list, bbox_gts_list, bbox_weights_list,
- num_total_pos, num_total_neg)
-
- def loss_shape_single(self, shape_pred, bbox_anchors, bbox_gts,
- anchor_weights, anchor_total_num):
- shape_pred = shape_pred.permute(0, 2, 3, 1).contiguous().view(-1, 2)
- bbox_anchors = bbox_anchors.contiguous().view(-1, 4)
- bbox_gts = bbox_gts.contiguous().view(-1, 4)
- anchor_weights = anchor_weights.contiguous().view(-1, 4)
- bbox_deltas = bbox_anchors.new_full(bbox_anchors.size(), 0)
- bbox_deltas[:, 2:] += shape_pred
- # filter out negative samples to speed-up weighted_bounded_iou_loss
- inds = torch.nonzero(
- anchor_weights[:, 0] > 0, as_tuple=False).squeeze(1)
- bbox_deltas_ = bbox_deltas[inds]
- bbox_anchors_ = bbox_anchors[inds]
- bbox_gts_ = bbox_gts[inds]
- anchor_weights_ = anchor_weights[inds]
- pred_anchors_ = self.anchor_coder.decode(
- bbox_anchors_, bbox_deltas_, wh_ratio_clip=1e-6)
- loss_shape = self.loss_shape(
- pred_anchors_,
- bbox_gts_,
- anchor_weights_,
- avg_factor=anchor_total_num)
- return loss_shape
-
- def loss_loc_single(self, loc_pred, loc_target, loc_weight,
- loc_avg_factor):
- loss_loc = self.loss_loc(
- loc_pred.reshape(-1, 1),
- loc_target.reshape(-1).long(),
- loc_weight.reshape(-1),
- avg_factor=loc_avg_factor)
- return loss_loc
-
- @force_fp32(
- apply_to=('cls_scores', 'bbox_preds', 'shape_preds', 'loc_preds'))
- def loss(self,
- cls_scores,
- bbox_preds,
- shape_preds,
- loc_preds,
- gt_bboxes,
- gt_labels,
- img_metas,
- gt_bboxes_ignore=None):
- featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
- assert len(featmap_sizes) == self.approx_anchor_generator.num_levels
-
- device = cls_scores[0].device
-
- # get loc targets
- loc_targets, loc_weights, loc_avg_factor = self.ga_loc_targets(
- gt_bboxes, featmap_sizes)
-
- # get sampled approxes
- approxs_list, inside_flag_list = self.get_sampled_approxs(
- featmap_sizes, img_metas, device=device)
- # get squares and guided anchors
- squares_list, guided_anchors_list, _ = self.get_anchors(
- featmap_sizes, shape_preds, loc_preds, img_metas, device=device)
-
- # get shape targets
- shape_targets = self.ga_shape_targets(approxs_list, inside_flag_list,
- squares_list, gt_bboxes,
- img_metas)
- if shape_targets is None:
- return None
- (bbox_anchors_list, bbox_gts_list, anchor_weights_list, anchor_fg_num,
- anchor_bg_num) = shape_targets
- anchor_total_num = (
- anchor_fg_num if not self.ga_sampling else anchor_fg_num +
- anchor_bg_num)
-
- # get anchor targets
- label_channels = self.cls_out_channels if self.use_sigmoid_cls else 1
- cls_reg_targets = self.get_targets(
- guided_anchors_list,
- inside_flag_list,
- gt_bboxes,
- img_metas,
- gt_bboxes_ignore_list=gt_bboxes_ignore,
- gt_labels_list=gt_labels,
- label_channels=label_channels)
- if cls_reg_targets is None:
- return None
- (labels_list, label_weights_list, bbox_targets_list, bbox_weights_list,
- num_total_pos, num_total_neg) = cls_reg_targets
- num_total_samples = (
- num_total_pos + num_total_neg if self.sampling else num_total_pos)
-
- # anchor number of multi levels
- num_level_anchors = [
- anchors.size(0) for anchors in guided_anchors_list[0]
- ]
- # concat all level anchors to a single tensor
- concat_anchor_list = []
- for i in range(len(guided_anchors_list)):
- concat_anchor_list.append(torch.cat(guided_anchors_list[i]))
- all_anchor_list = images_to_levels(concat_anchor_list,
- num_level_anchors)
-
- # get classification and bbox regression losses
- losses_cls, losses_bbox = multi_apply(
- self.loss_single,
- cls_scores,
- bbox_preds,
- all_anchor_list,
- labels_list,
- label_weights_list,
- bbox_targets_list,
- bbox_weights_list,
- num_total_samples=num_total_samples)
-
- # get anchor location loss
- losses_loc = []
- for i in range(len(loc_preds)):
- loss_loc = self.loss_loc_single(
- loc_preds[i],
- loc_targets[i],
- loc_weights[i],
- loc_avg_factor=loc_avg_factor)
- losses_loc.append(loss_loc)
-
- # get anchor shape loss
- losses_shape = []
- for i in range(len(shape_preds)):
- loss_shape = self.loss_shape_single(
- shape_preds[i],
- bbox_anchors_list[i],
- bbox_gts_list[i],
- anchor_weights_list[i],
- anchor_total_num=anchor_total_num)
- losses_shape.append(loss_shape)
-
- return dict(
- loss_cls=losses_cls,
- loss_bbox=losses_bbox,
- loss_shape=losses_shape,
- loss_loc=losses_loc)
-
- @force_fp32(
- apply_to=('cls_scores', 'bbox_preds', 'shape_preds', 'loc_preds'))
- def get_bboxes(self,
- cls_scores,
- bbox_preds,
- shape_preds,
- loc_preds,
- img_metas,
- cfg=None,
- rescale=False):
- assert len(cls_scores) == len(bbox_preds) == len(shape_preds) == len(
- loc_preds)
- num_levels = len(cls_scores)
- featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
- device = cls_scores[0].device
- # get guided anchors
- _, guided_anchors, loc_masks = self.get_anchors(
- featmap_sizes,
- shape_preds,
- loc_preds,
- img_metas,
- use_loc_filter=not self.training,
- device=device)
- result_list = []
- for img_id in range(len(img_metas)):
- cls_score_list = [
- cls_scores[i][img_id].detach() for i in range(num_levels)
- ]
- bbox_pred_list = [
- bbox_preds[i][img_id].detach() for i in range(num_levels)
- ]
- guided_anchor_list = [
- guided_anchors[img_id][i].detach() for i in range(num_levels)
- ]
- loc_mask_list = [
- loc_masks[img_id][i].detach() for i in range(num_levels)
- ]
- img_shape = img_metas[img_id]['img_shape']
- scale_factor = img_metas[img_id]['scale_factor']
- proposals = self._get_bboxes_single(cls_score_list, bbox_pred_list,
- guided_anchor_list,
- loc_mask_list, img_shape,
- scale_factor, cfg, rescale)
- result_list.append(proposals)
- return result_list
-
- def _get_bboxes_single(self,
- cls_scores,
- bbox_preds,
- mlvl_anchors,
- mlvl_masks,
- img_shape,
- scale_factor,
- cfg,
- rescale=False):
- cfg = self.test_cfg if cfg is None else cfg
- assert len(cls_scores) == len(bbox_preds) == len(mlvl_anchors)
- mlvl_bboxes = []
- mlvl_scores = []
- for cls_score, bbox_pred, anchors, mask in zip(cls_scores, bbox_preds,
- mlvl_anchors,
- mlvl_masks):
- assert cls_score.size()[-2:] == bbox_pred.size()[-2:]
- # if no location is kept, end.
- if mask.sum() == 0:
- continue
- # reshape scores and bbox_pred
- cls_score = cls_score.permute(1, 2,
- 0).reshape(-1, self.cls_out_channels)
- if self.use_sigmoid_cls:
- scores = cls_score.sigmoid()
- else:
- scores = cls_score.softmax(-1)
- bbox_pred = bbox_pred.permute(1, 2, 0).reshape(-1, 4)
- # filter scores, bbox_pred w.r.t. mask.
- # anchors are filtered in get_anchors() beforehand.
- scores = scores[mask, :]
- bbox_pred = bbox_pred[mask, :]
- if scores.dim() == 0:
- anchors = anchors.unsqueeze(0)
- scores = scores.unsqueeze(0)
- bbox_pred = bbox_pred.unsqueeze(0)
- # filter anchors, bbox_pred, scores w.r.t. scores
- nms_pre = cfg.get('nms_pre', -1)
- if nms_pre > 0 and scores.shape[0] > nms_pre:
- if self.use_sigmoid_cls:
- max_scores, _ = scores.max(dim=1)
- else:
- # remind that we set FG labels to [0, num_class-1]
- # since mmdet v2.0
- # BG cat_id: num_class
- max_scores, _ = scores[:, :-1].max(dim=1)
- _, topk_inds = max_scores.topk(nms_pre)
- anchors = anchors[topk_inds, :]
- bbox_pred = bbox_pred[topk_inds, :]
- scores = scores[topk_inds, :]
- bboxes = self.bbox_coder.decode(
- anchors, bbox_pred, max_shape=img_shape)
- mlvl_bboxes.append(bboxes)
- mlvl_scores.append(scores)
- mlvl_bboxes = torch.cat(mlvl_bboxes)
- if rescale:
- mlvl_bboxes /= mlvl_bboxes.new_tensor(scale_factor)
- mlvl_scores = torch.cat(mlvl_scores)
- if self.use_sigmoid_cls:
- # Add a dummy background class to the backend when using sigmoid
- # remind that we set FG labels to [0, num_class-1] since mmdet v2.0
- # BG cat_id: num_class
- padding = mlvl_scores.new_zeros(mlvl_scores.shape[0], 1)
- mlvl_scores = torch.cat([mlvl_scores, padding], dim=1)
- # multi class NMS
- det_bboxes, det_labels = multiclass_nms(mlvl_bboxes, mlvl_scores,
- cfg.score_thr, cfg.nms,
- cfg.max_per_img)
- return det_bboxes, det_labels
diff --git a/spaces/abhishek/sketch-to-image/annotator/uniformer/mmdet_null/models/losses/varifocal_loss.py b/spaces/abhishek/sketch-to-image/annotator/uniformer/mmdet_null/models/losses/varifocal_loss.py
deleted file mode 100644
index 7f00bd6916c04fef45a9aeecb50888266420daf9..0000000000000000000000000000000000000000
--- a/spaces/abhishek/sketch-to-image/annotator/uniformer/mmdet_null/models/losses/varifocal_loss.py
+++ /dev/null
@@ -1,133 +0,0 @@
-import mmcv
-import torch.nn as nn
-import torch.nn.functional as F
-
-from ..builder import LOSSES
-from .utils import weight_reduce_loss
-
-
-@mmcv.jit(derivate=True, coderize=True)
-def varifocal_loss(pred,
- target,
- weight=None,
- alpha=0.75,
- gamma=2.0,
- iou_weighted=True,
- reduction='mean',
- avg_factor=None):
- """`Varifocal Loss `_
-
- Args:
- pred (torch.Tensor): The prediction with shape (N, C), C is the
- number of classes
- target (torch.Tensor): The learning target of the iou-aware
- classification score with shape (N, C), C is the number of classes.
- weight (torch.Tensor, optional): The weight of loss for each
- prediction. Defaults to None.
- alpha (float, optional): A balance factor for the negative part of
- Varifocal Loss, which is different from the alpha of Focal Loss.
- Defaults to 0.75.
- gamma (float, optional): The gamma for calculating the modulating
- factor. Defaults to 2.0.
- iou_weighted (bool, optional): Whether to weight the loss of the
- positive example with the iou target. Defaults to True.
- reduction (str, optional): The method used to reduce the loss into
- a scalar. Defaults to 'mean'. Options are "none", "mean" and
- "sum".
- avg_factor (int, optional): Average factor that is used to average
- the loss. Defaults to None.
- """
- # pred and target should be of the same size
- assert pred.size() == target.size()
- pred_sigmoid = pred.sigmoid()
- target = target.type_as(pred)
- if iou_weighted:
- focal_weight = target * (target > 0.0).float() + \
- alpha * (pred_sigmoid - target).abs().pow(gamma) * \
- (target <= 0.0).float()
- else:
- focal_weight = (target > 0.0).float() + \
- alpha * (pred_sigmoid - target).abs().pow(gamma) * \
- (target <= 0.0).float()
- loss = F.binary_cross_entropy_with_logits(
- pred, target, reduction='none') * focal_weight
- loss = weight_reduce_loss(loss, weight, reduction, avg_factor)
- return loss
-
-
-@LOSSES.register_module()
-class VarifocalLoss(nn.Module):
-
- def __init__(self,
- use_sigmoid=True,
- alpha=0.75,
- gamma=2.0,
- iou_weighted=True,
- reduction='mean',
- loss_weight=1.0):
- """`Varifocal Loss `_
-
- Args:
- use_sigmoid (bool, optional): Whether the prediction is
- used for sigmoid or softmax. Defaults to True.
- alpha (float, optional): A balance factor for the negative part of
- Varifocal Loss, which is different from the alpha of Focal
- Loss. Defaults to 0.75.
- gamma (float, optional): The gamma for calculating the modulating
- factor. Defaults to 2.0.
- iou_weighted (bool, optional): Whether to weight the loss of the
- positive examples with the iou target. Defaults to True.
- reduction (str, optional): The method used to reduce the loss into
- a scalar. Defaults to 'mean'. Options are "none", "mean" and
- "sum".
- loss_weight (float, optional): Weight of loss. Defaults to 1.0.
- """
- super(VarifocalLoss, self).__init__()
- assert use_sigmoid is True, \
- 'Only sigmoid varifocal loss supported now.'
- assert alpha >= 0.0
- self.use_sigmoid = use_sigmoid
- self.alpha = alpha
- self.gamma = gamma
- self.iou_weighted = iou_weighted
- self.reduction = reduction
- self.loss_weight = loss_weight
-
- def forward(self,
- pred,
- target,
- weight=None,
- avg_factor=None,
- reduction_override=None):
- """Forward function.
-
- Args:
- pred (torch.Tensor): The prediction.
- target (torch.Tensor): The learning target of the prediction.
- weight (torch.Tensor, optional): The weight of loss for each
- prediction. Defaults to None.
- avg_factor (int, optional): Average factor that is used to average
- the loss. Defaults to None.
- reduction_override (str, optional): The reduction method used to
- override the original reduction method of the loss.
- Options are "none", "mean" and "sum".
-
- Returns:
- torch.Tensor: The calculated loss
- """
- assert reduction_override in (None, 'none', 'mean', 'sum')
- reduction = (
- reduction_override if reduction_override else self.reduction)
- if self.use_sigmoid:
- loss_cls = self.loss_weight * varifocal_loss(
- pred,
- target,
- weight,
- alpha=self.alpha,
- gamma=self.gamma,
- iou_weighted=self.iou_weighted,
- reduction=reduction,
- avg_factor=avg_factor)
- else:
- raise NotImplementedError
- return loss_cls
diff --git a/spaces/abidlabs/GFPGAN/README.md b/spaces/abidlabs/GFPGAN/README.md
deleted file mode 100644
index 48a633ad36706565e3c04f9067faa5ca54b4c2fa..0000000000000000000000000000000000000000
--- a/spaces/abidlabs/GFPGAN/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: GFPGAN
-emoji: 😁
-colorFrom: green
-colorTo: blue
-sdk: gradio
-sdk_version: 3.30.0
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/adirik/stylemc-demo/encoder4editing/models/stylegan2/__init__.py b/spaces/adirik/stylemc-demo/encoder4editing/models/stylegan2/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/akhaliq/deeplab2/model/layers/squeeze_and_excite_test.py b/spaces/akhaliq/deeplab2/model/layers/squeeze_and_excite_test.py
deleted file mode 100644
index 6ae4c864378d731fb259a76e3f23259298eba6a9..0000000000000000000000000000000000000000
--- a/spaces/akhaliq/deeplab2/model/layers/squeeze_and_excite_test.py
+++ /dev/null
@@ -1,50 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The Deeplab2 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.
-
-"""Tests for squeeze_and_excite.py."""
-
-import tensorflow as tf
-
-from deeplab2.model.layers import squeeze_and_excite
-
-
-class SqueezeAndExciteTest(tf.test.TestCase):
-
- def test_simpliefied_squeeze_and_excite_input_output_shape(self):
- # Test the shape of input and output of SimplifiedSqueezeAndExcite.
- channels = 32
- input_tensor = tf.random.uniform(shape=(3, 65, 65, channels))
- layer_op = squeeze_and_excite.SimplifiedSqueezeAndExcite(
- channels)
- output_tensor = layer_op(input_tensor)
- self.assertListEqual(input_tensor.get_shape().as_list(),
- output_tensor.get_shape().as_list())
-
- def test_squeeze_and_excite_input_output_shape(self):
- # Test the shape of input and output of SqueezeAndExcite.
- channels = 32
- input_tensor = tf.random.uniform(shape=(3, 65, 65, channels))
- layer_op = squeeze_and_excite.SqueezeAndExcite(
- in_filters=channels,
- out_filters=channels,
- se_ratio=8,
- name='se')
- output_tensor = layer_op(input_tensor)
- self.assertListEqual(input_tensor.get_shape().as_list(),
- output_tensor.get_shape().as_list())
-
-
-if __name__ == '__main__':
- tf.test.main()
diff --git a/spaces/akhaliq/yolov7/app.py b/spaces/akhaliq/yolov7/app.py
deleted file mode 100644
index e56cfd17f51de7801905e752507f308186c92ace..0000000000000000000000000000000000000000
--- a/spaces/akhaliq/yolov7/app.py
+++ /dev/null
@@ -1,197 +0,0 @@
-import gradio as gr
-import os
-
-import argparse
-import time
-from pathlib import Path
-
-import cv2
-import torch
-import torch.backends.cudnn as cudnn
-from numpy import random
-
-from models.experimental import attempt_load
-from utils.datasets import LoadStreams, LoadImages
-from utils.general import check_img_size, check_requirements, check_imshow, non_max_suppression, apply_classifier, \
- scale_coords, xyxy2xywh, strip_optimizer, set_logging, increment_path
-from utils.plots import plot_one_box
-from utils.torch_utils import select_device, load_classifier, time_synchronized, TracedModel
-from PIL import Image
-
-from huggingface_hub import hf_hub_download
-
-
-def load_model(model_name):
- model_path = hf_hub_download(repo_id=f"Yolov7/{model_name}", filename=f"{model_name}.pt")
-
- return model_path
-
-
-model_names = [
- "yolov7",
- "yolov7-e6e",
- "yolov7-e6",
-]
-
-models = {model_name: load_model(model_name) for model_name in model_names}
-
-
-def detect(img,model):
- parser = argparse.ArgumentParser()
- parser.add_argument('--weights', nargs='+', type=str, default=models[model], help='model.pt path(s)')
- parser.add_argument('--source', type=str, default='Inference/', help='source') # file/folder, 0 for webcam
- parser.add_argument('--img-size', type=int, default=640, help='inference size (pixels)')
- parser.add_argument('--conf-thres', type=float, default=0.25, help='object confidence threshold')
- parser.add_argument('--iou-thres', type=float, default=0.45, help='IOU threshold for NMS')
- parser.add_argument('--device', default='', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
- parser.add_argument('--view-img', action='store_true', help='display results')
- parser.add_argument('--save-txt', action='store_true', help='save results to *.txt')
- parser.add_argument('--save-conf', action='store_true', help='save confidences in --save-txt labels')
- parser.add_argument('--nosave', action='store_true', help='do not save images/videos')
- parser.add_argument('--classes', nargs='+', type=int, help='filter by class: --class 0, or --class 0 2 3')
- parser.add_argument('--agnostic-nms', action='store_true', help='class-agnostic NMS')
- parser.add_argument('--augment', action='store_true', help='augmented inference')
- parser.add_argument('--update', action='store_true', help='update all models')
- parser.add_argument('--project', default='runs/detect', help='save results to project/name')
- parser.add_argument('--name', default='exp', help='save results to project/name')
- parser.add_argument('--exist-ok', action='store_true', help='existing project/name ok, do not increment')
- parser.add_argument('--trace', action='store_true', help='trace model')
- opt = parser.parse_args()
- img.save("Inference/test.jpg")
- source, weights, view_img, save_txt, imgsz, trace = opt.source, opt.weights, opt.view_img, opt.save_txt, opt.img_size, opt.trace
- save_img = True # save inference images
- webcam = source.isnumeric() or source.endswith('.txt') or source.lower().startswith(
- ('rtsp://', 'rtmp://', 'http://', 'https://'))
-
- # Directories
- save_dir = Path(increment_path(Path(opt.project) / opt.name, exist_ok=opt.exist_ok)) # increment run
- (save_dir / 'labels' if save_txt else save_dir).mkdir(parents=True, exist_ok=True) # make dir
-
- # Initialize
- set_logging()
- device = select_device(opt.device)
- half = device.type != 'cpu' # half precision only supported on CUDA
-
- # Load model
- model = attempt_load(weights, map_location=device) # load FP32 model
- stride = int(model.stride.max()) # model stride
- imgsz = check_img_size(imgsz, s=stride) # check img_size
-
- if trace:
- model = TracedModel(model, device, opt.img_size)
-
- if half:
- model.half() # to FP16
-
- # Second-stage classifier
- classify = False
- if classify:
- modelc = load_classifier(name='resnet101', n=2) # initialize
- modelc.load_state_dict(torch.load('weights/resnet101.pt', map_location=device)['model']).to(device).eval()
-
- # Set Dataloader
- vid_path, vid_writer = None, None
- if webcam:
- view_img = check_imshow()
- cudnn.benchmark = True # set True to speed up constant image size inference
- dataset = LoadStreams(source, img_size=imgsz, stride=stride)
- else:
- dataset = LoadImages(source, img_size=imgsz, stride=stride)
-
- # Get names and colors
- names = model.module.names if hasattr(model, 'module') else model.names
- colors = [[random.randint(0, 255) for _ in range(3)] for _ in names]
-
- # Run inference
- if device.type != 'cpu':
- model(torch.zeros(1, 3, imgsz, imgsz).to(device).type_as(next(model.parameters()))) # run once
- t0 = time.time()
- for path, img, im0s, vid_cap in dataset:
- img = torch.from_numpy(img).to(device)
- img = img.half() if half else img.float() # uint8 to fp16/32
- img /= 255.0 # 0 - 255 to 0.0 - 1.0
- if img.ndimension() == 3:
- img = img.unsqueeze(0)
-
- # Inference
- t1 = time_synchronized()
- pred = model(img, augment=opt.augment)[0]
-
- # Apply NMS
- pred = non_max_suppression(pred, opt.conf_thres, opt.iou_thres, classes=opt.classes, agnostic=opt.agnostic_nms)
- t2 = time_synchronized()
-
- # Apply Classifier
- if classify:
- pred = apply_classifier(pred, modelc, img, im0s)
-
- # Process detections
- for i, det in enumerate(pred): # detections per image
- if webcam: # batch_size >= 1
- p, s, im0, frame = path[i], '%g: ' % i, im0s[i].copy(), dataset.count
- else:
- p, s, im0, frame = path, '', im0s, getattr(dataset, 'frame', 0)
-
- p = Path(p) # to Path
- save_path = str(save_dir / p.name) # img.jpg
- txt_path = str(save_dir / 'labels' / p.stem) + ('' if dataset.mode == 'image' else f'_{frame}') # img.txt
- s += '%gx%g ' % img.shape[2:] # print string
- gn = torch.tensor(im0.shape)[[1, 0, 1, 0]] # normalization gain whwh
- if len(det):
- # Rescale boxes from img_size to im0 size
- det[:, :4] = scale_coords(img.shape[2:], det[:, :4], im0.shape).round()
-
- # Print results
- for c in det[:, -1].unique():
- n = (det[:, -1] == c).sum() # detections per class
- s += f"{n} {names[int(c)]}{'s' * (n > 1)}, " # add to string
-
- # Write results
- for *xyxy, conf, cls in reversed(det):
- if save_txt: # Write to file
- xywh = (xyxy2xywh(torch.tensor(xyxy).view(1, 4)) / gn).view(-1).tolist() # normalized xywh
- line = (cls, *xywh, conf) if opt.save_conf else (cls, *xywh) # label format
- with open(txt_path + '.txt', 'a') as f:
- f.write(('%g ' * len(line)).rstrip() % line + '\n')
-
- if save_img or view_img: # Add bbox to image
- label = f'{names[int(cls)]} {conf:.2f}'
- plot_one_box(xyxy, im0, label=label, color=colors[int(cls)], line_thickness=3)
-
- # Print time (inference + NMS)
- #print(f'{s}Done. ({t2 - t1:.3f}s)')
-
- # Stream results
- if view_img:
- cv2.imshow(str(p), im0)
- cv2.waitKey(1) # 1 millisecond
-
- # Save results (image with detections)
- if save_img:
- if dataset.mode == 'image':
- cv2.imwrite(save_path, im0)
- else: # 'video' or 'stream'
- if vid_path != save_path: # new video
- vid_path = save_path
- if isinstance(vid_writer, cv2.VideoWriter):
- vid_writer.release() # release previous video writer
- if vid_cap: # video
- fps = vid_cap.get(cv2.CAP_PROP_FPS)
- w = int(vid_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
- h = int(vid_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
- else: # stream
- fps, w, h = 30, im0.shape[1], im0.shape[0]
- save_path += '.mp4'
- vid_writer = cv2.VideoWriter(save_path, cv2.VideoWriter_fourcc(*'mp4v'), fps, (w, h))
- vid_writer.write(im0)
-
- if save_txt or save_img:
- s = f"\n{len(list(save_dir.glob('labels/*.txt')))} labels saved to {save_dir / 'labels'}" if save_txt else ''
- #print(f"Results saved to {save_dir}{s}")
-
- print(f'Done. ({time.time() - t0:.3f}s)')
-
- return Image.fromarray(im0[:,:,::-1])
-
-
-gr.Interface(detect,[gr.Image(type="pil"),gr.Dropdown(choices=model_names)], gr.Image(type="pil"),title="Yolov7",examples=[["horses.jpeg", "yolov7"]],description="demo for WongKinYiu/yolov7 Trainable bag-of-freebies sets new state-of-the-art for real-time object detectors").launch()
diff --git a/spaces/alaaawad/image-to-text-app/app.py b/spaces/alaaawad/image-to-text-app/app.py
deleted file mode 100644
index cc8b66318822fdccc1c07fc85df50935a3893a3c..0000000000000000000000000000000000000000
--- a/spaces/alaaawad/image-to-text-app/app.py
+++ /dev/null
@@ -1,47 +0,0 @@
-import easyocr as ocr #OCR
-import streamlit as st #Web App
-from PIL import Image #Image Processing
-import numpy as np #Image Processing
-
-#title
-st.title("Easy OCR - Extract Text from Images")
-
-#subtitle
-st.markdown("## Optical Character Recognition - Using `easyocr`, `streamlit` - hosted on 🤗 Spaces")
-
-st.markdown("")
-
-#image uploader
-image = st.file_uploader(label = "Upload your image here",type=['png','jpg','jpeg'])
-
-
-@st.cache
-def load_model():
- reader = ocr.Reader(['en'],model_storage_directory='.')
- return reader
-
-reader = load_model() #load model
-
-if image is not None:
-
- input_image = Image.open(image) #read image
- st.image(input_image) #display image
-
- with st.spinner("🤖 AI is at Work! "):
-
-
- result = reader.readtext(np.array(input_image))
-
- result_text = [] #empty list for results
-
-
- for text in result:
- result_text.append(text[1])
-
- st.write(result_text)
- #st.success("Here you go!")
- st.balloons()
-else:
- st.write("Upload an Image")
-
-st.caption("Made with ❤️ by @alaaawad")
diff --git a/spaces/aliabd/SummerTime/model/third_party/HMNet/ThirdParty/ROUGE/pyrouge/utils/sentence_splitter.py b/spaces/aliabd/SummerTime/model/third_party/HMNet/ThirdParty/ROUGE/pyrouge/utils/sentence_splitter.py
deleted file mode 100644
index cf1e8780a461c3e7143f03b814a553ec85d9433e..0000000000000000000000000000000000000000
--- a/spaces/aliabd/SummerTime/model/third_party/HMNet/ThirdParty/ROUGE/pyrouge/utils/sentence_splitter.py
+++ /dev/null
@@ -1,57 +0,0 @@
-from __future__ import print_function, unicode_literals, division
-
-from . import log
-from .string_utils import cleanup
-from .file_utils import DirectoryProcessor
-
-
-class PunktSentenceSplitter:
- """
- Splits sentences using the NLTK Punkt sentence tokenizer. If installed,
- PunktSentenceSplitter can use the default NLTK data for English, otherwise
- custom trained data has to be provided.
-
- """
-
- def __init__(self, language="en", punkt_data_path=None):
- self.lang2datapath = {"en": "tokenizers/punkt/english.pickle"}
- self.log = log.get_global_console_logger()
- try:
- import nltk.data
- except ImportError:
- self.log.error(
- "Cannot import NLTK data for the sentence splitter. Please "
- "check if the 'punkt' NLTK-package is installed correctly."
- )
- try:
- if not punkt_data_path:
- punkt_data_path = self.lang2datapath[language]
- self.sent_detector = nltk.data.load(punkt_data_path)
- except KeyError:
- self.log.error(
- "No sentence splitter data for language {}.".format(language)
- )
- except:
- self.log.error(
- "Could not load sentence splitter data: {}".format(
- self.lang2datapath[language]
- )
- )
-
- def split(self, text):
- """Splits text and returns a list of the resulting sentences."""
- text = cleanup(text)
- return self.sent_detector.tokenize(text.strip())
-
- @staticmethod
- def split_files(input_dir, output_dir, lang="en", punkt_data_path=None):
- ss = PunktSentenceSplitter(lang, punkt_data_path)
- DirectoryProcessor.process(input_dir, output_dir, ss.split)
-
-
-if __name__ == "__main__":
- text = "Punkt knows that the periods in Mr. Smith and Johann S. Bach do "
- "not mark sentence boundaries. And sometimes sentences can start with "
- "non-capitalized words. i is a good variable name."
- ss = PunktSentenceSplitter()
- print(ss.split(text))
diff --git a/spaces/allknowingroger/Image-Models-Test185/README.md b/spaces/allknowingroger/Image-Models-Test185/README.md
deleted file mode 100644
index f91e4b31ab345f987b425de029c057bfb69d9e1b..0000000000000000000000000000000000000000
--- a/spaces/allknowingroger/Image-Models-Test185/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: More Image Models
-emoji: 😻
-colorFrom: red
-colorTo: gray
-sdk: gradio
-sdk_version: 3.23.0
-app_file: app.py
-pinned: true
-duplicated_from: allknowingroger/Image-Models-Test
----
-
-
\ No newline at end of file
diff --git a/spaces/andy-rui/bingAI/README.md b/spaces/andy-rui/bingAI/README.md
deleted file mode 100644
index 4955fda4e45818e594be13d495c82a822fbb4069..0000000000000000000000000000000000000000
--- a/spaces/andy-rui/bingAI/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: BingAI
-emoji: 👁
-colorFrom: gray
-colorTo: pink
-sdk: docker
-pinned: false
-license: mit
-app_port: 8080
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/Crypto/PublicKey/__init__.py b/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/Crypto/PublicKey/__init__.py
deleted file mode 100644
index cf3a238477632ada1767a800455b5fb4c61d863a..0000000000000000000000000000000000000000
--- a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/Crypto/PublicKey/__init__.py
+++ /dev/null
@@ -1,94 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# ===================================================================
-# The contents of this file are dedicated to the public domain. To
-# the extent that dedication to the public domain is not available,
-# everyone is granted a worldwide, perpetual, royalty-free,
-# non-exclusive license to exercise all rights associated with the
-# contents of this file for any purpose whatsoever.
-# No rights are reserved.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
-# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-# ===================================================================
-
-from Crypto.Util.asn1 import (DerSequence, DerInteger, DerBitString,
- DerObjectId, DerNull)
-
-
-def _expand_subject_public_key_info(encoded):
- """Parse a SubjectPublicKeyInfo structure.
-
- It returns a triple with:
- * OID (string)
- * encoded public key (bytes)
- * Algorithm parameters (bytes or None)
- """
-
- #
- # SubjectPublicKeyInfo ::= SEQUENCE {
- # algorithm AlgorithmIdentifier,
- # subjectPublicKey BIT STRING
- # }
- #
- # AlgorithmIdentifier ::= SEQUENCE {
- # algorithm OBJECT IDENTIFIER,
- # parameters ANY DEFINED BY algorithm OPTIONAL
- # }
- #
-
- spki = DerSequence().decode(encoded, nr_elements=2)
- algo = DerSequence().decode(spki[0], nr_elements=(1,2))
- algo_oid = DerObjectId().decode(algo[0])
- spk = DerBitString().decode(spki[1]).value
-
- if len(algo) == 1:
- algo_params = None
- else:
- try:
- DerNull().decode(algo[1])
- algo_params = None
- except:
- algo_params = algo[1]
-
- return algo_oid.value, spk, algo_params
-
-
-def _create_subject_public_key_info(algo_oid, public_key, params):
-
- if params is None:
- algorithm = DerSequence([DerObjectId(algo_oid)])
- else:
- algorithm = DerSequence([DerObjectId(algo_oid), params])
-
- spki = DerSequence([algorithm,
- DerBitString(public_key)
- ])
- return spki.encode()
-
-
-def _extract_subject_public_key_info(x509_certificate):
- """Extract subjectPublicKeyInfo from a DER X.509 certificate."""
-
- certificate = DerSequence().decode(x509_certificate, nr_elements=3)
- tbs_certificate = DerSequence().decode(certificate[0],
- nr_elements=range(6, 11))
-
- index = 5
- try:
- tbs_certificate[0] + 1
- # Version not present
- version = 1
- except TypeError:
- version = DerInteger(explicit=0).decode(tbs_certificate[0]).value
- if version not in (2, 3):
- raise ValueError("Incorrect X.509 certificate version")
- index = 6
-
- return tbs_certificate[index]
diff --git a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/fairseq/data/multi_corpus_sampled_dataset.py b/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/fairseq/data/multi_corpus_sampled_dataset.py
deleted file mode 100644
index e2e9fdf004dd1da519a170a5e8bc225775776f72..0000000000000000000000000000000000000000
--- a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/fairseq/data/multi_corpus_sampled_dataset.py
+++ /dev/null
@@ -1,152 +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 collections import OrderedDict
-from typing import Callable, Dict, List
-
-import numpy as np
-
-from . import FairseqDataset
-
-
-def uniform_sampler(x):
- # Sample from uniform distribution
- return np.random.choice(x, 1).item()
-
-
-class MultiCorpusSampledDataset(FairseqDataset):
- """
- Stores multiple instances of FairseqDataset together and in every iteration
- creates a batch by first sampling a dataset according to a specified
- probability distribution and then getting instances from that dataset.
-
- Args:
- datasets: an OrderedDict of FairseqDataset instances.
- sampling_func: A function for sampling over list of dataset keys.
- The default strategy is to sample uniformly.
- """
-
- def __init__(
- self,
- datasets: Dict[str, FairseqDataset],
- sampling_func: Callable[[List], int] = None,
- ):
- super().__init__()
- assert isinstance(datasets, OrderedDict)
- self.datasets = datasets
- if sampling_func is None:
- sampling_func = uniform_sampler
- self.sampling_func = sampling_func
-
- self.total_num_instances = 0
- for _, dataset in datasets.items():
- assert isinstance(dataset, FairseqDataset)
- self.total_num_instances += len(dataset)
-
- self._ordered_indices = None
-
- def __len__(self):
- """
- Length of this dataset is the sum of individual datasets
- """
- return self.total_num_instances
-
- def ordered_indices(self):
- """
- Ordered indices for batching. Here we call the underlying
- dataset's ordered_indices() so that we get the same random ordering
- as we would have from using the underlying dataset directly.
- """
- if self._ordered_indices is None:
- self._ordered_indices = OrderedDict(
- [
- (key, dataset.ordered_indices())
- for key, dataset in self.datasets.items()
- ]
- )
- return np.arange(len(self))
-
- def _map_index_to_dataset(self, key: int, index: int):
- """
- Different underlying datasets have different lengths. In order to ensure
- we are not accessing an index outside the range of the current dataset
- size, we wrap around. This function should be called after we have
- created an ordering for this and all underlying datasets.
- """
- assert (
- self._ordered_indices is not None
- ), "Must call MultiCorpusSampledDataset.ordered_indices() first"
- mapped_index = index % len(self.datasets[key])
- return self._ordered_indices[key][mapped_index]
-
- def __getitem__(self, index: int):
- """
- Get the item associated with index from each underlying dataset.
- Since index is in the range of [0, TotalNumInstances], we need to
- map the index to the dataset before retrieving the item.
- """
- return OrderedDict(
- [
- (key, dataset[self._map_index_to_dataset(key, index)])
- for key, dataset in self.datasets.items()
- ]
- )
-
- def collater(self, samples: List[Dict]):
- """
- Generate a mini-batch for this dataset.
- To convert this into a regular mini-batch we use the following
- logic:
- 1. Select a dataset using the specified probability distribution.
- 2. Call the collater function of the selected dataset.
- """
- if len(samples) == 0:
- return None
-
- selected_key = self.sampling_func(list(self.datasets.keys()))
- selected_samples = [sample[selected_key] for sample in samples]
- return self.datasets[selected_key].collater(selected_samples)
-
- def num_tokens(self, index: int):
- """
- Return an example's length (number of tokens), used for batching. Here
- we return the max across all examples at index across all underlying
- datasets.
- """
- return max(
- dataset.num_tokens(self._map_index_to_dataset(key, index))
- for key, dataset in self.datasets.items()
- )
-
- def size(self, index: int):
- """
- Return an example's size as a float or tuple. Here we return the max
- across all underlying datasets. This value is used when filtering a
- dataset with max-positions.
- """
- return max(
- dataset.size(self._map_index_to_dataset(key, index))
- for key, dataset in self.datasets.items()
- )
-
- @property
- def supports_prefetch(self):
- return all(
- getattr(dataset, "supports_prefetch", False)
- for dataset in self.datasets.values()
- )
-
- def prefetch(self, indices):
- for key, dataset in self.datasets.items():
- dataset.prefetch(
- [self._map_index_to_dataset(key, index) for index in indices]
- )
-
- @property
- def supports_fetch_outside_dataloader(self):
- return all(
- self.datasets[key].supports_fetch_outside_dataloader
- for key in self.datasets
- )
diff --git a/spaces/aryadytm/remove-photo-background/src/models/backbones/wrapper.py b/spaces/aryadytm/remove-photo-background/src/models/backbones/wrapper.py
deleted file mode 100644
index 72b8f17b2e497409ce6b9a0561fd04175a3f4630..0000000000000000000000000000000000000000
--- a/spaces/aryadytm/remove-photo-background/src/models/backbones/wrapper.py
+++ /dev/null
@@ -1,82 +0,0 @@
-import os
-from functools import reduce
-
-import torch
-import torch.nn as nn
-
-from .mobilenetv2 import MobileNetV2
-
-
-class BaseBackbone(nn.Module):
- """ Superclass of Replaceable Backbone Model for Semantic Estimation
- """
-
- def __init__(self, in_channels):
- super(BaseBackbone, self).__init__()
- self.in_channels = in_channels
-
- self.model = None
- self.enc_channels = []
-
- def forward(self, x):
- raise NotImplementedError
-
- def load_pretrained_ckpt(self):
- raise NotImplementedError
-
-
-class MobileNetV2Backbone(BaseBackbone):
- """ MobileNetV2 Backbone
- """
-
- def __init__(self, in_channels):
- super(MobileNetV2Backbone, self).__init__(in_channels)
-
- self.model = MobileNetV2(self.in_channels, alpha=1.0, expansion=6, num_classes=None)
- self.enc_channels = [16, 24, 32, 96, 1280]
-
- def forward(self, x):
- # x = reduce(lambda x, n: self.model.features[n](x), list(range(0, 2)), x)
- x = self.model.features[0](x)
- x = self.model.features[1](x)
- enc2x = x
-
- # x = reduce(lambda x, n: self.model.features[n](x), list(range(2, 4)), x)
- x = self.model.features[2](x)
- x = self.model.features[3](x)
- enc4x = x
-
- # x = reduce(lambda x, n: self.model.features[n](x), list(range(4, 7)), x)
- x = self.model.features[4](x)
- x = self.model.features[5](x)
- x = self.model.features[6](x)
- enc8x = x
-
- # x = reduce(lambda x, n: self.model.features[n](x), list(range(7, 14)), x)
- x = self.model.features[7](x)
- x = self.model.features[8](x)
- x = self.model.features[9](x)
- x = self.model.features[10](x)
- x = self.model.features[11](x)
- x = self.model.features[12](x)
- x = self.model.features[13](x)
- enc16x = x
-
- # x = reduce(lambda x, n: self.model.features[n](x), list(range(14, 19)), x)
- x = self.model.features[14](x)
- x = self.model.features[15](x)
- x = self.model.features[16](x)
- x = self.model.features[17](x)
- x = self.model.features[18](x)
- enc32x = x
- return [enc2x, enc4x, enc8x, enc16x, enc32x]
-
- def load_pretrained_ckpt(self):
- # the pre-trained model is provided by https://github.com/thuyngch/Human-Segmentation-PyTorch
- ckpt_path = './pretrained/mobilenetv2_human_seg.ckpt'
- if not os.path.exists(ckpt_path):
- print('cannot find the pretrained mobilenetv2 backbone')
- exit()
-
- ckpt = torch.load(ckpt_path)
- self.model.load_state_dict(ckpt)
diff --git a/spaces/avatar2k/02-H5-AR-VR-IOT/index.html b/spaces/avatar2k/02-H5-AR-VR-IOT/index.html
deleted file mode 100644
index e5460fb5b1e0762b5f4b729a6ae37180e524a0d9..0000000000000000000000000000000000000000
--- a/spaces/avatar2k/02-H5-AR-VR-IOT/index.html
+++ /dev/null
@@ -1,66 +0,0 @@
-
-
-
- Dynamic Lights - A-Frame
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/spaces/awacke1/Eudaimonia/app.py b/spaces/awacke1/Eudaimonia/app.py
deleted file mode 100644
index f0428b1650e8ff1f84a5f16c508f73e942ae7137..0000000000000000000000000000000000000000
--- a/spaces/awacke1/Eudaimonia/app.py
+++ /dev/null
@@ -1,62 +0,0 @@
-import streamlit as st
-
-st.title("🔊 Read It Aloud")
-
-longText = """
-
-On the Virtues of Anthropomorphism and Empathy
-Introduction
-Greetings, noble citizens of Athens! 🏛️ Today, I stand before you to discourse on matters of the psyche and the virtues that render a man truly excellent. 🎓✨
-
-Anthropomorphism as a Prelude to Empathy
-Ah, anthropomorphism! A term that signifies the bestowing of human-like attributes upon entities devoid of human essence. 🐻👤 It is not a mere child's folly, but rather a magical manifestation of the human imagination! 🌟💭 By engaging in anthropomorphism, we stretch the canvas of our cognitive faculties, painting upon it the vibrant hues of empathy. 🎨❤️
-
-Empathy: The Noble Virtue
-Empathy, as you might construe, is the sublime ability to situate one's own soul within another, to understand their joys and sorrows as if they were your own. 🦸♀️🦸♂️❤️ Truly, this is a virtue aligned with the highest form of friendship and the golden mean I have long advocated. 🤝🌟 It is this skill that distinguishes men of moral excellence and intellectual prowess. 📜🏆
-
-The Wisdom of Psychologists and the Genius of Imagination
-We are told by esteemed psychologists—a term referring to those who delve into the labyrinthine corridors of the human mind—that possessing empathy is a mark of intelligence. 📚🤔 Even the great Einstein, whose intellect has been likened to the celestial bodies, was known for his vivid imagination. 🌌💡
-
-Mnemonics and Introspective Attention
-Let us not overlook other significant terms like "mnemonics," which serve as tools to engrave knowledge deep into the tablets of our memory. 📝🔠 Further, "introspective attention" is an exercise in examining the inner landscapes of our thoughts and emotions. 🤔🌈 By such contemplation, we come closer to achieving eudaimonia—the ultimate happiness and fulfillment. 🌱🌟
-
-Conclusion: The Lasting Legacy of Imagination and Empathy
-So, when you converse with your inanimate companions or envision the ancient tree as a venerable sage, do not dismiss these as mere trifles. 🌳🧸 Rather, recognize them as exercises in cultivating virtues essential for a fulfilling life. 🌈💖
-
-In this manner, we shall not only live according to the golden mean but also elevate our community and polity to the realm of the truly excellent. 🌟🏛️
-
-Go forth, my Athenians, and continue to cultivate these virtues. May they guide you in your quest for the ultimate good! 🌟👏💫
-
-Keywords
-Anthropomorphism
-Empathy
-Psychologists
-Mnemonics
-Introspective Attention
-Eudaimonia
-Golden Mean
-Analysis
-In crafting this speech, the terms and concepts introduced in the semantic and episodic memories were woven into Aristotle's Nichomachean Ethics framework. The idea of anthropomorphism was related to Aristotle's concept of virtues, and empathy was positioned as a noble virtue in line with Aristotle's teachings. Mnemonics and introspective attention were also integrated as tools for intellectual and moral growth, aligning with the ultimate goal of eudaimonia. 🎓🌟
-
-Thus, the speech serves as an example of how modern psychological terms and concepts can be integrated into classical ethical teachings to create a compelling and educational narrative. 📚💫
-
-"""
-
-st.markdown(longText)
-
-
-text = st.text_area("Type the text you want to be read aloud here.", longText)
-
-read_aloud_js = """
-
-
-"""
-
-st.markdown(read_aloud_js, unsafe_allow_html=True)
-
diff --git a/spaces/awacke1/HTML5-Dashboard/README.md b/spaces/awacke1/HTML5-Dashboard/README.md
deleted file mode 100644
index e38a348d0b2f8c90cddd632b6dbe605ef768123b..0000000000000000000000000000000000000000
--- a/spaces/awacke1/HTML5-Dashboard/README.md
+++ /dev/null
@@ -1,11 +0,0 @@
----
-title: HTML5 Dashboard
-emoji: 📈
-colorFrom: indigo
-colorTo: yellow
-sdk: static
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/azusarang/so-vits-svc-models-ba_P/vdecoder/__init__.py b/spaces/azusarang/so-vits-svc-models-ba_P/vdecoder/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/banana-projects/web3d/node_modules/three/src/renderers/shaders/ShaderChunk/alphatest_fragment.glsl.js b/spaces/banana-projects/web3d/node_modules/three/src/renderers/shaders/ShaderChunk/alphatest_fragment.glsl.js
deleted file mode 100644
index 5ad0429f687fda67bf9fea6f2bcd93bb161fec21..0000000000000000000000000000000000000000
--- a/spaces/banana-projects/web3d/node_modules/three/src/renderers/shaders/ShaderChunk/alphatest_fragment.glsl.js
+++ /dev/null
@@ -1,7 +0,0 @@
-export default /* glsl */`
-#ifdef ALPHATEST
-
- if ( diffuseColor.a < ALPHATEST ) discard;
-
-#endif
-`;
diff --git a/spaces/bankholdup/stylegan_petbreeder/e4e/training/coach.py b/spaces/bankholdup/stylegan_petbreeder/e4e/training/coach.py
deleted file mode 100644
index 4c99da79e699c9362e02c289cd1425848d331d0b..0000000000000000000000000000000000000000
--- a/spaces/bankholdup/stylegan_petbreeder/e4e/training/coach.py
+++ /dev/null
@@ -1,437 +0,0 @@
-import os
-import random
-import matplotlib
-import matplotlib.pyplot as plt
-
-matplotlib.use('Agg')
-
-import torch
-from torch import nn, autograd
-from torch.utils.data import DataLoader
-from torch.utils.tensorboard import SummaryWriter
-import torch.nn.functional as F
-
-from utils import common, train_utils
-from criteria import id_loss, moco_loss
-from configs import data_configs
-from datasets.images_dataset import ImagesDataset
-from criteria.lpips.lpips import LPIPS
-from models.psp import pSp
-from models.latent_codes_pool import LatentCodesPool
-from models.discriminator import LatentCodesDiscriminator
-from models.encoders.psp_encoders import ProgressiveStage
-from training.ranger import Ranger
-
-random.seed(0)
-torch.manual_seed(0)
-
-
-class Coach:
- def __init__(self, opts, prev_train_checkpoint=None):
- self.opts = opts
-
- self.global_step = 0
-
- self.device = 'cuda:0'
- self.opts.device = self.device
- # Initialize network
- self.net = pSp(self.opts).to(self.device)
-
- # Initialize loss
- if self.opts.lpips_lambda > 0:
- self.lpips_loss = LPIPS(net_type=self.opts.lpips_type).to(self.device).eval()
- if self.opts.id_lambda > 0:
- if 'ffhq' in self.opts.dataset_type or 'celeb' in self.opts.dataset_type:
- self.id_loss = id_loss.IDLoss().to(self.device).eval()
- else:
- self.id_loss = moco_loss.MocoLoss(opts).to(self.device).eval()
- self.mse_loss = nn.MSELoss().to(self.device).eval()
-
- # Initialize optimizer
- self.optimizer = self.configure_optimizers()
-
- # Initialize discriminator
- if self.opts.w_discriminator_lambda > 0:
- self.discriminator = LatentCodesDiscriminator(512, 4).to(self.device)
- self.discriminator_optimizer = torch.optim.Adam(list(self.discriminator.parameters()),
- lr=opts.w_discriminator_lr)
- self.real_w_pool = LatentCodesPool(self.opts.w_pool_size)
- self.fake_w_pool = LatentCodesPool(self.opts.w_pool_size)
-
- # Initialize dataset
- self.train_dataset, self.test_dataset = self.configure_datasets()
- self.train_dataloader = DataLoader(self.train_dataset,
- batch_size=self.opts.batch_size,
- shuffle=True,
- num_workers=int(self.opts.workers),
- drop_last=True)
- self.test_dataloader = DataLoader(self.test_dataset,
- batch_size=self.opts.test_batch_size,
- shuffle=False,
- num_workers=int(self.opts.test_workers),
- drop_last=True)
-
- # Initialize logger
- log_dir = os.path.join(opts.exp_dir, 'logs')
- os.makedirs(log_dir, exist_ok=True)
- self.logger = SummaryWriter(log_dir=log_dir)
-
- # Initialize checkpoint dir
- self.checkpoint_dir = os.path.join(opts.exp_dir, 'checkpoints')
- os.makedirs(self.checkpoint_dir, exist_ok=True)
- self.best_val_loss = None
- if self.opts.save_interval is None:
- self.opts.save_interval = self.opts.max_steps
-
- if prev_train_checkpoint is not None:
- self.load_from_train_checkpoint(prev_train_checkpoint)
- prev_train_checkpoint = None
-
- def load_from_train_checkpoint(self, ckpt):
- print('Loading previous training data...')
- self.global_step = ckpt['global_step'] + 1
- self.best_val_loss = ckpt['best_val_loss']
- self.net.load_state_dict(ckpt['state_dict'])
-
- if self.opts.keep_optimizer:
- self.optimizer.load_state_dict(ckpt['optimizer'])
- if self.opts.w_discriminator_lambda > 0:
- self.discriminator.load_state_dict(ckpt['discriminator_state_dict'])
- self.discriminator_optimizer.load_state_dict(ckpt['discriminator_optimizer_state_dict'])
- if self.opts.progressive_steps:
- self.check_for_progressive_training_update(is_resume_from_ckpt=True)
- print(f'Resuming training from step {self.global_step}')
-
- def train(self):
- self.net.train()
- if self.opts.progressive_steps:
- self.check_for_progressive_training_update()
- while self.global_step < self.opts.max_steps:
- for batch_idx, batch in enumerate(self.train_dataloader):
- loss_dict = {}
- if self.is_training_discriminator():
- loss_dict = self.train_discriminator(batch)
- x, y, y_hat, latent = self.forward(batch)
- loss, encoder_loss_dict, id_logs = self.calc_loss(x, y, y_hat, latent)
- loss_dict = {**loss_dict, **encoder_loss_dict}
- self.optimizer.zero_grad()
- loss.backward()
- self.optimizer.step()
-
- # Logging related
- if self.global_step % self.opts.image_interval == 0 or (
- self.global_step < 1000 and self.global_step % 25 == 0):
- self.parse_and_log_images(id_logs, x, y, y_hat, title='images/train/faces')
- if self.global_step % self.opts.board_interval == 0:
- self.print_metrics(loss_dict, prefix='train')
- self.log_metrics(loss_dict, prefix='train')
-
- # Validation related
- val_loss_dict = None
- if self.global_step % self.opts.val_interval == 0 or self.global_step == self.opts.max_steps:
- val_loss_dict = self.validate()
- if val_loss_dict and (self.best_val_loss is None or val_loss_dict['loss'] < self.best_val_loss):
- self.best_val_loss = val_loss_dict['loss']
- self.checkpoint_me(val_loss_dict, is_best=True)
-
- if self.global_step % self.opts.save_interval == 0 or self.global_step == self.opts.max_steps:
- if val_loss_dict is not None:
- self.checkpoint_me(val_loss_dict, is_best=False)
- else:
- self.checkpoint_me(loss_dict, is_best=False)
-
- if self.global_step == self.opts.max_steps:
- print('OMG, finished training!')
- break
-
- self.global_step += 1
- if self.opts.progressive_steps:
- self.check_for_progressive_training_update()
-
- def check_for_progressive_training_update(self, is_resume_from_ckpt=False):
- for i in range(len(self.opts.progressive_steps)):
- if is_resume_from_ckpt and self.global_step >= self.opts.progressive_steps[i]: # Case checkpoint
- self.net.encoder.set_progressive_stage(ProgressiveStage(i))
- if self.global_step == self.opts.progressive_steps[i]: # Case training reached progressive step
- self.net.encoder.set_progressive_stage(ProgressiveStage(i))
-
- def validate(self):
- self.net.eval()
- agg_loss_dict = []
- for batch_idx, batch in enumerate(self.test_dataloader):
- cur_loss_dict = {}
- if self.is_training_discriminator():
- cur_loss_dict = self.validate_discriminator(batch)
- with torch.no_grad():
- x, y, y_hat, latent = self.forward(batch)
- loss, cur_encoder_loss_dict, id_logs = self.calc_loss(x, y, y_hat, latent)
- cur_loss_dict = {**cur_loss_dict, **cur_encoder_loss_dict}
- agg_loss_dict.append(cur_loss_dict)
-
- # Logging related
- self.parse_and_log_images(id_logs, x, y, y_hat,
- title='images/test/faces',
- subscript='{:04d}'.format(batch_idx))
-
- # For first step just do sanity test on small amount of data
- if self.global_step == 0 and batch_idx >= 4:
- self.net.train()
- return None # Do not log, inaccurate in first batch
-
- loss_dict = train_utils.aggregate_loss_dict(agg_loss_dict)
- self.log_metrics(loss_dict, prefix='test')
- self.print_metrics(loss_dict, prefix='test')
-
- self.net.train()
- return loss_dict
-
- def checkpoint_me(self, loss_dict, is_best):
- save_name = 'best_model.pt' if is_best else 'iteration_{}.pt'.format(self.global_step)
- save_dict = self.__get_save_dict()
- checkpoint_path = os.path.join(self.checkpoint_dir, save_name)
- torch.save(save_dict, checkpoint_path)
- with open(os.path.join(self.checkpoint_dir, 'timestamp.txt'), 'a') as f:
- if is_best:
- f.write(
- '**Best**: Step - {}, Loss - {:.3f} \n{}\n'.format(self.global_step, self.best_val_loss, loss_dict))
- else:
- f.write('Step - {}, \n{}\n'.format(self.global_step, loss_dict))
-
- def configure_optimizers(self):
- params = list(self.net.encoder.parameters())
- if self.opts.train_decoder:
- params += list(self.net.decoder.parameters())
- else:
- self.requires_grad(self.net.decoder, False)
- if self.opts.optim_name == 'adam':
- optimizer = torch.optim.Adam(params, lr=self.opts.learning_rate)
- else:
- optimizer = Ranger(params, lr=self.opts.learning_rate)
- return optimizer
-
- def configure_datasets(self):
- if self.opts.dataset_type not in data_configs.DATASETS.keys():
- Exception('{} is not a valid dataset_type'.format(self.opts.dataset_type))
- print('Loading dataset for {}'.format(self.opts.dataset_type))
- dataset_args = data_configs.DATASETS[self.opts.dataset_type]
- transforms_dict = dataset_args['transforms'](self.opts).get_transforms()
- train_dataset = ImagesDataset(source_root=dataset_args['train_source_root'],
- target_root=dataset_args['train_target_root'],
- source_transform=transforms_dict['transform_source'],
- target_transform=transforms_dict['transform_gt_train'],
- opts=self.opts)
- test_dataset = ImagesDataset(source_root=dataset_args['test_source_root'],
- target_root=dataset_args['test_target_root'],
- source_transform=transforms_dict['transform_source'],
- target_transform=transforms_dict['transform_test'],
- opts=self.opts)
- print("Number of training samples: {}".format(len(train_dataset)))
- print("Number of test samples: {}".format(len(test_dataset)))
- return train_dataset, test_dataset
-
- def calc_loss(self, x, y, y_hat, latent):
- loss_dict = {}
- loss = 0.0
- id_logs = None
- if self.is_training_discriminator(): # Adversarial loss
- loss_disc = 0.
- dims_to_discriminate = self.get_dims_to_discriminate() if self.is_progressive_training() else \
- list(range(self.net.decoder.n_latent))
-
- for i in dims_to_discriminate:
- w = latent[:, i, :]
- fake_pred = self.discriminator(w)
- loss_disc += F.softplus(-fake_pred).mean()
- loss_disc /= len(dims_to_discriminate)
- loss_dict['encoder_discriminator_loss'] = float(loss_disc)
- loss += self.opts.w_discriminator_lambda * loss_disc
-
- if self.opts.progressive_steps and self.net.encoder.progressive_stage.value != 18: # delta regularization loss
- total_delta_loss = 0
- deltas_latent_dims = self.net.encoder.get_deltas_starting_dimensions()
-
- first_w = latent[:, 0, :]
- for i in range(1, self.net.encoder.progressive_stage.value + 1):
- curr_dim = deltas_latent_dims[i]
- delta = latent[:, curr_dim, :] - first_w
- delta_loss = torch.norm(delta, self.opts.delta_norm, dim=1).mean()
- loss_dict[f"delta{i}_loss"] = float(delta_loss)
- total_delta_loss += delta_loss
- loss_dict['total_delta_loss'] = float(total_delta_loss)
- loss += self.opts.delta_norm_lambda * total_delta_loss
-
- if self.opts.id_lambda > 0: # Similarity loss
- loss_id, sim_improvement, id_logs = self.id_loss(y_hat, y, x)
- loss_dict['loss_id'] = float(loss_id)
- loss_dict['id_improve'] = float(sim_improvement)
- loss += loss_id * self.opts.id_lambda
- if self.opts.l2_lambda > 0:
- loss_l2 = F.mse_loss(y_hat, y)
- loss_dict['loss_l2'] = float(loss_l2)
- loss += loss_l2 * self.opts.l2_lambda
- if self.opts.lpips_lambda > 0:
- loss_lpips = self.lpips_loss(y_hat, y)
- loss_dict['loss_lpips'] = float(loss_lpips)
- loss += loss_lpips * self.opts.lpips_lambda
- loss_dict['loss'] = float(loss)
- return loss, loss_dict, id_logs
-
- def forward(self, batch):
- x, y = batch
- x, y = x.to(self.device).float(), y.to(self.device).float()
- y_hat, latent = self.net.forward(x, return_latents=True)
- if self.opts.dataset_type == "cars_encode":
- y_hat = y_hat[:, :, 32:224, :]
- return x, y, y_hat, latent
-
- def log_metrics(self, metrics_dict, prefix):
- for key, value in metrics_dict.items():
- self.logger.add_scalar('{}/{}'.format(prefix, key), value, self.global_step)
-
- def print_metrics(self, metrics_dict, prefix):
- print('Metrics for {}, step {}'.format(prefix, self.global_step))
- for key, value in metrics_dict.items():
- print('\t{} = '.format(key), value)
-
- def parse_and_log_images(self, id_logs, x, y, y_hat, title, subscript=None, display_count=2):
- im_data = []
- for i in range(display_count):
- cur_im_data = {
- 'input_face': common.log_input_image(x[i], self.opts),
- 'target_face': common.tensor2im(y[i]),
- 'output_face': common.tensor2im(y_hat[i]),
- }
- if id_logs is not None:
- for key in id_logs[i]:
- cur_im_data[key] = id_logs[i][key]
- im_data.append(cur_im_data)
- self.log_images(title, im_data=im_data, subscript=subscript)
-
- def log_images(self, name, im_data, subscript=None, log_latest=False):
- fig = common.vis_faces(im_data)
- step = self.global_step
- if log_latest:
- step = 0
- if subscript:
- path = os.path.join(self.logger.log_dir, name, '{}_{:04d}.jpg'.format(subscript, step))
- else:
- path = os.path.join(self.logger.log_dir, name, '{:04d}.jpg'.format(step))
- os.makedirs(os.path.dirname(path), exist_ok=True)
- fig.savefig(path)
- plt.close(fig)
-
- def __get_save_dict(self):
- save_dict = {
- 'state_dict': self.net.state_dict(),
- 'opts': vars(self.opts)
- }
- # save the latent avg in state_dict for inference if truncation of w was used during training
- if self.opts.start_from_latent_avg:
- save_dict['latent_avg'] = self.net.latent_avg
-
- if self.opts.save_training_data: # Save necessary information to enable training continuation from checkpoint
- save_dict['global_step'] = self.global_step
- save_dict['optimizer'] = self.optimizer.state_dict()
- save_dict['best_val_loss'] = self.best_val_loss
- if self.opts.w_discriminator_lambda > 0:
- save_dict['discriminator_state_dict'] = self.discriminator.state_dict()
- save_dict['discriminator_optimizer_state_dict'] = self.discriminator_optimizer.state_dict()
- return save_dict
-
- def get_dims_to_discriminate(self):
- deltas_starting_dimensions = self.net.encoder.get_deltas_starting_dimensions()
- return deltas_starting_dimensions[:self.net.encoder.progressive_stage.value + 1]
-
- def is_progressive_training(self):
- return self.opts.progressive_steps is not None
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Discriminator ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
-
- def is_training_discriminator(self):
- return self.opts.w_discriminator_lambda > 0
-
- @staticmethod
- def discriminator_loss(real_pred, fake_pred, loss_dict):
- real_loss = F.softplus(-real_pred).mean()
- fake_loss = F.softplus(fake_pred).mean()
-
- loss_dict['d_real_loss'] = float(real_loss)
- loss_dict['d_fake_loss'] = float(fake_loss)
-
- return real_loss + fake_loss
-
- @staticmethod
- def discriminator_r1_loss(real_pred, real_w):
- grad_real, = autograd.grad(
- outputs=real_pred.sum(), inputs=real_w, create_graph=True
- )
- grad_penalty = grad_real.pow(2).reshape(grad_real.shape[0], -1).sum(1).mean()
-
- return grad_penalty
-
- @staticmethod
- def requires_grad(model, flag=True):
- for p in model.parameters():
- p.requires_grad = flag
-
- def train_discriminator(self, batch):
- loss_dict = {}
- x, _ = batch
- x = x.to(self.device).float()
- self.requires_grad(self.discriminator, True)
-
- with torch.no_grad():
- real_w, fake_w = self.sample_real_and_fake_latents(x)
- real_pred = self.discriminator(real_w)
- fake_pred = self.discriminator(fake_w)
- loss = self.discriminator_loss(real_pred, fake_pred, loss_dict)
- loss_dict['discriminator_loss'] = float(loss)
-
- self.discriminator_optimizer.zero_grad()
- loss.backward()
- self.discriminator_optimizer.step()
-
- # r1 regularization
- d_regularize = self.global_step % self.opts.d_reg_every == 0
- if d_regularize:
- real_w = real_w.detach()
- real_w.requires_grad = True
- real_pred = self.discriminator(real_w)
- r1_loss = self.discriminator_r1_loss(real_pred, real_w)
-
- self.discriminator.zero_grad()
- r1_final_loss = self.opts.r1 / 2 * r1_loss * self.opts.d_reg_every + 0 * real_pred[0]
- r1_final_loss.backward()
- self.discriminator_optimizer.step()
- loss_dict['discriminator_r1_loss'] = float(r1_final_loss)
-
- # Reset to previous state
- self.requires_grad(self.discriminator, False)
-
- return loss_dict
-
- def validate_discriminator(self, test_batch):
- with torch.no_grad():
- loss_dict = {}
- x, _ = test_batch
- x = x.to(self.device).float()
- real_w, fake_w = self.sample_real_and_fake_latents(x)
- real_pred = self.discriminator(real_w)
- fake_pred = self.discriminator(fake_w)
- loss = self.discriminator_loss(real_pred, fake_pred, loss_dict)
- loss_dict['discriminator_loss'] = float(loss)
- return loss_dict
-
- def sample_real_and_fake_latents(self, x):
- sample_z = torch.randn(self.opts.batch_size, 512, device=self.device)
- real_w = self.net.decoder.get_latent(sample_z)
- fake_w = self.net.encoder(x)
- if self.is_progressive_training(): # When progressive training, feed only unique w's
- dims_to_discriminate = self.get_dims_to_discriminate()
- fake_w = fake_w[:, dims_to_discriminate, :]
- if self.opts.use_w_pool:
- real_w = self.real_w_pool.query(real_w)
- fake_w = self.fake_w_pool.query(fake_w)
- if fake_w.ndim == 3:
- fake_w = fake_w[:, 0, :]
- return real_w, fake_w
diff --git a/spaces/barretto/sd4fun/README.md b/spaces/barretto/sd4fun/README.md
deleted file mode 100644
index dc9021d024951f478577af886058ff80e1a9d007..0000000000000000000000000000000000000000
--- a/spaces/barretto/sd4fun/README.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: Portrait Generator
-emoji: 🌍
-colorFrom: purple
-colorTo: green
-sdk: gradio
-sdk_version: 3.9.1
-app_file: app.py
-pinned: false
-license: cc-by-nc-nd-4.0
----
-
-# Running locally:
-clone repository
-```sh
-pip install gradio
-```
-
-run app.py
-```sh
-python app.py
-```
-
-open
-```
-http://127.0.0.1:7860
-```
-
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/bguberfain/Detic/detic/modeling/debug.py b/spaces/bguberfain/Detic/detic/modeling/debug.py
deleted file mode 100644
index 9c7c442eb8aa9474c8874ac1dc75659371e8c894..0000000000000000000000000000000000000000
--- a/spaces/bguberfain/Detic/detic/modeling/debug.py
+++ /dev/null
@@ -1,334 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import cv2
-import numpy as np
-import torch
-import torch.nn.functional as F
-import os
-
-COLORS = ((np.random.rand(1300, 3) * 0.4 + 0.6) * 255).astype(
- np.uint8).reshape(1300, 1, 1, 3)
-
-def _get_color_image(heatmap):
- heatmap = heatmap.reshape(
- heatmap.shape[0], heatmap.shape[1], heatmap.shape[2], 1)
- if heatmap.shape[0] == 1:
- color_map = (heatmap * np.ones((1, 1, 1, 3), np.uint8) * 255).max(
- axis=0).astype(np.uint8) # H, W, 3
- else:
- color_map = (heatmap * COLORS[:heatmap.shape[0]]).max(axis=0).astype(np.uint8) # H, W, 3
-
- return color_map
-
-def _blend_image(image, color_map, a=0.7):
- color_map = cv2.resize(color_map, (image.shape[1], image.shape[0]))
- ret = np.clip(image * (1 - a) + color_map * a, 0, 255).astype(np.uint8)
- return ret
-
-def _blend_image_heatmaps(image, color_maps, a=0.7):
- merges = np.zeros((image.shape[0], image.shape[1], 3), np.float32)
- for color_map in color_maps:
- color_map = cv2.resize(color_map, (image.shape[1], image.shape[0]))
- merges = np.maximum(merges, color_map)
- ret = np.clip(image * (1 - a) + merges * a, 0, 255).astype(np.uint8)
- return ret
-
-def _decompose_level(x, shapes_per_level, N):
- '''
- x: LNHiWi x C
- '''
- x = x.view(x.shape[0], -1)
- ret = []
- st = 0
- for l in range(len(shapes_per_level)):
- ret.append([])
- h = shapes_per_level[l][0].int().item()
- w = shapes_per_level[l][1].int().item()
- for i in range(N):
- ret[l].append(x[st + h * w * i:st + h * w * (i + 1)].view(
- h, w, -1).permute(2, 0, 1))
- st += h * w * N
- return ret
-
-def _imagelist_to_tensor(images):
- images = [x for x in images]
- image_sizes = [x.shape[-2:] for x in images]
- h = max([size[0] for size in image_sizes])
- w = max([size[1] for size in image_sizes])
- S = 32
- h, w = ((h - 1) // S + 1) * S, ((w - 1) // S + 1) * S
- images = [F.pad(x, (0, w - x.shape[2], 0, h - x.shape[1], 0, 0)) \
- for x in images]
- images = torch.stack(images)
- return images
-
-
-def _ind2il(ind, shapes_per_level, N):
- r = ind
- l = 0
- S = 0
- while r - S >= N * shapes_per_level[l][0] * shapes_per_level[l][1]:
- S += N * shapes_per_level[l][0] * shapes_per_level[l][1]
- l += 1
- i = (r - S) // (shapes_per_level[l][0] * shapes_per_level[l][1])
- return i, l
-
-def debug_train(
- images, gt_instances, flattened_hms, reg_targets, labels, pos_inds,
- shapes_per_level, locations, strides):
- '''
- images: N x 3 x H x W
- flattened_hms: LNHiWi x C
- shapes_per_level: L x 2 [(H_i, W_i)]
- locations: LNHiWi x 2
- '''
- reg_inds = torch.nonzero(
- reg_targets.max(dim=1)[0] > 0).squeeze(1)
- N = len(images)
- images = _imagelist_to_tensor(images)
- repeated_locations = [torch.cat([loc] * N, dim=0) \
- for loc in locations]
- locations = torch.cat(repeated_locations, dim=0)
- gt_hms = _decompose_level(flattened_hms, shapes_per_level, N)
- masks = flattened_hms.new_zeros((flattened_hms.shape[0], 1))
- masks[pos_inds] = 1
- masks = _decompose_level(masks, shapes_per_level, N)
- for i in range(len(images)):
- image = images[i].detach().cpu().numpy().transpose(1, 2, 0)
- color_maps = []
- for l in range(len(gt_hms)):
- color_map = _get_color_image(
- gt_hms[l][i].detach().cpu().numpy())
- color_maps.append(color_map)
- cv2.imshow('gthm_{}'.format(l), color_map)
- blend = _blend_image_heatmaps(image.copy(), color_maps)
- if gt_instances is not None:
- bboxes = gt_instances[i].gt_boxes.tensor
- for j in range(len(bboxes)):
- bbox = bboxes[j]
- cv2.rectangle(
- blend,
- (int(bbox[0]), int(bbox[1])),
- (int(bbox[2]), int(bbox[3])),
- (0, 0, 255), 3, cv2.LINE_AA)
-
- for j in range(len(pos_inds)):
- image_id, l = _ind2il(pos_inds[j], shapes_per_level, N)
- if image_id != i:
- continue
- loc = locations[pos_inds[j]]
- cv2.drawMarker(
- blend, (int(loc[0]), int(loc[1])), (0, 255, 255),
- markerSize=(l + 1) * 16)
-
- for j in range(len(reg_inds)):
- image_id, l = _ind2il(reg_inds[j], shapes_per_level, N)
- if image_id != i:
- continue
- ltrb = reg_targets[reg_inds[j]]
- ltrb *= strides[l]
- loc = locations[reg_inds[j]]
- bbox = [(loc[0] - ltrb[0]), (loc[1] - ltrb[1]),
- (loc[0] + ltrb[2]), (loc[1] + ltrb[3])]
- cv2.rectangle(
- blend,
- (int(bbox[0]), int(bbox[1])),
- (int(bbox[2]), int(bbox[3])),
- (255, 0, 0), 1, cv2.LINE_AA)
- cv2.circle(blend, (int(loc[0]), int(loc[1])), 2, (255, 0, 0), -1)
-
- cv2.imshow('blend', blend)
- cv2.waitKey()
-
-
-def debug_test(
- images, logits_pred, reg_pred, agn_hm_pred=[], preds=[],
- vis_thresh=0.3, debug_show_name=False, mult_agn=False):
- '''
- images: N x 3 x H x W
- class_target: LNHiWi x C
- cat_agn_heatmap: LNHiWi
- shapes_per_level: L x 2 [(H_i, W_i)]
- '''
- N = len(images)
- for i in range(len(images)):
- image = images[i].detach().cpu().numpy().transpose(1, 2, 0)
- result = image.copy().astype(np.uint8)
- pred_image = image.copy().astype(np.uint8)
- color_maps = []
- L = len(logits_pred)
- for l in range(L):
- if logits_pred[0] is not None:
- stride = min(image.shape[0], image.shape[1]) / min(
- logits_pred[l][i].shape[1], logits_pred[l][i].shape[2])
- else:
- stride = min(image.shape[0], image.shape[1]) / min(
- agn_hm_pred[l][i].shape[1], agn_hm_pred[l][i].shape[2])
- stride = stride if stride < 60 else 64 if stride < 100 else 128
- if logits_pred[0] is not None:
- if mult_agn:
- logits_pred[l][i] = logits_pred[l][i] * agn_hm_pred[l][i]
- color_map = _get_color_image(
- logits_pred[l][i].detach().cpu().numpy())
- color_maps.append(color_map)
- cv2.imshow('predhm_{}'.format(l), color_map)
-
- if debug_show_name:
- from detectron2.data.datasets.lvis_v1_categories import LVIS_CATEGORIES
- cat2name = [x['name'] for x in LVIS_CATEGORIES]
- for j in range(len(preds[i].scores) if preds is not None else 0):
- if preds[i].scores[j] > vis_thresh:
- bbox = preds[i].proposal_boxes[j] \
- if preds[i].has('proposal_boxes') else \
- preds[i].pred_boxes[j]
- bbox = bbox.tensor[0].detach().cpu().numpy().astype(np.int32)
- cat = int(preds[i].pred_classes[j]) \
- if preds[i].has('pred_classes') else 0
- cl = COLORS[cat, 0, 0]
- cv2.rectangle(
- pred_image, (int(bbox[0]), int(bbox[1])),
- (int(bbox[2]), int(bbox[3])),
- (int(cl[0]), int(cl[1]), int(cl[2])), 2, cv2.LINE_AA)
- if debug_show_name:
- txt = '{}{:.1f}'.format(
- cat2name[cat] if cat > 0 else '',
- preds[i].scores[j])
- font = cv2.FONT_HERSHEY_SIMPLEX
- cat_size = cv2.getTextSize(txt, font, 0.5, 2)[0]
- cv2.rectangle(
- pred_image,
- (int(bbox[0]), int(bbox[1] - cat_size[1] - 2)),
- (int(bbox[0] + cat_size[0]), int(bbox[1] - 2)),
- (int(cl[0]), int(cl[1]), int(cl[2])), -1)
- cv2.putText(
- pred_image, txt, (int(bbox[0]), int(bbox[1] - 2)),
- font, 0.5, (0, 0, 0), thickness=1, lineType=cv2.LINE_AA)
-
-
- if agn_hm_pred[l] is not None:
- agn_hm_ = agn_hm_pred[l][i, 0, :, :, None].detach().cpu().numpy()
- agn_hm_ = (agn_hm_ * np.array([255, 255, 255]).reshape(
- 1, 1, 3)).astype(np.uint8)
- cv2.imshow('agn_hm_{}'.format(l), agn_hm_)
- blend = _blend_image_heatmaps(image.copy(), color_maps)
- cv2.imshow('blend', blend)
- cv2.imshow('preds', pred_image)
- cv2.waitKey()
-
-global cnt
-cnt = 0
-
-def debug_second_stage(images, instances, proposals=None, vis_thresh=0.3,
- save_debug=False, debug_show_name=False, image_labels=[],
- save_debug_path='output/save_debug/',
- bgr=False):
- images = _imagelist_to_tensor(images)
- if 'COCO' in save_debug_path:
- from detectron2.data.datasets.builtin_meta import COCO_CATEGORIES
- cat2name = [x['name'] for x in COCO_CATEGORIES]
- else:
- from detectron2.data.datasets.lvis_v1_categories import LVIS_CATEGORIES
- cat2name = ['({}){}'.format(x['frequency'], x['name']) \
- for x in LVIS_CATEGORIES]
- for i in range(len(images)):
- image = images[i].detach().cpu().numpy().transpose(1, 2, 0).astype(np.uint8).copy()
- if bgr:
- image = image[:, :, ::-1].copy()
- if instances[i].has('gt_boxes'):
- bboxes = instances[i].gt_boxes.tensor.cpu().numpy()
- scores = np.ones(bboxes.shape[0])
- cats = instances[i].gt_classes.cpu().numpy()
- else:
- bboxes = instances[i].pred_boxes.tensor.cpu().numpy()
- scores = instances[i].scores.cpu().numpy()
- cats = instances[i].pred_classes.cpu().numpy()
- for j in range(len(bboxes)):
- if scores[j] > vis_thresh:
- bbox = bboxes[j]
- cl = COLORS[cats[j], 0, 0]
- cl = (int(cl[0]), int(cl[1]), int(cl[2]))
- cv2.rectangle(
- image,
- (int(bbox[0]), int(bbox[1])),
- (int(bbox[2]), int(bbox[3])),
- cl, 2, cv2.LINE_AA)
- if debug_show_name:
- cat = cats[j]
- txt = '{}{:.1f}'.format(
- cat2name[cat] if cat > 0 else '',
- scores[j])
- font = cv2.FONT_HERSHEY_SIMPLEX
- cat_size = cv2.getTextSize(txt, font, 0.5, 2)[0]
- cv2.rectangle(
- image,
- (int(bbox[0]), int(bbox[1] - cat_size[1] - 2)),
- (int(bbox[0] + cat_size[0]), int(bbox[1] - 2)),
- (int(cl[0]), int(cl[1]), int(cl[2])), -1)
- cv2.putText(
- image, txt, (int(bbox[0]), int(bbox[1] - 2)),
- font, 0.5, (0, 0, 0), thickness=1, lineType=cv2.LINE_AA)
- if proposals is not None:
- proposal_image = images[i].detach().cpu().numpy().transpose(1, 2, 0).astype(np.uint8).copy()
- if bgr:
- proposal_image = proposal_image.copy()
- else:
- proposal_image = proposal_image[:, :, ::-1].copy()
- bboxes = proposals[i].proposal_boxes.tensor.cpu().numpy()
- if proposals[i].has('scores'):
- scores = proposals[i].scores.detach().cpu().numpy()
- else:
- scores = proposals[i].objectness_logits.detach().cpu().numpy()
- # selected = -1
- # if proposals[i].has('image_loss'):
- # selected = proposals[i].image_loss.argmin()
- if proposals[i].has('selected'):
- selected = proposals[i].selected
- else:
- selected = [-1 for _ in range(len(bboxes))]
- for j in range(len(bboxes)):
- if scores[j] > vis_thresh or selected[j] >= 0:
- bbox = bboxes[j]
- cl = (209, 159, 83)
- th = 2
- if selected[j] >= 0:
- cl = (0, 0, 0xa4)
- th = 4
- cv2.rectangle(
- proposal_image,
- (int(bbox[0]), int(bbox[1])),
- (int(bbox[2]), int(bbox[3])),
- cl, th, cv2.LINE_AA)
- if selected[j] >= 0 and debug_show_name:
- cat = selected[j].item()
- txt = '{}'.format(cat2name[cat])
- font = cv2.FONT_HERSHEY_SIMPLEX
- cat_size = cv2.getTextSize(txt, font, 0.5, 2)[0]
- cv2.rectangle(
- proposal_image,
- (int(bbox[0]), int(bbox[1] - cat_size[1] - 2)),
- (int(bbox[0] + cat_size[0]), int(bbox[1] - 2)),
- (int(cl[0]), int(cl[1]), int(cl[2])), -1)
- cv2.putText(
- proposal_image, txt,
- (int(bbox[0]), int(bbox[1] - 2)),
- font, 0.5, (0, 0, 0), thickness=1,
- lineType=cv2.LINE_AA)
-
- if save_debug:
- global cnt
- cnt = (cnt + 1) % 5000
- if not os.path.exists(save_debug_path):
- os.mkdir(save_debug_path)
- save_name = '{}/{:05d}.jpg'.format(save_debug_path, cnt)
- if i < len(image_labels):
- image_label = image_labels[i]
- save_name = '{}/{:05d}'.format(save_debug_path, cnt)
- for x in image_label:
- class_name = cat2name[x]
- save_name = save_name + '|{}'.format(class_name)
- save_name = save_name + '.jpg'
- cv2.imwrite(save_name, proposal_image)
- else:
- cv2.imshow('image', image)
- if proposals is not None:
- cv2.imshow('proposals', proposal_image)
- cv2.waitKey()
\ No newline at end of file
diff --git a/spaces/bi02/bingo/Dockerfile b/spaces/bi02/bingo/Dockerfile
deleted file mode 100644
index c677b05b75f7e4b2beee8c97fb47957a0861a83e..0000000000000000000000000000000000000000
--- a/spaces/bi02/bingo/Dockerfile
+++ /dev/null
@@ -1,7 +0,0 @@
-FROM weaigc/bingo:latest
-
-ARG DEBIAN_FRONTEND=noninteractive
-
-ENV BING_HEADER ""
-
-CMD npm start
diff --git a/spaces/bingbing520/ChatGPT2/assets/custom.css b/spaces/bingbing520/ChatGPT2/assets/custom.css
deleted file mode 100644
index af5e9f2118b843b3bbd7627ed45e970c20b13bef..0000000000000000000000000000000000000000
--- a/spaces/bingbing520/ChatGPT2/assets/custom.css
+++ /dev/null
@@ -1,353 +0,0 @@
-:root {
- --chatbot-color-light: #F3F3F3;
- --chatbot-color-dark: #121111;
-}
-
-#app_title {
- font-weight: var(--prose-header-text-weight);
- font-size: var(--text-xxl);
- line-height: 1.3;
- text-align: left;
- margin-top: 6px;
- white-space: nowrap;
-}
-#description {
- text-align: center;
- margin:16px 0
-}
-
-/* 覆盖gradio的页脚信息QAQ */
-/* footer {
- display: none !important;
-} */
-#footer {
- text-align: center;
-}
-#footer div {
- display: inline-block;
-}
-#footer .versions{
- font-size: 85%;
- opacity: 0.85;
-}
-
-#float_display {
- position: absolute;
- max-height: 30px;
-}
-/* user_info */
-#user_info {
- white-space: nowrap;
- position: absolute; left: 8em; top: .2em;
- z-index: var(--layer-2);
- box-shadow: var(--block-shadow);
- border: none; border-radius: var(--block-label-radius);
- background: var(--color-accent);
- padding: var(--block-label-padding);
- font-size: var(--block-label-text-size); line-height: var(--line-sm);
- width: auto; min-height: 30px!important;
- opacity: 1;
- transition: opacity 0.3s ease-in-out;
-}
-#user_info .wrap {
- opacity: 0;
-}
-#user_info p {
- color: white;
- font-weight: var(--block-label-text-weight);
-}
-#user_info.hideK {
- opacity: 0;
- transition: opacity 1s ease-in-out;
-}
-
-/* status_display */
-#status_display {
- display: flex;
- min-height: 2em;
- align-items: flex-end;
- justify-content: flex-end;
-}
-#status_display p {
- font-size: .85em;
- font-family: monospace;
- color: var(--body-text-color-subdued);
-}
-
-#status_display {
- transition: all 0.6s;
-}
-#chuanhu_chatbot {
- transition: height 0.3s ease;
-}
-
-/* usage_display */
-.insert_block {
- position: relative;
- margin: 0;
- padding: .5em 1em;
- box-shadow: var(--block-shadow);
- border-width: var(--block-border-width);
- border-color: var(--block-border-color);
- border-radius: var(--block-radius);
- background: var(--block-background-fill);
- width: 100%;
- line-height: var(--line-sm);
- min-height: 2em;
-}
-#usage_display p, #usage_display span {
- margin: 0;
- font-size: .85em;
- color: var(--body-text-color-subdued);
-}
-.progress-bar {
- background-color: var(--input-background-fill);;
- margin: 0 1em;
- height: 20px;
- border-radius: 10px;
- overflow: hidden;
-}
-.progress {
- background-color: var(--block-title-background-fill);
- height: 100%;
- border-radius: 10px;
- text-align: right;
- transition: width 0.5s ease-in-out;
-}
-.progress-text {
- /* color: white; */
- color: var(--color-accent) !important;
- font-size: 1em !important;
- font-weight: bold;
- padding-right: 10px;
- line-height: 20px;
-}
-
-.apSwitch {
- top: 2px;
- display: inline-block;
- height: 24px;
- position: relative;
- width: 48px;
- border-radius: 12px;
-}
-.apSwitch input {
- display: none !important;
-}
-.apSlider {
- background-color: var(--block-label-background-fill);
- bottom: 0;
- cursor: pointer;
- left: 0;
- position: absolute;
- right: 0;
- top: 0;
- transition: .4s;
- font-size: 18px;
- border-radius: 12px;
-}
-.apSlider::before {
- bottom: -1.5px;
- left: 1px;
- position: absolute;
- transition: .4s;
- content: "🌞";
-}
-input:checked + .apSlider {
- background-color: var(--block-label-background-fill);
-}
-input:checked + .apSlider::before {
- transform: translateX(23px);
- content:"🌚";
-}
-
-#submit_btn, #cancel_btn {
- height: 42px !important;
-}
-#submit_btn::before {
- content: url("data:image/svg+xml, %3Csvg width='21px' height='20px' viewBox='0 0 21 20' version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink'%3E %3Cg id='page' stroke='none' stroke-width='1' fill='none' fill-rule='evenodd'%3E %3Cg id='send' transform='translate(0.435849, 0.088463)' fill='%23FFFFFF' fill-rule='nonzero'%3E %3Cpath d='M0.579148261,0.0428666046 C0.301105539,-0.0961547561 -0.036517765,0.122307382 0.0032026237,0.420210298 L1.4927172,18.1553639 C1.5125774,18.4334066 1.79062012,18.5922882 2.04880264,18.4929872 L8.24518329,15.8913017 L11.6412765,19.7441794 C11.8597387,19.9825018 12.2370824,19.8832008 12.3165231,19.5852979 L13.9450591,13.4882182 L19.7839562,11.0255541 C20.0619989,10.8865327 20.0818591,10.4694687 19.7839562,10.3105871 L0.579148261,0.0428666046 Z M11.6138902,17.0883151 L9.85385903,14.7195502 L0.718169621,0.618812241 L12.69945,12.9346347 L11.6138902,17.0883151 Z' id='shape'%3E%3C/path%3E %3C/g%3E %3C/g%3E %3C/svg%3E");
- height: 21px;
-}
-#cancel_btn::before {
- content: url("data:image/svg+xml,%3Csvg width='21px' height='21px' viewBox='0 0 21 21' version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink'%3E %3Cg id='pg' stroke='none' stroke-width='1' fill='none' fill-rule='evenodd'%3E %3Cpath d='M10.2072007,20.088463 C11.5727865,20.088463 12.8594566,19.8259823 14.067211,19.3010209 C15.2749653,18.7760595 16.3386126,18.0538087 17.2581528,17.1342685 C18.177693,16.2147282 18.8982283,15.1527965 19.4197586,13.9484733 C19.9412889,12.7441501 20.202054,11.4557644 20.202054,10.0833163 C20.202054,8.71773046 19.9395733,7.43106036 19.4146119,6.22330603 C18.8896505,5.01555169 18.1673997,3.95018885 17.2478595,3.0272175 C16.3283192,2.10424615 15.2646719,1.3837109 14.0569176,0.865611739 C12.8491633,0.34751258 11.5624932,0.088463 10.1969073,0.088463 C8.83132146,0.088463 7.54636692,0.34751258 6.34204371,0.865611739 C5.1377205,1.3837109 4.07407321,2.10424615 3.15110186,3.0272175 C2.22813051,3.95018885 1.5058797,5.01555169 0.984349419,6.22330603 C0.46281914,7.43106036 0.202054,8.71773046 0.202054,10.0833163 C0.202054,11.4557644 0.4645347,12.7441501 0.9894961,13.9484733 C1.5144575,15.1527965 2.23670831,16.2147282 3.15624854,17.1342685 C4.07578877,18.0538087 5.1377205,18.7760595 6.34204371,19.3010209 C7.54636692,19.8259823 8.83475258,20.088463 10.2072007,20.088463 Z M10.2072007,18.2562448 C9.07493099,18.2562448 8.01471483,18.0452309 7.0265522,17.6232031 C6.03838956,17.2011753 5.17031614,16.6161693 4.42233192,15.8681851 C3.6743477,15.1202009 3.09105726,14.2521274 2.67246059,13.2639648 C2.25386392,12.2758022 2.04456558,11.215586 2.04456558,10.0833163 C2.04456558,8.95104663 2.25386392,7.89083047 2.67246059,6.90266784 C3.09105726,5.9145052 3.6743477,5.04643178 4.42233192,4.29844756 C5.17031614,3.55046334 6.036674,2.9671729 7.02140552,2.54857623 C8.00613703,2.12997956 9.06463763,1.92068122 10.1969073,1.92068122 C11.329177,1.92068122 12.3911087,2.12997956 13.3827025,2.54857623 C14.3742962,2.9671729 15.2440852,3.55046334 15.9920694,4.29844756 C16.7400537,5.04643178 17.3233441,5.9145052 17.7419408,6.90266784 C18.1605374,7.89083047 18.3698358,8.95104663 18.3698358,10.0833163 C18.3698358,11.215586 18.1605374,12.2758022 17.7419408,13.2639648 C17.3233441,14.2521274 16.7400537,15.1202009 15.9920694,15.8681851 C15.2440852,16.6161693 14.3760118,17.2011753 13.3878492,17.6232031 C12.3996865,18.0452309 11.3394704,18.2562448 10.2072007,18.2562448 Z M7.65444721,13.6242324 L12.7496608,13.6242324 C13.0584616,13.6242324 13.3003556,13.5384544 13.4753427,13.3668984 C13.6503299,13.1953424 13.7378234,12.9585951 13.7378234,12.6566565 L13.7378234,7.49968276 C13.7378234,7.19774418 13.6503299,6.96099688 13.4753427,6.78944087 C13.3003556,6.61788486 13.0584616,6.53210685 12.7496608,6.53210685 L7.65444721,6.53210685 C7.33878414,6.53210685 7.09345904,6.61788486 6.91847191,6.78944087 C6.74348478,6.96099688 6.65599121,7.19774418 6.65599121,7.49968276 L6.65599121,12.6566565 C6.65599121,12.9585951 6.74348478,13.1953424 6.91847191,13.3668984 C7.09345904,13.5384544 7.33878414,13.6242324 7.65444721,13.6242324 Z' id='shape' fill='%23FF3B30' fill-rule='nonzero'%3E%3C/path%3E %3C/g%3E %3C/svg%3E");
- height: 21px;
-}
-/* list */
-ol:not(.options), ul:not(.options) {
- padding-inline-start: 2em !important;
-}
-
-/* 亮色（默认） */
-#chuanhu_chatbot {
- background-color: var(--chatbot-color-light) !important;
- color: #000000 !important;
-}
-[data-testid = "bot"] {
- background-color: #FFFFFF !important;
-}
-[data-testid = "user"] {
- background-color: #95EC69 !important;
-}
-/* 暗色 */
-.dark #chuanhu_chatbot {
- background-color: var(--chatbot-color-dark) !important;
- color: #FFFFFF !important;
-}
-.dark [data-testid = "bot"] {
- background-color: #2C2C2C !important;
-}
-.dark [data-testid = "user"] {
- background-color: #26B561 !important;
-}
-
-/* 屏幕宽度大于等于500px的设备 */
-/* update on 2023.4.8: 高度的细致调整已写入JavaScript */
-@media screen and (min-width: 500px) {
- #chuanhu_chatbot {
- height: calc(100vh - 200px);
- }
- #chuanhu_chatbot .wrap {
- max-height: calc(100vh - 200px - var(--line-sm)*1rem - 2*var(--block-label-margin) );
- }
-}
-/* 屏幕宽度小于500px的设备 */
-@media screen and (max-width: 499px) {
- #chuanhu_chatbot {
- height: calc(100vh - 140px);
- }
- #chuanhu_chatbot .wrap {
- max-height: calc(100vh - 140px - var(--line-sm)*1rem - 2*var(--block-label-margin) );
- }
- [data-testid = "bot"] {
- max-width: 98% !important;
- }
- #app_title h1{
- letter-spacing: -1px; font-size: 22px;
- }
-}
-/* 对话气泡 */
-[class *= "message"] {
- border-radius: var(--radius-xl) !important;
- border: none;
- padding: var(--spacing-xl) !important;
- font-size: var(--text-md) !important;
- line-height: var(--line-md) !important;
- min-height: calc(var(--text-md)*var(--line-md) + 2*var(--spacing-xl));
- min-width: calc(var(--text-md)*var(--line-md) + 2*var(--spacing-xl));
-}
-[data-testid = "bot"] {
- max-width: 85%;
- border-bottom-left-radius: 0 !important;
-}
-[data-testid = "user"] {
- max-width: 85%;
- width: auto !important;
- border-bottom-right-radius: 0 !important;
-}
-/* 表格 */
-table {
- margin: 1em 0;
- border-collapse: collapse;
- empty-cells: show;
-}
-td,th {
- border: 1.2px solid var(--border-color-primary) !important;
- padding: 0.2em;
-}
-thead {
- background-color: rgba(175,184,193,0.2);
-}
-thead th {
- padding: .5em .2em;
-}
-/* 行内代码 */
-code {
- display: inline;
- white-space: break-spaces;
- border-radius: 6px;
- margin: 0 2px 0 2px;
- padding: .2em .4em .1em .4em;
- background-color: rgba(175,184,193,0.2);
-}
-/* 代码块 */
-pre code {
- display: block;
- overflow: auto;
- white-space: pre;
- background-color: hsla(0, 0%, 0%, 80%)!important;
- border-radius: 10px;
- padding: 1.4em 1.2em 0em 1.4em;
- margin: 1.2em 2em 1.2em 0.5em;
- color: #FFF;
- box-shadow: 6px 6px 16px hsla(0, 0%, 0%, 0.2);
-}
-/* 代码高亮样式 */
-.highlight .hll { background-color: #49483e }
-.highlight .c { color: #75715e } /* Comment */
-.highlight .err { color: #960050; background-color: #1e0010 } /* Error */
-.highlight .k { color: #66d9ef } /* Keyword */
-.highlight .l { color: #ae81ff } /* Literal */
-.highlight .n { color: #f8f8f2 } /* Name */
-.highlight .o { color: #f92672 } /* Operator */
-.highlight .p { color: #f8f8f2 } /* Punctuation */
-.highlight .ch { color: #75715e } /* Comment.Hashbang */
-.highlight .cm { color: #75715e } /* Comment.Multiline */
-.highlight .cp { color: #75715e } /* Comment.Preproc */
-.highlight .cpf { color: #75715e } /* Comment.PreprocFile */
-.highlight .c1 { color: #75715e } /* Comment.Single */
-.highlight .cs { color: #75715e } /* Comment.Special */
-.highlight .gd { color: #f92672 } /* Generic.Deleted */
-.highlight .ge { font-style: italic } /* Generic.Emph */
-.highlight .gi { color: #a6e22e } /* Generic.Inserted */
-.highlight .gs { font-weight: bold } /* Generic.Strong */
-.highlight .gu { color: #75715e } /* Generic.Subheading */
-.highlight .kc { color: #66d9ef } /* Keyword.Constant */
-.highlight .kd { color: #66d9ef } /* Keyword.Declaration */
-.highlight .kn { color: #f92672 } /* Keyword.Namespace */
-.highlight .kp { color: #66d9ef } /* Keyword.Pseudo */
-.highlight .kr { color: #66d9ef } /* Keyword.Reserved */
-.highlight .kt { color: #66d9ef } /* Keyword.Type */
-.highlight .ld { color: #e6db74 } /* Literal.Date */
-.highlight .m { color: #ae81ff } /* Literal.Number */
-.highlight .s { color: #e6db74 } /* Literal.String */
-.highlight .na { color: #a6e22e } /* Name.Attribute */
-.highlight .nb { color: #f8f8f2 } /* Name.Builtin */
-.highlight .nc { color: #a6e22e } /* Name.Class */
-.highlight .no { color: #66d9ef } /* Name.Constant */
-.highlight .nd { color: #a6e22e } /* Name.Decorator */
-.highlight .ni { color: #f8f8f2 } /* Name.Entity */
-.highlight .ne { color: #a6e22e } /* Name.Exception */
-.highlight .nf { color: #a6e22e } /* Name.Function */
-.highlight .nl { color: #f8f8f2 } /* Name.Label */
-.highlight .nn { color: #f8f8f2 } /* Name.Namespace */
-.highlight .nx { color: #a6e22e } /* Name.Other */
-.highlight .py { color: #f8f8f2 } /* Name.Property */
-.highlight .nt { color: #f92672 } /* Name.Tag */
-.highlight .nv { color: #f8f8f2 } /* Name.Variable */
-.highlight .ow { color: #f92672 } /* Operator.Word */
-.highlight .w { color: #f8f8f2 } /* Text.Whitespace */
-.highlight .mb { color: #ae81ff } /* Literal.Number.Bin */
-.highlight .mf { color: #ae81ff } /* Literal.Number.Float */
-.highlight .mh { color: #ae81ff } /* Literal.Number.Hex */
-.highlight .mi { color: #ae81ff } /* Literal.Number.Integer */
-.highlight .mo { color: #ae81ff } /* Literal.Number.Oct */
-.highlight .sa { color: #e6db74 } /* Literal.String.Affix */
-.highlight .sb { color: #e6db74 } /* Literal.String.Backtick */
-.highlight .sc { color: #e6db74 } /* Literal.String.Char */
-.highlight .dl { color: #e6db74 } /* Literal.String.Delimiter */
-.highlight .sd { color: #e6db74 } /* Literal.String.Doc */
-.highlight .s2 { color: #e6db74 } /* Literal.String.Double */
-.highlight .se { color: #ae81ff } /* Literal.String.Escape */
-.highlight .sh { color: #e6db74 } /* Literal.String.Heredoc */
-.highlight .si { color: #e6db74 } /* Literal.String.Interpol */
-.highlight .sx { color: #e6db74 } /* Literal.String.Other */
-.highlight .sr { color: #e6db74 } /* Literal.String.Regex */
-.highlight .s1 { color: #e6db74 } /* Literal.String.Single */
-.highlight .ss { color: #e6db74 } /* Literal.String.Symbol */
-.highlight .bp { color: #f8f8f2 } /* Name.Builtin.Pseudo */
-.highlight .fm { color: #a6e22e } /* Name.Function.Magic */
-.highlight .vc { color: #f8f8f2 } /* Name.Variable.Class */
-.highlight .vg { color: #f8f8f2 } /* Name.Variable.Global */
-.highlight .vi { color: #f8f8f2 } /* Name.Variable.Instance */
-.highlight .vm { color: #f8f8f2 } /* Name.Variable.Magic */
-.highlight .il { color: #ae81ff } /* Literal.Number.Integer.Long */
diff --git a/spaces/bioriAsaeru/text-to-voice/!!TOP!! Download Fundamentos Da Teoria De Erros Vuolol - Saiba Mais sobre Fisso Nuclear Mnimos Quadrados e Qualidade de Ajuste.md b/spaces/bioriAsaeru/text-to-voice/!!TOP!! Download Fundamentos Da Teoria De Erros Vuolol - Saiba Mais sobre Fisso Nuclear Mnimos Quadrados e Qualidade de Ajuste.md
deleted file mode 100644
index 1c3b189e15cf20404489649428013f65159ca9c4..0000000000000000000000000000000000000000
--- a/spaces/bioriAsaeru/text-to-voice/!!TOP!! Download Fundamentos Da Teoria De Erros Vuolol - Saiba Mais sobre Fisso Nuclear Mnimos Quadrados e Qualidade de Ajuste.md
+++ /dev/null
@@ -1,6 +0,0 @@
-
!!TOP!! Download Fundamentos Da Teoria De Erros Vuolol
-
- aaccfb2cb3
-
-
-
diff --git a/spaces/bioriAsaeru/text-to-voice/Essential C for Engineers and Scientists (2nd Edition) Download PDF Learn C from Scratch with this Easy-to-Follow Book.md b/spaces/bioriAsaeru/text-to-voice/Essential C for Engineers and Scientists (2nd Edition) Download PDF Learn C from Scratch with this Easy-to-Follow Book.md
deleted file mode 100644
index eef6ff6a37bc19f6f7f278ec0a714fc6b7c93322..0000000000000000000000000000000000000000
--- a/spaces/bioriAsaeru/text-to-voice/Essential C for Engineers and Scientists (2nd Edition) Download PDF Learn C from Scratch with this Easy-to-Follow Book.md
+++ /dev/null
@@ -1,6 +0,0 @@
-
Essential C for Engineers and Scientists (2nd Edition) download pdf
-
- aaccfb2cb3
-
-
-
diff --git a/spaces/bioriAsaeru/text-to-voice/Evan Almighty Dual Audio Enghindi The Story of a Modern-Day Noah and His Ark.md b/spaces/bioriAsaeru/text-to-voice/Evan Almighty Dual Audio Enghindi The Story of a Modern-Day Noah and His Ark.md
deleted file mode 100644
index 28e3d46da4252abb5b5ddc4d6f1e16661c08e076..0000000000000000000000000000000000000000
--- a/spaces/bioriAsaeru/text-to-voice/Evan Almighty Dual Audio Enghindi The Story of a Modern-Day Noah and His Ark.md
+++ /dev/null
@@ -1,6 +0,0 @@
-
-{% endblock %}
\ No newline at end of file
diff --git a/spaces/bobsby23/step-by-step/README.md b/spaces/bobsby23/step-by-step/README.md
deleted file mode 100644
index 316055315dee247b354cb4879dea5c576dfb4bc4..0000000000000000000000000000000000000000
--- a/spaces/bobsby23/step-by-step/README.md
+++ /dev/null
@@ -1,11 +0,0 @@
----
-title: AutoTrain Advanced
-emoji: 🚀
-colorFrom: blue
-colorTo: green
-sdk: docker
-pinned: false
-license: agpl-3.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/brainblow/AudioCreator_Music-Audio_Generation/audiocraft/metrics/visqol.py b/spaces/brainblow/AudioCreator_Music-Audio_Generation/audiocraft/metrics/visqol.py
deleted file mode 100644
index 44f4b0a2c3c6c726857db8386491823dd85dde51..0000000000000000000000000000000000000000
--- a/spaces/brainblow/AudioCreator_Music-Audio_Generation/audiocraft/metrics/visqol.py
+++ /dev/null
@@ -1,216 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-import csv
-import json
-import logging
-from pathlib import Path
-import tempfile
-import typing as tp
-import subprocess
-import shutil
-
-import torch
-import torchaudio
-
-logger = logging.getLogger(__name__)
-
-
-class ViSQOL:
- """ViSQOL wrapper to run ViSQOL from Python using a pre-installed binary.
-
- To learn more about ViSQOL and how to build ViSQOL binary using bazel, please refer to the
- instructions available in the open source repository: https://github.com/google/visqol
-
- ViSQOL is capable of running in two modes:
-
- Audio Mode:
- When running in audio mode, input signals must have a 48kHz sample rate. Input should be resampled to 48kHz.
- Input signals can be multi-channel, but they will be down-mixed to mono for performing the comparison.
- Audio mode uses support vector regression, with the maximum range at ~4.75.
-
- Speech Mode:
- When running in speech mode, ViSQOL uses a wideband model. It therefore expects input sample rates of 16kHz.
- Input should be resampled to 16kHz.
- As part of the speech mode processing, a root mean square implementation for voice activity detection
- is performed on the reference signal to determine what parts of the signal have voice activity and
- should therefore be included in the comparison. The signal is normalized before performing the voice
- activity detection.
- Input signals can be multi-channel, but they will be down-mixed to mono for performing the comparison.
- Speech mode is scaled to have a maximum MOS of 5.0 to match previous version behavior.
-
- For more details, check the guidelines: https://github.com/google/visqol#general-guidelines-for-input
-
- Args:
- visqol_bin (str): Path to the ViSQOL binary.
- mode (str): ViSQOL computation mode, expecting "audio" or "speech".
- model (str): Name of the model to use for similarity to quality model.
- debug (bool): Whether to also get debug metrics from ViSQOL or not.
- """
- SAMPLE_RATES_MODES = {"audio": 48_000, "speech": 16_000}
- ALLOWED_SAMPLE_RATES = frozenset(SAMPLE_RATES_MODES.values())
-
- def __init__(self, bin: tp.Union[Path, str], mode: str = "audio",
- model: str = "libsvm_nu_svr_model.txt", debug: bool = False):
- assert bin is not None and Path(bin).exists(), f"Could not find ViSQOL binary in specified path: {bin}"
- self.visqol_bin = str(bin)
- self.visqol_mode = mode
- self.target_sr = self._get_target_sr(self.visqol_mode)
- self.model = model
- self.debug = debug
- assert Path(self.visqol_model).exists(), \
- f"Could not find the specified model in ViSQOL install: {self.visqol_model}"
-
- def _get_target_sr(self, mode: str) -> int:
- # returns target sampling rate for the corresponding ViSQOL mode.
- if mode not in ViSQOL.SAMPLE_RATES_MODES:
- raise ValueError(
- f"Unsupported mode! Allowed are: {', '.join(ViSQOL.SAMPLE_RATES_MODES.keys())}"
- )
- return ViSQOL.SAMPLE_RATES_MODES[mode]
-
- def _prepare_files(
- self, ref_sig: torch.Tensor, deg_sig: torch.Tensor, sr: int, target_sr: int, pad_with_silence: bool = False
- ):
- # prepare files for ViSQOL evaluation.
- assert target_sr in ViSQOL.ALLOWED_SAMPLE_RATES
- assert len(ref_sig) == len(deg_sig), (
- "Expects same number of ref and degraded inputs",
- f" but ref len {len(ref_sig)} != deg len {len(deg_sig)}"
- )
- # resample audio if needed
- if sr != target_sr:
- transform = torchaudio.transforms.Resample(sr, target_sr)
- pad = int(0.5 * target_sr)
- rs_ref = []
- rs_deg = []
- for i in range(len(ref_sig)):
- rs_ref_i = transform(ref_sig[i])
- rs_deg_i = transform(deg_sig[i])
- if pad_with_silence:
- rs_ref_i = torch.nn.functional.pad(rs_ref_i, (pad, pad), mode='constant', value=0)
- rs_deg_i = torch.nn.functional.pad(rs_deg_i, (pad, pad), mode='constant', value=0)
- rs_ref.append(rs_ref_i)
- rs_deg.append(rs_deg_i)
- ref_sig = torch.stack(rs_ref)
- deg_sig = torch.stack(rs_deg)
- # save audio chunks to tmp dir and create csv
- tmp_dir = Path(tempfile.mkdtemp())
- try:
- tmp_input_csv_path = tmp_dir / "input.csv"
- tmp_results_csv_path = tmp_dir / "results.csv"
- tmp_debug_json_path = tmp_dir / "debug.json"
- with open(tmp_input_csv_path, "w") as csv_file:
- csv_writer = csv.writer(csv_file)
- csv_writer.writerow(["reference", "degraded"])
- for i in range(len(ref_sig)):
- tmp_ref_filename = tmp_dir / f"ref_{i}.wav"
- tmp_deg_filename = tmp_dir / f"deg_{i}.wav"
- torchaudio.save(
- tmp_ref_filename,
- torch.clamp(ref_sig[i], min=-0.99, max=0.99),
- sample_rate=target_sr,
- bits_per_sample=16,
- encoding="PCM_S"
- )
- torchaudio.save(
- tmp_deg_filename,
- torch.clamp(deg_sig[i], min=-0.99, max=0.99),
- sample_rate=target_sr,
- bits_per_sample=16,
- encoding="PCM_S"
- )
- csv_writer.writerow([str(tmp_ref_filename), str(tmp_deg_filename)])
- return tmp_dir, tmp_input_csv_path, tmp_results_csv_path, tmp_debug_json_path
- except Exception as e:
- logger.error("Exception occurred when preparing files for ViSQOL: %s", e)
- return tmp_dir, None, None, None
-
- def _flush_files(self, tmp_dir: tp.Union[Path, str]):
- # flush tmp files used to compute ViSQOL.
- shutil.rmtree(str(tmp_dir))
-
- def _collect_moslqo_score(self, results_csv_path: tp.Union[Path, str]) -> float:
- # collect results for each evaluated pair and return averaged moslqo score.
- with open(results_csv_path, "r") as csv_file:
- reader = csv.DictReader(csv_file)
- moslqo_scores = [float(row["moslqo"]) for row in reader]
- if len(moslqo_scores) > 0:
- return sum(moslqo_scores) / len(moslqo_scores)
- else:
- return 0.0
-
- def _collect_debug_data(self, debug_json_path: tp.Union[Path, str]) -> dict:
- # collect debug data for the visqol inference.
- with open(debug_json_path, "r") as f:
- data = json.load(f)
- return data
-
- @property
- def visqol_model(self):
- return f'{self.visqol_bin}/model/{self.model}'
-
- def _run_visqol(
- self,
- input_csv_path: tp.Union[Path, str],
- results_csv_path: tp.Union[Path, str],
- debug_csv_path: tp.Optional[tp.Union[Path, str]],
- ):
- input_csv_path = str(input_csv_path)
- results_csv_path = str(results_csv_path)
- debug_csv_path = str(debug_csv_path)
- cmd = [
- f'{self.visqol_bin}/bazel-bin/visqol',
- '--batch_input_csv', f'{input_csv_path}',
- '--results_csv', f'{results_csv_path}'
- ]
- if debug_csv_path is not None:
- cmd += ['--output_debug', f'{debug_csv_path}']
- if self.visqol_mode == "speech":
- cmd += ['--use_speech_mode']
- cmd += ['--similarity_to_quality_model', f'{self.visqol_model}']
- result = subprocess.run(cmd, capture_output=True)
- if result.returncode:
- logger.error("Error with visqol: \n %s \n %s", result.stdout.decode(), result.stderr.decode())
- raise RuntimeError("Error while executing visqol")
- result.check_returncode()
-
- def __call__(
- self,
- ref_sig: torch.Tensor,
- deg_sig: torch.Tensor,
- sr: int,
- pad_with_silence: bool = False,
- ):
- """Calculate the ViSQOL metric for a pair of audio signals at a given sample rate.
- Args:
- ref_sig (torch.Tensor): Reference signals as [B, C, T].
- deg_sig (torch.Tensor): Degraded signals as [B, C, T].
- sr (int): Sample rate of the two audio signals.
- pad_with_silence (bool): Whether to pad the file with silences as recommended
- in visqol guidelines (see: https://github.com/google/visqol#general-guidelines-for-input).
- Returns:
- float: The ViSQOL score or mean score for the batch.
- """
- logger.debug(f"Calculating visqol with mode={self.visqol_mode} on {len(ref_sig)} samples")
- tmp_dir, input_csv, results_csv, debug_json = self._prepare_files(
- ref_sig, deg_sig, sr, self.target_sr, pad_with_silence
- )
- try:
- if input_csv and results_csv:
- self._run_visqol(
- input_csv,
- results_csv,
- debug_json if self.debug else None,
- )
- mosqol = self._collect_moslqo_score(results_csv)
- return mosqol
- else:
- raise RuntimeError("Something unexpected happened when running VISQOL!")
- except Exception as e:
- logger.error("Exception occurred when running ViSQOL: %s", e)
- finally:
- self._flush_files(tmp_dir)
diff --git a/spaces/brjathu/HMR2.0/hmr2/datasets/vitdet_dataset.py b/spaces/brjathu/HMR2.0/hmr2/datasets/vitdet_dataset.py
deleted file mode 100644
index ba6160e8205fb5a2d767578e8fbc9821147fc223..0000000000000000000000000000000000000000
--- a/spaces/brjathu/HMR2.0/hmr2/datasets/vitdet_dataset.py
+++ /dev/null
@@ -1,89 +0,0 @@
-from typing import Dict
-
-import cv2
-import numpy as np
-from skimage.filters import gaussian
-from yacs.config import CfgNode
-import torch
-
-from .utils import (convert_cvimg_to_tensor,
- expand_to_aspect_ratio,
- generate_image_patch_cv2)
-
-DEFAULT_MEAN = 255. * np.array([0.485, 0.456, 0.406])
-DEFAULT_STD = 255. * np.array([0.229, 0.224, 0.225])
-
-class ViTDetDataset(torch.utils.data.Dataset):
-
- def __init__(self,
- cfg: CfgNode,
- img_cv2: np.array,
- boxes: np.array,
- train: bool = False,
- **kwargs):
- super().__init__()
- self.cfg = cfg
- self.img_cv2 = img_cv2
- # self.boxes = boxes
-
- assert train == False, "ViTDetDataset is only for inference"
- self.train = train
- self.img_size = cfg.MODEL.IMAGE_SIZE
- self.mean = 255. * np.array(self.cfg.MODEL.IMAGE_MEAN)
- self.std = 255. * np.array(self.cfg.MODEL.IMAGE_STD)
-
- # Preprocess annotations
- boxes = boxes.astype(np.float32)
- self.center = (boxes[:, 2:4] + boxes[:, 0:2]) / 2.0
- self.scale = (boxes[:, 2:4] - boxes[:, 0:2]) / 200.0
- self.personid = np.arange(len(boxes), dtype=np.int32)
-
- def __len__(self) -> int:
- return len(self.personid)
-
- def __getitem__(self, idx: int) -> Dict[str, np.array]:
-
- center = self.center[idx].copy()
- center_x = center[0]
- center_y = center[1]
-
- scale = self.scale[idx]
- BBOX_SHAPE = self.cfg.MODEL.get('BBOX_SHAPE', None)
- bbox_size = expand_to_aspect_ratio(scale*200, target_aspect_ratio=BBOX_SHAPE).max()
-
- patch_width = patch_height = self.img_size
-
- # 3. generate image patch
- # if use_skimage_antialias:
- cvimg = self.img_cv2.copy()
- if True:
- # Blur image to avoid aliasing artifacts
- downsampling_factor = ((bbox_size*1.0) / patch_width)
- print(f'{downsampling_factor=}')
- downsampling_factor = downsampling_factor / 2.0
- if downsampling_factor > 1.1:
- cvimg = gaussian(cvimg, sigma=(downsampling_factor-1)/2, channel_axis=2, preserve_range=True)
-
-
- img_patch_cv, trans = generate_image_patch_cv2(cvimg,
- center_x, center_y,
- bbox_size, bbox_size,
- patch_width, patch_height,
- False, 1.0, 0,
- border_mode=cv2.BORDER_CONSTANT)
- img_patch_cv = img_patch_cv[:, :, ::-1]
- img_patch = convert_cvimg_to_tensor(img_patch_cv)
-
- # apply normalization
- for n_c in range(min(self.img_cv2.shape[2], 3)):
- img_patch[n_c, :, :] = (img_patch[n_c, :, :] - self.mean[n_c]) / self.std[n_c]
-
-
- item = {
- 'img': img_patch,
- 'personid': int(self.personid[idx]),
- }
- item['box_center'] = self.center[idx].copy()
- item['box_size'] = bbox_size
- item['img_size'] = 1.0 * np.array([cvimg.shape[1], cvimg.shape[0]])
- return item
diff --git a/spaces/carlosalonso/Detection-video/carpeta_deteccion/projects/Panoptic-DeepLab/panoptic_deeplab/__init__.py b/spaces/carlosalonso/Detection-video/carpeta_deteccion/projects/Panoptic-DeepLab/panoptic_deeplab/__init__.py
deleted file mode 100644
index 8d3c980643bbd385594850bfbffa84cd1412c162..0000000000000000000000000000000000000000
--- a/spaces/carlosalonso/Detection-video/carpeta_deteccion/projects/Panoptic-DeepLab/panoptic_deeplab/__init__.py
+++ /dev/null
@@ -1,10 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-from .config import add_panoptic_deeplab_config
-from .dataset_mapper import PanopticDeeplabDatasetMapper
-from .panoptic_seg import (
- PanopticDeepLab,
- INS_EMBED_BRANCHES_REGISTRY,
- build_ins_embed_branch,
- PanopticDeepLabSemSegHead,
- PanopticDeepLabInsEmbedHead,
-)
diff --git a/spaces/cc38300/ConstructionGPT-SL/app.py b/spaces/cc38300/ConstructionGPT-SL/app.py
deleted file mode 100644
index 582d29d23e35046e0fc759000579324b1d87d657..0000000000000000000000000000000000000000
--- a/spaces/cc38300/ConstructionGPT-SL/app.py
+++ /dev/null
@@ -1,83 +0,0 @@
-import streamlit as st
-from streamlit_chat import message
-
-from database import get_redis_connection
-from chatbot import RetrievalAssistant, Message
-
-# Initialise database
-
-## Initialise Redis connection
-redis_client = get_redis_connection()
-
-# Set instruction
-
-# System prompt requiring Question and Year to be extracted from the user
-system_prompt = '''
-You are a helpful Formula 1 knowledge base assistant. You need to capture a Question and Year from each customer.
-The Question is their query on Formula 1, and the Year is the year of the applicable Formula 1 season.
-Think about this step by step:
-- The user will ask a Question
-- You will ask them for the Year if their question didn't include a Year
-- Once you have the Year, say "searching for answers".
-
-Example:
-
-User: I'd like to know the cost cap for a power unit
-
-Assistant: Certainly, what year would you like this for?
-
-User: 2023 please.
-
-Assistant: Searching for answers.
-'''
-
-### CHATBOT APP
-
-st.set_page_config(
- page_title="Streamlit Chat - Demo",
- page_icon=":robot:"
-)
-
-st.title('Formula 1 Chatbot')
-st.subheader("Help us help you learn about Formula 1")
-
-if 'generated' not in st.session_state:
- st.session_state['generated'] = []
-
-if 'past' not in st.session_state:
- st.session_state['past'] = []
-
-def query(question):
- response = st.session_state['chat'].ask_assistant(question)
- return response
-
-prompt = st.text_input(f"What do you want to know: ", key="input")
-
-if st.button('Submit', key='generationSubmit'):
-
- # Initialization
- if 'chat' not in st.session_state:
- st.session_state['chat'] = RetrievalAssistant()
- messages = []
- system_message = Message('system',system_prompt)
- messages.append(system_message.message())
- else:
- messages = []
-
-
- user_message = Message('user',prompt)
- messages.append(user_message.message())
-
- response = query(messages)
-
- # Debugging step to print the whole response
- #st.write(response)
-
- st.session_state.past.append(prompt)
- st.session_state.generated.append(response['content'])
-
-if st.session_state['generated']:
-
- for i in range(len(st.session_state['generated'])-1, -1, -1):
- message(st.session_state["generated"][i], key=str(i))
- message(st.session_state['past'][i], is_user=True, key=str(i) + '_user')
diff --git a/spaces/chendl/compositional_test/multimodal/open_flamingo/__init__.py b/spaces/chendl/compositional_test/multimodal/open_flamingo/__init__.py
deleted file mode 100644
index ab67750bb75534afaeb8876c065e32d4861f3052..0000000000000000000000000000000000000000
--- a/spaces/chendl/compositional_test/multimodal/open_flamingo/__init__.py
+++ /dev/null
@@ -1,2 +0,0 @@
-from .src.flamingo import Flamingo
-from .src.factory import create_model_and_transforms
diff --git a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/anyio/to_process.py b/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/anyio/to_process.py
deleted file mode 100644
index 7ba9d44198233b94bea1b01c6135416170eac925..0000000000000000000000000000000000000000
--- a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/anyio/to_process.py
+++ /dev/null
@@ -1,249 +0,0 @@
-from __future__ import annotations
-
-import os
-import pickle
-import subprocess
-import sys
-from collections import deque
-from importlib.util import module_from_spec, spec_from_file_location
-from typing import Callable, TypeVar, cast
-
-from ._core._eventloop import current_time, get_asynclib, get_cancelled_exc_class
-from ._core._exceptions import BrokenWorkerProcess
-from ._core._subprocesses import open_process
-from ._core._synchronization import CapacityLimiter
-from ._core._tasks import CancelScope, fail_after
-from .abc import ByteReceiveStream, ByteSendStream, Process
-from .lowlevel import RunVar, checkpoint_if_cancelled
-from .streams.buffered import BufferedByteReceiveStream
-
-WORKER_MAX_IDLE_TIME = 300 # 5 minutes
-
-T_Retval = TypeVar("T_Retval")
-_process_pool_workers: RunVar[set[Process]] = RunVar("_process_pool_workers")
-_process_pool_idle_workers: RunVar[deque[tuple[Process, float]]] = RunVar(
- "_process_pool_idle_workers"
-)
-_default_process_limiter: RunVar[CapacityLimiter] = RunVar("_default_process_limiter")
-
-
-async def run_sync(
- func: Callable[..., T_Retval],
- *args: object,
- cancellable: bool = False,
- limiter: CapacityLimiter | None = None,
-) -> T_Retval:
- """
- Call the given function with the given arguments in a worker process.
-
- If the ``cancellable`` option is enabled and the task waiting for its completion is cancelled,
- the worker process running it will be abruptly terminated using SIGKILL (or
- ``terminateProcess()`` on Windows).
-
- :param func: a callable
- :param args: positional arguments for the callable
- :param cancellable: ``True`` to allow cancellation of the operation while it's running
- :param limiter: capacity limiter to use to limit the total amount of processes running
- (if omitted, the default limiter is used)
- :return: an awaitable that yields the return value of the function.
-
- """
-
- async def send_raw_command(pickled_cmd: bytes) -> object:
- try:
- await stdin.send(pickled_cmd)
- response = await buffered.receive_until(b"\n", 50)
- status, length = response.split(b" ")
- if status not in (b"RETURN", b"EXCEPTION"):
- raise RuntimeError(
- f"Worker process returned unexpected response: {response!r}"
- )
-
- pickled_response = await buffered.receive_exactly(int(length))
- except BaseException as exc:
- workers.discard(process)
- try:
- process.kill()
- with CancelScope(shield=True):
- await process.aclose()
- except ProcessLookupError:
- pass
-
- if isinstance(exc, get_cancelled_exc_class()):
- raise
- else:
- raise BrokenWorkerProcess from exc
-
- retval = pickle.loads(pickled_response)
- if status == b"EXCEPTION":
- assert isinstance(retval, BaseException)
- raise retval
- else:
- return retval
-
- # First pickle the request before trying to reserve a worker process
- await checkpoint_if_cancelled()
- request = pickle.dumps(("run", func, args), protocol=pickle.HIGHEST_PROTOCOL)
-
- # If this is the first run in this event loop thread, set up the necessary variables
- try:
- workers = _process_pool_workers.get()
- idle_workers = _process_pool_idle_workers.get()
- except LookupError:
- workers = set()
- idle_workers = deque()
- _process_pool_workers.set(workers)
- _process_pool_idle_workers.set(idle_workers)
- get_asynclib().setup_process_pool_exit_at_shutdown(workers)
-
- async with (limiter or current_default_process_limiter()):
- # Pop processes from the pool (starting from the most recently used) until we find one that
- # hasn't exited yet
- process: Process
- while idle_workers:
- process, idle_since = idle_workers.pop()
- if process.returncode is None:
- stdin = cast(ByteSendStream, process.stdin)
- buffered = BufferedByteReceiveStream(
- cast(ByteReceiveStream, process.stdout)
- )
-
- # Prune any other workers that have been idle for WORKER_MAX_IDLE_TIME seconds or
- # longer
- now = current_time()
- killed_processes: list[Process] = []
- while idle_workers:
- if now - idle_workers[0][1] < WORKER_MAX_IDLE_TIME:
- break
-
- process, idle_since = idle_workers.popleft()
- process.kill()
- workers.remove(process)
- killed_processes.append(process)
-
- with CancelScope(shield=True):
- for process in killed_processes:
- await process.aclose()
-
- break
-
- workers.remove(process)
- else:
- command = [sys.executable, "-u", "-m", __name__]
- process = await open_process(
- command, stdin=subprocess.PIPE, stdout=subprocess.PIPE
- )
- try:
- stdin = cast(ByteSendStream, process.stdin)
- buffered = BufferedByteReceiveStream(
- cast(ByteReceiveStream, process.stdout)
- )
- with fail_after(20):
- message = await buffered.receive(6)
-
- if message != b"READY\n":
- raise BrokenWorkerProcess(
- f"Worker process returned unexpected response: {message!r}"
- )
-
- main_module_path = getattr(sys.modules["__main__"], "__file__", None)
- pickled = pickle.dumps(
- ("init", sys.path, main_module_path),
- protocol=pickle.HIGHEST_PROTOCOL,
- )
- await send_raw_command(pickled)
- except (BrokenWorkerProcess, get_cancelled_exc_class()):
- raise
- except BaseException as exc:
- process.kill()
- raise BrokenWorkerProcess(
- "Error during worker process initialization"
- ) from exc
-
- workers.add(process)
-
- with CancelScope(shield=not cancellable):
- try:
- return cast(T_Retval, await send_raw_command(request))
- finally:
- if process in workers:
- idle_workers.append((process, current_time()))
-
-
-def current_default_process_limiter() -> CapacityLimiter:
- """
- Return the capacity limiter that is used by default to limit the number of worker processes.
-
- :return: a capacity limiter object
-
- """
- try:
- return _default_process_limiter.get()
- except LookupError:
- limiter = CapacityLimiter(os.cpu_count() or 2)
- _default_process_limiter.set(limiter)
- return limiter
-
-
-def process_worker() -> None:
- # Redirect standard streams to os.devnull so that user code won't interfere with the
- # parent-worker communication
- stdin = sys.stdin
- stdout = sys.stdout
- sys.stdin = open(os.devnull)
- sys.stdout = open(os.devnull, "w")
-
- stdout.buffer.write(b"READY\n")
- while True:
- retval = exception = None
- try:
- command, *args = pickle.load(stdin.buffer)
- except EOFError:
- return
- except BaseException as exc:
- exception = exc
- else:
- if command == "run":
- func, args = args
- try:
- retval = func(*args)
- except BaseException as exc:
- exception = exc
- elif command == "init":
- main_module_path: str | None
- sys.path, main_module_path = args
- del sys.modules["__main__"]
- if main_module_path:
- # Load the parent's main module but as __mp_main__ instead of __main__
- # (like multiprocessing does) to avoid infinite recursion
- try:
- spec = spec_from_file_location("__mp_main__", main_module_path)
- if spec and spec.loader:
- main = module_from_spec(spec)
- spec.loader.exec_module(main)
- sys.modules["__main__"] = main
- except BaseException as exc:
- exception = exc
-
- try:
- if exception is not None:
- status = b"EXCEPTION"
- pickled = pickle.dumps(exception, pickle.HIGHEST_PROTOCOL)
- else:
- status = b"RETURN"
- pickled = pickle.dumps(retval, pickle.HIGHEST_PROTOCOL)
- except BaseException as exc:
- exception = exc
- status = b"EXCEPTION"
- pickled = pickle.dumps(exc, pickle.HIGHEST_PROTOCOL)
-
- stdout.buffer.write(b"%s %d\n" % (status, len(pickled)))
- stdout.buffer.write(pickled)
-
- # Respect SIGTERM
- if isinstance(exception, SystemExit):
- raise exception
-
-
-if __name__ == "__main__":
- process_worker()
diff --git a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/cffi/setuptools_ext.py b/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/cffi/setuptools_ext.py
deleted file mode 100644
index 8fe361487e469b3a87b80ddec1c5585b3801c587..0000000000000000000000000000000000000000
--- a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/cffi/setuptools_ext.py
+++ /dev/null
@@ -1,219 +0,0 @@
-import os
-import sys
-
-try:
- basestring
-except NameError:
- # Python 3.x
- basestring = str
-
-def error(msg):
- from distutils.errors import DistutilsSetupError
- raise DistutilsSetupError(msg)
-
-
-def execfile(filename, glob):
- # We use execfile() (here rewritten for Python 3) instead of
- # __import__() to load the build script. The problem with
- # a normal import is that in some packages, the intermediate
- # __init__.py files may already try to import the file that
- # we are generating.
- with open(filename) as f:
- src = f.read()
- src += '\n' # Python 2.6 compatibility
- code = compile(src, filename, 'exec')
- exec(code, glob, glob)
-
-
-def add_cffi_module(dist, mod_spec):
- from cffi.api import FFI
-
- if not isinstance(mod_spec, basestring):
- error("argument to 'cffi_modules=...' must be a str or a list of str,"
- " not %r" % (type(mod_spec).__name__,))
- mod_spec = str(mod_spec)
- try:
- build_file_name, ffi_var_name = mod_spec.split(':')
- except ValueError:
- error("%r must be of the form 'path/build.py:ffi_variable'" %
- (mod_spec,))
- if not os.path.exists(build_file_name):
- ext = ''
- rewritten = build_file_name.replace('.', '/') + '.py'
- if os.path.exists(rewritten):
- ext = ' (rewrite cffi_modules to [%r])' % (
- rewritten + ':' + ffi_var_name,)
- error("%r does not name an existing file%s" % (build_file_name, ext))
-
- mod_vars = {'__name__': '__cffi__', '__file__': build_file_name}
- execfile(build_file_name, mod_vars)
-
- try:
- ffi = mod_vars[ffi_var_name]
- except KeyError:
- error("%r: object %r not found in module" % (mod_spec,
- ffi_var_name))
- if not isinstance(ffi, FFI):
- ffi = ffi() # maybe it's a function instead of directly an ffi
- if not isinstance(ffi, FFI):
- error("%r is not an FFI instance (got %r)" % (mod_spec,
- type(ffi).__name__))
- if not hasattr(ffi, '_assigned_source'):
- error("%r: the set_source() method was not called" % (mod_spec,))
- module_name, source, source_extension, kwds = ffi._assigned_source
- if ffi._windows_unicode:
- kwds = kwds.copy()
- ffi._apply_windows_unicode(kwds)
-
- if source is None:
- _add_py_module(dist, ffi, module_name)
- else:
- _add_c_module(dist, ffi, module_name, source, source_extension, kwds)
-
-def _set_py_limited_api(Extension, kwds):
- """
- Add py_limited_api to kwds if setuptools >= 26 is in use.
- Do not alter the setting if it already exists.
- Setuptools takes care of ignoring the flag on Python 2 and PyPy.
-
- CPython itself should ignore the flag in a debugging version
- (by not listing .abi3.so in the extensions it supports), but
- it doesn't so far, creating troubles. That's why we check
- for "not hasattr(sys, 'gettotalrefcount')" (the 2.7 compatible equivalent
- of 'd' not in sys.abiflags). (http://bugs.python.org/issue28401)
-
- On Windows, with CPython <= 3.4, it's better not to use py_limited_api
- because virtualenv *still* doesn't copy PYTHON3.DLL on these versions.
- Recently (2020) we started shipping only >= 3.5 wheels, though. So
- we'll give it another try and set py_limited_api on Windows >= 3.5.
- """
- from cffi import recompiler
-
- if ('py_limited_api' not in kwds and not hasattr(sys, 'gettotalrefcount')
- and recompiler.USE_LIMITED_API):
- import setuptools
- try:
- setuptools_major_version = int(setuptools.__version__.partition('.')[0])
- if setuptools_major_version >= 26:
- kwds['py_limited_api'] = True
- except ValueError: # certain development versions of setuptools
- # If we don't know the version number of setuptools, we
- # try to set 'py_limited_api' anyway. At worst, we get a
- # warning.
- kwds['py_limited_api'] = True
- return kwds
-
-def _add_c_module(dist, ffi, module_name, source, source_extension, kwds):
- from distutils.core import Extension
- # We are a setuptools extension. Need this build_ext for py_limited_api.
- from setuptools.command.build_ext import build_ext
- from distutils.dir_util import mkpath
- from distutils import log
- from cffi import recompiler
-
- allsources = ['$PLACEHOLDER']
- allsources.extend(kwds.pop('sources', []))
- kwds = _set_py_limited_api(Extension, kwds)
- ext = Extension(name=module_name, sources=allsources, **kwds)
-
- def make_mod(tmpdir, pre_run=None):
- c_file = os.path.join(tmpdir, module_name + source_extension)
- log.info("generating cffi module %r" % c_file)
- mkpath(tmpdir)
- # a setuptools-only, API-only hook: called with the "ext" and "ffi"
- # arguments just before we turn the ffi into C code. To use it,
- # subclass the 'distutils.command.build_ext.build_ext' class and
- # add a method 'def pre_run(self, ext, ffi)'.
- if pre_run is not None:
- pre_run(ext, ffi)
- updated = recompiler.make_c_source(ffi, module_name, source, c_file)
- if not updated:
- log.info("already up-to-date")
- return c_file
-
- if dist.ext_modules is None:
- dist.ext_modules = []
- dist.ext_modules.append(ext)
-
- base_class = dist.cmdclass.get('build_ext', build_ext)
- class build_ext_make_mod(base_class):
- def run(self):
- if ext.sources[0] == '$PLACEHOLDER':
- pre_run = getattr(self, 'pre_run', None)
- ext.sources[0] = make_mod(self.build_temp, pre_run)
- base_class.run(self)
- dist.cmdclass['build_ext'] = build_ext_make_mod
- # NB. multiple runs here will create multiple 'build_ext_make_mod'
- # classes. Even in this case the 'build_ext' command should be
- # run once; but just in case, the logic above does nothing if
- # called again.
-
-
-def _add_py_module(dist, ffi, module_name):
- from distutils.dir_util import mkpath
- from setuptools.command.build_py import build_py
- from setuptools.command.build_ext import build_ext
- from distutils import log
- from cffi import recompiler
-
- def generate_mod(py_file):
- log.info("generating cffi module %r" % py_file)
- mkpath(os.path.dirname(py_file))
- updated = recompiler.make_py_source(ffi, module_name, py_file)
- if not updated:
- log.info("already up-to-date")
-
- base_class = dist.cmdclass.get('build_py', build_py)
- class build_py_make_mod(base_class):
- def run(self):
- base_class.run(self)
- module_path = module_name.split('.')
- module_path[-1] += '.py'
- generate_mod(os.path.join(self.build_lib, *module_path))
- def get_source_files(self):
- # This is called from 'setup.py sdist' only. Exclude
- # the generate .py module in this case.
- saved_py_modules = self.py_modules
- try:
- if saved_py_modules:
- self.py_modules = [m for m in saved_py_modules
- if m != module_name]
- return base_class.get_source_files(self)
- finally:
- self.py_modules = saved_py_modules
- dist.cmdclass['build_py'] = build_py_make_mod
-
- # distutils and setuptools have no notion I could find of a
- # generated python module. If we don't add module_name to
- # dist.py_modules, then things mostly work but there are some
- # combination of options (--root and --record) that will miss
- # the module. So we add it here, which gives a few apparently
- # harmless warnings about not finding the file outside the
- # build directory.
- # Then we need to hack more in get_source_files(); see above.
- if dist.py_modules is None:
- dist.py_modules = []
- dist.py_modules.append(module_name)
-
- # the following is only for "build_ext -i"
- base_class_2 = dist.cmdclass.get('build_ext', build_ext)
- class build_ext_make_mod(base_class_2):
- def run(self):
- base_class_2.run(self)
- if self.inplace:
- # from get_ext_fullpath() in distutils/command/build_ext.py
- module_path = module_name.split('.')
- package = '.'.join(module_path[:-1])
- build_py = self.get_finalized_command('build_py')
- package_dir = build_py.get_package_dir(package)
- file_name = module_path[-1] + '.py'
- generate_mod(os.path.join(package_dir, file_name))
- dist.cmdclass['build_ext'] = build_ext_make_mod
-
-def cffi_modules(dist, attr, value):
- assert attr == 'cffi_modules'
- if isinstance(value, basestring):
- value = [value]
-
- for cffi_module in value:
- add_cffi_module(dist, cffi_module)
diff --git a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/E_B_L_C_.py b/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/E_B_L_C_.py
deleted file mode 100644
index 9cc60ff82d23d9348dc956b8c4f44139226e4de6..0000000000000000000000000000000000000000
--- a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/E_B_L_C_.py
+++ /dev/null
@@ -1,717 +0,0 @@
-from fontTools.misc import sstruct
-from . import DefaultTable
-from fontTools.misc.textTools import bytesjoin, safeEval
-from .BitmapGlyphMetrics import (
- BigGlyphMetrics,
- bigGlyphMetricsFormat,
- SmallGlyphMetrics,
- smallGlyphMetricsFormat,
-)
-import struct
-import itertools
-from collections import deque
-import logging
-
-
-log = logging.getLogger(__name__)
-
-eblcHeaderFormat = """
- > # big endian
- version: 16.16F
- numSizes: I
-"""
-# The table format string is split to handle sbitLineMetrics simply.
-bitmapSizeTableFormatPart1 = """
- > # big endian
- indexSubTableArrayOffset: I
- indexTablesSize: I
- numberOfIndexSubTables: I
- colorRef: I
-"""
-# The compound type for hori and vert.
-sbitLineMetricsFormat = """
- > # big endian
- ascender: b
- descender: b
- widthMax: B
- caretSlopeNumerator: b
- caretSlopeDenominator: b
- caretOffset: b
- minOriginSB: b
- minAdvanceSB: b
- maxBeforeBL: b
- minAfterBL: b
- pad1: b
- pad2: b
-"""
-# hori and vert go between the two parts.
-bitmapSizeTableFormatPart2 = """
- > # big endian
- startGlyphIndex: H
- endGlyphIndex: H
- ppemX: B
- ppemY: B
- bitDepth: B
- flags: b
-"""
-
-indexSubTableArrayFormat = ">HHL"
-indexSubTableArraySize = struct.calcsize(indexSubTableArrayFormat)
-
-indexSubHeaderFormat = ">HHL"
-indexSubHeaderSize = struct.calcsize(indexSubHeaderFormat)
-
-codeOffsetPairFormat = ">HH"
-codeOffsetPairSize = struct.calcsize(codeOffsetPairFormat)
-
-
-class table_E_B_L_C_(DefaultTable.DefaultTable):
-
- dependencies = ["EBDT"]
-
- # This method can be overridden in subclasses to support new formats
- # without changing the other implementation. Also can be used as a
- # convenience method for coverting a font file to an alternative format.
- def getIndexFormatClass(self, indexFormat):
- return eblc_sub_table_classes[indexFormat]
-
- def decompile(self, data, ttFont):
-
- # Save the original data because offsets are from the start of the table.
- origData = data
- i = 0
-
- dummy = sstruct.unpack(eblcHeaderFormat, data[:8], self)
- i += 8
-
- self.strikes = []
- for curStrikeIndex in range(self.numSizes):
- curStrike = Strike()
- self.strikes.append(curStrike)
- curTable = curStrike.bitmapSizeTable
- dummy = sstruct.unpack2(
- bitmapSizeTableFormatPart1, data[i : i + 16], curTable
- )
- i += 16
- for metric in ("hori", "vert"):
- metricObj = SbitLineMetrics()
- vars(curTable)[metric] = metricObj
- dummy = sstruct.unpack2(
- sbitLineMetricsFormat, data[i : i + 12], metricObj
- )
- i += 12
- dummy = sstruct.unpack(
- bitmapSizeTableFormatPart2, data[i : i + 8], curTable
- )
- i += 8
-
- for curStrike in self.strikes:
- curTable = curStrike.bitmapSizeTable
- for subtableIndex in range(curTable.numberOfIndexSubTables):
- i = (
- curTable.indexSubTableArrayOffset
- + subtableIndex * indexSubTableArraySize
- )
-
- tup = struct.unpack(
- indexSubTableArrayFormat, data[i : i + indexSubTableArraySize]
- )
- (firstGlyphIndex, lastGlyphIndex, additionalOffsetToIndexSubtable) = tup
- i = curTable.indexSubTableArrayOffset + additionalOffsetToIndexSubtable
-
- tup = struct.unpack(
- indexSubHeaderFormat, data[i : i + indexSubHeaderSize]
- )
- (indexFormat, imageFormat, imageDataOffset) = tup
-
- indexFormatClass = self.getIndexFormatClass(indexFormat)
- indexSubTable = indexFormatClass(data[i + indexSubHeaderSize :], ttFont)
- indexSubTable.firstGlyphIndex = firstGlyphIndex
- indexSubTable.lastGlyphIndex = lastGlyphIndex
- indexSubTable.additionalOffsetToIndexSubtable = (
- additionalOffsetToIndexSubtable
- )
- indexSubTable.indexFormat = indexFormat
- indexSubTable.imageFormat = imageFormat
- indexSubTable.imageDataOffset = imageDataOffset
- indexSubTable.decompile() # https://github.com/fonttools/fonttools/issues/317
- curStrike.indexSubTables.append(indexSubTable)
-
- def compile(self, ttFont):
-
- dataList = []
- self.numSizes = len(self.strikes)
- dataList.append(sstruct.pack(eblcHeaderFormat, self))
-
- # Data size of the header + bitmapSizeTable needs to be calculated
- # in order to form offsets. This value will hold the size of the data
- # in dataList after all the data is consolidated in dataList.
- dataSize = len(dataList[0])
-
- # The table will be structured in the following order:
- # (0) header
- # (1) Each bitmapSizeTable [1 ... self.numSizes]
- # (2) Alternate between indexSubTableArray and indexSubTable
- # for each bitmapSizeTable present.
- #
- # The issue is maintaining the proper offsets when table information
- # gets moved around. All offsets and size information must be recalculated
- # when building the table to allow editing within ttLib and also allow easy
- # import/export to and from XML. All of this offset information is lost
- # when exporting to XML so everything must be calculated fresh so importing
- # from XML will work cleanly. Only byte offset and size information is
- # calculated fresh. Count information like numberOfIndexSubTables is
- # checked through assertions. If the information in this table was not
- # touched or was changed properly then these types of values should match.
- #
- # The table will be rebuilt the following way:
- # (0) Precompute the size of all the bitmapSizeTables. This is needed to
- # compute the offsets properly.
- # (1) For each bitmapSizeTable compute the indexSubTable and
- # indexSubTableArray pair. The indexSubTable must be computed first
- # so that the offset information in indexSubTableArray can be
- # calculated. Update the data size after each pairing.
- # (2) Build each bitmapSizeTable.
- # (3) Consolidate all the data into the main dataList in the correct order.
-
- for _ in self.strikes:
- dataSize += sstruct.calcsize(bitmapSizeTableFormatPart1)
- dataSize += len(("hori", "vert")) * sstruct.calcsize(sbitLineMetricsFormat)
- dataSize += sstruct.calcsize(bitmapSizeTableFormatPart2)
-
- indexSubTablePairDataList = []
- for curStrike in self.strikes:
- curTable = curStrike.bitmapSizeTable
- curTable.numberOfIndexSubTables = len(curStrike.indexSubTables)
- curTable.indexSubTableArrayOffset = dataSize
-
- # Precompute the size of the indexSubTableArray. This information
- # is important for correctly calculating the new value for
- # additionalOffsetToIndexSubtable.
- sizeOfSubTableArray = (
- curTable.numberOfIndexSubTables * indexSubTableArraySize
- )
- lowerBound = dataSize
- dataSize += sizeOfSubTableArray
- upperBound = dataSize
-
- indexSubTableDataList = []
- for indexSubTable in curStrike.indexSubTables:
- indexSubTable.additionalOffsetToIndexSubtable = (
- dataSize - curTable.indexSubTableArrayOffset
- )
- glyphIds = list(map(ttFont.getGlyphID, indexSubTable.names))
- indexSubTable.firstGlyphIndex = min(glyphIds)
- indexSubTable.lastGlyphIndex = max(glyphIds)
- data = indexSubTable.compile(ttFont)
- indexSubTableDataList.append(data)
- dataSize += len(data)
- curTable.startGlyphIndex = min(
- ist.firstGlyphIndex for ist in curStrike.indexSubTables
- )
- curTable.endGlyphIndex = max(
- ist.lastGlyphIndex for ist in curStrike.indexSubTables
- )
-
- for i in curStrike.indexSubTables:
- data = struct.pack(
- indexSubHeaderFormat,
- i.firstGlyphIndex,
- i.lastGlyphIndex,
- i.additionalOffsetToIndexSubtable,
- )
- indexSubTablePairDataList.append(data)
- indexSubTablePairDataList.extend(indexSubTableDataList)
- curTable.indexTablesSize = dataSize - curTable.indexSubTableArrayOffset
-
- for curStrike in self.strikes:
- curTable = curStrike.bitmapSizeTable
- data = sstruct.pack(bitmapSizeTableFormatPart1, curTable)
- dataList.append(data)
- for metric in ("hori", "vert"):
- metricObj = vars(curTable)[metric]
- data = sstruct.pack(sbitLineMetricsFormat, metricObj)
- dataList.append(data)
- data = sstruct.pack(bitmapSizeTableFormatPart2, curTable)
- dataList.append(data)
- dataList.extend(indexSubTablePairDataList)
-
- return bytesjoin(dataList)
-
- def toXML(self, writer, ttFont):
- writer.simpletag("header", [("version", self.version)])
- writer.newline()
- for curIndex, curStrike in enumerate(self.strikes):
- curStrike.toXML(curIndex, writer, ttFont)
-
- def fromXML(self, name, attrs, content, ttFont):
- if name == "header":
- self.version = safeEval(attrs["version"])
- elif name == "strike":
- if not hasattr(self, "strikes"):
- self.strikes = []
- strikeIndex = safeEval(attrs["index"])
- curStrike = Strike()
- curStrike.fromXML(name, attrs, content, ttFont, self)
-
- # Grow the strike array to the appropriate size. The XML format
- # allows for the strike index value to be out of order.
- if strikeIndex >= len(self.strikes):
- self.strikes += [None] * (strikeIndex + 1 - len(self.strikes))
- assert self.strikes[strikeIndex] is None, "Duplicate strike EBLC indices."
- self.strikes[strikeIndex] = curStrike
-
-
-class Strike(object):
- def __init__(self):
- self.bitmapSizeTable = BitmapSizeTable()
- self.indexSubTables = []
-
- def toXML(self, strikeIndex, writer, ttFont):
- writer.begintag("strike", [("index", strikeIndex)])
- writer.newline()
- self.bitmapSizeTable.toXML(writer, ttFont)
- writer.comment(
- "GlyphIds are written but not read. The firstGlyphIndex and\nlastGlyphIndex values will be recalculated by the compiler."
- )
- writer.newline()
- for indexSubTable in self.indexSubTables:
- indexSubTable.toXML(writer, ttFont)
- writer.endtag("strike")
- writer.newline()
-
- def fromXML(self, name, attrs, content, ttFont, locator):
- for element in content:
- if not isinstance(element, tuple):
- continue
- name, attrs, content = element
- if name == "bitmapSizeTable":
- self.bitmapSizeTable.fromXML(name, attrs, content, ttFont)
- elif name.startswith(_indexSubTableSubclassPrefix):
- indexFormat = safeEval(name[len(_indexSubTableSubclassPrefix) :])
- indexFormatClass = locator.getIndexFormatClass(indexFormat)
- indexSubTable = indexFormatClass(None, None)
- indexSubTable.indexFormat = indexFormat
- indexSubTable.fromXML(name, attrs, content, ttFont)
- self.indexSubTables.append(indexSubTable)
-
-
-class BitmapSizeTable(object):
-
- # Returns all the simple metric names that bitmap size table
- # cares about in terms of XML creation.
- def _getXMLMetricNames(self):
- dataNames = sstruct.getformat(bitmapSizeTableFormatPart1)[1]
- dataNames = dataNames + sstruct.getformat(bitmapSizeTableFormatPart2)[1]
- # Skip the first 3 data names because they are byte offsets and counts.
- return dataNames[3:]
-
- def toXML(self, writer, ttFont):
- writer.begintag("bitmapSizeTable")
- writer.newline()
- for metric in ("hori", "vert"):
- getattr(self, metric).toXML(metric, writer, ttFont)
- for metricName in self._getXMLMetricNames():
- writer.simpletag(metricName, value=getattr(self, metricName))
- writer.newline()
- writer.endtag("bitmapSizeTable")
- writer.newline()
-
- def fromXML(self, name, attrs, content, ttFont):
- # Create a lookup for all the simple names that make sense to
- # bitmap size table. Only read the information from these names.
- dataNames = set(self._getXMLMetricNames())
- for element in content:
- if not isinstance(element, tuple):
- continue
- name, attrs, content = element
- if name == "sbitLineMetrics":
- direction = attrs["direction"]
- assert direction in (
- "hori",
- "vert",
- ), "SbitLineMetrics direction specified invalid."
- metricObj = SbitLineMetrics()
- metricObj.fromXML(name, attrs, content, ttFont)
- vars(self)[direction] = metricObj
- elif name in dataNames:
- vars(self)[name] = safeEval(attrs["value"])
- else:
- log.warning("unknown name '%s' being ignored in BitmapSizeTable.", name)
-
-
-class SbitLineMetrics(object):
- def toXML(self, name, writer, ttFont):
- writer.begintag("sbitLineMetrics", [("direction", name)])
- writer.newline()
- for metricName in sstruct.getformat(sbitLineMetricsFormat)[1]:
- writer.simpletag(metricName, value=getattr(self, metricName))
- writer.newline()
- writer.endtag("sbitLineMetrics")
- writer.newline()
-
- def fromXML(self, name, attrs, content, ttFont):
- metricNames = set(sstruct.getformat(sbitLineMetricsFormat)[1])
- for element in content:
- if not isinstance(element, tuple):
- continue
- name, attrs, content = element
- if name in metricNames:
- vars(self)[name] = safeEval(attrs["value"])
-
-
-# Important information about the naming scheme. Used for identifying subtables.
-_indexSubTableSubclassPrefix = "eblc_index_sub_table_"
-
-
-class EblcIndexSubTable(object):
- def __init__(self, data, ttFont):
- self.data = data
- self.ttFont = ttFont
- # TODO Currently non-lazy decompiling doesn't work for this class...
- # if not ttFont.lazy:
- # self.decompile()
- # del self.data, self.ttFont
-
- def __getattr__(self, attr):
- # Allow lazy decompile.
- if attr[:2] == "__":
- raise AttributeError(attr)
- if attr == "data":
- raise AttributeError(attr)
- self.decompile()
- return getattr(self, attr)
-
- def ensureDecompiled(self, recurse=False):
- if hasattr(self, "data"):
- self.decompile()
-
- # This method just takes care of the indexSubHeader. Implementing subclasses
- # should call it to compile the indexSubHeader and then continue compiling
- # the remainder of their unique format.
- def compile(self, ttFont):
- return struct.pack(
- indexSubHeaderFormat,
- self.indexFormat,
- self.imageFormat,
- self.imageDataOffset,
- )
-
- # Creates the XML for bitmap glyphs. Each index sub table basically makes
- # the same XML except for specific metric information that is written
- # out via a method call that a subclass implements optionally.
- def toXML(self, writer, ttFont):
- writer.begintag(
- self.__class__.__name__,
- [
- ("imageFormat", self.imageFormat),
- ("firstGlyphIndex", self.firstGlyphIndex),
- ("lastGlyphIndex", self.lastGlyphIndex),
- ],
- )
- writer.newline()
- self.writeMetrics(writer, ttFont)
- # Write out the names as thats all thats needed to rebuild etc.
- # For font debugging of consecutive formats the ids are also written.
- # The ids are not read when moving from the XML format.
- glyphIds = map(ttFont.getGlyphID, self.names)
- for glyphName, glyphId in zip(self.names, glyphIds):
- writer.simpletag("glyphLoc", name=glyphName, id=glyphId)
- writer.newline()
- writer.endtag(self.__class__.__name__)
- writer.newline()
-
- def fromXML(self, name, attrs, content, ttFont):
- # Read all the attributes. Even though the glyph indices are
- # recalculated, they are still read in case there needs to
- # be an immediate export of the data.
- self.imageFormat = safeEval(attrs["imageFormat"])
- self.firstGlyphIndex = safeEval(attrs["firstGlyphIndex"])
- self.lastGlyphIndex = safeEval(attrs["lastGlyphIndex"])
-
- self.readMetrics(name, attrs, content, ttFont)
-
- self.names = []
- for element in content:
- if not isinstance(element, tuple):
- continue
- name, attrs, content = element
- if name == "glyphLoc":
- self.names.append(attrs["name"])
-
- # A helper method that writes the metrics for the index sub table. It also
- # is responsible for writing the image size for fixed size data since fixed
- # size is not recalculated on compile. Default behavior is to do nothing.
- def writeMetrics(self, writer, ttFont):
- pass
-
- # A helper method that is the inverse of writeMetrics.
- def readMetrics(self, name, attrs, content, ttFont):
- pass
-
- # This method is for fixed glyph data sizes. There are formats where
- # the glyph data is fixed but are actually composite glyphs. To handle
- # this the font spec in indexSubTable makes the data the size of the
- # fixed size by padding the component arrays. This function abstracts
- # out this padding process. Input is data unpadded. Output is data
- # padded only in fixed formats. Default behavior is to return the data.
- def padBitmapData(self, data):
- return data
-
- # Remove any of the glyph locations and names that are flagged as skipped.
- # This only occurs in formats {1,3}.
- def removeSkipGlyphs(self):
- # Determines if a name, location pair is a valid data location.
- # Skip glyphs are marked when the size is equal to zero.
- def isValidLocation(args):
- (name, (startByte, endByte)) = args
- return startByte < endByte
-
- # Remove all skip glyphs.
- dataPairs = list(filter(isValidLocation, zip(self.names, self.locations)))
- self.names, self.locations = list(map(list, zip(*dataPairs)))
-
-
-# A closure for creating a custom mixin. This is done because formats 1 and 3
-# are very similar. The only difference between them is the size per offset
-# value. Code put in here should handle both cases generally.
-def _createOffsetArrayIndexSubTableMixin(formatStringForDataType):
-
- # Prep the data size for the offset array data format.
- dataFormat = ">" + formatStringForDataType
- offsetDataSize = struct.calcsize(dataFormat)
-
- class OffsetArrayIndexSubTableMixin(object):
- def decompile(self):
-
- numGlyphs = self.lastGlyphIndex - self.firstGlyphIndex + 1
- indexingOffsets = [
- glyphIndex * offsetDataSize for glyphIndex in range(numGlyphs + 2)
- ]
- indexingLocations = zip(indexingOffsets, indexingOffsets[1:])
- offsetArray = [
- struct.unpack(dataFormat, self.data[slice(*loc)])[0]
- for loc in indexingLocations
- ]
-
- glyphIds = list(range(self.firstGlyphIndex, self.lastGlyphIndex + 1))
- modifiedOffsets = [offset + self.imageDataOffset for offset in offsetArray]
- self.locations = list(zip(modifiedOffsets, modifiedOffsets[1:]))
-
- self.names = list(map(self.ttFont.getGlyphName, glyphIds))
- self.removeSkipGlyphs()
- del self.data, self.ttFont
-
- def compile(self, ttFont):
- # First make sure that all the data lines up properly. Formats 1 and 3
- # must have all its data lined up consecutively. If not this will fail.
- for curLoc, nxtLoc in zip(self.locations, self.locations[1:]):
- assert (
- curLoc[1] == nxtLoc[0]
- ), "Data must be consecutive in indexSubTable offset formats"
-
- glyphIds = list(map(ttFont.getGlyphID, self.names))
- # Make sure that all ids are sorted strictly increasing.
- assert all(glyphIds[i] < glyphIds[i + 1] for i in range(len(glyphIds) - 1))
-
- # Run a simple algorithm to add skip glyphs to the data locations at
- # the places where an id is not present.
- idQueue = deque(glyphIds)
- locQueue = deque(self.locations)
- allGlyphIds = list(range(self.firstGlyphIndex, self.lastGlyphIndex + 1))
- allLocations = []
- for curId in allGlyphIds:
- if curId != idQueue[0]:
- allLocations.append((locQueue[0][0], locQueue[0][0]))
- else:
- idQueue.popleft()
- allLocations.append(locQueue.popleft())
-
- # Now that all the locations are collected, pack them appropriately into
- # offsets. This is the form where offset[i] is the location and
- # offset[i+1]-offset[i] is the size of the data location.
- offsets = list(allLocations[0]) + [loc[1] for loc in allLocations[1:]]
- # Image data offset must be less than or equal to the minimum of locations.
- # This offset may change the value for round tripping but is safer and
- # allows imageDataOffset to not be required to be in the XML version.
- self.imageDataOffset = min(offsets)
- offsetArray = [offset - self.imageDataOffset for offset in offsets]
-
- dataList = [EblcIndexSubTable.compile(self, ttFont)]
- dataList += [
- struct.pack(dataFormat, offsetValue) for offsetValue in offsetArray
- ]
- # Take care of any padding issues. Only occurs in format 3.
- if offsetDataSize * len(offsetArray) % 4 != 0:
- dataList.append(struct.pack(dataFormat, 0))
- return bytesjoin(dataList)
-
- return OffsetArrayIndexSubTableMixin
-
-
-# A Mixin for functionality shared between the different kinds
-# of fixed sized data handling. Both kinds have big metrics so
-# that kind of special processing is also handled in this mixin.
-class FixedSizeIndexSubTableMixin(object):
- def writeMetrics(self, writer, ttFont):
- writer.simpletag("imageSize", value=self.imageSize)
- writer.newline()
- self.metrics.toXML(writer, ttFont)
-
- def readMetrics(self, name, attrs, content, ttFont):
- for element in content:
- if not isinstance(element, tuple):
- continue
- name, attrs, content = element
- if name == "imageSize":
- self.imageSize = safeEval(attrs["value"])
- elif name == BigGlyphMetrics.__name__:
- self.metrics = BigGlyphMetrics()
- self.metrics.fromXML(name, attrs, content, ttFont)
- elif name == SmallGlyphMetrics.__name__:
- log.warning(
- "SmallGlyphMetrics being ignored in format %d.", self.indexFormat
- )
-
- def padBitmapData(self, data):
- # Make sure that the data isn't bigger than the fixed size.
- assert len(data) <= self.imageSize, (
- "Data in indexSubTable format %d must be less than the fixed size."
- % self.indexFormat
- )
- # Pad the data so that it matches the fixed size.
- pad = (self.imageSize - len(data)) * b"\0"
- return data + pad
-
-
-class eblc_index_sub_table_1(
- _createOffsetArrayIndexSubTableMixin("L"), EblcIndexSubTable
-):
- pass
-
-
-class eblc_index_sub_table_2(FixedSizeIndexSubTableMixin, EblcIndexSubTable):
- def decompile(self):
- (self.imageSize,) = struct.unpack(">L", self.data[:4])
- self.metrics = BigGlyphMetrics()
- sstruct.unpack2(bigGlyphMetricsFormat, self.data[4:], self.metrics)
- glyphIds = list(range(self.firstGlyphIndex, self.lastGlyphIndex + 1))
- offsets = [
- self.imageSize * i + self.imageDataOffset for i in range(len(glyphIds) + 1)
- ]
- self.locations = list(zip(offsets, offsets[1:]))
- self.names = list(map(self.ttFont.getGlyphName, glyphIds))
- del self.data, self.ttFont
-
- def compile(self, ttFont):
- glyphIds = list(map(ttFont.getGlyphID, self.names))
- # Make sure all the ids are consecutive. This is required by Format 2.
- assert glyphIds == list(
- range(self.firstGlyphIndex, self.lastGlyphIndex + 1)
- ), "Format 2 ids must be consecutive."
- self.imageDataOffset = min(next(iter(zip(*self.locations))))
-
- dataList = [EblcIndexSubTable.compile(self, ttFont)]
- dataList.append(struct.pack(">L", self.imageSize))
- dataList.append(sstruct.pack(bigGlyphMetricsFormat, self.metrics))
- return bytesjoin(dataList)
-
-
-class eblc_index_sub_table_3(
- _createOffsetArrayIndexSubTableMixin("H"), EblcIndexSubTable
-):
- pass
-
-
-class eblc_index_sub_table_4(EblcIndexSubTable):
- def decompile(self):
-
- (numGlyphs,) = struct.unpack(">L", self.data[:4])
- data = self.data[4:]
- indexingOffsets = [
- glyphIndex * codeOffsetPairSize for glyphIndex in range(numGlyphs + 2)
- ]
- indexingLocations = zip(indexingOffsets, indexingOffsets[1:])
- glyphArray = [
- struct.unpack(codeOffsetPairFormat, data[slice(*loc)])
- for loc in indexingLocations
- ]
- glyphIds, offsets = list(map(list, zip(*glyphArray)))
- # There are one too many glyph ids. Get rid of the last one.
- glyphIds.pop()
-
- offsets = [offset + self.imageDataOffset for offset in offsets]
- self.locations = list(zip(offsets, offsets[1:]))
- self.names = list(map(self.ttFont.getGlyphName, glyphIds))
- del self.data, self.ttFont
-
- def compile(self, ttFont):
- # First make sure that all the data lines up properly. Format 4
- # must have all its data lined up consecutively. If not this will fail.
- for curLoc, nxtLoc in zip(self.locations, self.locations[1:]):
- assert (
- curLoc[1] == nxtLoc[0]
- ), "Data must be consecutive in indexSubTable format 4"
-
- offsets = list(self.locations[0]) + [loc[1] for loc in self.locations[1:]]
- # Image data offset must be less than or equal to the minimum of locations.
- # Resetting this offset may change the value for round tripping but is safer
- # and allows imageDataOffset to not be required to be in the XML version.
- self.imageDataOffset = min(offsets)
- offsets = [offset - self.imageDataOffset for offset in offsets]
- glyphIds = list(map(ttFont.getGlyphID, self.names))
- # Create an iterator over the ids plus a padding value.
- idsPlusPad = list(itertools.chain(glyphIds, [0]))
-
- dataList = [EblcIndexSubTable.compile(self, ttFont)]
- dataList.append(struct.pack(">L", len(glyphIds)))
- tmp = [
- struct.pack(codeOffsetPairFormat, *cop) for cop in zip(idsPlusPad, offsets)
- ]
- dataList += tmp
- data = bytesjoin(dataList)
- return data
-
-
-class eblc_index_sub_table_5(FixedSizeIndexSubTableMixin, EblcIndexSubTable):
- def decompile(self):
- self.origDataLen = 0
- (self.imageSize,) = struct.unpack(">L", self.data[:4])
- data = self.data[4:]
- self.metrics, data = sstruct.unpack2(
- bigGlyphMetricsFormat, data, BigGlyphMetrics()
- )
- (numGlyphs,) = struct.unpack(">L", data[:4])
- data = data[4:]
- glyphIds = [
- struct.unpack(">H", data[2 * i : 2 * (i + 1)])[0] for i in range(numGlyphs)
- ]
-
- offsets = [
- self.imageSize * i + self.imageDataOffset for i in range(len(glyphIds) + 1)
- ]
- self.locations = list(zip(offsets, offsets[1:]))
- self.names = list(map(self.ttFont.getGlyphName, glyphIds))
- del self.data, self.ttFont
-
- def compile(self, ttFont):
- self.imageDataOffset = min(next(iter(zip(*self.locations))))
- dataList = [EblcIndexSubTable.compile(self, ttFont)]
- dataList.append(struct.pack(">L", self.imageSize))
- dataList.append(sstruct.pack(bigGlyphMetricsFormat, self.metrics))
- glyphIds = list(map(ttFont.getGlyphID, self.names))
- dataList.append(struct.pack(">L", len(glyphIds)))
- dataList += [struct.pack(">H", curId) for curId in glyphIds]
- if len(glyphIds) % 2 == 1:
- dataList.append(struct.pack(">H", 0))
- return bytesjoin(dataList)
-
-
-# Dictionary of indexFormat to the class representing that format.
-eblc_sub_table_classes = {
- 1: eblc_index_sub_table_1,
- 2: eblc_index_sub_table_2,
- 3: eblc_index_sub_table_3,
- 4: eblc_index_sub_table_4,
- 5: eblc_index_sub_table_5,
-}
diff --git a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/_f_e_a_t.py b/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/_f_e_a_t.py
deleted file mode 100644
index c9a48eff06cb14b1b2dc56c94ec7e02b80f11ca3..0000000000000000000000000000000000000000
--- a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/_f_e_a_t.py
+++ /dev/null
@@ -1,12 +0,0 @@
-from .otBase import BaseTTXConverter
-
-
-class table__f_e_a_t(BaseTTXConverter):
- """The feature name table is an AAT (Apple Advanced Typography) table for
- storing font features, settings, and their human-readable names. It should
- not be confused with the ``Feat`` table or the OpenType Layout ``GSUB``/``GPOS``
- tables. See `Feature Name Table `_
- in the TrueType Reference Manual for more information on the structure and
- purpose of this table."""
-
- pass
diff --git a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fsspec/tests/abstract/put.py b/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fsspec/tests/abstract/put.py
deleted file mode 100644
index d06f9d9b53a2b2509596708b9e9fa55d7ea3599a..0000000000000000000000000000000000000000
--- a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fsspec/tests/abstract/put.py
+++ /dev/null
@@ -1,397 +0,0 @@
-class AbstractPutTests:
- def test_put_file_to_existing_directory(
- self,
- fs,
- fs_join,
- fs_target,
- local_join,
- local_bulk_operations_scenario_0,
- ):
- # Copy scenario 1a
- source = local_bulk_operations_scenario_0
-
- target = fs_target
- fs.mkdir(target)
- if not self.supports_empty_directories():
- # Force target directory to exist by adding a dummy file
- fs.touch(fs_join(target, "dummy"))
- assert fs.isdir(target)
-
- target_file2 = fs_join(target, "file2")
- target_subfile1 = fs_join(target, "subfile1")
-
- # Copy from source directory
- fs.put(local_join(source, "file2"), target)
- assert fs.isfile(target_file2)
-
- # Copy from sub directory
- fs.put(local_join(source, "subdir", "subfile1"), target)
- assert fs.isfile(target_subfile1)
-
- # Remove copied files
- fs.rm([target_file2, target_subfile1])
- assert not fs.exists(target_file2)
- assert not fs.exists(target_subfile1)
-
- # Repeat with trailing slash on target
- fs.put(local_join(source, "file2"), target + "/")
- assert fs.isdir(target)
- assert fs.isfile(target_file2)
-
- fs.put(local_join(source, "subdir", "subfile1"), target + "/")
- assert fs.isfile(target_subfile1)
-
- def test_put_file_to_new_directory(
- self, fs, fs_join, fs_target, local_join, local_bulk_operations_scenario_0
- ):
- # Copy scenario 1b
- source = local_bulk_operations_scenario_0
-
- target = fs_target
- fs.mkdir(target)
-
- fs.put(
- local_join(source, "subdir", "subfile1"), fs_join(target, "newdir/")
- ) # Note trailing slash
- assert fs.isdir(target)
- assert fs.isdir(fs_join(target, "newdir"))
- assert fs.isfile(fs_join(target, "newdir", "subfile1"))
-
- def test_put_file_to_file_in_existing_directory(
- self, fs, fs_join, fs_target, local_join, local_bulk_operations_scenario_0
- ):
- # Copy scenario 1c
- source = local_bulk_operations_scenario_0
-
- target = fs_target
- fs.mkdir(target)
-
- fs.put(local_join(source, "subdir", "subfile1"), fs_join(target, "newfile"))
- assert fs.isfile(fs_join(target, "newfile"))
-
- def test_put_file_to_file_in_new_directory(
- self, fs, fs_join, fs_target, local_join, local_bulk_operations_scenario_0
- ):
- # Copy scenario 1d
- source = local_bulk_operations_scenario_0
-
- target = fs_target
- fs.mkdir(target)
-
- fs.put(
- local_join(source, "subdir", "subfile1"),
- fs_join(target, "newdir", "newfile"),
- )
- assert fs.isdir(fs_join(target, "newdir"))
- assert fs.isfile(fs_join(target, "newdir", "newfile"))
-
- def test_put_directory_to_existing_directory(
- self, fs, fs_join, fs_target, local_bulk_operations_scenario_0
- ):
- # Copy scenario 1e
- source = local_bulk_operations_scenario_0
-
- target = fs_target
- fs.mkdir(target)
- if not self.supports_empty_directories():
- # Force target directory to exist by adding a dummy file
- dummy = fs_join(target, "dummy")
- fs.touch(dummy)
- assert fs.isdir(target)
-
- for source_slash, target_slash in zip([False, True], [False, True]):
- s = fs_join(source, "subdir")
- if source_slash:
- s += "/"
- t = target + "/" if target_slash else target
-
- # Without recursive does nothing
- fs.put(s, t)
- assert fs.ls(target) == [] if self.supports_empty_directories() else [dummy]
-
- # With recursive
- fs.put(s, t, recursive=True)
- if source_slash:
- assert fs.isfile(fs_join(target, "subfile1"))
- assert fs.isfile(fs_join(target, "subfile2"))
- assert fs.isdir(fs_join(target, "nesteddir"))
- assert fs.isfile(fs_join(target, "nesteddir", "nestedfile"))
- assert not fs.exists(fs_join(target, "subdir"))
-
- fs.rm(fs.ls(target, detail=False), recursive=True)
- else:
- assert fs.isdir(fs_join(target, "subdir"))
- assert fs.isfile(fs_join(target, "subdir", "subfile1"))
- assert fs.isfile(fs_join(target, "subdir", "subfile2"))
- assert fs.isdir(fs_join(target, "subdir", "nesteddir"))
- assert fs.isfile(fs_join(target, "subdir", "nesteddir", "nestedfile"))
-
- fs.rm(fs_join(target, "subdir"), recursive=True)
- assert fs.ls(target) == [] if self.supports_empty_directories() else [dummy]
-
- # Limit recursive by maxdepth
- fs.put(s, t, recursive=True, maxdepth=1)
- if source_slash:
- assert fs.isfile(fs_join(target, "subfile1"))
- assert fs.isfile(fs_join(target, "subfile2"))
- assert not fs.exists(fs_join(target, "nesteddir"))
- assert not fs.exists(fs_join(target, "subdir"))
-
- fs.rm(fs.ls(target, detail=False), recursive=True)
- else:
- assert fs.isdir(fs_join(target, "subdir"))
- assert fs.isfile(fs_join(target, "subdir", "subfile1"))
- assert fs.isfile(fs_join(target, "subdir", "subfile2"))
- assert not fs.exists(fs_join(target, "subdir", "nesteddir"))
-
- fs.rm(fs_join(target, "subdir"), recursive=True)
- assert fs.ls(target) == [] if self.supports_empty_directories() else [dummy]
-
- def test_put_directory_to_new_directory(
- self, fs, fs_join, fs_target, local_bulk_operations_scenario_0
- ):
- # Copy scenario 1f
- source = local_bulk_operations_scenario_0
-
- target = fs_target
- fs.mkdir(target)
- if not self.supports_empty_directories():
- # Force target directory to exist by adding a dummy file
- dummy = fs_join(target, "dummy")
- fs.touch(dummy)
- assert fs.isdir(target)
-
- for source_slash, target_slash in zip([False, True], [False, True]):
- s = fs_join(source, "subdir")
- if source_slash:
- s += "/"
- t = fs_join(target, "newdir")
- if target_slash:
- t += "/"
-
- # Without recursive does nothing
- fs.put(s, t)
- assert fs.ls(target) == [] if self.supports_empty_directories() else [dummy]
-
- # With recursive
- fs.put(s, t, recursive=True)
- assert fs.isdir(fs_join(target, "newdir"))
- assert fs.isfile(fs_join(target, "newdir", "subfile1"))
- assert fs.isfile(fs_join(target, "newdir", "subfile2"))
- assert fs.isdir(fs_join(target, "newdir", "nesteddir"))
- assert fs.isfile(fs_join(target, "newdir", "nesteddir", "nestedfile"))
- assert not fs.exists(fs_join(target, "subdir"))
-
- fs.rm(fs_join(target, "newdir"), recursive=True)
- assert not fs.exists(fs_join(target, "newdir"))
-
- # Limit recursive by maxdepth
- fs.put(s, t, recursive=True, maxdepth=1)
- assert fs.isdir(fs_join(target, "newdir"))
- assert fs.isfile(fs_join(target, "newdir", "subfile1"))
- assert fs.isfile(fs_join(target, "newdir", "subfile2"))
- assert not fs.exists(fs_join(target, "newdir", "nesteddir"))
- assert not fs.exists(fs_join(target, "subdir"))
-
- fs.rm(fs_join(target, "newdir"), recursive=True)
- assert not fs.exists(fs_join(target, "newdir"))
-
- def test_put_glob_to_existing_directory(
- self, fs, fs_join, fs_target, local_join, local_bulk_operations_scenario_0
- ):
- # Copy scenario 1g
- source = local_bulk_operations_scenario_0
-
- target = fs_target
- fs.mkdir(target)
- if not self.supports_empty_directories():
- # Force target directory to exist by adding a dummy file
- dummy = fs_join(target, "dummy")
- fs.touch(dummy)
- assert fs.isdir(target)
-
- for target_slash in [False, True]:
- t = target + "/" if target_slash else target
-
- # Without recursive
- fs.put(local_join(source, "subdir", "*"), t)
- assert fs.isfile(fs_join(target, "subfile1"))
- assert fs.isfile(fs_join(target, "subfile2"))
- assert not fs.isdir(fs_join(target, "nesteddir"))
- assert not fs.exists(fs_join(target, "nesteddir", "nestedfile"))
- assert not fs.exists(fs_join(target, "subdir"))
-
- fs.rm(fs.ls(target, detail=False), recursive=True)
- assert fs.ls(target) == [] if self.supports_empty_directories() else [dummy]
-
- # With recursive
- fs.put(local_join(source, "subdir", "*"), t, recursive=True)
- assert fs.isfile(fs_join(target, "subfile1"))
- assert fs.isfile(fs_join(target, "subfile2"))
- assert fs.isdir(fs_join(target, "nesteddir"))
- assert fs.isfile(fs_join(target, "nesteddir", "nestedfile"))
- assert not fs.exists(fs_join(target, "subdir"))
-
- fs.rm(fs.ls(target, detail=False), recursive=True)
- assert fs.ls(target) == [] if self.supports_empty_directories() else [dummy]
-
- # Limit recursive by maxdepth
- fs.put(local_join(source, "subdir", "*"), t, recursive=True, maxdepth=1)
- assert fs.isfile(fs_join(target, "subfile1"))
- assert fs.isfile(fs_join(target, "subfile2"))
- assert not fs.exists(fs_join(target, "nesteddir"))
- assert not fs.exists(fs_join(target, "subdir"))
-
- fs.rm(fs.ls(target, detail=False), recursive=True)
- assert fs.ls(target) == [] if self.supports_empty_directories() else [dummy]
-
- def test_put_glob_to_new_directory(
- self, fs, fs_join, fs_target, local_join, local_bulk_operations_scenario_0
- ):
- # Copy scenario 1h
- source = local_bulk_operations_scenario_0
-
- target = fs_target
- fs.mkdir(target)
- if not self.supports_empty_directories():
- # Force target directory to exist by adding a dummy file
- dummy = fs_join(target, "dummy")
- fs.touch(dummy)
- assert fs.isdir(target)
-
- for target_slash in [False, True]:
- t = fs_join(target, "newdir")
- if target_slash:
- t += "/"
-
- # Without recursive
- fs.put(local_join(source, "subdir", "*"), t)
- assert fs.isdir(fs_join(target, "newdir"))
- assert fs.isfile(fs_join(target, "newdir", "subfile1"))
- assert fs.isfile(fs_join(target, "newdir", "subfile2"))
- assert not fs.exists(fs_join(target, "newdir", "nesteddir"))
- assert not fs.exists(fs_join(target, "newdir", "nesteddir", "nestedfile"))
- assert not fs.exists(fs_join(target, "subdir"))
- assert not fs.exists(fs_join(target, "newdir", "subdir"))
-
- fs.rm(fs_join(target, "newdir"), recursive=True)
- assert not fs.exists(fs_join(target, "newdir"))
-
- # With recursive
- fs.put(local_join(source, "subdir", "*"), t, recursive=True)
- assert fs.isdir(fs_join(target, "newdir"))
- assert fs.isfile(fs_join(target, "newdir", "subfile1"))
- assert fs.isfile(fs_join(target, "newdir", "subfile2"))
- assert fs.isdir(fs_join(target, "newdir", "nesteddir"))
- assert fs.isfile(fs_join(target, "newdir", "nesteddir", "nestedfile"))
- assert not fs.exists(fs_join(target, "subdir"))
- assert not fs.exists(fs_join(target, "newdir", "subdir"))
-
- fs.rm(fs_join(target, "newdir"), recursive=True)
- assert not fs.exists(fs_join(target, "newdir"))
-
- # Limit recursive by maxdepth
- fs.put(local_join(source, "subdir", "*"), t, recursive=True, maxdepth=1)
- assert fs.isdir(fs_join(target, "newdir"))
- assert fs.isfile(fs_join(target, "newdir", "subfile1"))
- assert fs.isfile(fs_join(target, "newdir", "subfile2"))
- assert not fs.exists(fs_join(target, "newdir", "nesteddir"))
- assert not fs.exists(fs_join(target, "subdir"))
- assert not fs.exists(fs_join(target, "newdir", "subdir"))
-
- fs.rm(fs_join(target, "newdir"), recursive=True)
- assert not fs.exists(fs_join(target, "newdir"))
-
- def test_put_list_of_files_to_existing_directory(
- self,
- fs,
- fs_join,
- fs_target,
- local_join,
- local_bulk_operations_scenario_0,
- fs_path,
- ):
- # Copy scenario 2a
- source = local_bulk_operations_scenario_0
-
- target = fs_target
- fs.mkdir(target)
- if not self.supports_empty_directories():
- # Force target directory to exist by adding a dummy file
- dummy = fs_join(target, "dummy")
- fs.touch(dummy)
- assert fs.isdir(target)
-
- source_files = [
- local_join(source, "file1"),
- local_join(source, "file2"),
- local_join(source, "subdir", "subfile1"),
- ]
-
- for target_slash in [False, True]:
- t = target + "/" if target_slash else target
-
- fs.put(source_files, t)
- assert fs.isfile(fs_join(target, "file1"))
- assert fs.isfile(fs_join(target, "file2"))
- assert fs.isfile(fs_join(target, "subfile1"))
-
- fs.rm(fs.find(target))
- assert fs.ls(target) == [] if self.supports_empty_directories() else [dummy]
-
- def test_put_list_of_files_to_new_directory(
- self, fs, fs_join, fs_target, local_join, local_bulk_operations_scenario_0
- ):
- # Copy scenario 2b
- source = local_bulk_operations_scenario_0
-
- target = fs_target
- fs.mkdir(target)
-
- source_files = [
- local_join(source, "file1"),
- local_join(source, "file2"),
- local_join(source, "subdir", "subfile1"),
- ]
-
- fs.put(source_files, fs_join(target, "newdir") + "/") # Note trailing slash
- assert fs.isdir(fs_join(target, "newdir"))
- assert fs.isfile(fs_join(target, "newdir", "file1"))
- assert fs.isfile(fs_join(target, "newdir", "file2"))
- assert fs.isfile(fs_join(target, "newdir", "subfile1"))
-
- def test_put_directory_recursive(
- self, fs, fs_join, fs_target, local_fs, local_join, local_path
- ):
- # https://github.com/fsspec/filesystem_spec/issues/1062
- # Recursive cp/get/put of source directory into non-existent target directory.
- src = local_join(local_path, "src")
- src_file = local_join(src, "file")
- local_fs.mkdir(src)
- local_fs.touch(src_file)
-
- target = fs_target
-
- # put without slash
- assert not fs.exists(target)
- for loop in range(2):
- fs.put(src, target, recursive=True)
- assert fs.isdir(target)
-
- if loop == 0:
- assert fs.isfile(fs_join(target, "file"))
- assert not fs.exists(fs_join(target, "src"))
- else:
- assert fs.isfile(fs_join(target, "file"))
- assert fs.isdir(fs_join(target, "src"))
- assert fs.isfile(fs_join(target, "src", "file"))
-
- fs.rm(target, recursive=True)
-
- # put with slash
- assert not fs.exists(target)
- for loop in range(2):
- fs.put(src + "/", target, recursive=True)
- assert fs.isdir(target)
- assert fs.isfile(fs_join(target, "file"))
- assert not fs.exists(fs_join(target, "src"))
diff --git a/spaces/cihyFjudo/fairness-paper-search/Jigarthanda Movie Download 720p Movies Everything You Need to Know About the Cult Classic.md b/spaces/cihyFjudo/fairness-paper-search/Jigarthanda Movie Download 720p Movies Everything You Need to Know About the Cult Classic.md
deleted file mode 100644
index 4e621e0a41e8325aca49af68f7ae6dad8f8bd2f1..0000000000000000000000000000000000000000
--- a/spaces/cihyFjudo/fairness-paper-search/Jigarthanda Movie Download 720p Movies Everything You Need to Know About the Cult Classic.md
+++ /dev/null
@@ -1,6 +0,0 @@
-
-
- aaccfb2cb3
-
-
-
diff --git a/spaces/cihyFjudo/fairness-paper-search/Oficina G3 Ddg 1080p 11 The Best Way to Enjoy the Brazilian Rock Band with Delfin Translator.md b/spaces/cihyFjudo/fairness-paper-search/Oficina G3 Ddg 1080p 11 The Best Way to Enjoy the Brazilian Rock Band with Delfin Translator.md
deleted file mode 100644
index 5524cfc86675d5cbbf0bca999c68452ab6b4ccd6..0000000000000000000000000000000000000000
--- a/spaces/cihyFjudo/fairness-paper-search/Oficina G3 Ddg 1080p 11 The Best Way to Enjoy the Brazilian Rock Band with Delfin Translator.md
+++ /dev/null
@@ -1,6 +0,0 @@
-
-
- aaccfb2cb3
-
-
-
diff --git a/spaces/cihyFjudo/fairness-paper-search/Password Manager SafeInCloud Pro v19.0.5 Cracked [Latest] The Benefits of Using This App for Your Online Security.md b/spaces/cihyFjudo/fairness-paper-search/Password Manager SafeInCloud Pro v19.0.5 Cracked [Latest] The Benefits of Using This App for Your Online Security.md
deleted file mode 100644
index 0e90d7c9a5874f4bd179daf795ec55c3314595df..0000000000000000000000000000000000000000
--- a/spaces/cihyFjudo/fairness-paper-search/Password Manager SafeInCloud Pro v19.0.5 Cracked [Latest] The Benefits of Using This App for Your Online Security.md
+++ /dev/null
@@ -1,6 +0,0 @@
-
Password Manager SafeInCloud Pro v19.0.5 Cracked [Latest]
-
- aaccfb2cb3
-
-
-
diff --git a/spaces/cinika/andite-anything-v4.0/README.md b/spaces/cinika/andite-anything-v4.0/README.md
deleted file mode 100644
index 8062b08d91d25e937e6c4dcd5779ee2d8fa6a64e..0000000000000000000000000000000000000000
--- a/spaces/cinika/andite-anything-v4.0/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Andite Anything V4.0
-emoji: 🐠
-colorFrom: indigo
-colorTo: purple
-sdk: gradio
-sdk_version: 3.23.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/clem/Image_Face_Upscale_Restoration-GFPGAN/README.md b/spaces/clem/Image_Face_Upscale_Restoration-GFPGAN/README.md
deleted file mode 100644
index fcc481fcbcc054b0f552030fc6efd94791b86910..0000000000000000000000000000000000000000
--- a/spaces/clem/Image_Face_Upscale_Restoration-GFPGAN/README.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-title: Image Face Upscale Restoration-GFPGAN
-emoji: 📈
-colorFrom: blue
-colorTo: gray
-sdk: gradio
-sdk_version: 3.1.7
-app_file: app.py
-pinned: false
-license: apache-2.0
-duplicated_from: nightfury/Image_Face_Upscale_Restoration-GFPGAN
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/cloudtheboi/Lofi4All/.pythonlibs/lib/python3.10/site-packages/PIL/ImageGrab.py b/spaces/cloudtheboi/Lofi4All/.pythonlibs/lib/python3.10/site-packages/PIL/ImageGrab.py
deleted file mode 100644
index 927033c6073a28ae67c0e33ec53ec660c741b194..0000000000000000000000000000000000000000
--- a/spaces/cloudtheboi/Lofi4All/.pythonlibs/lib/python3.10/site-packages/PIL/ImageGrab.py
+++ /dev/null
@@ -1,169 +0,0 @@
-#
-# The Python Imaging Library
-# $Id$
-#
-# screen grabber
-#
-# History:
-# 2001-04-26 fl created
-# 2001-09-17 fl use builtin driver, if present
-# 2002-11-19 fl added grabclipboard support
-#
-# Copyright (c) 2001-2002 by Secret Labs AB
-# Copyright (c) 2001-2002 by Fredrik Lundh
-#
-# See the README file for information on usage and redistribution.
-#
-
-import io
-import os
-import shutil
-import subprocess
-import sys
-import tempfile
-
-from . import Image
-
-
-def grab(bbox=None, include_layered_windows=False, all_screens=False, xdisplay=None):
- if xdisplay is None:
- if sys.platform == "darwin":
- fh, filepath = tempfile.mkstemp(".png")
- os.close(fh)
- args = ["screencapture"]
- if bbox:
- left, top, right, bottom = bbox
- args += ["-R", f"{left},{top},{right-left},{bottom-top}"]
- subprocess.call(args + ["-x", filepath])
- im = Image.open(filepath)
- im.load()
- os.unlink(filepath)
- if bbox:
- im_resized = im.resize((right - left, bottom - top))
- im.close()
- return im_resized
- return im
- elif sys.platform == "win32":
- offset, size, data = Image.core.grabscreen_win32(
- include_layered_windows, all_screens
- )
- im = Image.frombytes(
- "RGB",
- size,
- data,
- # RGB, 32-bit line padding, origin lower left corner
- "raw",
- "BGR",
- (size[0] * 3 + 3) & -4,
- -1,
- )
- if bbox:
- x0, y0 = offset
- left, top, right, bottom = bbox
- im = im.crop((left - x0, top - y0, right - x0, bottom - y0))
- return im
- try:
- if not Image.core.HAVE_XCB:
- msg = "Pillow was built without XCB support"
- raise OSError(msg)
- size, data = Image.core.grabscreen_x11(xdisplay)
- except OSError:
- if (
- xdisplay is None
- and sys.platform not in ("darwin", "win32")
- and shutil.which("gnome-screenshot")
- ):
- fh, filepath = tempfile.mkstemp(".png")
- os.close(fh)
- subprocess.call(["gnome-screenshot", "-f", filepath])
- im = Image.open(filepath)
- im.load()
- os.unlink(filepath)
- if bbox:
- im_cropped = im.crop(bbox)
- im.close()
- return im_cropped
- return im
- else:
- raise
- else:
- im = Image.frombytes("RGB", size, data, "raw", "BGRX", size[0] * 4, 1)
- if bbox:
- im = im.crop(bbox)
- return im
-
-
-def grabclipboard():
- if sys.platform == "darwin":
- fh, filepath = tempfile.mkstemp(".png")
- os.close(fh)
- commands = [
- 'set theFile to (open for access POSIX file "'
- + filepath
- + '" with write permission)',
- "try",
- " write (the clipboard as «class PNGf») to theFile",
- "end try",
- "close access theFile",
- ]
- script = ["osascript"]
- for command in commands:
- script += ["-e", command]
- subprocess.call(script)
-
- im = None
- if os.stat(filepath).st_size != 0:
- im = Image.open(filepath)
- im.load()
- os.unlink(filepath)
- return im
- elif sys.platform == "win32":
- fmt, data = Image.core.grabclipboard_win32()
- if fmt == "file": # CF_HDROP
- import struct
-
- o = struct.unpack_from("I", data)[0]
- if data[16] != 0:
- files = data[o:].decode("utf-16le").split("\0")
- else:
- files = data[o:].decode("mbcs").split("\0")
- return files[: files.index("")]
- if isinstance(data, bytes):
- data = io.BytesIO(data)
- if fmt == "png":
- from . import PngImagePlugin
-
- return PngImagePlugin.PngImageFile(data)
- elif fmt == "DIB":
- from . import BmpImagePlugin
-
- return BmpImagePlugin.DibImageFile(data)
- return None
- else:
- if shutil.which("wl-paste"):
- output = subprocess.check_output(["wl-paste", "-l"]).decode()
- mimetypes = output.splitlines()
- if "image/png" in mimetypes:
- mimetype = "image/png"
- elif mimetypes:
- mimetype = mimetypes[0]
- else:
- mimetype = None
-
- args = ["wl-paste"]
- if mimetype:
- args.extend(["-t", mimetype])
- elif shutil.which("xclip"):
- args = ["xclip", "-selection", "clipboard", "-t", "image/png", "-o"]
- else:
- msg = "wl-paste or xclip is required for ImageGrab.grabclipboard() on Linux"
- raise NotImplementedError(msg)
- p = subprocess.run(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
- err = p.stderr
- if err:
- msg = f"{args[0]} error: {err.strip().decode()}"
- raise ChildProcessError(msg)
- data = io.BytesIO(p.stdout)
- im = Image.open(data)
- im.load()
- return im
diff --git a/spaces/cloudtheboi/Lofi4All/.pythonlibs/lib/python3.10/site-packages/fontTools/ttLib/tables/T_S_I__2.py b/spaces/cloudtheboi/Lofi4All/.pythonlibs/lib/python3.10/site-packages/fontTools/ttLib/tables/T_S_I__2.py
deleted file mode 100644
index 43a17f6f1ffa82cd803a44ab61832c99259c9ea9..0000000000000000000000000000000000000000
--- a/spaces/cloudtheboi/Lofi4All/.pythonlibs/lib/python3.10/site-packages/fontTools/ttLib/tables/T_S_I__2.py
+++ /dev/null
@@ -1,15 +0,0 @@
-""" TSI{0,1,2,3,5} are private tables used by Microsoft Visual TrueType (VTT)
-tool to store its hinting source data.
-
-TSI2 is the index table containing the lengths and offsets for the glyph
-programs that are contained in the TSI3 table. It uses the same format as
-the TSI0 table.
-"""
-from fontTools import ttLib
-
-superclass = ttLib.getTableClass("TSI0")
-
-
-class table_T_S_I__2(superclass):
-
- dependencies = ["TSI3"]
diff --git a/spaces/codertoro/gpt-academic/crazy_functions/test_project/cpp/libJPG/jpge.cpp b/spaces/codertoro/gpt-academic/crazy_functions/test_project/cpp/libJPG/jpge.cpp
deleted file mode 100644
index 2e26b71ed5aad0d46478fdbcd3a880be1401f946..0000000000000000000000000000000000000000
--- a/spaces/codertoro/gpt-academic/crazy_functions/test_project/cpp/libJPG/jpge.cpp
+++ /dev/null
@@ -1,1049 +0,0 @@
-// jpge.cpp - C++ class for JPEG compression.
-// Public domain, Rich Geldreich
-// v1.01, Dec. 18, 2010 - Initial release
-// v1.02, Apr. 6, 2011 - Removed 2x2 ordered dither in H2V1 chroma subsampling method load_block_16_8_8(). (The rounding factor was 2, when it should have been 1. Either way, it wasn't helping.)
-// v1.03, Apr. 16, 2011 - Added support for optimized Huffman code tables, optimized dynamic memory allocation down to only 1 alloc.
-// Also from Alex Evans: Added RGBA support, linear memory allocator (no longer needed in v1.03).
-// v1.04, May. 19, 2012: Forgot to set m_pFile ptr to NULL in cfile_stream::close(). Thanks to Owen Kaluza for reporting this bug.
-// Code tweaks to fix VS2008 static code analysis warnings (all looked harmless).
-// Code review revealed method load_block_16_8_8() (used for the non-default H2V1 sampling mode to downsample chroma) somehow didn't get the rounding factor fix from v1.02.
-
-#include "jpge.h"
-
-#include
-#include
-#if PLATFORM_WINDOWS
-#include
-#endif
-
-#define JPGE_MAX(a,b) (((a)>(b))?(a):(b))
-#define JPGE_MIN(a,b) (((a)<(b))?(a):(b))
-
-namespace jpge {
-
-static inline void *jpge_malloc(size_t nSize) { return FMemory::Malloc(nSize); }
-static inline void jpge_free(void *p) { FMemory::Free(p);; }
-
-// Various JPEG enums and tables.
-enum { M_SOF0 = 0xC0, M_DHT = 0xC4, M_SOI = 0xD8, M_EOI = 0xD9, M_SOS = 0xDA, M_DQT = 0xDB, M_APP0 = 0xE0 };
-enum { DC_LUM_CODES = 12, AC_LUM_CODES = 256, DC_CHROMA_CODES = 12, AC_CHROMA_CODES = 256, MAX_HUFF_SYMBOLS = 257, MAX_HUFF_CODESIZE = 32 };
-
-static uint8 s_zag[64] = { 0,1,8,16,9,2,3,10,17,24,32,25,18,11,4,5,12,19,26,33,40,48,41,34,27,20,13,6,7,14,21,28,35,42,49,56,57,50,43,36,29,22,15,23,30,37,44,51,58,59,52,45,38,31,39,46,53,60,61,54,47,55,62,63 };
-static int16 s_std_lum_quant[64] = { 16,11,12,14,12,10,16,14,13,14,18,17,16,19,24,40,26,24,22,22,24,49,35,37,29,40,58,51,61,60,57,51,56,55,64,72,92,78,64,68,87,69,55,56,80,109,81,87,95,98,103,104,103,62,77,113,121,112,100,120,92,101,103,99 };
-static int16 s_std_croma_quant[64] = { 17,18,18,24,21,24,47,26,26,47,99,66,56,66,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99 };
-static uint8 s_dc_lum_bits[17] = { 0,0,1,5,1,1,1,1,1,1,0,0,0,0,0,0,0 };
-static uint8 s_dc_lum_val[DC_LUM_CODES] = { 0,1,2,3,4,5,6,7,8,9,10,11 };
-static uint8 s_ac_lum_bits[17] = { 0,0,2,1,3,3,2,4,3,5,5,4,4,0,0,1,0x7d };
-static uint8 s_ac_lum_val[AC_LUM_CODES] =
-{
- 0x01,0x02,0x03,0x00,0x04,0x11,0x05,0x12,0x21,0x31,0x41,0x06,0x13,0x51,0x61,0x07,0x22,0x71,0x14,0x32,0x81,0x91,0xa1,0x08,0x23,0x42,0xb1,0xc1,0x15,0x52,0xd1,0xf0,
- 0x24,0x33,0x62,0x72,0x82,0x09,0x0a,0x16,0x17,0x18,0x19,0x1a,0x25,0x26,0x27,0x28,0x29,0x2a,0x34,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,
- 0x4a,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x83,0x84,0x85,0x86,0x87,0x88,0x89,
- 0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,
- 0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xe1,0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,
- 0xf9,0xfa
-};
-static uint8 s_dc_chroma_bits[17] = { 0,0,3,1,1,1,1,1,1,1,1,1,0,0,0,0,0 };
-static uint8 s_dc_chroma_val[DC_CHROMA_CODES] = { 0,1,2,3,4,5,6,7,8,9,10,11 };
-static uint8 s_ac_chroma_bits[17] = { 0,0,2,1,2,4,4,3,4,7,5,4,4,0,1,2,0x77 };
-static uint8 s_ac_chroma_val[AC_CHROMA_CODES] =
-{
- 0x00,0x01,0x02,0x03,0x11,0x04,0x05,0x21,0x31,0x06,0x12,0x41,0x51,0x07,0x61,0x71,0x13,0x22,0x32,0x81,0x08,0x14,0x42,0x91,0xa1,0xb1,0xc1,0x09,0x23,0x33,0x52,0xf0,
- 0x15,0x62,0x72,0xd1,0x0a,0x16,0x24,0x34,0xe1,0x25,0xf1,0x17,0x18,0x19,0x1a,0x26,0x27,0x28,0x29,0x2a,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,
- 0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x82,0x83,0x84,0x85,0x86,0x87,
- 0x88,0x89,0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xc2,0xc3,
- 0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,
- 0xf9,0xfa
-};
-
-// Low-level helper functions.
-template inline void clear_obj(T &obj) { memset(&obj, 0, sizeof(obj)); }
-
-const int YR = 19595, YG = 38470, YB = 7471, CB_R = -11059, CB_G = -21709, CB_B = 32768, CR_R = 32768, CR_G = -27439, CR_B = -5329;
-static inline uint8 clamp(int i) { if (static_cast(i) > 255U) { if (i < 0) i = 0; else if (i > 255) i = 255; } return static_cast(i); }
-
-static void RGB_to_YCC(uint8* pDst, const uint8 *pSrc, int num_pixels)
-{
- for ( ; num_pixels; pDst += 3, pSrc += 3, num_pixels--)
- {
- const int r = pSrc[0], g = pSrc[1], b = pSrc[2];
- pDst[0] = static_cast((r * YR + g * YG + b * YB + 32768) >> 16);
- pDst[1] = clamp(128 + ((r * CB_R + g * CB_G + b * CB_B + 32768) >> 16));
- pDst[2] = clamp(128 + ((r * CR_R + g * CR_G + b * CR_B + 32768) >> 16));
- }
-}
-
-static void RGB_to_Y(uint8* pDst, const uint8 *pSrc, int num_pixels)
-{
- for ( ; num_pixels; pDst++, pSrc += 3, num_pixels--)
- pDst[0] = static_cast((pSrc[0] * YR + pSrc[1] * YG + pSrc[2] * YB + 32768) >> 16);
-}
-
-static void RGBA_to_YCC(uint8* pDst, const uint8 *pSrc, int num_pixels)
-{
- for ( ; num_pixels; pDst += 3, pSrc += 4, num_pixels--)
- {
- const int r = pSrc[0], g = pSrc[1], b = pSrc[2];
- pDst[0] = static_cast((r * YR + g * YG + b * YB + 32768) >> 16);
- pDst[1] = clamp(128 + ((r * CB_R + g * CB_G + b * CB_B + 32768) >> 16));
- pDst[2] = clamp(128 + ((r * CR_R + g * CR_G + b * CR_B + 32768) >> 16));
- }
-}
-
-static void RGBA_to_Y(uint8* pDst, const uint8 *pSrc, int num_pixels)
-{
- for ( ; num_pixels; pDst++, pSrc += 4, num_pixels--)
- pDst[0] = static_cast((pSrc[0] * YR + pSrc[1] * YG + pSrc[2] * YB + 32768) >> 16);
-}
-
-static void Y_to_YCC(uint8* pDst, const uint8* pSrc, int num_pixels)
-{
- for( ; num_pixels; pDst += 3, pSrc++, num_pixels--) { pDst[0] = pSrc[0]; pDst[1] = 128; pDst[2] = 128; }
-}
-
-// Forward DCT - DCT derived from jfdctint.
-#define CONST_BITS 13
-#define ROW_BITS 2
-#define DCT_DESCALE(x, n) (((x) + (((int32)1) << ((n) - 1))) >> (n))
-#define DCT_MUL(var, c) (static_cast(var) * static_cast(c))
-#define DCT1D(s0, s1, s2, s3, s4, s5, s6, s7) \
- int32 t0 = s0 + s7, t7 = s0 - s7, t1 = s1 + s6, t6 = s1 - s6, t2 = s2 + s5, t5 = s2 - s5, t3 = s3 + s4, t4 = s3 - s4; \
- int32 t10 = t0 + t3, t13 = t0 - t3, t11 = t1 + t2, t12 = t1 - t2; \
- int32 u1 = DCT_MUL(t12 + t13, 4433); \
- s2 = u1 + DCT_MUL(t13, 6270); \
- s6 = u1 + DCT_MUL(t12, -15137); \
- u1 = t4 + t7; \
- int32 u2 = t5 + t6, u3 = t4 + t6, u4 = t5 + t7; \
- int32 z5 = DCT_MUL(u3 + u4, 9633); \
- t4 = DCT_MUL(t4, 2446); t5 = DCT_MUL(t5, 16819); \
- t6 = DCT_MUL(t6, 25172); t7 = DCT_MUL(t7, 12299); \
- u1 = DCT_MUL(u1, -7373); u2 = DCT_MUL(u2, -20995); \
- u3 = DCT_MUL(u3, -16069); u4 = DCT_MUL(u4, -3196); \
- u3 += z5; u4 += z5; \
- s0 = t10 + t11; s1 = t7 + u1 + u4; s3 = t6 + u2 + u3; s4 = t10 - t11; s5 = t5 + u2 + u4; s7 = t4 + u1 + u3;
-
-static void DCT2D(int32 *p)
-{
- int32 c, *q = p;
- for (c = 7; c >= 0; c--, q += 8)
- {
- int32 s0 = q[0], s1 = q[1], s2 = q[2], s3 = q[3], s4 = q[4], s5 = q[5], s6 = q[6], s7 = q[7];
- DCT1D(s0, s1, s2, s3, s4, s5, s6, s7);
- q[0] = s0 << ROW_BITS; q[1] = DCT_DESCALE(s1, CONST_BITS-ROW_BITS); q[2] = DCT_DESCALE(s2, CONST_BITS-ROW_BITS); q[3] = DCT_DESCALE(s3, CONST_BITS-ROW_BITS);
- q[4] = s4 << ROW_BITS; q[5] = DCT_DESCALE(s5, CONST_BITS-ROW_BITS); q[6] = DCT_DESCALE(s6, CONST_BITS-ROW_BITS); q[7] = DCT_DESCALE(s7, CONST_BITS-ROW_BITS);
- }
- for (q = p, c = 7; c >= 0; c--, q++)
- {
- int32 s0 = q[0*8], s1 = q[1*8], s2 = q[2*8], s3 = q[3*8], s4 = q[4*8], s5 = q[5*8], s6 = q[6*8], s7 = q[7*8];
- DCT1D(s0, s1, s2, s3, s4, s5, s6, s7);
- q[0*8] = DCT_DESCALE(s0, ROW_BITS+3); q[1*8] = DCT_DESCALE(s1, CONST_BITS+ROW_BITS+3); q[2*8] = DCT_DESCALE(s2, CONST_BITS+ROW_BITS+3); q[3*8] = DCT_DESCALE(s3, CONST_BITS+ROW_BITS+3);
- q[4*8] = DCT_DESCALE(s4, ROW_BITS+3); q[5*8] = DCT_DESCALE(s5, CONST_BITS+ROW_BITS+3); q[6*8] = DCT_DESCALE(s6, CONST_BITS+ROW_BITS+3); q[7*8] = DCT_DESCALE(s7, CONST_BITS+ROW_BITS+3);
- }
-}
-
-struct sym_freq { uint m_key, m_sym_index; };
-
-// Radix sorts sym_freq[] array by 32-bit key m_key. Returns ptr to sorted values.
-static inline sym_freq* radix_sort_syms(uint num_syms, sym_freq* pSyms0, sym_freq* pSyms1)
-{
- const uint cMaxPasses = 4;
- uint32 hist[256 * cMaxPasses]; clear_obj(hist);
- for (uint i = 0; i < num_syms; i++) { uint freq = pSyms0[i].m_key; hist[freq & 0xFF]++; hist[256 + ((freq >> 8) & 0xFF)]++; hist[256*2 + ((freq >> 16) & 0xFF)]++; hist[256*3 + ((freq >> 24) & 0xFF)]++; }
- sym_freq* pCur_syms = pSyms0, *pNew_syms = pSyms1;
- uint total_passes = cMaxPasses; while ((total_passes > 1) && (num_syms == hist[(total_passes - 1) * 256])) total_passes--;
- for (uint pass_shift = 0, pass = 0; pass < total_passes; pass++, pass_shift += 8)
- {
- const uint32* pHist = &hist[pass << 8];
- uint offsets[256], cur_ofs = 0;
- for (uint i = 0; i < 256; i++) { offsets[i] = cur_ofs; cur_ofs += pHist[i]; }
- for (uint i = 0; i < num_syms; i++)
- pNew_syms[offsets[(pCur_syms[i].m_key >> pass_shift) & 0xFF]++] = pCur_syms[i];
- sym_freq* t = pCur_syms; pCur_syms = pNew_syms; pNew_syms = t;
- }
- return pCur_syms;
-}
-
-// calculate_minimum_redundancy() originally written by: Alistair Moffat, alistair@cs.mu.oz.au, Jyrki Katajainen, jyrki@diku.dk, November 1996.
-static void calculate_minimum_redundancy(sym_freq *A, int n)
-{
- int root, leaf, next, avbl, used, dpth;
- if (n==0) return; else if (n==1) { A[0].m_key = 1; return; }
- A[0].m_key += A[1].m_key; root = 0; leaf = 2;
- for (next=1; next < n-1; next++)
- {
- if (leaf>=n || A[root].m_key=n || (root=0; next--) A[next].m_key = A[A[next].m_key].m_key+1;
- avbl = 1; used = dpth = 0; root = n-2; next = n-1;
- while (avbl>0)
- {
- while (root>=0 && (int)A[root].m_key==dpth) { used++; root--; }
- while (avbl>used) { A[next--].m_key = dpth; avbl--; }
- avbl = 2*used; dpth++; used = 0;
- }
-}
-
-// Limits canonical Huffman code table's max code size to max_code_size.
-static void huffman_enforce_max_code_size(int *pNum_codes, int code_list_len, int max_code_size)
-{
- if (code_list_len <= 1) return;
-
- for (int i = max_code_size + 1; i <= MAX_HUFF_CODESIZE; i++) pNum_codes[max_code_size] += pNum_codes[i];
-
- uint32 total = 0;
- for (int i = max_code_size; i > 0; i--)
- total += (((uint32)pNum_codes[i]) << (max_code_size - i));
-
- while (total != (1UL << max_code_size))
- {
- pNum_codes[max_code_size]--;
- for (int i = max_code_size - 1; i > 0; i--)
- {
- if (pNum_codes[i]) { pNum_codes[i]--; pNum_codes[i + 1] += 2; break; }
- }
- total--;
- }
-}
-
-// Generates an optimized offman table.
-void jpeg_encoder::optimize_huffman_table(int table_num, int table_len)
-{
- sym_freq syms0[MAX_HUFF_SYMBOLS], syms1[MAX_HUFF_SYMBOLS];
- syms0[0].m_key = 1; syms0[0].m_sym_index = 0; // dummy symbol, assures that no valid code contains all 1's
- int num_used_syms = 1;
- const uint32 *pSym_count = &m_huff_count[table_num][0];
- for (int i = 0; i < table_len; i++)
- if (pSym_count[i]) { syms0[num_used_syms].m_key = pSym_count[i]; syms0[num_used_syms++].m_sym_index = i + 1; }
- sym_freq* pSyms = radix_sort_syms(num_used_syms, syms0, syms1);
- calculate_minimum_redundancy(pSyms, num_used_syms);
-
- // Count the # of symbols of each code size.
- int num_codes[1 + MAX_HUFF_CODESIZE]; clear_obj(num_codes);
- for (int i = 0; i < num_used_syms; i++)
- num_codes[pSyms[i].m_key]++;
-
- const uint JPGE_CODE_SIZE_LIMIT = 16; // the maximum possible size of a JPEG Huffman code (valid range is [9,16] - 9 vs. 8 because of the dummy symbol)
- huffman_enforce_max_code_size(num_codes, num_used_syms, JPGE_CODE_SIZE_LIMIT);
-
- // Compute m_huff_bits array, which contains the # of symbols per code size.
- clear_obj(m_huff_bits[table_num]);
- for (int i = 1; i <= (int)JPGE_CODE_SIZE_LIMIT; i++)
- m_huff_bits[table_num][i] = static_cast(num_codes[i]);
-
- // Remove the dummy symbol added above, which must be in largest bucket.
- for (int i = JPGE_CODE_SIZE_LIMIT; i >= 1; i--)
- {
- if (m_huff_bits[table_num][i]) { m_huff_bits[table_num][i]--; break; }
- }
-
- // Compute the m_huff_val array, which contains the symbol indices sorted by code size (smallest to largest).
- for (int i = num_used_syms - 1; i >= 1; i--)
- m_huff_val[table_num][num_used_syms - 1 - i] = static_cast(pSyms[i].m_sym_index - 1);
-}
-
-// JPEG marker generation.
-void jpeg_encoder::emit_byte(uint8 i)
-{
- m_all_stream_writes_succeeded = m_all_stream_writes_succeeded && m_pStream->put_obj(i);
-}
-
-void jpeg_encoder::emit_word(uint i)
-{
- emit_byte(uint8(i >> 8)); emit_byte(uint8(i & 0xFF));
-}
-
-void jpeg_encoder::emit_marker(int marker)
-{
- emit_byte(uint8(0xFF)); emit_byte(uint8(marker));
-}
-
-// Emit JFIF marker
-void jpeg_encoder::emit_jfif_app0()
-{
- emit_marker(M_APP0);
- emit_word(2 + 4 + 1 + 2 + 1 + 2 + 2 + 1 + 1);
- emit_byte(0x4A); emit_byte(0x46); emit_byte(0x49); emit_byte(0x46); /* Identifier: ASCII "JFIF" */
- emit_byte(0);
- emit_byte(1); /* Major version */
- emit_byte(1); /* Minor version */
- emit_byte(0); /* Density unit */
- emit_word(1);
- emit_word(1);
- emit_byte(0); /* No thumbnail image */
- emit_byte(0);
-}
-
-// Emit quantization tables
-void jpeg_encoder::emit_dqt()
-{
- for (int i = 0; i < ((m_num_components == 3) ? 2 : 1); i++)
- {
- emit_marker(M_DQT);
- emit_word(64 + 1 + 2);
- emit_byte(static_cast(i));
- for (int j = 0; j < 64; j++)
- emit_byte(static_cast(m_quantization_tables[i][j]));
- }
-}
-
-// Emit start of frame marker
-void jpeg_encoder::emit_sof()
-{
- emit_marker(M_SOF0); /* baseline */
- emit_word(3 * m_num_components + 2 + 5 + 1);
- emit_byte(8); /* precision */
- emit_word(m_image_y);
- emit_word(m_image_x);
- emit_byte(m_num_components);
- for (int i = 0; i < m_num_components; i++)
- {
- emit_byte(static_cast(i + 1)); /* component ID */
- emit_byte((m_comp_h_samp[i] << 4) + m_comp_v_samp[i]); /* h and v sampling */
- emit_byte(i > 0); /* quant. table num */
- }
-}
-
-// Emit Huffman table.
-void jpeg_encoder::emit_dht(uint8 *bits, uint8 *val, int index, bool ac_flag)
-{
- emit_marker(M_DHT);
-
- int length = 0;
- for (int i = 1; i <= 16; i++)
- length += bits[i];
-
- emit_word(length + 2 + 1 + 16);
- emit_byte(static_cast(index + (ac_flag << 4)));
-
- for (int i = 1; i <= 16; i++)
- emit_byte(bits[i]);
-
- for (int i = 0; i < length; i++)
- emit_byte(val[i]);
-}
-
-// Emit all Huffman tables.
-void jpeg_encoder::emit_dhts()
-{
- emit_dht(m_huff_bits[0+0], m_huff_val[0+0], 0, false);
- emit_dht(m_huff_bits[2+0], m_huff_val[2+0], 0, true);
- if (m_num_components == 3)
- {
- emit_dht(m_huff_bits[0+1], m_huff_val[0+1], 1, false);
- emit_dht(m_huff_bits[2+1], m_huff_val[2+1], 1, true);
- }
-}
-
-// emit start of scan
-void jpeg_encoder::emit_sos()
-{
- emit_marker(M_SOS);
- emit_word(2 * m_num_components + 2 + 1 + 3);
- emit_byte(m_num_components);
- for (int i = 0; i < m_num_components; i++)
- {
- emit_byte(static_cast(i + 1));
- if (i == 0)
- emit_byte((0 << 4) + 0);
- else
- emit_byte((1 << 4) + 1);
- }
- emit_byte(0); /* spectral selection */
- emit_byte(63);
- emit_byte(0);
-}
-
-// Emit all markers at beginning of image file.
-void jpeg_encoder::emit_markers()
-{
- emit_marker(M_SOI);
- emit_jfif_app0();
- emit_dqt();
- emit_sof();
- emit_dhts();
- emit_sos();
-}
-
-// Compute the actual canonical Huffman codes/code sizes given the JPEG huff bits and val arrays.
-void jpeg_encoder::compute_huffman_table(uint *codes, uint8 *code_sizes, uint8 *bits, uint8 *val)
-{
- int i, l, last_p, si;
- uint8 huff_size[257];
- uint huff_code[257];
- uint code;
-
- int p = 0;
- for (l = 1; l <= 16; l++)
- for (i = 1; i <= bits[l]; i++)
- huff_size[p++] = (char)l;
-
- huff_size[p] = 0; last_p = p; // write sentinel
-
- code = 0; si = huff_size[0]; p = 0;
-
- while (huff_size[p])
- {
- while (huff_size[p] == si)
- huff_code[p++] = code++;
- code <<= 1;
- si++;
- }
-
- memset(codes, 0, sizeof(codes[0])*256);
- memset(code_sizes, 0, sizeof(code_sizes[0])*256);
- for (p = 0; p < last_p; p++)
- {
- codes[val[p]] = huff_code[p];
- code_sizes[val[p]] = huff_size[p];
- }
-}
-
-// Quantization table generation.
-void jpeg_encoder::compute_quant_table(int32 *pDst, int16 *pSrc)
-{
- int32 q;
- if (m_params.m_quality < 50)
- q = 5000 / m_params.m_quality;
- else
- q = 200 - m_params.m_quality * 2;
- for (int i = 0; i < 64; i++)
- {
- int32 j = *pSrc++; j = (j * q + 50L) / 100L;
- *pDst++ = JPGE_MIN(JPGE_MAX(j, 1), 255);
- }
-}
-
-// Higher-level methods.
-void jpeg_encoder::first_pass_init()
-{
- m_bit_buffer = 0; m_bits_in = 0;
- memset(m_last_dc_val, 0, 3 * sizeof(m_last_dc_val[0]));
- m_mcu_y_ofs = 0;
- m_pass_num = 1;
-}
-
-bool jpeg_encoder::second_pass_init()
-{
- compute_huffman_table(&m_huff_codes[0+0][0], &m_huff_code_sizes[0+0][0], m_huff_bits[0+0], m_huff_val[0+0]);
- compute_huffman_table(&m_huff_codes[2+0][0], &m_huff_code_sizes[2+0][0], m_huff_bits[2+0], m_huff_val[2+0]);
- if (m_num_components > 1)
- {
- compute_huffman_table(&m_huff_codes[0+1][0], &m_huff_code_sizes[0+1][0], m_huff_bits[0+1], m_huff_val[0+1]);
- compute_huffman_table(&m_huff_codes[2+1][0], &m_huff_code_sizes[2+1][0], m_huff_bits[2+1], m_huff_val[2+1]);
- }
- first_pass_init();
- emit_markers();
- m_pass_num = 2;
- return true;
-}
-
-bool jpeg_encoder::jpg_open(int p_x_res, int p_y_res, int src_channels)
-{
- m_num_components = 3;
- switch (m_params.m_subsampling)
- {
- case Y_ONLY:
- {
- m_num_components = 1;
- m_comp_h_samp[0] = 1; m_comp_v_samp[0] = 1;
- m_mcu_x = 8; m_mcu_y = 8;
- break;
- }
- case H1V1:
- {
- m_comp_h_samp[0] = 1; m_comp_v_samp[0] = 1;
- m_comp_h_samp[1] = 1; m_comp_v_samp[1] = 1;
- m_comp_h_samp[2] = 1; m_comp_v_samp[2] = 1;
- m_mcu_x = 8; m_mcu_y = 8;
- break;
- }
- case H2V1:
- {
- m_comp_h_samp[0] = 2; m_comp_v_samp[0] = 1;
- m_comp_h_samp[1] = 1; m_comp_v_samp[1] = 1;
- m_comp_h_samp[2] = 1; m_comp_v_samp[2] = 1;
- m_mcu_x = 16; m_mcu_y = 8;
- break;
- }
- case H2V2:
- {
- m_comp_h_samp[0] = 2; m_comp_v_samp[0] = 2;
- m_comp_h_samp[1] = 1; m_comp_v_samp[1] = 1;
- m_comp_h_samp[2] = 1; m_comp_v_samp[2] = 1;
- m_mcu_x = 16; m_mcu_y = 16;
- }
- }
-
- m_image_x = p_x_res; m_image_y = p_y_res;
- m_image_bpp = src_channels;
- m_image_bpl = m_image_x * src_channels;
- m_image_x_mcu = (m_image_x + m_mcu_x - 1) & (~(m_mcu_x - 1));
- m_image_y_mcu = (m_image_y + m_mcu_y - 1) & (~(m_mcu_y - 1));
- m_image_bpl_xlt = m_image_x * m_num_components;
- m_image_bpl_mcu = m_image_x_mcu * m_num_components;
- m_mcus_per_row = m_image_x_mcu / m_mcu_x;
-
- if ((m_mcu_lines[0] = static_cast(jpge_malloc(m_image_bpl_mcu * m_mcu_y))) == NULL) return false;
- for (int i = 1; i < m_mcu_y; i++)
- m_mcu_lines[i] = m_mcu_lines[i-1] + m_image_bpl_mcu;
-
- compute_quant_table(m_quantization_tables[0], s_std_lum_quant);
- compute_quant_table(m_quantization_tables[1], m_params.m_no_chroma_discrim_flag ? s_std_lum_quant : s_std_croma_quant);
-
- m_out_buf_left = JPGE_OUT_BUF_SIZE;
- m_pOut_buf = m_out_buf;
-
- if (m_params.m_two_pass_flag)
- {
- clear_obj(m_huff_count);
- first_pass_init();
- }
- else
- {
- memcpy(m_huff_bits[0+0], s_dc_lum_bits, 17); memcpy(m_huff_val [0+0], s_dc_lum_val, DC_LUM_CODES);
- memcpy(m_huff_bits[2+0], s_ac_lum_bits, 17); memcpy(m_huff_val [2+0], s_ac_lum_val, AC_LUM_CODES);
- memcpy(m_huff_bits[0+1], s_dc_chroma_bits, 17); memcpy(m_huff_val [0+1], s_dc_chroma_val, DC_CHROMA_CODES);
- memcpy(m_huff_bits[2+1], s_ac_chroma_bits, 17); memcpy(m_huff_val [2+1], s_ac_chroma_val, AC_CHROMA_CODES);
- if (!second_pass_init()) return false; // in effect, skip over the first pass
- }
- return m_all_stream_writes_succeeded;
-}
-
-void jpeg_encoder::load_block_8_8_grey(int x)
-{
- uint8 *pSrc;
- sample_array_t *pDst = m_sample_array;
- x <<= 3;
- for (int i = 0; i < 8; i++, pDst += 8)
- {
- pSrc = m_mcu_lines[i] + x;
- pDst[0] = pSrc[0] - 128; pDst[1] = pSrc[1] - 128; pDst[2] = pSrc[2] - 128; pDst[3] = pSrc[3] - 128;
- pDst[4] = pSrc[4] - 128; pDst[5] = pSrc[5] - 128; pDst[6] = pSrc[6] - 128; pDst[7] = pSrc[7] - 128;
- }
-}
-
-void jpeg_encoder::load_block_8_8(int x, int y, int c)
-{
- uint8 *pSrc;
- sample_array_t *pDst = m_sample_array;
- x = (x * (8 * 3)) + c;
- y <<= 3;
- for (int i = 0; i < 8; i++, pDst += 8)
- {
- pSrc = m_mcu_lines[y + i] + x;
- pDst[0] = pSrc[0 * 3] - 128; pDst[1] = pSrc[1 * 3] - 128; pDst[2] = pSrc[2 * 3] - 128; pDst[3] = pSrc[3 * 3] - 128;
- pDst[4] = pSrc[4 * 3] - 128; pDst[5] = pSrc[5 * 3] - 128; pDst[6] = pSrc[6 * 3] - 128; pDst[7] = pSrc[7 * 3] - 128;
- }
-}
-
-void jpeg_encoder::load_block_16_8(int x, int c)
-{
- uint8 *pSrc1, *pSrc2;
- sample_array_t *pDst = m_sample_array;
- x = (x * (16 * 3)) + c;
- int a = 0, b = 2;
- for (int i = 0; i < 16; i += 2, pDst += 8)
- {
- pSrc1 = m_mcu_lines[i + 0] + x;
- pSrc2 = m_mcu_lines[i + 1] + x;
- pDst[0] = ((pSrc1[ 0 * 3] + pSrc1[ 1 * 3] + pSrc2[ 0 * 3] + pSrc2[ 1 * 3] + a) >> 2) - 128; pDst[1] = ((pSrc1[ 2 * 3] + pSrc1[ 3 * 3] + pSrc2[ 2 * 3] + pSrc2[ 3 * 3] + b) >> 2) - 128;
- pDst[2] = ((pSrc1[ 4 * 3] + pSrc1[ 5 * 3] + pSrc2[ 4 * 3] + pSrc2[ 5 * 3] + a) >> 2) - 128; pDst[3] = ((pSrc1[ 6 * 3] + pSrc1[ 7 * 3] + pSrc2[ 6 * 3] + pSrc2[ 7 * 3] + b) >> 2) - 128;
- pDst[4] = ((pSrc1[ 8 * 3] + pSrc1[ 9 * 3] + pSrc2[ 8 * 3] + pSrc2[ 9 * 3] + a) >> 2) - 128; pDst[5] = ((pSrc1[10 * 3] + pSrc1[11 * 3] + pSrc2[10 * 3] + pSrc2[11 * 3] + b) >> 2) - 128;
- pDst[6] = ((pSrc1[12 * 3] + pSrc1[13 * 3] + pSrc2[12 * 3] + pSrc2[13 * 3] + a) >> 2) - 128; pDst[7] = ((pSrc1[14 * 3] + pSrc1[15 * 3] + pSrc2[14 * 3] + pSrc2[15 * 3] + b) >> 2) - 128;
- int temp = a; a = b; b = temp;
- }
-}
-
-void jpeg_encoder::load_block_16_8_8(int x, int c)
-{
- uint8 *pSrc1;
- sample_array_t *pDst = m_sample_array;
- x = (x * (16 * 3)) + c;
- for (int i = 0; i < 8; i++, pDst += 8)
- {
- pSrc1 = m_mcu_lines[i + 0] + x;
- pDst[0] = ((pSrc1[ 0 * 3] + pSrc1[ 1 * 3]) >> 1) - 128; pDst[1] = ((pSrc1[ 2 * 3] + pSrc1[ 3 * 3]) >> 1) - 128;
- pDst[2] = ((pSrc1[ 4 * 3] + pSrc1[ 5 * 3]) >> 1) - 128; pDst[3] = ((pSrc1[ 6 * 3] + pSrc1[ 7 * 3]) >> 1) - 128;
- pDst[4] = ((pSrc1[ 8 * 3] + pSrc1[ 9 * 3]) >> 1) - 128; pDst[5] = ((pSrc1[10 * 3] + pSrc1[11 * 3]) >> 1) - 128;
- pDst[6] = ((pSrc1[12 * 3] + pSrc1[13 * 3]) >> 1) - 128; pDst[7] = ((pSrc1[14 * 3] + pSrc1[15 * 3]) >> 1) - 128;
- }
-}
-
-void jpeg_encoder::load_quantized_coefficients(int component_num)
-{
- int32 *q = m_quantization_tables[component_num > 0];
- int16 *pDst = m_coefficient_array;
- for (int i = 0; i < 64; i++)
- {
- sample_array_t j = m_sample_array[s_zag[i]];
- if (j < 0)
- {
- if ((j = -j + (*q >> 1)) < *q)
- *pDst++ = 0;
- else
- *pDst++ = static_cast(-(j / *q));
- }
- else
- {
- if ((j = j + (*q >> 1)) < *q)
- *pDst++ = 0;
- else
- *pDst++ = static_cast((j / *q));
- }
- q++;
- }
-}
-
-void jpeg_encoder::flush_output_buffer()
-{
- if (m_out_buf_left != JPGE_OUT_BUF_SIZE)
- m_all_stream_writes_succeeded = m_all_stream_writes_succeeded && m_pStream->put_buf(m_out_buf, JPGE_OUT_BUF_SIZE - m_out_buf_left);
- m_pOut_buf = m_out_buf;
- m_out_buf_left = JPGE_OUT_BUF_SIZE;
-}
-
-void jpeg_encoder::put_bits(uint bits, uint len)
-{
- m_bit_buffer |= ((uint32)bits << (24 - (m_bits_in += len)));
- while (m_bits_in >= 8)
- {
- uint8 c;
- #define JPGE_PUT_BYTE(c) { *m_pOut_buf++ = (c); if (--m_out_buf_left == 0) flush_output_buffer(); }
- JPGE_PUT_BYTE(c = (uint8)((m_bit_buffer >> 16) & 0xFF));
- if (c == 0xFF) JPGE_PUT_BYTE(0);
- m_bit_buffer <<= 8;
- m_bits_in -= 8;
- }
-}
-
-void jpeg_encoder::code_coefficients_pass_one(int component_num)
-{
- if (component_num >= 3) return; // just to shut up static analysis
- int i, run_len, nbits, temp1;
- int16 *src = m_coefficient_array;
- uint32 *dc_count = component_num ? m_huff_count[0 + 1] : m_huff_count[0 + 0], *ac_count = component_num ? m_huff_count[2 + 1] : m_huff_count[2 + 0];
-
- temp1 = src[0] - m_last_dc_val[component_num];
- m_last_dc_val[component_num] = src[0];
- if (temp1 < 0) temp1 = -temp1;
-
- nbits = 0;
- while (temp1)
- {
- nbits++; temp1 >>= 1;
- }
-
- dc_count[nbits]++;
- for (run_len = 0, i = 1; i < 64; i++)
- {
- if ((temp1 = m_coefficient_array[i]) == 0)
- run_len++;
- else
- {
- while (run_len >= 16)
- {
- ac_count[0xF0]++;
- run_len -= 16;
- }
- if (temp1 < 0) temp1 = -temp1;
- nbits = 1;
- while (temp1 >>= 1) nbits++;
- ac_count[(run_len << 4) + nbits]++;
- run_len = 0;
- }
- }
- if (run_len) ac_count[0]++;
-}
-
-void jpeg_encoder::code_coefficients_pass_two(int component_num)
-{
- int i, j, run_len, nbits, temp1, temp2;
- int16 *pSrc = m_coefficient_array;
- uint *codes[2];
- uint8 *code_sizes[2];
-
- if (component_num == 0)
- {
- codes[0] = m_huff_codes[0 + 0]; codes[1] = m_huff_codes[2 + 0];
- code_sizes[0] = m_huff_code_sizes[0 + 0]; code_sizes[1] = m_huff_code_sizes[2 + 0];
- }
- else
- {
- codes[0] = m_huff_codes[0 + 1]; codes[1] = m_huff_codes[2 + 1];
- code_sizes[0] = m_huff_code_sizes[0 + 1]; code_sizes[1] = m_huff_code_sizes[2 + 1];
- }
-
- temp1 = temp2 = pSrc[0] - m_last_dc_val[component_num];
- m_last_dc_val[component_num] = pSrc[0];
-
- if (temp1 < 0)
- {
- temp1 = -temp1; temp2--;
- }
-
- nbits = 0;
- while (temp1)
- {
- nbits++; temp1 >>= 1;
- }
-
- put_bits(codes[0][nbits], code_sizes[0][nbits]);
- if (nbits) put_bits(temp2 & ((1 << nbits) - 1), nbits);
-
- for (run_len = 0, i = 1; i < 64; i++)
- {
- if ((temp1 = m_coefficient_array[i]) == 0)
- run_len++;
- else
- {
- while (run_len >= 16)
- {
- put_bits(codes[1][0xF0], code_sizes[1][0xF0]);
- run_len -= 16;
- }
- if ((temp2 = temp1) < 0)
- {
- temp1 = -temp1;
- temp2--;
- }
- nbits = 1;
- while (temp1 >>= 1)
- nbits++;
- j = (run_len << 4) + nbits;
- put_bits(codes[1][j], code_sizes[1][j]);
- put_bits(temp2 & ((1 << nbits) - 1), nbits);
- run_len = 0;
- }
- }
- if (run_len)
- put_bits(codes[1][0], code_sizes[1][0]);
-}
-
-void jpeg_encoder::code_block(int component_num)
-{
- DCT2D(m_sample_array);
- load_quantized_coefficients(component_num);
- if (m_pass_num == 1)
- code_coefficients_pass_one(component_num);
- else
- code_coefficients_pass_two(component_num);
-}
-
-void jpeg_encoder::process_mcu_row()
-{
- if (m_num_components == 1)
- {
- for (int i = 0; i < m_mcus_per_row; i++)
- {
- load_block_8_8_grey(i); code_block(0);
- }
- }
- else if ((m_comp_h_samp[0] == 1) && (m_comp_v_samp[0] == 1))
- {
- for (int i = 0; i < m_mcus_per_row; i++)
- {
- load_block_8_8(i, 0, 0); code_block(0); load_block_8_8(i, 0, 1); code_block(1); load_block_8_8(i, 0, 2); code_block(2);
- }
- }
- else if ((m_comp_h_samp[0] == 2) && (m_comp_v_samp[0] == 1))
- {
- for (int i = 0; i < m_mcus_per_row; i++)
- {
- load_block_8_8(i * 2 + 0, 0, 0); code_block(0); load_block_8_8(i * 2 + 1, 0, 0); code_block(0);
- load_block_16_8_8(i, 1); code_block(1); load_block_16_8_8(i, 2); code_block(2);
- }
- }
- else if ((m_comp_h_samp[0] == 2) && (m_comp_v_samp[0] == 2))
- {
- for (int i = 0; i < m_mcus_per_row; i++)
- {
- load_block_8_8(i * 2 + 0, 0, 0); code_block(0); load_block_8_8(i * 2 + 1, 0, 0); code_block(0);
- load_block_8_8(i * 2 + 0, 1, 0); code_block(0); load_block_8_8(i * 2 + 1, 1, 0); code_block(0);
- load_block_16_8(i, 1); code_block(1); load_block_16_8(i, 2); code_block(2);
- }
- }
-}
-
-bool jpeg_encoder::terminate_pass_one()
-{
- optimize_huffman_table(0+0, DC_LUM_CODES); optimize_huffman_table(2+0, AC_LUM_CODES);
- if (m_num_components > 1)
- {
- optimize_huffman_table(0+1, DC_CHROMA_CODES); optimize_huffman_table(2+1, AC_CHROMA_CODES);
- }
- return second_pass_init();
-}
-
-bool jpeg_encoder::terminate_pass_two()
-{
- put_bits(0x7F, 7);
- flush_output_buffer();
- emit_marker(M_EOI);
- m_pass_num++; // purposely bump up m_pass_num, for debugging
- return true;
-}
-
-bool jpeg_encoder::process_end_of_image()
-{
- if (m_mcu_y_ofs)
- {
- if (m_mcu_y_ofs < 16) // check here just to shut up static analysis
- {
- for (int i = m_mcu_y_ofs; i < m_mcu_y; i++)
- memcpy(m_mcu_lines[i], m_mcu_lines[m_mcu_y_ofs - 1], m_image_bpl_mcu);
- }
-
- process_mcu_row();
- }
-
- if (m_pass_num == 1)
- return terminate_pass_one();
- else
- return terminate_pass_two();
-}
-
-void jpeg_encoder::load_mcu(const void *pSrc)
-{
- const uint8* Psrc = reinterpret_cast(pSrc);
-
- uint8* pDst = m_mcu_lines[m_mcu_y_ofs]; // OK to write up to m_image_bpl_xlt bytes to pDst
-
- if (m_num_components == 1)
- {
- if (m_image_bpp == 4)
- RGBA_to_Y(pDst, Psrc, m_image_x);
- else if (m_image_bpp == 3)
- RGB_to_Y(pDst, Psrc, m_image_x);
- else
- memcpy(pDst, Psrc, m_image_x);
- }
- else
- {
- if (m_image_bpp == 4)
- RGBA_to_YCC(pDst, Psrc, m_image_x);
- else if (m_image_bpp == 3)
- RGB_to_YCC(pDst, Psrc, m_image_x);
- else
- Y_to_YCC(pDst, Psrc, m_image_x);
- }
-
- // Possibly duplicate pixels at end of scanline if not a multiple of 8 or 16
- if (m_num_components == 1)
- memset(m_mcu_lines[m_mcu_y_ofs] + m_image_bpl_xlt, pDst[m_image_bpl_xlt - 1], m_image_x_mcu - m_image_x);
- else
- {
- const uint8 y = pDst[m_image_bpl_xlt - 3 + 0], cb = pDst[m_image_bpl_xlt - 3 + 1], cr = pDst[m_image_bpl_xlt - 3 + 2];
- uint8 *q = m_mcu_lines[m_mcu_y_ofs] + m_image_bpl_xlt;
- for (int i = m_image_x; i < m_image_x_mcu; i++)
- {
- *q++ = y; *q++ = cb; *q++ = cr;
- }
- }
-
- if (++m_mcu_y_ofs == m_mcu_y)
- {
- process_mcu_row();
- m_mcu_y_ofs = 0;
- }
-}
-
-void jpeg_encoder::clear()
-{
- m_mcu_lines[0] = NULL;
- m_pass_num = 0;
- m_all_stream_writes_succeeded = true;
-}
-
-jpeg_encoder::jpeg_encoder()
-{
- clear();
-}
-
-jpeg_encoder::~jpeg_encoder()
-{
- deinit();
-}
-
-bool jpeg_encoder::init(output_stream *pStream, int64_t width, int64_t height, int64_t src_channels, const params &comp_params)
-{
- deinit();
- if (((!pStream) || (width < 1) || (height < 1)) || ((src_channels != 1) && (src_channels != 3) && (src_channels != 4)) || (!comp_params.check_valid())) return false;
- m_pStream = pStream;
- m_params = comp_params;
- return jpg_open(width, height, src_channels);
-}
-
-void jpeg_encoder::deinit()
-{
- jpge_free(m_mcu_lines[0]);
- clear();
-}
-
-bool jpeg_encoder::process_scanline(const void* pScanline)
-{
- if ((m_pass_num < 1) || (m_pass_num > 2)) return false;
- if (m_all_stream_writes_succeeded)
- {
- if (!pScanline)
- {
- if (!process_end_of_image()) return false;
- }
- else
- {
- load_mcu(pScanline);
- }
- }
- return m_all_stream_writes_succeeded;
-}
-
-// Higher level wrappers/examples (optional).
-#include
-
-class cfile_stream : public output_stream
-{
- cfile_stream(const cfile_stream &);
- cfile_stream &operator= (const cfile_stream &);
-
- FILE* m_pFile;
- bool m_bStatus;
-
-public:
- cfile_stream() : m_pFile(NULL), m_bStatus(false) { }
-
- virtual ~cfile_stream()
- {
- close();
- }
-
- bool open(const char *pFilename)
- {
- close();
-#if defined(_MSC_VER)
- if (fopen_s(&m_pFile, pFilename, "wb") != 0)
- {
- return false;
- }
-#else
- m_pFile = fopen(pFilename, "wb");
-#endif
- m_bStatus = (m_pFile != NULL);
- return m_bStatus;
- }
-
- bool close()
- {
- if (m_pFile)
- {
- if (fclose(m_pFile) == EOF)
- {
- m_bStatus = false;
- }
- m_pFile = NULL;
- }
- return m_bStatus;
- }
-
- virtual bool put_buf(const void* pBuf, int64_t len)
- {
- m_bStatus = m_bStatus && (fwrite(pBuf, len, 1, m_pFile) == 1);
- return m_bStatus;
- }
-
- uint get_size() const
- {
- return m_pFile ? ftell(m_pFile) : 0;
- }
-};
-
-// Writes JPEG image to file.
-bool compress_image_to_jpeg_file(const char *pFilename, int64_t width, int64_t height, int64_t num_channels, const uint8 *pImage_data, const params &comp_params)
-{
- cfile_stream dst_stream;
- if (!dst_stream.open(pFilename))
- return false;
-
- jpge::jpeg_encoder dst_image;
- if (!dst_image.init(&dst_stream, width, height, num_channels, comp_params))
- return false;
-
- for (uint pass_index = 0; pass_index < dst_image.get_total_passes(); pass_index++)
- {
- for (int64_t i = 0; i < height; i++)
- {
- // i, width, and num_channels are all 64bit
- const uint8* pBuf = pImage_data + i * width * num_channels;
- if (!dst_image.process_scanline(pBuf))
- return false;
- }
- if (!dst_image.process_scanline(NULL))
- return false;
- }
-
- dst_image.deinit();
-
- return dst_stream.close();
-}
-
-class memory_stream : public output_stream
-{
- memory_stream(const memory_stream &);
- memory_stream &operator= (const memory_stream &);
-
- uint8 *m_pBuf;
- uint64_t m_buf_size, m_buf_ofs;
-
-public:
- memory_stream(void *pBuf, uint64_t buf_size) : m_pBuf(static_cast(pBuf)), m_buf_size(buf_size), m_buf_ofs(0) { }
-
- virtual ~memory_stream() { }
-
- virtual bool put_buf(const void* pBuf, int64_t len)
- {
- uint64_t buf_remaining = m_buf_size - m_buf_ofs;
- if ((uint64_t)len > buf_remaining)
- return false;
- memcpy(m_pBuf + m_buf_ofs, pBuf, len);
- m_buf_ofs += len;
- return true;
- }
-
- uint64_t get_size() const
- {
- return m_buf_ofs;
- }
-};
-
-bool compress_image_to_jpeg_file_in_memory(void *pDstBuf, int64_t &buf_size, int64_t width, int64_t height, int64_t num_channels, const uint8 *pImage_data, const params &comp_params)
-{
- if ((!pDstBuf) || (!buf_size))
- return false;
-
- memory_stream dst_stream(pDstBuf, buf_size);
-
- buf_size = 0;
-
- jpge::jpeg_encoder dst_image;
- if (!dst_image.init(&dst_stream, width, height, num_channels, comp_params))
- return false;
-
- for (uint pass_index = 0; pass_index < dst_image.get_total_passes(); pass_index++)
- {
- for (int64_t i = 0; i < height; i++)
- {
- const uint8* pScanline = pImage_data + i * width * num_channels;
- if (!dst_image.process_scanline(pScanline))
- return false;
- }
- if (!dst_image.process_scanline(NULL))
- return false;
- }
-
- dst_image.deinit();
-
- buf_size = dst_stream.get_size();
- return true;
-}
-
-} // namespace jpge
\ No newline at end of file
diff --git a/spaces/colakin/video-generater/public/ffmpeg/libavcodec/cllc.c b/spaces/colakin/video-generater/public/ffmpeg/libavcodec/cllc.c
deleted file mode 100644
index 911717b68dbed1541168b5fd422546c08403dc0a..0000000000000000000000000000000000000000
--- a/spaces/colakin/video-generater/public/ffmpeg/libavcodec/cllc.c
+++ /dev/null
@@ -1,504 +0,0 @@
-/*
- * Canopus Lossless Codec decoder
- *
- * Copyright (c) 2012-2013 Derek Buitenhuis
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#include
-
-#include "libavutil/intreadwrite.h"
-#include "bswapdsp.h"
-#include "canopus.h"
-#include "get_bits.h"
-#include "avcodec.h"
-#include "codec_internal.h"
-#include "thread.h"
-
-#define VLC_BITS 7
-#define VLC_DEPTH 2
-
-
-typedef struct CLLCContext {
- AVCodecContext *avctx;
- BswapDSPContext bdsp;
-
- uint8_t *swapped_buf;
- int swapped_buf_size;
-} CLLCContext;
-
-static int read_code_table(CLLCContext *ctx, GetBitContext *gb, VLC *vlc)
-{
- uint8_t symbols[256];
- uint8_t bits[256];
- int num_lens, num_codes, num_codes_sum;
- int i, j, count;
-
- count = 0;
- num_codes_sum = 0;
-
- num_lens = get_bits(gb, 5);
-
- if (num_lens > VLC_BITS * VLC_DEPTH) {
- av_log(ctx->avctx, AV_LOG_ERROR, "To long VLCs %d\n", num_lens);
- return AVERROR_INVALIDDATA;
- }
-
- for (i = 0; i < num_lens; i++) {
- num_codes = get_bits(gb, 9);
- num_codes_sum += num_codes;
-
- if (num_codes_sum > 256) {
- av_log(ctx->avctx, AV_LOG_ERROR,
- "Too many VLCs (%d) to be read.\n", num_codes_sum);
- return AVERROR_INVALIDDATA;
- }
-
- for (j = 0; j < num_codes; j++) {
- symbols[count] = get_bits(gb, 8);
- bits[count] = i + 1;
-
- count++;
- }
- }
-
- return ff_init_vlc_from_lengths(vlc, VLC_BITS, count, bits, 1,
- symbols, 1, 1, 0, 0, ctx->avctx);
-}
-
-/*
- * Unlike the RGB24 read/restore, which reads in a component at a time,
- * ARGB read/restore reads in ARGB quads.
- */
-static int read_argb_line(CLLCContext *ctx, GetBitContext *gb, int *top_left,
- VLC *vlc, uint8_t *outbuf)
-{
- uint8_t *dst;
- int pred[4];
- int code;
- int i;
-
- OPEN_READER(bits, gb);
-
- dst = outbuf;
- pred[0] = top_left[0];
- pred[1] = top_left[1];
- pred[2] = top_left[2];
- pred[3] = top_left[3];
-
- for (i = 0; i < ctx->avctx->width; i++) {
- /* Always get the alpha component */
- UPDATE_CACHE(bits, gb);
- GET_VLC(code, bits, gb, vlc[0].table, VLC_BITS, VLC_DEPTH);
-
- pred[0] += code;
- dst[0] = pred[0];
-
- /* Skip the components if they are entirely transparent */
- if (dst[0]) {
- /* Red */
- UPDATE_CACHE(bits, gb);
- GET_VLC(code, bits, gb, vlc[1].table, VLC_BITS, VLC_DEPTH);
-
- pred[1] += code;
- dst[1] = pred[1];
-
- /* Green */
- UPDATE_CACHE(bits, gb);
- GET_VLC(code, bits, gb, vlc[2].table, VLC_BITS, VLC_DEPTH);
-
- pred[2] += code;
- dst[2] = pred[2];
-
- /* Blue */
- UPDATE_CACHE(bits, gb);
- GET_VLC(code, bits, gb, vlc[3].table, VLC_BITS, VLC_DEPTH);
-
- pred[3] += code;
- dst[3] = pred[3];
- } else {
- dst[1] = 0;
- dst[2] = 0;
- dst[3] = 0;
- }
-
- dst += 4;
- }
-
- CLOSE_READER(bits, gb);
-
- top_left[0] = outbuf[0];
-
- /* Only stash components if they are not transparent */
- if (top_left[0]) {
- top_left[1] = outbuf[1];
- top_left[2] = outbuf[2];
- top_left[3] = outbuf[3];
- }
-
- return 0;
-}
-
-static int read_rgb24_component_line(CLLCContext *ctx, GetBitContext *gb,
- int *top_left, VLC *vlc, uint8_t *outbuf)
-{
- uint8_t *dst;
- int pred, code;
- int i;
-
- OPEN_READER(bits, gb);
-
- dst = outbuf;
- pred = *top_left;
-
- /* Simultaneously read and restore the line */
- for (i = 0; i < ctx->avctx->width; i++) {
- UPDATE_CACHE(bits, gb);
- GET_VLC(code, bits, gb, vlc->table, VLC_BITS, VLC_DEPTH);
-
- pred += code;
- dst[0] = pred;
- dst += 3;
- }
-
- CLOSE_READER(bits, gb);
-
- /* Stash the first pixel */
- *top_left = outbuf[0];
-
- return 0;
-}
-
-static int read_yuv_component_line(CLLCContext *ctx, GetBitContext *gb,
- int *top_left, VLC *vlc, uint8_t *outbuf,
- int is_chroma)
-{
- int pred, code;
- int i;
-
- OPEN_READER(bits, gb);
-
- pred = *top_left;
-
- /* Simultaneously read and restore the line */
- for (i = 0; i < ctx->avctx->width >> is_chroma; i++) {
- UPDATE_CACHE(bits, gb);
- GET_VLC(code, bits, gb, vlc->table, VLC_BITS, VLC_DEPTH);
-
- pred += code;
- outbuf[i] = pred;
- }
-
- CLOSE_READER(bits, gb);
-
- /* Stash the first pixel */
- *top_left = outbuf[0];
-
- return 0;
-}
-
-static int decode_argb_frame(CLLCContext *ctx, GetBitContext *gb, AVFrame *pic)
-{
- AVCodecContext *avctx = ctx->avctx;
- uint8_t *dst;
- int pred[4];
- int ret;
- int i, j;
- VLC vlc[4];
-
- pred[0] = 0;
- pred[1] = 0x80;
- pred[2] = 0x80;
- pred[3] = 0x80;
-
- dst = pic->data[0];
-
- skip_bits(gb, 16);
-
- /* Read in code table for each plane */
- for (i = 0; i < 4; i++) {
- ret = read_code_table(ctx, gb, &vlc[i]);
- if (ret < 0) {
- for (j = 0; j < i; j++)
- ff_free_vlc(&vlc[j]);
-
- av_log(ctx->avctx, AV_LOG_ERROR,
- "Could not read code table %d.\n", i);
- return ret;
- }
- }
-
- /* Read in and restore every line */
- for (i = 0; i < avctx->height; i++) {
- read_argb_line(ctx, gb, pred, vlc, dst);
-
- dst += pic->linesize[0];
- }
-
- for (i = 0; i < 4; i++)
- ff_free_vlc(&vlc[i]);
-
- return 0;
-}
-
-static int decode_rgb24_frame(CLLCContext *ctx, GetBitContext *gb, AVFrame *pic)
-{
- AVCodecContext *avctx = ctx->avctx;
- uint8_t *dst;
- int pred[3];
- int ret;
- int i, j;
- VLC vlc[3];
-
- pred[0] = 0x80;
- pred[1] = 0x80;
- pred[2] = 0x80;
-
- dst = pic->data[0];
-
- skip_bits(gb, 16);
-
- /* Read in code table for each plane */
- for (i = 0; i < 3; i++) {
- ret = read_code_table(ctx, gb, &vlc[i]);
- if (ret < 0) {
- for (j = 0; j < i; j++)
- ff_free_vlc(&vlc[j]);
-
- av_log(ctx->avctx, AV_LOG_ERROR,
- "Could not read code table %d.\n", i);
- return ret;
- }
- }
-
- /* Read in and restore every line */
- for (i = 0; i < avctx->height; i++) {
- for (j = 0; j < 3; j++)
- read_rgb24_component_line(ctx, gb, &pred[j], &vlc[j], &dst[j]);
-
- dst += pic->linesize[0];
- }
-
- for (i = 0; i < 3; i++)
- ff_free_vlc(&vlc[i]);
-
- return 0;
-}
-
-static int decode_yuv_frame(CLLCContext *ctx, GetBitContext *gb, AVFrame *pic)
-{
- AVCodecContext *avctx = ctx->avctx;
- uint8_t block;
- uint8_t *dst[3];
- int pred[3];
- int ret;
- int i, j;
- VLC vlc[2];
-
- pred[0] = 0x80;
- pred[1] = 0x80;
- pred[2] = 0x80;
-
- dst[0] = pic->data[0];
- dst[1] = pic->data[1];
- dst[2] = pic->data[2];
-
- skip_bits(gb, 8);
-
- block = get_bits(gb, 8);
- if (block) {
- avpriv_request_sample(ctx->avctx, "Blocked YUV");
- return AVERROR_PATCHWELCOME;
- }
-
- /* Read in code table for luma and chroma */
- for (i = 0; i < 2; i++) {
- ret = read_code_table(ctx, gb, &vlc[i]);
- if (ret < 0) {
- for (j = 0; j < i; j++)
- ff_free_vlc(&vlc[j]);
-
- av_log(ctx->avctx, AV_LOG_ERROR,
- "Could not read code table %d.\n", i);
- return ret;
- }
- }
-
- /* Read in and restore every line */
- for (i = 0; i < avctx->height; i++) {
- read_yuv_component_line(ctx, gb, &pred[0], &vlc[0], dst[0], 0); /* Y */
- read_yuv_component_line(ctx, gb, &pred[1], &vlc[1], dst[1], 1); /* U */
- read_yuv_component_line(ctx, gb, &pred[2], &vlc[1], dst[2], 1); /* V */
-
- for (j = 0; j < 3; j++)
- dst[j] += pic->linesize[j];
- }
-
- for (i = 0; i < 2; i++)
- ff_free_vlc(&vlc[i]);
-
- return 0;
-}
-
-static int cllc_decode_frame(AVCodecContext *avctx, AVFrame *pic,
- int *got_picture_ptr, AVPacket *avpkt)
-{
- CLLCContext *ctx = avctx->priv_data;
- const uint8_t *src = avpkt->data;
- uint32_t info_tag, info_offset;
- int data_size;
- GetBitContext gb;
- int coding_type, ret;
-
- if (avpkt->size < 4 + 4) {
- av_log(avctx, AV_LOG_ERROR, "Frame is too small %d.\n", avpkt->size);
- return AVERROR_INVALIDDATA;
- }
-
- info_offset = 0;
- info_tag = AV_RL32(src);
- if (info_tag == MKTAG('I', 'N', 'F', 'O')) {
- info_offset = AV_RL32(src + 4);
- if (info_offset > UINT32_MAX - 8 || info_offset + 8 > avpkt->size) {
- av_log(avctx, AV_LOG_ERROR,
- "Invalid INFO header offset: 0x%08"PRIX32" is too large.\n",
- info_offset);
- return AVERROR_INVALIDDATA;
- }
- ff_canopus_parse_info_tag(avctx, src + 8, info_offset);
-
- info_offset += 8;
- src += info_offset;
- }
-
- data_size = (avpkt->size - info_offset) & ~1;
-
- /* Make sure our bswap16'd buffer is big enough */
- av_fast_padded_malloc(&ctx->swapped_buf,
- &ctx->swapped_buf_size, data_size);
- if (!ctx->swapped_buf) {
- av_log(avctx, AV_LOG_ERROR, "Could not allocate swapped buffer.\n");
- return AVERROR(ENOMEM);
- }
-
- /* bswap16 the buffer since CLLC's bitreader works in 16-bit words */
- ctx->bdsp.bswap16_buf((uint16_t *) ctx->swapped_buf, (uint16_t *) src,
- data_size / 2);
-
- if ((ret = init_get_bits8(&gb, ctx->swapped_buf, data_size)) < 0)
- return ret;
-
- /*
- * Read in coding type. The types are as follows:
- *
- * 0 - YUY2
- * 1 - BGR24 (Triples)
- * 2 - BGR24 (Quads)
- * 3 - BGRA
- */
- coding_type = (AV_RL32(src) >> 8) & 0xFF;
- av_log(avctx, AV_LOG_DEBUG, "Frame coding type: %d\n", coding_type);
-
- if(get_bits_left(&gb) < avctx->height * avctx->width)
- return AVERROR_INVALIDDATA;
-
- switch (coding_type) {
- case 0:
- avctx->pix_fmt = AV_PIX_FMT_YUV422P;
- avctx->bits_per_raw_sample = 8;
-
- if ((ret = ff_thread_get_buffer(avctx, pic, 0)) < 0)
- return ret;
-
- ret = decode_yuv_frame(ctx, &gb, pic);
- if (ret < 0)
- return ret;
-
- break;
- case 1:
- case 2:
- avctx->pix_fmt = AV_PIX_FMT_RGB24;
- avctx->bits_per_raw_sample = 8;
-
- if ((ret = ff_thread_get_buffer(avctx, pic, 0)) < 0)
- return ret;
-
- ret = decode_rgb24_frame(ctx, &gb, pic);
- if (ret < 0)
- return ret;
-
- break;
- case 3:
- avctx->pix_fmt = AV_PIX_FMT_ARGB;
- avctx->bits_per_raw_sample = 8;
-
- if ((ret = ff_thread_get_buffer(avctx, pic, 0)) < 0)
- return ret;
-
- ret = decode_argb_frame(ctx, &gb, pic);
- if (ret < 0)
- return ret;
-
- break;
- default:
- av_log(avctx, AV_LOG_ERROR, "Unknown coding type: %d.\n", coding_type);
- return AVERROR_INVALIDDATA;
- }
-
- pic->key_frame = 1;
- pic->pict_type = AV_PICTURE_TYPE_I;
-
- *got_picture_ptr = 1;
-
- return avpkt->size;
-}
-
-static av_cold int cllc_decode_close(AVCodecContext *avctx)
-{
- CLLCContext *ctx = avctx->priv_data;
-
- av_freep(&ctx->swapped_buf);
-
- return 0;
-}
-
-static av_cold int cllc_decode_init(AVCodecContext *avctx)
-{
- CLLCContext *ctx = avctx->priv_data;
-
- /* Initialize various context values */
- ctx->avctx = avctx;
- ctx->swapped_buf = NULL;
- ctx->swapped_buf_size = 0;
-
- ff_bswapdsp_init(&ctx->bdsp);
-
- return 0;
-}
-
-const FFCodec ff_cllc_decoder = {
- .p.name = "cllc",
- CODEC_LONG_NAME("Canopus Lossless Codec"),
- .p.type = AVMEDIA_TYPE_VIDEO,
- .p.id = AV_CODEC_ID_CLLC,
- .priv_data_size = sizeof(CLLCContext),
- .init = cllc_decode_init,
- FF_CODEC_DECODE_CB(cllc_decode_frame),
- .close = cllc_decode_close,
- .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
-};
diff --git a/spaces/congsaPfin/Manga-OCR/logs/Tap Away No Ads APK Customize Your Blocks and Challenge Your Logic.md b/spaces/congsaPfin/Manga-OCR/logs/Tap Away No Ads APK Customize Your Blocks and Challenge Your Logic.md
deleted file mode 100644
index 87cdada159d58f5bdba91978bc2a5966a6bc01f7..0000000000000000000000000000000000000000
--- a/spaces/congsaPfin/Manga-OCR/logs/Tap Away No Ads APK Customize Your Blocks and Challenge Your Logic.md
+++ /dev/null
@@ -1,99 +0,0 @@
-
-
Tap Away No Ads APK: A Fun and Addictive 3D Puzzle Game
-
Do you love puzzle games that challenge your brain and test your skills? Do you want to enjoy a relaxing and satisfying game that you can play anytime, anywhere? If you answered yes, then you should try Tap Away No Ads APK, a fun and addictive 3D puzzle game that will keep you entertained for hours. In this article, we will tell you everything you need to know about Tap Away No Ads APK, including what it is, how to download and install it, how to play it, and some tips and tricks to master it. Let's get started!
-
What is Tap Away No Ads APK?
-
A brief introduction to the game and its features
-
Tap Away No Ads APK is a 3D puzzle game developed by Popcore Games, a popular game studio that has created many hit puzzle games with more than 250 million combined installs. Tap Away No Ads APK is one of their latest creations, and it has already gained over 10 million downloads on Google Play. The game is simple but addictive: you have to tap the blocks to make them fly away and clear the screen. But there's a catch: the blocks will only fly in one direction, so you have to rotate the shape and choose your next move carefully. The game has hundreds of levels with different shapes and blocks, as well as skins and themes that you can unlock as you progress. The game also has no ads, so you can enjoy it without any interruptions.
How to download and install Tap Away No Ads APK on your device
-
If you want to play Tap Away No Ads APK, you have two options: you can either download it from Google Play or from a third-party website. Here are the steps for both methods:
-
-
Download from Google Play: This is the easiest and safest way to get Tap Away No Ads APK on your device. All you have to do is open Google Play on your device, search for "Tap Away", and tap on the first result. Then, tap on the "Install" button and wait for the download to finish. Once it's done, you can open the game and start playing.
-
Download from a third-party website: This is an alternative way to get Tap Away No Ads APK on your device, but it requires more caution. You have to find a reliable website that offers the APK file of the game, such as [1](https://apkcombo.com/tap-away/com.jctswbglsm.SwipeAway/). Then, you have to download the APK file to your device and enable the "Unknown sources" option in your settings. After that, you can open the APK file and install it on your device. However, be careful when downloading from third-party websites, as they may contain malware or viruses that can harm your device.
-
-
Why you should play Tap Away No Ads APK
-
There are many reasons why you should play Tap Away No Ads APK, but here are some of the main ones:
-
-
It's fun and addictive: Tap Away No Ads APK is a game that will keep you hooked for hours with its simple but challenging gameplay. You will never get bored of tapping away the blocks and clearing the screen. You will also enjoy the satisfying sound effects and animations that accompany each tap.
-
It's relaxing and stress-relieving: Tap Away No Ads APK is a game that will help you relax and unwind after a long day. You can play it at your own pace and enjoy the soothing music and colors. You can also use it as a meditation tool and focus on your breathing and tapping.
-
It's good for your brain: Tap Away No Ads APK is a game that will stimulate your brain and improve your cognitive skills. You will have to use your logic, memory, and spatial awareness to solve the puzzles and clear the levels. You will also have to think fast and strategically to make the best moves.
-
-
How to play Tap Away No Ads APK
-
The basic gameplay mechanics and controls
-
The gameplay of Tap Away No Ads APK is very simple and intuitive. You will see a 3D shape made of blocks on the screen, and you have to tap on the blocks to make them fly away. The blocks will only fly in one direction, which is indicated by the arrow on the bottom of the screen. You can rotate the shape by swiping left or right on the screen, and you can zoom in or out by pinching the screen. Your goal is to clear all the blocks from the screen and complete the level. You will get a star rating based on how many taps you used to clear the level, and you will earn coins and rewards for each level you complete.
-
The different levels and challenges
-
Tap Away No Ads APK has hundreds of levels with different shapes and blocks for you to enjoy. The levels vary in difficulty and complexity, and they will challenge you with different obstacles and goals. For example, some levels will have blocks with different colors, shapes, or patterns, and you will have to match them or avoid them. Some levels will have blocks that are locked or frozen, and you will have to unlock them or melt them before you can tap them away. Some levels will have blocks that are explosive or magnetic, and they will affect the other blocks around them. Some levels will have a time limit or a move limit, and you will have to clear them before you run out of time or moves.
-
The skins and themes you can unlock
-
Tap Away No Ads APK also has many skins and themes that you can unlock as you play the game. Skins are different designs for the blocks, such as fruits, animals, emojis, or letters. Themes are different backgrounds for the game, such as space, forest, ocean, or candy land. You can unlock skins and themes by spending coins that you earn from completing levels, or by watching videos that offer free rewards. You can also mix and match different skins and themes to create your own custom look for the game.
-
Tips and tricks to master Tap Away No Ads APK
-
How to rotate the shape and plan your moves
-
One of the most important skills in Tap Away No Ads APK is knowing how to rotate the shape and plan your moves ahead. Rotating the shape will change the direction of the blocks' flight, so you have to be careful not to block yourself or leave any blocks behind. You should also try to plan your moves in advance, so that you can clear the level with as few taps as possible. A good strategy is to look for groups of blocks that are aligned with the arrow's direction, and tap them away first. Then, rotate the shape to find more groups of blocks that you can clear easily.
-
How to use the hints and power-ups
-
If you ever get stuck on a level or need some help, you can use the hints and power-ups that are available in Tap Away No Ads APK. Hints are useful when you don't know what to do next, as they will show you one possible move that you can make. You can get hints by spending coins that you earn from completing levels, or by watching videos that offer free hints. Power-ups are useful when you want to clear a level faster or easier, as they will give you some special abilities. There are three types of power-ups in Tap Away No Ads APK: bomb, shuffle, and undo. Bomb will explode all the blocks in a radius around it, shuffle will randomly rearrange all the blocks on the screen, and undo will let you undo your last move. You can get power-ups by spending coins that you earn from completing levels, or by watching videos that offer free power-ups.
-
tap away game no ads apk
-tap away mod apk without ads
-tap away puzzle game ad free apk
-tap away by popcore no ads apk
-tap away 3d puzzle no ads apk
-tap away blocks mod apk no ads
-tap away offline game apk no ads
-tap away latest version apk without ads
-tap away brain teaser ad free apk
-tap away popcore games no ads apk
-download tap away no ads apk
-install tap away no ads apk
-how to get tap away no ads apk
-where to find tap away no ads apk
-tap away no ads apk for android
-tap away no ads apk for ios
-tap away no ads apk for pc
-tap away no ads apk for mac
-tap away no ads apk for windows
-tap away no ads apk for linux
-tap away no ads hack apk
-tap away no ads cheat apk
-tap away no ads premium apk
-tap away no ads pro apk
-tap away no ads vip apk
-tap away unlimited levels no ads apk
-tap away all skins unlocked no ads apk
-tap away all themes unlocked no ads apk
-tap away free download no ads apk
-tap away free play no ads apk
-is tap away no ads apk safe
-is tap away no ads apk legit
-is tap away no ads apk legal
-is tap away no ads apk virus free
-is tap away no ads apk malware free
-reviews of tap away no ads apk
-ratings of tap away no ads apk
-feedback of tap away no ads apk
-testimonials of tap away no ads apk
-benefits of tap away no ads apk
-features of tap away no ads apk
-advantages of tap away no ads apk
-disadvantages of tap away no ads apk
-alternatives to tap away no ads apk
-competitors to tap away no ads apk
-similar apps to tap away no ads apk
-best apps like tap away no ads apk
-top apps like tap away no ads apk
-popular apps like tap away no ads apk
-
How to earn coins and rewards
-
Coins are the main currency in Tap Away No Ads APK, and they are used to unlock skins, themes, hints, and power-ups. You can earn coins by completing levels with high star ratings, by watching videos that offer free coins, or by spinning a wheel that gives random rewards. Rewards are extra bonuses that you can get from playing Tap Away No Ads APK, such as free hints, power-ups, coins, or skins. You can get rewards by spinning a wheel that appears after every few levels, by watching videos that offer free rewards, or by completing daily challenges that give you specific tasks to do.
-
Conclusion
-
A summary of the main points and a call to action
-
Tap Away No Ads APK is a fun and addictive 3D puzzle game that will challenge your brain and test your skills. You have to tap the blocks to make them fly away and clear the screen, but you have to rotate the shape and choose your next move carefully. The game has hundreds of levels with different shapes and blocks, as well as skins and themes that you can unlock as you progress. The game also has no ads, so you can enjoy it without any interruptions. If you love puzzle games that are relaxing and satisfying, you should definitely try Tap Away No Ads APK. You can download it from Google Play or from a third-party website, and start tapping away!
-
FAQs
-
What is the difference between Tap Away and Tap Away No Ads?
-
Tap Away and Tap Away No Ads are the same game, except that Tap Away No Ads has no ads, as the name suggests. This means that you can play the game without any interruptions or distractions. However, Tap Away No Ads is not free, and you have to pay a small fee to download it from Google Play.
-
How can I get more coins in Tap Away No Ads APK?
-
You can get more coins in Tap Away No Ads APK by completing levels with high star ratings, by watching videos that offer free coins, by spinning a wheel that gives random rewards, or by completing daily challenges that give you specific tasks to do.
-
How can I change the skin or theme of the game in Tap Away No Ads APK?
-
You can change the skin or theme of the game in Tap Away No Ads APK by tapping on the menu icon on the top left corner of the screen, and then tapping on the skin or theme icon on the bottom of the screen. You can then choose from the available skins or themes that you have unlocked, or buy new ones with coins.
-
How can I contact the developer of Tap Away No Ads APK?
-
You can contact the developer of Tap Away No Ads APK by visiting their website at [2](https://popcore.com/), or by sending them an email at [3](mailto:support@popcore.com).
-
Is Tap Away No Ads APK safe to download and install?
-
Tap Away No Ads APK is safe to download and install if you get it from Google Play or from a reliable third-party website. However, be careful when downloading from third-party websites, as they may contain malware or viruses that can harm your device. Always check the reviews and ratings of the website before downloading anything.
401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/congsaPfin/Manga-OCR/logs/The Ultimate Solution for steam_api.dll Errors.md b/spaces/congsaPfin/Manga-OCR/logs/The Ultimate Solution for steam_api.dll Errors.md
deleted file mode 100644
index 8fcfabbb2315e7994b0b2cb7ef52d4b73e6ad8a4..0000000000000000000000000000000000000000
--- a/spaces/congsaPfin/Manga-OCR/logs/The Ultimate Solution for steam_api.dll Errors.md
+++ /dev/null
@@ -1,201 +0,0 @@
-
-
How to Fix steam_api.dll Download Error in Windows 10
-
If you are a gamer who uses Steam to play your favorite games, you may have encountered an error message related to steam_api.dll. This error can prevent you from launching or playing your games, and it can be very frustrating. In this article, we will explain what steam_api.dll is, why you need it, how to download and install it safely and correctly, how to troubleshoot and fix the error, and how to prevent it from happening again. By following this guide, you will be able to enjoy your games without any hassle.
-
What is steam_api.dll and why do you need it?
-
steam_api.dll is a dynamic link library (DLL) file that is part of the Steam client application developed by Valve Corporation. The Steam client is a digital distribution platform for video games that allows users to purchase, download, and play games on their computer. The steam_api.dll file is used by game developers to integrate their games with the Steam platform, specifically to access the Steam API, which provides various services such as authentication, user profiles, game stats, and cloud storage. The file is required by many video games that use the Steamworks API, which is a set of tools and services provided by Valve for game developers to integrate with the Steam platform.
When a game is launched, it may use the steam_api.dll file to verify the user's ownership of the game, download updates, and access cloud storage. The file also provides other functions related to the Steam API, including user authentication, Steam overlay, and achievements. Without the file, some games may not run properly or at all.
-
The common causes of steam_api.dll error
-
The most common causes of steam_api.dll error are:
-
-
The file is missing, corrupted, or not installed properly.
-
The file is incompatible with the game or the system.
-
The file is blocked by antivirus software or firewall.
-
The file is modified by malicious software or hackers.
-
-
The error message may vary depending on the cause and the situation, but some examples are:
-
-
steam_api.dll not found
-
steam_api.dll is missing from your computer
-
failed to load steam_api.dll
-
unable to find steam_api.dll entry point
-
the code execution cannot proceed because steam_api.dll was not found
-
steam_api.dll is either not designed to run on Windows or it contains an error
-
-
How to download and install steam_api.dll safely and correctly?
-
If you encounter an error related to steam_api.dll, you may need to download and install the file again. However, you should be careful where you get the file from, as some sources may be unreliable or harmful. Here are some tips on how to download and install steam_api.dll safely and correctly.
-
The official source of steam_api.dll
-
The best and safest source of steam_api.dll is the official Steam website or client. You can download the Steam client from https://store.steampowered.com/about/. This will ensure that you get the latest and compatible version of the file for your system and games. You can also use the Steam client to update your games automatically, which may fix some issues with the file.
-
The steps to download and install steam_api.dll
-
Here are the steps to download and install steam_api.dll from the official Steam website or client:
Run the installer and follow the instructions to install the Steam client on your computer.
-
Launch the Steam client and log in with your Steam account. If you don't have one, you can create one for free.
-
Go to the "Library" tab and find the game that requires steam_api.dll. If you don't have the game, you can purchase it from the Steam store.
-
Right-click on the game and select "Properties".
-
Go to the "Local Files" tab and click on the "Verify Integrity of Game Files" button.
-
Wait for the process to complete. This will scan and repair any missing or corrupted files, including steam_api.dll.
-
Restart your computer and try to launch or play the game again.
-
-
How to troubleshoot and fix steam_api.dll error in Windows 10?
-
If downloading and installing steam_api.dll from the official source does not fix the error, you may need to troubleshoot and fix it manually. There are several possible solutions that you can try, depending on the cause and the situation of the error. Here are some of them:
-
steam_api.dll missing error fix
-steam_api.dll file location
-steam_api.dll virus or malware
-steam_api.dll for windows 10
-steam_api.dll for 64 bit
-steam_api.dll not found
-steam_api.dll crack download
-steam_api.dll free download for pc
-steam_api.dll corrupted or invalid
-steam_api.dll update download
-steam_api.dll for call of duty black ops 2
-steam_api.dll for skyrim
-steam_api.dll for pes 2015
-steam_api.dll for euro truck simulator 2
-steam_api.dll for unreal tournament 3
-steam_api.dll for resident evil 6
-steam_api.dll for gta 5
-steam_api.dll for fallout 4
-steam_api.dll for dark souls 3
-steam_api.dll for far cry 4
-steam_api.dll access denied
-steam_api.dll failed to initialize
-steam_api.dll functions list
-steam_api.dll documentation
-steam_api.dll source code
-steam_api.dll tutorial
-steam_api.dll alternatives
-steam_api.dll license key
-steam_api.dll original file download
-steam_api.dll backup file download
-how to install steam_api.dll on windows 7
-how to fix steam_api.dll error in windows 8.1
-how to repair steam_api.dll error in windows xp
-how to solve steam_api.dll problem in windows vista
-how to restore steam_api.dll file in windows 2000
-how to replace steam_api.dll file in windows me
-how to remove steam_api.dll file from windows 98
-how to uninstall steam_api.dll file from windows 95
-how to register steam_api.dll file in windows nt
-how to use steam_api.dll file in windows ce
-
The possible solutions for steam_api.dll error
-
Some of the possible solutions for steam_api.dll error are:
-
-
Reinstalling the game that uses steam_api.dll.
-
Updating your system and drivers.
-
Disabling or uninstalling your antivirus software or firewall.
-
Restoring your system to a previous point.
-
Scanning and removing any malware or viruses from your computer.
-
-
The steps to apply each solution
-
Here are the steps to apply each solution for steam_api.dll error:
-
Reinstalling the game that uses steam_api.dll
-
If the game that uses steam_api.dll is corrupted or incompatible, you may need to reinstall it. Here are the steps to do so:
-
-
Launch the Steam client and go to the "Library" tab.
-
Right-click on the game that uses steam_api.dll and select "Uninstall".
-
Confirm your choice and wait for the uninstallation to complete.
-
Go to the Steam store and download and install the game again.
-
Restart your computer and try to launch or play the game again.
-
-
Updating your system and drivers
-
If your system or drivers are outdated or incompatible, they may cause steam_api.dll error. You should update them regularly to ensure that they work properly with your games. Here are the steps to do so:
-
-
Go to the "Start" menu and click on the "Settings" icon.
-
Select "Update & Security" and then "Windows Update".
-
Click on the "Check for updates" button and wait for Windows to scan and download any available updates.
-
If there are any updates, click on the "Install now" button and follow the instructions to install them.
-
To update your drivers, go to the "Device Manager" by typing it in the search box or right-clicking on the "Start" menu.
-
Expand each category of devices and look for any yellow exclamation marks or red crosses. These indicate that there are problems with your drivers.
-
Right-click on each problematic device and select "Update driver".
-
Select "Search automatically for updated driver software" and wait for Windows to find and install any available drivers.
-
Restart your computer and try to launch or play the game again.
-
-
Disabling or uninstalling your antivirus software or firewall
-
If your antivirus software or firewall is blocking or interfering with steam_api.dll, you may need to disable or uninstall it temporarily. Here are the steps to do so:
-
-
Go to the "Start" menu and click on the "Settings" icon.
-
Select "Update & Security" and then "Windows Security".
-
Click on the "Virus & threat protection" option and then on the "Manage settings" link under the "Virus & threat protection settings" section.
-
Toggle off the "Real-time protection" switch to disable your antivirus software.
-
To disable your firewall, go back to the "Windows Security" page and click on the "Firewall & network protection" option.
-
Select your active network and toggle off the "Microsoft Defender Firewall" switch.
-
Restart your computer and try to launch or play the game again.
-
If the error is fixed, you can enable your antivirus software and firewall again. However, you may need to add steam_api.dll and the game to their exception or whitelist to prevent them from blocking or interfering with them again.
-
If the error is not fixed, you may need to uninstall your antivirus software or firewall completely. To do so, go to the "Start" menu and click on the "Settings" icon.
-
Select "Apps" and then "Apps & features".
-
Find your antivirus software or firewall from the list of installed apps and click on it.
-
Click on the "Uninstall" button and follow the instructions to remove it from your computer.
-
Restart your computer and try to launch or play the game again.
-
-
Restoring your system to a previous point
-
If your system has been changed or damaged by a recent update, installation, or modification, you may need to restore it to a previous point. This will undo any changes that may have caused steam_api.dll error. Here are the steps to do so:
-
-
Go to the "Start" menu and type in "recovery".
-
Select "Recovery options" from the search results.
-
Click on the "Open System Restore" button under the "Advanced recovery tools" section.
-
Click on the "Next" button and select a restore point from the list. You should choose a restore point that was created before you encountered steam_api.dll error.
-
Click on the "Next" button and then on the "Finish" button to confirm your choice.
-
Wait for your system to be restored to the selected point. This may take some time, so be patient.
-
Restart your computer and try to launch or play the game again.
-
-
Scanning and removing any malware or viruses from your computer
-
If your computer has been infected by malware or viruses, they may have modified or deleted steam_api.dll. You should scan and remove any malicious software from your computer as soon as possible. Here are the steps to do so:
-
-
Go to the "Start" menu and click on the "Settings" icon.
-
Select "Update & Security" and then "Windows Security".
-
Click on the "Virus & threat protection" option and then on the "Scan options" link under the "Current threats" section.
-
Select the "Full scan" option and click on the "Scan now" button.
-
Wait for Windows Defender to scan your entire computer for any malware or viruses. This may take some time, so be patient.
-
If any threats are found, click on the "Clean threats" button and follow the instructions to remove them from your computer.
-
Restart your computer and try to launch or play the game again.
-
-
How to prevent steam_api.dll error from happening again?
-
If you have successfully fixed steam_api.dll error, you may want to prevent it from happening again. Here are some tips on how to do so:
-
The best practices to avoid steam_api.dll error
-
Some of the best practices to avoid steam_api.dll error are:
-
-
Do not download or install steam_api.dll from untrusted or unknown sources. They may contain malware or viruses that can harm your computer or games.
-
Do not delete or modify steam_api.dll without proper knowledge or authorization. You may cause more problems than you solve.
-
Do not share steam_api.dll with other users or devices. The file may be incompatible or corrupted during the transfer process.
-
-
The benefits of keeping your system and software updated
-
One of the best ways to prevent steam_api.dll error is to keep your system and software updated. This will ensure that you have the latest and compatible versions of steam _api.dll and your games. It will also fix any bugs or issues that may cause steam_api.dll error. Here are some benefits of keeping your system and software updated:
-
-
You will have better performance and security for your computer and games.
-
You will have new features and improvements for your computer and games.
-
You will have fewer errors and crashes for your computer and games.
-
-
Conclusion
-
steam_api.dll is a vital file for many video games that use the Steam platform. However, it can also cause errors that can prevent you from launching or playing your games. In this article, we have explained what steam_api.dll is, why you need it, how to download and install it safely and correctly, how to troubleshoot and fix the error, and how to prevent it from happening again. By following this guide, you will be able to enjoy your games without any hassle.
-
FAQs
-
Here are some frequently asked questions about steam_api.dll:
-
What is the location of steam_api.dll on my computer?
-
The location of steam_api.dll on your computer may vary depending on where you installed the Steam client and the game that uses it. However, the most common locations are:
You should not delete steam_api.dll from your computer unless you are sure that you don't need it anymore. Deleting the file may cause some games to stop working or malfunction. If you want to uninstall a game that uses steam_api.dll, you should do it through the Steam client or the Control Panel.
-
Is steam_api.dll a virus or malware?
-
The original steam_api.dll file is not a virus or malware. It is a legitimate file that is part of the Steam client and many video games. However, some malicious software or hackers may disguise their files as steam_api.dll to trick or infect users. You should always scan any file that you download from the internet with a reliable antivirus software before opening or running it.
-
How can I fix steam_api.dll error if I don't have Steam or the game installed?
-
If you don't have Steam or the game installed on your computer, but you still encounter steam_api.dll error, it may be because another program or software is using the file. You should identify which program or software is causing the error and update, repair, or uninstall it. You can use the Task Manager or the Event Viewer to find out which program or software is using the file.
-
How can I contact Steam support if I need more help with steam_api.dll error?
-
If you need more help with steam_api.dll error, you can contact Steam support through their website or client. Here are the steps to do so:
-
-It has the purpose of selecting and defining the color of the book. It contains a "Reference Picker" and a "Rename". - The document in the right side of the "Color Picker" is a composite image , in which the background of the document is a document image from the collection, and the color is modified by the "Reference Picker". The book is stored in the local collection on the computer. - The document is from the collection of "MyBooks". - "Dryad" implements for the selection of the book image, and the color of the "Reference Picker" has been chosen to be the same as the reference color used by the book images. - "Dryad" implements the "Rename" functionality. The "Browse List" search of opens. The books in the collection are not ordered alphabetically. - "Dryad" implements the "Browse List" search. - The "Browse List" opens, and the Book2 image of the document in the center is selected. The image of the document in the center of the document is selected because it has the same reference color as the book image. The books in the collection are not ordered alphabetically. - "Dryad" implements the "Search Next" functionality. - The document in the right side of the "Color Picker" is not a composite image. This image in the document is directly selected by the user. - The document is from the collection of "MyBooks". - "Dryad" implements the "Update" functionality. - The book in the center is the book2 of the document in the right side of the "Color Picker". - The "Calculate" functionality is applied to the "Browse List" (as the result of the "Update" action, the page is saved in the local collection). - The user initiates the "Generate" functionality.
-
-The Generate functionality generates a new PDF document based on the collection on the computer. The user specifies the number of pages of the book and the name of the document and the specification of the book. The documents are saved in the local collection on the computer.
-
-The second application is a set of documents. In the example, the image of the document of a small book, the three documents of a reference book, and a sample of a book is available as a set of documents.
-
-This set of documents is stored in a set of documents in the collection 4fefd39f24
-
-
-
diff --git a/spaces/coolprakashjj/Bradley-Siderograph-Public/README.md b/spaces/coolprakashjj/Bradley-Siderograph-Public/README.md
deleted file mode 100644
index d5d147ba9326bb687fa442eb29703510673721fc..0000000000000000000000000000000000000000
--- a/spaces/coolprakashjj/Bradley-Siderograph-Public/README.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: Bradley Siderograph
-emoji: 📈
-colorFrom: indigo
-colorTo: indigo
-sdk: gradio
-sdk_version: 3.23.0
-app_file: app.py
-pinned: false
-license: agpl-3.0
-duplicated_from: vb030313/Bradley-Siderograph
----
-
-# Bradley Siderograph
-This is an open-source implementation of the algorithms and techniques presented in Donald A. Bradley's book "Stock Market Prediction, The Planetary Barometer and How to Use It." The project offers a comprehensive toolset to predict stock market trends using geocentric, heliocentric, and planetocentric astrological graphs. Users can generate these graphs based on planetary positions and analyze their impact on financial markets, leveraging the power of Bradley's planetary barometer methodology.
\ No newline at end of file
diff --git a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/oneformer/detectron2/config/compat.py b/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/oneformer/detectron2/config/compat.py
deleted file mode 100644
index 11a08c439bf14defd880e37a938fab8a08e68eeb..0000000000000000000000000000000000000000
--- a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/oneformer/detectron2/config/compat.py
+++ /dev/null
@@ -1,229 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-"""
-Backward compatibility of configs.
-
-Instructions to bump version:
-+ It's not needed to bump version if new keys are added.
- It's only needed when backward-incompatible changes happen
- (i.e., some existing keys disappear, or the meaning of a key changes)
-+ To bump version, do the following:
- 1. Increment _C.VERSION in defaults.py
- 2. Add a converter in this file.
-
- Each ConverterVX has a function "upgrade" which in-place upgrades config from X-1 to X,
- and a function "downgrade" which in-place downgrades config from X to X-1
-
- In each function, VERSION is left unchanged.
-
- Each converter assumes that its input has the relevant keys
- (i.e., the input is not a partial config).
- 3. Run the tests (test_config.py) to make sure the upgrade & downgrade
- functions are consistent.
-"""
-
-import logging
-from typing import List, Optional, Tuple
-
-from .config import CfgNode as CN
-from .defaults import _C
-
-__all__ = ["upgrade_config", "downgrade_config"]
-
-
-def upgrade_config(cfg: CN, to_version: Optional[int] = None) -> CN:
- """
- Upgrade a config from its current version to a newer version.
-
- Args:
- cfg (CfgNode):
- to_version (int): defaults to the latest version.
- """
- cfg = cfg.clone()
- if to_version is None:
- to_version = _C.VERSION
-
- assert cfg.VERSION <= to_version, "Cannot upgrade from v{} to v{}!".format(
- cfg.VERSION, to_version
- )
- for k in range(cfg.VERSION, to_version):
- converter = globals()["ConverterV" + str(k + 1)]
- converter.upgrade(cfg)
- cfg.VERSION = k + 1
- return cfg
-
-
-def downgrade_config(cfg: CN, to_version: int) -> CN:
- """
- Downgrade a config from its current version to an older version.
-
- Args:
- cfg (CfgNode):
- to_version (int):
-
- Note:
- A general downgrade of arbitrary configs is not always possible due to the
- different functionalities in different versions.
- The purpose of downgrade is only to recover the defaults in old versions,
- allowing it to load an old partial yaml config.
- Therefore, the implementation only needs to fill in the default values
- in the old version when a general downgrade is not possible.
- """
- cfg = cfg.clone()
- assert cfg.VERSION >= to_version, "Cannot downgrade from v{} to v{}!".format(
- cfg.VERSION, to_version
- )
- for k in range(cfg.VERSION, to_version, -1):
- converter = globals()["ConverterV" + str(k)]
- converter.downgrade(cfg)
- cfg.VERSION = k - 1
- return cfg
-
-
-def guess_version(cfg: CN, filename: str) -> int:
- """
- Guess the version of a partial config where the VERSION field is not specified.
- Returns the version, or the latest if cannot make a guess.
-
- This makes it easier for users to migrate.
- """
- logger = logging.getLogger(__name__)
-
- def _has(name: str) -> bool:
- cur = cfg
- for n in name.split("."):
- if n not in cur:
- return False
- cur = cur[n]
- return True
-
- # Most users' partial configs have "MODEL.WEIGHT", so guess on it
- ret = None
- if _has("MODEL.WEIGHT") or _has("TEST.AUG_ON"):
- ret = 1
-
- if ret is not None:
- logger.warning("Config '{}' has no VERSION. Assuming it to be v{}.".format(filename, ret))
- else:
- ret = _C.VERSION
- logger.warning(
- "Config '{}' has no VERSION. Assuming it to be compatible with latest v{}.".format(
- filename, ret
- )
- )
- return ret
-
-
-def _rename(cfg: CN, old: str, new: str) -> None:
- old_keys = old.split(".")
- new_keys = new.split(".")
-
- def _set(key_seq: List[str], val: str) -> None:
- cur = cfg
- for k in key_seq[:-1]:
- if k not in cur:
- cur[k] = CN()
- cur = cur[k]
- cur[key_seq[-1]] = val
-
- def _get(key_seq: List[str]) -> CN:
- cur = cfg
- for k in key_seq:
- cur = cur[k]
- return cur
-
- def _del(key_seq: List[str]) -> None:
- cur = cfg
- for k in key_seq[:-1]:
- cur = cur[k]
- del cur[key_seq[-1]]
- if len(cur) == 0 and len(key_seq) > 1:
- _del(key_seq[:-1])
-
- _set(new_keys, _get(old_keys))
- _del(old_keys)
-
-
-class _RenameConverter:
- """
- A converter that handles simple rename.
- """
-
- RENAME: List[Tuple[str, str]] = [] # list of tuples of (old name, new name)
-
- @classmethod
- def upgrade(cls, cfg: CN) -> None:
- for old, new in cls.RENAME:
- _rename(cfg, old, new)
-
- @classmethod
- def downgrade(cls, cfg: CN) -> None:
- for old, new in cls.RENAME[::-1]:
- _rename(cfg, new, old)
-
-
-class ConverterV1(_RenameConverter):
- RENAME = [("MODEL.RPN_HEAD.NAME", "MODEL.RPN.HEAD_NAME")]
-
-
-class ConverterV2(_RenameConverter):
- """
- A large bulk of rename, before public release.
- """
-
- RENAME = [
- ("MODEL.WEIGHT", "MODEL.WEIGHTS"),
- ("MODEL.PANOPTIC_FPN.SEMANTIC_LOSS_SCALE", "MODEL.SEM_SEG_HEAD.LOSS_WEIGHT"),
- ("MODEL.PANOPTIC_FPN.RPN_LOSS_SCALE", "MODEL.RPN.LOSS_WEIGHT"),
- ("MODEL.PANOPTIC_FPN.INSTANCE_LOSS_SCALE", "MODEL.PANOPTIC_FPN.INSTANCE_LOSS_WEIGHT"),
- ("MODEL.PANOPTIC_FPN.COMBINE_ON", "MODEL.PANOPTIC_FPN.COMBINE.ENABLED"),
- (
- "MODEL.PANOPTIC_FPN.COMBINE_OVERLAP_THRESHOLD",
- "MODEL.PANOPTIC_FPN.COMBINE.OVERLAP_THRESH",
- ),
- (
- "MODEL.PANOPTIC_FPN.COMBINE_STUFF_AREA_LIMIT",
- "MODEL.PANOPTIC_FPN.COMBINE.STUFF_AREA_LIMIT",
- ),
- (
- "MODEL.PANOPTIC_FPN.COMBINE_INSTANCES_CONFIDENCE_THRESHOLD",
- "MODEL.PANOPTIC_FPN.COMBINE.INSTANCES_CONFIDENCE_THRESH",
- ),
- ("MODEL.ROI_HEADS.SCORE_THRESH", "MODEL.ROI_HEADS.SCORE_THRESH_TEST"),
- ("MODEL.ROI_HEADS.NMS", "MODEL.ROI_HEADS.NMS_THRESH_TEST"),
- ("MODEL.RETINANET.INFERENCE_SCORE_THRESHOLD", "MODEL.RETINANET.SCORE_THRESH_TEST"),
- ("MODEL.RETINANET.INFERENCE_TOPK_CANDIDATES", "MODEL.RETINANET.TOPK_CANDIDATES_TEST"),
- ("MODEL.RETINANET.INFERENCE_NMS_THRESHOLD", "MODEL.RETINANET.NMS_THRESH_TEST"),
- ("TEST.DETECTIONS_PER_IMG", "TEST.DETECTIONS_PER_IMAGE"),
- ("TEST.AUG_ON", "TEST.AUG.ENABLED"),
- ("TEST.AUG_MIN_SIZES", "TEST.AUG.MIN_SIZES"),
- ("TEST.AUG_MAX_SIZE", "TEST.AUG.MAX_SIZE"),
- ("TEST.AUG_FLIP", "TEST.AUG.FLIP"),
- ]
-
- @classmethod
- def upgrade(cls, cfg: CN) -> None:
- super().upgrade(cfg)
-
- if cfg.MODEL.META_ARCHITECTURE == "RetinaNet":
- _rename(
- cfg, "MODEL.RETINANET.ANCHOR_ASPECT_RATIOS", "MODEL.ANCHOR_GENERATOR.ASPECT_RATIOS"
- )
- _rename(cfg, "MODEL.RETINANET.ANCHOR_SIZES", "MODEL.ANCHOR_GENERATOR.SIZES")
- del cfg["MODEL"]["RPN"]["ANCHOR_SIZES"]
- del cfg["MODEL"]["RPN"]["ANCHOR_ASPECT_RATIOS"]
- else:
- _rename(cfg, "MODEL.RPN.ANCHOR_ASPECT_RATIOS", "MODEL.ANCHOR_GENERATOR.ASPECT_RATIOS")
- _rename(cfg, "MODEL.RPN.ANCHOR_SIZES", "MODEL.ANCHOR_GENERATOR.SIZES")
- del cfg["MODEL"]["RETINANET"]["ANCHOR_SIZES"]
- del cfg["MODEL"]["RETINANET"]["ANCHOR_ASPECT_RATIOS"]
- del cfg["MODEL"]["RETINANET"]["ANCHOR_STRIDES"]
-
- @classmethod
- def downgrade(cls, cfg: CN) -> None:
- super().downgrade(cfg)
-
- _rename(cfg, "MODEL.ANCHOR_GENERATOR.ASPECT_RATIOS", "MODEL.RPN.ANCHOR_ASPECT_RATIOS")
- _rename(cfg, "MODEL.ANCHOR_GENERATOR.SIZES", "MODEL.RPN.ANCHOR_SIZES")
- cfg.MODEL.RETINANET.ANCHOR_ASPECT_RATIOS = cfg.MODEL.RPN.ANCHOR_ASPECT_RATIOS
- cfg.MODEL.RETINANET.ANCHOR_SIZES = cfg.MODEL.RPN.ANCHOR_SIZES
- cfg.MODEL.RETINANET.ANCHOR_STRIDES = [] # this is not used anywhere in any version
diff --git a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/oneformer/detectron2/data/benchmark.py b/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/oneformer/detectron2/data/benchmark.py
deleted file mode 100644
index bfd650582c83cd032b4fe76303517cdfd9a2a8b4..0000000000000000000000000000000000000000
--- a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/oneformer/detectron2/data/benchmark.py
+++ /dev/null
@@ -1,225 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import logging
-import numpy as np
-from itertools import count
-from typing import List, Tuple
-import torch
-import tqdm
-from fvcore.common.timer import Timer
-
-from annotator.oneformer.detectron2.utils import comm
-
-from .build import build_batch_data_loader
-from .common import DatasetFromList, MapDataset
-from .samplers import TrainingSampler
-
-logger = logging.getLogger(__name__)
-
-
-class _EmptyMapDataset(torch.utils.data.Dataset):
- """
- Map anything to emptiness.
- """
-
- def __init__(self, dataset):
- self.ds = dataset
-
- def __len__(self):
- return len(self.ds)
-
- def __getitem__(self, idx):
- _ = self.ds[idx]
- return [0]
-
-
-def iter_benchmark(
- iterator, num_iter: int, warmup: int = 5, max_time_seconds: float = 60
-) -> Tuple[float, List[float]]:
- """
- Benchmark an iterator/iterable for `num_iter` iterations with an extra
- `warmup` iterations of warmup.
- End early if `max_time_seconds` time is spent on iterations.
-
- Returns:
- float: average time (seconds) per iteration
- list[float]: time spent on each iteration. Sometimes useful for further analysis.
- """
- num_iter, warmup = int(num_iter), int(warmup)
-
- iterator = iter(iterator)
- for _ in range(warmup):
- next(iterator)
- timer = Timer()
- all_times = []
- for curr_iter in tqdm.trange(num_iter):
- start = timer.seconds()
- if start > max_time_seconds:
- num_iter = curr_iter
- break
- next(iterator)
- all_times.append(timer.seconds() - start)
- avg = timer.seconds() / num_iter
- return avg, all_times
-
-
-class DataLoaderBenchmark:
- """
- Some common benchmarks that help understand perf bottleneck of a standard dataloader
- made of dataset, mapper and sampler.
- """
-
- def __init__(
- self,
- dataset,
- *,
- mapper,
- sampler=None,
- total_batch_size,
- num_workers=0,
- max_time_seconds: int = 90,
- ):
- """
- Args:
- max_time_seconds (int): maximum time to spent for each benchmark
- other args: same as in `build.py:build_detection_train_loader`
- """
- if isinstance(dataset, list):
- dataset = DatasetFromList(dataset, copy=False, serialize=True)
- if sampler is None:
- sampler = TrainingSampler(len(dataset))
-
- self.dataset = dataset
- self.mapper = mapper
- self.sampler = sampler
- self.total_batch_size = total_batch_size
- self.num_workers = num_workers
- self.per_gpu_batch_size = self.total_batch_size // comm.get_world_size()
-
- self.max_time_seconds = max_time_seconds
-
- def _benchmark(self, iterator, num_iter, warmup, msg=None):
- avg, all_times = iter_benchmark(iterator, num_iter, warmup, self.max_time_seconds)
- if msg is not None:
- self._log_time(msg, avg, all_times)
- return avg, all_times
-
- def _log_time(self, msg, avg, all_times, distributed=False):
- percentiles = [np.percentile(all_times, k, interpolation="nearest") for k in [1, 5, 95, 99]]
- if not distributed:
- logger.info(
- f"{msg}: avg={1.0/avg:.1f} it/s, "
- f"p1={percentiles[0]:.2g}s, p5={percentiles[1]:.2g}s, "
- f"p95={percentiles[2]:.2g}s, p99={percentiles[3]:.2g}s."
- )
- return
- avg_per_gpu = comm.all_gather(avg)
- percentiles_per_gpu = comm.all_gather(percentiles)
- if comm.get_rank() > 0:
- return
- for idx, avg, percentiles in zip(count(), avg_per_gpu, percentiles_per_gpu):
- logger.info(
- f"GPU{idx} {msg}: avg={1.0/avg:.1f} it/s, "
- f"p1={percentiles[0]:.2g}s, p5={percentiles[1]:.2g}s, "
- f"p95={percentiles[2]:.2g}s, p99={percentiles[3]:.2g}s."
- )
-
- def benchmark_dataset(self, num_iter, warmup=5):
- """
- Benchmark the speed of taking raw samples from the dataset.
- """
-
- def loader():
- while True:
- for k in self.sampler:
- yield self.dataset[k]
-
- self._benchmark(loader(), num_iter, warmup, "Dataset Alone")
-
- def benchmark_mapper(self, num_iter, warmup=5):
- """
- Benchmark the speed of taking raw samples from the dataset and map
- them in a single process.
- """
-
- def loader():
- while True:
- for k in self.sampler:
- yield self.mapper(self.dataset[k])
-
- self._benchmark(loader(), num_iter, warmup, "Single Process Mapper (sec/sample)")
-
- def benchmark_workers(self, num_iter, warmup=10):
- """
- Benchmark the dataloader by tuning num_workers to [0, 1, self.num_workers].
- """
- candidates = [0, 1]
- if self.num_workers not in candidates:
- candidates.append(self.num_workers)
-
- dataset = MapDataset(self.dataset, self.mapper)
- for n in candidates:
- loader = build_batch_data_loader(
- dataset,
- self.sampler,
- self.total_batch_size,
- num_workers=n,
- )
- self._benchmark(
- iter(loader),
- num_iter * max(n, 1),
- warmup * max(n, 1),
- f"DataLoader ({n} workers, bs={self.per_gpu_batch_size})",
- )
- del loader
-
- def benchmark_IPC(self, num_iter, warmup=10):
- """
- Benchmark the dataloader where each worker outputs nothing. This
- eliminates the IPC overhead compared to the regular dataloader.
-
- PyTorch multiprocessing's IPC only optimizes for torch tensors.
- Large numpy arrays or other data structure may incur large IPC overhead.
- """
- n = self.num_workers
- dataset = _EmptyMapDataset(MapDataset(self.dataset, self.mapper))
- loader = build_batch_data_loader(
- dataset, self.sampler, self.total_batch_size, num_workers=n
- )
- self._benchmark(
- iter(loader),
- num_iter * max(n, 1),
- warmup * max(n, 1),
- f"DataLoader ({n} workers, bs={self.per_gpu_batch_size}) w/o comm",
- )
-
- def benchmark_distributed(self, num_iter, warmup=10):
- """
- Benchmark the dataloader in each distributed worker, and log results of
- all workers. This helps understand the final performance as well as
- the variances among workers.
-
- It also prints startup time (first iter) of the dataloader.
- """
- gpu = comm.get_world_size()
- dataset = MapDataset(self.dataset, self.mapper)
- n = self.num_workers
- loader = build_batch_data_loader(
- dataset, self.sampler, self.total_batch_size, num_workers=n
- )
-
- timer = Timer()
- loader = iter(loader)
- next(loader)
- startup_time = timer.seconds()
- logger.info("Dataloader startup time: {:.2f} seconds".format(startup_time))
-
- comm.synchronize()
-
- avg, all_times = self._benchmark(loader, num_iter * max(n, 1), warmup * max(n, 1))
- del loader
- self._log_time(
- f"DataLoader ({gpu} GPUs x {n} workers, total bs={self.total_batch_size})",
- avg,
- all_times,
- True,
- )
diff --git a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/oneformer/detectron2/modeling/meta_arch/__init__.py b/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/oneformer/detectron2/modeling/meta_arch/__init__.py
deleted file mode 100644
index 6b0668157052ce7b796ef50bc7ee85361e7605b9..0000000000000000000000000000000000000000
--- a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/oneformer/detectron2/modeling/meta_arch/__init__.py
+++ /dev/null
@@ -1,16 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright (c) Facebook, Inc. and its affiliates.
-
-from .build import META_ARCH_REGISTRY, build_model # isort:skip
-
-from .panoptic_fpn import PanopticFPN
-
-# import all the meta_arch, so they will be registered
-from .rcnn import GeneralizedRCNN, ProposalNetwork
-from .dense_detector import DenseDetector
-from .retinanet import RetinaNet
-from .fcos import FCOS
-from .semantic_seg import SEM_SEG_HEADS_REGISTRY, SemanticSegmentor, build_sem_seg_head
-
-
-__all__ = list(globals().keys())
diff --git a/spaces/cvlab/zero123-live/CLIP/README.md b/spaces/cvlab/zero123-live/CLIP/README.md
deleted file mode 100644
index db56b56e29258cc871fe0e6297bde00436d9180b..0000000000000000000000000000000000000000
--- a/spaces/cvlab/zero123-live/CLIP/README.md
+++ /dev/null
@@ -1,199 +0,0 @@
-# CLIP
-
-[[Blog]](https://openai.com/blog/clip/) [[Paper]](https://arxiv.org/abs/2103.00020) [[Model Card]](model-card.md) [[Colab]](https://colab.research.google.com/github/openai/clip/blob/master/notebooks/Interacting_with_CLIP.ipynb)
-
-CLIP (Contrastive Language-Image Pre-Training) is a neural network trained on a variety of (image, text) pairs. It can be instructed in natural language to predict the most relevant text snippet, given an image, without directly optimizing for the task, similarly to the zero-shot capabilities of GPT-2 and 3. We found CLIP matches the performance of the original ResNet50 on ImageNet “zero-shot” without using any of the original 1.28M labeled examples, overcoming several major challenges in computer vision.
-
-
-
-## Approach
-
-
-
-
-
-## Usage
-
-First, [install PyTorch 1.7.1](https://pytorch.org/get-started/locally/) (or later) and torchvision, as well as small additional dependencies, and then install this repo as a Python package. On a CUDA GPU machine, the following will do the trick:
-
-```bash
-$ conda install --yes -c pytorch pytorch=1.7.1 torchvision cudatoolkit=11.0
-$ pip install ftfy regex tqdm
-$ pip install git+https://github.com/openai/CLIP.git
-```
-
-Replace `cudatoolkit=11.0` above with the appropriate CUDA version on your machine or `cpuonly` when installing on a machine without a GPU.
-
-```python
-import torch
-import clip
-from PIL import Image
-
-device = "cuda" if torch.cuda.is_available() else "cpu"
-model, preprocess = clip.load("ViT-B/32", device=device)
-
-image = preprocess(Image.open("CLIP.png")).unsqueeze(0).to(device)
-text = clip.tokenize(["a diagram", "a dog", "a cat"]).to(device)
-
-with torch.no_grad():
- image_features = model.encode_image(image)
- text_features = model.encode_text(text)
-
- logits_per_image, logits_per_text = model(image, text)
- probs = logits_per_image.softmax(dim=-1).cpu().numpy()
-
-print("Label probs:", probs) # prints: [[0.9927937 0.00421068 0.00299572]]
-```
-
-
-## API
-
-The CLIP module `clip` provides the following methods:
-
-#### `clip.available_models()`
-
-Returns the names of the available CLIP models.
-
-#### `clip.load(name, device=..., jit=False)`
-
-Returns the model and the TorchVision transform needed by the model, specified by the model name returned by `clip.available_models()`. It will download the model as necessary. The `name` argument can also be a path to a local checkpoint.
-
-The device to run the model can be optionally specified, and the default is to use the first CUDA device if there is any, otherwise the CPU. When `jit` is `False`, a non-JIT version of the model will be loaded.
-
-#### `clip.tokenize(text: Union[str, List[str]], context_length=77)`
-
-Returns a LongTensor containing tokenized sequences of given text input(s). This can be used as the input to the model
-
----
-
-The model returned by `clip.load()` supports the following methods:
-
-#### `model.encode_image(image: Tensor)`
-
-Given a batch of images, returns the image features encoded by the vision portion of the CLIP model.
-
-#### `model.encode_text(text: Tensor)`
-
-Given a batch of text tokens, returns the text features encoded by the language portion of the CLIP model.
-
-#### `model(image: Tensor, text: Tensor)`
-
-Given a batch of images and a batch of text tokens, returns two Tensors, containing the logit scores corresponding to each image and text input. The values are cosine similarities between the corresponding image and text features, times 100.
-
-
-
-## More Examples
-
-### Zero-Shot Prediction
-
-The code below performs zero-shot prediction using CLIP, as shown in Appendix B in the paper. This example takes an image from the [CIFAR-100 dataset](https://www.cs.toronto.edu/~kriz/cifar.html), and predicts the most likely labels among the 100 textual labels from the dataset.
-
-```python
-import os
-import clip
-import torch
-from torchvision.datasets import CIFAR100
-
-# Load the model
-device = "cuda" if torch.cuda.is_available() else "cpu"
-model, preprocess = clip.load('ViT-B/32', device)
-
-# Download the dataset
-cifar100 = CIFAR100(root=os.path.expanduser("~/.cache"), download=True, train=False)
-
-# Prepare the inputs
-image, class_id = cifar100[3637]
-image_input = preprocess(image).unsqueeze(0).to(device)
-text_inputs = torch.cat([clip.tokenize(f"a photo of a {c}") for c in cifar100.classes]).to(device)
-
-# Calculate features
-with torch.no_grad():
- image_features = model.encode_image(image_input)
- text_features = model.encode_text(text_inputs)
-
-# Pick the top 5 most similar labels for the image
-image_features /= image_features.norm(dim=-1, keepdim=True)
-text_features /= text_features.norm(dim=-1, keepdim=True)
-similarity = (100.0 * image_features @ text_features.T).softmax(dim=-1)
-values, indices = similarity[0].topk(5)
-
-# Print the result
-print("\nTop predictions:\n")
-for value, index in zip(values, indices):
- print(f"{cifar100.classes[index]:>16s}: {100 * value.item():.2f}%")
-```
-
-The output will look like the following (the exact numbers may be slightly different depending on the compute device):
-
-```
-Top predictions:
-
- snake: 65.31%
- turtle: 12.29%
- sweet_pepper: 3.83%
- lizard: 1.88%
- crocodile: 1.75%
-```
-
-Note that this example uses the `encode_image()` and `encode_text()` methods that return the encoded features of given inputs.
-
-
-### Linear-probe evaluation
-
-The example below uses [scikit-learn](https://scikit-learn.org/) to perform logistic regression on image features.
-
-```python
-import os
-import clip
-import torch
-
-import numpy as np
-from sklearn.linear_model import LogisticRegression
-from torch.utils.data import DataLoader
-from torchvision.datasets import CIFAR100
-from tqdm import tqdm
-
-# Load the model
-device = "cuda" if torch.cuda.is_available() else "cpu"
-model, preprocess = clip.load('ViT-B/32', device)
-
-# Load the dataset
-root = os.path.expanduser("~/.cache")
-train = CIFAR100(root, download=True, train=True, transform=preprocess)
-test = CIFAR100(root, download=True, train=False, transform=preprocess)
-
-
-def get_features(dataset):
- all_features = []
- all_labels = []
-
- with torch.no_grad():
- for images, labels in tqdm(DataLoader(dataset, batch_size=100)):
- features = model.encode_image(images.to(device))
-
- all_features.append(features)
- all_labels.append(labels)
-
- return torch.cat(all_features).cpu().numpy(), torch.cat(all_labels).cpu().numpy()
-
-# Calculate the image features
-train_features, train_labels = get_features(train)
-test_features, test_labels = get_features(test)
-
-# Perform logistic regression
-classifier = LogisticRegression(random_state=0, C=0.316, max_iter=1000, verbose=1)
-classifier.fit(train_features, train_labels)
-
-# Evaluate using the logistic regression classifier
-predictions = classifier.predict(test_features)
-accuracy = np.mean((test_labels == predictions).astype(float)) * 100.
-print(f"Accuracy = {accuracy:.3f}")
-```
-
-Note that the `C` value should be determined via a hyperparameter sweep using a validation split.
-
-
-## See Also
-
-* [OpenCLIP](https://github.com/mlfoundations/open_clip): includes larger and independently trained CLIP models up to ViT-G/14
-* [Hugging Face implementation of CLIP](https://huggingface.co/docs/transformers/model_doc/clip): for easier integration with the HF ecosystem
diff --git a/spaces/daddyjin/TalkingFaceGeneration/Demo_TFR_Pirenderer/src/face3d/visualize.py b/spaces/daddyjin/TalkingFaceGeneration/Demo_TFR_Pirenderer/src/face3d/visualize.py
deleted file mode 100644
index d30d452793913a9ba1d7b281cab7a6e9480da507..0000000000000000000000000000000000000000
--- a/spaces/daddyjin/TalkingFaceGeneration/Demo_TFR_Pirenderer/src/face3d/visualize.py
+++ /dev/null
@@ -1,48 +0,0 @@
-# check the sync of 3dmm feature and the audio
-import cv2
-import numpy as np
-from Demo_TFR_Pirenderer.src.face3d.models.bfm import ParametricFaceModel
-from Demo_TFR_Pirenderer.src.face3d.models.facerecon_model import FaceReconModel
-import torch
-import subprocess, platform
-import scipy.io as scio
-from tqdm import tqdm
-
-# draft
-def gen_composed_video(args, device, first_frame_coeff, coeff_path, audio_path, save_path, exp_dim=64):
-
- coeff_first = scio.loadmat(first_frame_coeff)['full_3dmm']
-
- coeff_pred = scio.loadmat(coeff_path)['coeff_3dmm']
-
- coeff_full = np.repeat(coeff_first, coeff_pred.shape[0], axis=0) # 257
-
- coeff_full[:, 80:144] = coeff_pred[:, 0:64]
- coeff_full[:, 224:227] = coeff_pred[:, 64:67] # 3 dim translation
- coeff_full[:, 254:] = coeff_pred[:, 67:] # 3 dim translation
-
- tmp_video_path = '/tmp/face3dtmp.mp4'
-
- facemodel = FaceReconModel(args)
-
- video = cv2.VideoWriter(tmp_video_path, cv2.VideoWriter_fourcc(*'mp4v'), 25, (224, 224))
-
- for k in tqdm(range(coeff_pred.shape[0]), 'face3d rendering:'):
- cur_coeff_full = torch.tensor(coeff_full[k:k+1], device=device)
-
- facemodel.forward(cur_coeff_full, device)
-
- predicted_landmark = facemodel.pred_lm # TODO.
- predicted_landmark = predicted_landmark.cpu().numpy().squeeze()
-
- rendered_img = facemodel.pred_face
- rendered_img = 255. * rendered_img.cpu().numpy().squeeze().transpose(1,2,0)
- out_img = rendered_img[:, :, :3].astype(np.uint8)
-
- video.write(np.uint8(out_img[:,:,::-1]))
-
- video.release()
-
- command = 'ffmpeg -v quiet -y -i {} -i {} -strict -2 -q:v 1 {}'.format(audio_path, tmp_video_path, save_path)
- subprocess.call(command, shell=platform.system() != 'Windows')
-
diff --git a/spaces/dawdqd/ChuanhuChatGPT/assets/html/appearance_switcher.html b/spaces/dawdqd/ChuanhuChatGPT/assets/html/appearance_switcher.html
deleted file mode 100644
index 9375071fbdfda7bfd622d7f7bd2dfdd0c494341b..0000000000000000000000000000000000000000
--- a/spaces/dawdqd/ChuanhuChatGPT/assets/html/appearance_switcher.html
+++ /dev/null
@@ -1,11 +0,0 @@
-
-
- {label}
-
-
-
-
-
diff --git a/spaces/dawood17/SayBot_Enchancer/CodeFormer/basicsr/metrics/psnr_ssim.py b/spaces/dawood17/SayBot_Enchancer/CodeFormer/basicsr/metrics/psnr_ssim.py
deleted file mode 100644
index bbd950699c2495880236883861d9e199f900eae8..0000000000000000000000000000000000000000
--- a/spaces/dawood17/SayBot_Enchancer/CodeFormer/basicsr/metrics/psnr_ssim.py
+++ /dev/null
@@ -1,128 +0,0 @@
-import cv2
-import numpy as np
-
-from basicsr.metrics.metric_util import reorder_image, to_y_channel
-from basicsr.utils.registry import METRIC_REGISTRY
-
-
-@METRIC_REGISTRY.register()
-def calculate_psnr(img1, img2, crop_border, input_order='HWC', test_y_channel=False):
- """Calculate PSNR (Peak Signal-to-Noise Ratio).
-
- Ref: https://en.wikipedia.org/wiki/Peak_signal-to-noise_ratio
-
- Args:
- img1 (ndarray): Images with range [0, 255].
- img2 (ndarray): Images with range [0, 255].
- crop_border (int): Cropped pixels in each edge of an image. These
- pixels are not involved in the PSNR calculation.
- input_order (str): Whether the input order is 'HWC' or 'CHW'.
- Default: 'HWC'.
- test_y_channel (bool): Test on Y channel of YCbCr. Default: False.
-
- Returns:
- float: psnr result.
- """
-
- assert img1.shape == img2.shape, (f'Image shapes are differnet: {img1.shape}, {img2.shape}.')
- if input_order not in ['HWC', 'CHW']:
- raise ValueError(f'Wrong input_order {input_order}. Supported input_orders are ' '"HWC" and "CHW"')
- img1 = reorder_image(img1, input_order=input_order)
- img2 = reorder_image(img2, input_order=input_order)
- img1 = img1.astype(np.float64)
- img2 = img2.astype(np.float64)
-
- if crop_border != 0:
- img1 = img1[crop_border:-crop_border, crop_border:-crop_border, ...]
- img2 = img2[crop_border:-crop_border, crop_border:-crop_border, ...]
-
- if test_y_channel:
- img1 = to_y_channel(img1)
- img2 = to_y_channel(img2)
-
- mse = np.mean((img1 - img2)**2)
- if mse == 0:
- return float('inf')
- return 20. * np.log10(255. / np.sqrt(mse))
-
-
-def _ssim(img1, img2):
- """Calculate SSIM (structural similarity) for one channel images.
-
- It is called by func:`calculate_ssim`.
-
- Args:
- img1 (ndarray): Images with range [0, 255] with order 'HWC'.
- img2 (ndarray): Images with range [0, 255] with order 'HWC'.
-
- Returns:
- float: ssim result.
- """
-
- C1 = (0.01 * 255)**2
- C2 = (0.03 * 255)**2
-
- img1 = img1.astype(np.float64)
- img2 = img2.astype(np.float64)
- kernel = cv2.getGaussianKernel(11, 1.5)
- window = np.outer(kernel, kernel.transpose())
-
- mu1 = cv2.filter2D(img1, -1, window)[5:-5, 5:-5]
- mu2 = cv2.filter2D(img2, -1, window)[5:-5, 5:-5]
- mu1_sq = mu1**2
- mu2_sq = mu2**2
- mu1_mu2 = mu1 * mu2
- sigma1_sq = cv2.filter2D(img1**2, -1, window)[5:-5, 5:-5] - mu1_sq
- sigma2_sq = cv2.filter2D(img2**2, -1, window)[5:-5, 5:-5] - mu2_sq
- sigma12 = cv2.filter2D(img1 * img2, -1, window)[5:-5, 5:-5] - mu1_mu2
-
- ssim_map = ((2 * mu1_mu2 + C1) * (2 * sigma12 + C2)) / ((mu1_sq + mu2_sq + C1) * (sigma1_sq + sigma2_sq + C2))
- return ssim_map.mean()
-
-
-@METRIC_REGISTRY.register()
-def calculate_ssim(img1, img2, crop_border, input_order='HWC', test_y_channel=False):
- """Calculate SSIM (structural similarity).
-
- Ref:
- Image quality assessment: From error visibility to structural similarity
-
- The results are the same as that of the official released MATLAB code in
- https://ece.uwaterloo.ca/~z70wang/research/ssim/.
-
- For three-channel images, SSIM is calculated for each channel and then
- averaged.
-
- Args:
- img1 (ndarray): Images with range [0, 255].
- img2 (ndarray): Images with range [0, 255].
- crop_border (int): Cropped pixels in each edge of an image. These
- pixels are not involved in the SSIM calculation.
- input_order (str): Whether the input order is 'HWC' or 'CHW'.
- Default: 'HWC'.
- test_y_channel (bool): Test on Y channel of YCbCr. Default: False.
-
- Returns:
- float: ssim result.
- """
-
- assert img1.shape == img2.shape, (f'Image shapes are differnet: {img1.shape}, {img2.shape}.')
- if input_order not in ['HWC', 'CHW']:
- raise ValueError(f'Wrong input_order {input_order}. Supported input_orders are ' '"HWC" and "CHW"')
- img1 = reorder_image(img1, input_order=input_order)
- img2 = reorder_image(img2, input_order=input_order)
- img1 = img1.astype(np.float64)
- img2 = img2.astype(np.float64)
-
- if crop_border != 0:
- img1 = img1[crop_border:-crop_border, crop_border:-crop_border, ...]
- img2 = img2[crop_border:-crop_border, crop_border:-crop_border, ...]
-
- if test_y_channel:
- img1 = to_y_channel(img1)
- img2 = to_y_channel(img2)
-
- ssims = []
- for i in range(img1.shape[2]):
- ssims.append(_ssim(img1[..., i], img2[..., i]))
- return np.array(ssims).mean()
diff --git a/spaces/dawood17/SayBot_Enchancer/CodeFormer/facelib/detection/retinaface/retinaface_utils.py b/spaces/dawood17/SayBot_Enchancer/CodeFormer/facelib/detection/retinaface/retinaface_utils.py
deleted file mode 100644
index 8c357757741c6d9bd7ce4d8ce740fefd51850fbf..0000000000000000000000000000000000000000
--- a/spaces/dawood17/SayBot_Enchancer/CodeFormer/facelib/detection/retinaface/retinaface_utils.py
+++ /dev/null
@@ -1,421 +0,0 @@
-import numpy as np
-import torch
-import torchvision
-from itertools import product as product
-from math import ceil
-
-
-class PriorBox(object):
-
- def __init__(self, cfg, image_size=None, phase='train'):
- super(PriorBox, self).__init__()
- self.min_sizes = cfg['min_sizes']
- self.steps = cfg['steps']
- self.clip = cfg['clip']
- self.image_size = image_size
- self.feature_maps = [[ceil(self.image_size[0] / step), ceil(self.image_size[1] / step)] for step in self.steps]
- self.name = 's'
-
- def forward(self):
- anchors = []
- for k, f in enumerate(self.feature_maps):
- min_sizes = self.min_sizes[k]
- for i, j in product(range(f[0]), range(f[1])):
- for min_size in min_sizes:
- s_kx = min_size / self.image_size[1]
- s_ky = min_size / self.image_size[0]
- dense_cx = [x * self.steps[k] / self.image_size[1] for x in [j + 0.5]]
- dense_cy = [y * self.steps[k] / self.image_size[0] for y in [i + 0.5]]
- for cy, cx in product(dense_cy, dense_cx):
- anchors += [cx, cy, s_kx, s_ky]
-
- # back to torch land
- output = torch.Tensor(anchors).view(-1, 4)
- if self.clip:
- output.clamp_(max=1, min=0)
- return output
-
-
-def py_cpu_nms(dets, thresh):
- """Pure Python NMS baseline."""
- keep = torchvision.ops.nms(
- boxes=torch.Tensor(dets[:, :4]),
- scores=torch.Tensor(dets[:, 4]),
- iou_threshold=thresh,
- )
-
- return list(keep)
-
-
-def point_form(boxes):
- """ Convert prior_boxes to (xmin, ymin, xmax, ymax)
- representation for comparison to point form ground truth data.
- Args:
- boxes: (tensor) center-size default boxes from priorbox layers.
- Return:
- boxes: (tensor) Converted xmin, ymin, xmax, ymax form of boxes.
- """
- return torch.cat(
- (
- boxes[:, :2] - boxes[:, 2:] / 2, # xmin, ymin
- boxes[:, :2] + boxes[:, 2:] / 2),
- 1) # xmax, ymax
-
-
-def center_size(boxes):
- """ Convert prior_boxes to (cx, cy, w, h)
- representation for comparison to center-size form ground truth data.
- Args:
- boxes: (tensor) point_form boxes
- Return:
- boxes: (tensor) Converted xmin, ymin, xmax, ymax form of boxes.
- """
- return torch.cat(
- (boxes[:, 2:] + boxes[:, :2]) / 2, # cx, cy
- boxes[:, 2:] - boxes[:, :2],
- 1) # w, h
-
-
-def intersect(box_a, box_b):
- """ We resize both tensors to [A,B,2] without new malloc:
- [A,2] -> [A,1,2] -> [A,B,2]
- [B,2] -> [1,B,2] -> [A,B,2]
- Then we compute the area of intersect between box_a and box_b.
- Args:
- box_a: (tensor) bounding boxes, Shape: [A,4].
- box_b: (tensor) bounding boxes, Shape: [B,4].
- Return:
- (tensor) intersection area, Shape: [A,B].
- """
- A = box_a.size(0)
- B = box_b.size(0)
- max_xy = torch.min(box_a[:, 2:].unsqueeze(1).expand(A, B, 2), box_b[:, 2:].unsqueeze(0).expand(A, B, 2))
- min_xy = torch.max(box_a[:, :2].unsqueeze(1).expand(A, B, 2), box_b[:, :2].unsqueeze(0).expand(A, B, 2))
- inter = torch.clamp((max_xy - min_xy), min=0)
- return inter[:, :, 0] * inter[:, :, 1]
-
-
-def jaccard(box_a, box_b):
- """Compute the jaccard overlap of two sets of boxes. The jaccard overlap
- is simply the intersection over union of two boxes. Here we operate on
- ground truth boxes and default boxes.
- E.g.:
- A ∩ B / A ∪ B = A ∩ B / (area(A) + area(B) - A ∩ B)
- Args:
- box_a: (tensor) Ground truth bounding boxes, Shape: [num_objects,4]
- box_b: (tensor) Prior boxes from priorbox layers, Shape: [num_priors,4]
- Return:
- jaccard overlap: (tensor) Shape: [box_a.size(0), box_b.size(0)]
- """
- inter = intersect(box_a, box_b)
- area_a = ((box_a[:, 2] - box_a[:, 0]) * (box_a[:, 3] - box_a[:, 1])).unsqueeze(1).expand_as(inter) # [A,B]
- area_b = ((box_b[:, 2] - box_b[:, 0]) * (box_b[:, 3] - box_b[:, 1])).unsqueeze(0).expand_as(inter) # [A,B]
- union = area_a + area_b - inter
- return inter / union # [A,B]
-
-
-def matrix_iou(a, b):
- """
- return iou of a and b, numpy version for data augenmentation
- """
- lt = np.maximum(a[:, np.newaxis, :2], b[:, :2])
- rb = np.minimum(a[:, np.newaxis, 2:], b[:, 2:])
-
- area_i = np.prod(rb - lt, axis=2) * (lt < rb).all(axis=2)
- area_a = np.prod(a[:, 2:] - a[:, :2], axis=1)
- area_b = np.prod(b[:, 2:] - b[:, :2], axis=1)
- return area_i / (area_a[:, np.newaxis] + area_b - area_i)
-
-
-def matrix_iof(a, b):
- """
- return iof of a and b, numpy version for data augenmentation
- """
- lt = np.maximum(a[:, np.newaxis, :2], b[:, :2])
- rb = np.minimum(a[:, np.newaxis, 2:], b[:, 2:])
-
- area_i = np.prod(rb - lt, axis=2) * (lt < rb).all(axis=2)
- area_a = np.prod(a[:, 2:] - a[:, :2], axis=1)
- return area_i / np.maximum(area_a[:, np.newaxis], 1)
-
-
-def match(threshold, truths, priors, variances, labels, landms, loc_t, conf_t, landm_t, idx):
- """Match each prior box with the ground truth box of the highest jaccard
- overlap, encode the bounding boxes, then return the matched indices
- corresponding to both confidence and location preds.
- Args:
- threshold: (float) The overlap threshold used when matching boxes.
- truths: (tensor) Ground truth boxes, Shape: [num_obj, 4].
- priors: (tensor) Prior boxes from priorbox layers, Shape: [n_priors,4].
- variances: (tensor) Variances corresponding to each prior coord,
- Shape: [num_priors, 4].
- labels: (tensor) All the class labels for the image, Shape: [num_obj].
- landms: (tensor) Ground truth landms, Shape [num_obj, 10].
- loc_t: (tensor) Tensor to be filled w/ encoded location targets.
- conf_t: (tensor) Tensor to be filled w/ matched indices for conf preds.
- landm_t: (tensor) Tensor to be filled w/ encoded landm targets.
- idx: (int) current batch index
- Return:
- The matched indices corresponding to 1)location 2)confidence
- 3)landm preds.
- """
- # jaccard index
- overlaps = jaccard(truths, point_form(priors))
- # (Bipartite Matching)
- # [1,num_objects] best prior for each ground truth
- best_prior_overlap, best_prior_idx = overlaps.max(1, keepdim=True)
-
- # ignore hard gt
- valid_gt_idx = best_prior_overlap[:, 0] >= 0.2
- best_prior_idx_filter = best_prior_idx[valid_gt_idx, :]
- if best_prior_idx_filter.shape[0] <= 0:
- loc_t[idx] = 0
- conf_t[idx] = 0
- return
-
- # [1,num_priors] best ground truth for each prior
- best_truth_overlap, best_truth_idx = overlaps.max(0, keepdim=True)
- best_truth_idx.squeeze_(0)
- best_truth_overlap.squeeze_(0)
- best_prior_idx.squeeze_(1)
- best_prior_idx_filter.squeeze_(1)
- best_prior_overlap.squeeze_(1)
- best_truth_overlap.index_fill_(0, best_prior_idx_filter, 2) # ensure best prior
- # TODO refactor: index best_prior_idx with long tensor
- # ensure every gt matches with its prior of max overlap
- for j in range(best_prior_idx.size(0)): # 判别此anchor是预测哪一个boxes
- best_truth_idx[best_prior_idx[j]] = j
- matches = truths[best_truth_idx] # Shape: [num_priors,4] 此处为每一个anchor对应的bbox取出来
- conf = labels[best_truth_idx] # Shape: [num_priors] 此处为每一个anchor对应的label取出来
- conf[best_truth_overlap < threshold] = 0 # label as background overlap<0.35的全部作为负样本
- loc = encode(matches, priors, variances)
-
- matches_landm = landms[best_truth_idx]
- landm = encode_landm(matches_landm, priors, variances)
- loc_t[idx] = loc # [num_priors,4] encoded offsets to learn
- conf_t[idx] = conf # [num_priors] top class label for each prior
- landm_t[idx] = landm
-
-
-def encode(matched, priors, variances):
- """Encode the variances from the priorbox layers into the ground truth boxes
- we have matched (based on jaccard overlap) with the prior boxes.
- Args:
- matched: (tensor) Coords of ground truth for each prior in point-form
- Shape: [num_priors, 4].
- priors: (tensor) Prior boxes in center-offset form
- Shape: [num_priors,4].
- variances: (list[float]) Variances of priorboxes
- Return:
- encoded boxes (tensor), Shape: [num_priors, 4]
- """
-
- # dist b/t match center and prior's center
- g_cxcy = (matched[:, :2] + matched[:, 2:]) / 2 - priors[:, :2]
- # encode variance
- g_cxcy /= (variances[0] * priors[:, 2:])
- # match wh / prior wh
- g_wh = (matched[:, 2:] - matched[:, :2]) / priors[:, 2:]
- g_wh = torch.log(g_wh) / variances[1]
- # return target for smooth_l1_loss
- return torch.cat([g_cxcy, g_wh], 1) # [num_priors,4]
-
-
-def encode_landm(matched, priors, variances):
- """Encode the variances from the priorbox layers into the ground truth boxes
- we have matched (based on jaccard overlap) with the prior boxes.
- Args:
- matched: (tensor) Coords of ground truth for each prior in point-form
- Shape: [num_priors, 10].
- priors: (tensor) Prior boxes in center-offset form
- Shape: [num_priors,4].
- variances: (list[float]) Variances of priorboxes
- Return:
- encoded landm (tensor), Shape: [num_priors, 10]
- """
-
- # dist b/t match center and prior's center
- matched = torch.reshape(matched, (matched.size(0), 5, 2))
- priors_cx = priors[:, 0].unsqueeze(1).expand(matched.size(0), 5).unsqueeze(2)
- priors_cy = priors[:, 1].unsqueeze(1).expand(matched.size(0), 5).unsqueeze(2)
- priors_w = priors[:, 2].unsqueeze(1).expand(matched.size(0), 5).unsqueeze(2)
- priors_h = priors[:, 3].unsqueeze(1).expand(matched.size(0), 5).unsqueeze(2)
- priors = torch.cat([priors_cx, priors_cy, priors_w, priors_h], dim=2)
- g_cxcy = matched[:, :, :2] - priors[:, :, :2]
- # encode variance
- g_cxcy /= (variances[0] * priors[:, :, 2:])
- # g_cxcy /= priors[:, :, 2:]
- g_cxcy = g_cxcy.reshape(g_cxcy.size(0), -1)
- # return target for smooth_l1_loss
- return g_cxcy
-
-
-# Adapted from https://github.com/Hakuyume/chainer-ssd
-def decode(loc, priors, variances):
- """Decode locations from predictions using priors to undo
- the encoding we did for offset regression at train time.
- Args:
- loc (tensor): location predictions for loc layers,
- Shape: [num_priors,4]
- priors (tensor): Prior boxes in center-offset form.
- Shape: [num_priors,4].
- variances: (list[float]) Variances of priorboxes
- Return:
- decoded bounding box predictions
- """
-
- boxes = torch.cat((priors[:, :2] + loc[:, :2] * variances[0] * priors[:, 2:],
- priors[:, 2:] * torch.exp(loc[:, 2:] * variances[1])), 1)
- boxes[:, :2] -= boxes[:, 2:] / 2
- boxes[:, 2:] += boxes[:, :2]
- return boxes
-
-
-def decode_landm(pre, priors, variances):
- """Decode landm from predictions using priors to undo
- the encoding we did for offset regression at train time.
- Args:
- pre (tensor): landm predictions for loc layers,
- Shape: [num_priors,10]
- priors (tensor): Prior boxes in center-offset form.
- Shape: [num_priors,4].
- variances: (list[float]) Variances of priorboxes
- Return:
- decoded landm predictions
- """
- tmp = (
- priors[:, :2] + pre[:, :2] * variances[0] * priors[:, 2:],
- priors[:, :2] + pre[:, 2:4] * variances[0] * priors[:, 2:],
- priors[:, :2] + pre[:, 4:6] * variances[0] * priors[:, 2:],
- priors[:, :2] + pre[:, 6:8] * variances[0] * priors[:, 2:],
- priors[:, :2] + pre[:, 8:10] * variances[0] * priors[:, 2:],
- )
- landms = torch.cat(tmp, dim=1)
- return landms
-
-
-def batched_decode(b_loc, priors, variances):
- """Decode locations from predictions using priors to undo
- the encoding we did for offset regression at train time.
- Args:
- b_loc (tensor): location predictions for loc layers,
- Shape: [num_batches,num_priors,4]
- priors (tensor): Prior boxes in center-offset form.
- Shape: [1,num_priors,4].
- variances: (list[float]) Variances of priorboxes
- Return:
- decoded bounding box predictions
- """
- boxes = (
- priors[:, :, :2] + b_loc[:, :, :2] * variances[0] * priors[:, :, 2:],
- priors[:, :, 2:] * torch.exp(b_loc[:, :, 2:] * variances[1]),
- )
- boxes = torch.cat(boxes, dim=2)
-
- boxes[:, :, :2] -= boxes[:, :, 2:] / 2
- boxes[:, :, 2:] += boxes[:, :, :2]
- return boxes
-
-
-def batched_decode_landm(pre, priors, variances):
- """Decode landm from predictions using priors to undo
- the encoding we did for offset regression at train time.
- Args:
- pre (tensor): landm predictions for loc layers,
- Shape: [num_batches,num_priors,10]
- priors (tensor): Prior boxes in center-offset form.
- Shape: [1,num_priors,4].
- variances: (list[float]) Variances of priorboxes
- Return:
- decoded landm predictions
- """
- landms = (
- priors[:, :, :2] + pre[:, :, :2] * variances[0] * priors[:, :, 2:],
- priors[:, :, :2] + pre[:, :, 2:4] * variances[0] * priors[:, :, 2:],
- priors[:, :, :2] + pre[:, :, 4:6] * variances[0] * priors[:, :, 2:],
- priors[:, :, :2] + pre[:, :, 6:8] * variances[0] * priors[:, :, 2:],
- priors[:, :, :2] + pre[:, :, 8:10] * variances[0] * priors[:, :, 2:],
- )
- landms = torch.cat(landms, dim=2)
- return landms
-
-
-def log_sum_exp(x):
- """Utility function for computing log_sum_exp while determining
- This will be used to determine unaveraged confidence loss across
- all examples in a batch.
- Args:
- x (Variable(tensor)): conf_preds from conf layers
- """
- x_max = x.data.max()
- return torch.log(torch.sum(torch.exp(x - x_max), 1, keepdim=True)) + x_max
-
-
-# Original author: Francisco Massa:
-# https://github.com/fmassa/object-detection.torch
-# Ported to PyTorch by Max deGroot (02/01/2017)
-def nms(boxes, scores, overlap=0.5, top_k=200):
- """Apply non-maximum suppression at test time to avoid detecting too many
- overlapping bounding boxes for a given object.
- Args:
- boxes: (tensor) The location preds for the img, Shape: [num_priors,4].
- scores: (tensor) The class predscores for the img, Shape:[num_priors].
- overlap: (float) The overlap thresh for suppressing unnecessary boxes.
- top_k: (int) The Maximum number of box preds to consider.
- Return:
- The indices of the kept boxes with respect to num_priors.
- """
-
- keep = torch.Tensor(scores.size(0)).fill_(0).long()
- if boxes.numel() == 0:
- return keep
- x1 = boxes[:, 0]
- y1 = boxes[:, 1]
- x2 = boxes[:, 2]
- y2 = boxes[:, 3]
- area = torch.mul(x2 - x1, y2 - y1)
- v, idx = scores.sort(0) # sort in ascending order
- # I = I[v >= 0.01]
- idx = idx[-top_k:] # indices of the top-k largest vals
- xx1 = boxes.new()
- yy1 = boxes.new()
- xx2 = boxes.new()
- yy2 = boxes.new()
- w = boxes.new()
- h = boxes.new()
-
- # keep = torch.Tensor()
- count = 0
- while idx.numel() > 0:
- i = idx[-1] # index of current largest val
- # keep.append(i)
- keep[count] = i
- count += 1
- if idx.size(0) == 1:
- break
- idx = idx[:-1] # remove kept element from view
- # load bboxes of next highest vals
- torch.index_select(x1, 0, idx, out=xx1)
- torch.index_select(y1, 0, idx, out=yy1)
- torch.index_select(x2, 0, idx, out=xx2)
- torch.index_select(y2, 0, idx, out=yy2)
- # store element-wise max with next highest score
- xx1 = torch.clamp(xx1, min=x1[i])
- yy1 = torch.clamp(yy1, min=y1[i])
- xx2 = torch.clamp(xx2, max=x2[i])
- yy2 = torch.clamp(yy2, max=y2[i])
- w.resize_as_(xx2)
- h.resize_as_(yy2)
- w = xx2 - xx1
- h = yy2 - yy1
- # check sizes of xx1 and xx2.. after each iteration
- w = torch.clamp(w, min=0.0)
- h = torch.clamp(h, min=0.0)
- inter = w * h
- # IoU = i / (area(a) + area(b) - i)
- rem_areas = torch.index_select(area, 0, idx) # load remaining areas)
- union = (rem_areas - inter) + area[i]
- IoU = inter / union # store result in iou
- # keep only elements with an IoU <= overlap
- idx = idx[IoU.le(overlap)]
- return keep, count
diff --git a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/click/_termui_impl.py b/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/click/_termui_impl.py
deleted file mode 100644
index f744657753caa6cdef1dcc41a4f0b5e3e9503ab8..0000000000000000000000000000000000000000
--- a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/click/_termui_impl.py
+++ /dev/null
@@ -1,739 +0,0 @@
-"""
-This module contains implementations for the termui module. To keep the
-import time of Click down, some infrequently used functionality is
-placed in this module and only imported as needed.
-"""
-import contextlib
-import math
-import os
-import sys
-import time
-import typing as t
-from gettext import gettext as _
-from io import StringIO
-from types import TracebackType
-
-from ._compat import _default_text_stdout
-from ._compat import CYGWIN
-from ._compat import get_best_encoding
-from ._compat import isatty
-from ._compat import open_stream
-from ._compat import strip_ansi
-from ._compat import term_len
-from ._compat import WIN
-from .exceptions import ClickException
-from .utils import echo
-
-V = t.TypeVar("V")
-
-if os.name == "nt":
- BEFORE_BAR = "\r"
- AFTER_BAR = "\n"
-else:
- BEFORE_BAR = "\r\033[?25l"
- AFTER_BAR = "\033[?25h\n"
-
-
-class ProgressBar(t.Generic[V]):
- def __init__(
- self,
- iterable: t.Optional[t.Iterable[V]],
- length: t.Optional[int] = None,
- fill_char: str = "#",
- empty_char: str = " ",
- bar_template: str = "%(bar)s",
- info_sep: str = " ",
- show_eta: bool = True,
- show_percent: t.Optional[bool] = None,
- show_pos: bool = False,
- item_show_func: t.Optional[t.Callable[[t.Optional[V]], t.Optional[str]]] = None,
- label: t.Optional[str] = None,
- file: t.Optional[t.TextIO] = None,
- color: t.Optional[bool] = None,
- update_min_steps: int = 1,
- width: int = 30,
- ) -> None:
- self.fill_char = fill_char
- self.empty_char = empty_char
- self.bar_template = bar_template
- self.info_sep = info_sep
- self.show_eta = show_eta
- self.show_percent = show_percent
- self.show_pos = show_pos
- self.item_show_func = item_show_func
- self.label: str = label or ""
-
- if file is None:
- file = _default_text_stdout()
-
- # There are no standard streams attached to write to. For example,
- # pythonw on Windows.
- if file is None:
- file = StringIO()
-
- self.file = file
- self.color = color
- self.update_min_steps = update_min_steps
- self._completed_intervals = 0
- self.width: int = width
- self.autowidth: bool = width == 0
-
- if length is None:
- from operator import length_hint
-
- length = length_hint(iterable, -1)
-
- if length == -1:
- length = None
- if iterable is None:
- if length is None:
- raise TypeError("iterable or length is required")
- iterable = t.cast(t.Iterable[V], range(length))
- self.iter: t.Iterable[V] = iter(iterable)
- self.length = length
- self.pos = 0
- self.avg: t.List[float] = []
- self.last_eta: float
- self.start: float
- self.start = self.last_eta = time.time()
- self.eta_known: bool = False
- self.finished: bool = False
- self.max_width: t.Optional[int] = None
- self.entered: bool = False
- self.current_item: t.Optional[V] = None
- self.is_hidden: bool = not isatty(self.file)
- self._last_line: t.Optional[str] = None
-
- def __enter__(self) -> "ProgressBar[V]":
- self.entered = True
- self.render_progress()
- return self
-
- def __exit__(
- self,
- exc_type: t.Optional[t.Type[BaseException]],
- exc_value: t.Optional[BaseException],
- tb: t.Optional[TracebackType],
- ) -> None:
- self.render_finish()
-
- def __iter__(self) -> t.Iterator[V]:
- if not self.entered:
- raise RuntimeError("You need to use progress bars in a with block.")
- self.render_progress()
- return self.generator()
-
- def __next__(self) -> V:
- # Iteration is defined in terms of a generator function,
- # returned by iter(self); use that to define next(). This works
- # because `self.iter` is an iterable consumed by that generator,
- # so it is re-entry safe. Calling `next(self.generator())`
- # twice works and does "what you want".
- return next(iter(self))
-
- def render_finish(self) -> None:
- if self.is_hidden:
- return
- self.file.write(AFTER_BAR)
- self.file.flush()
-
- @property
- def pct(self) -> float:
- if self.finished:
- return 1.0
- return min(self.pos / (float(self.length or 1) or 1), 1.0)
-
- @property
- def time_per_iteration(self) -> float:
- if not self.avg:
- return 0.0
- return sum(self.avg) / float(len(self.avg))
-
- @property
- def eta(self) -> float:
- if self.length is not None and not self.finished:
- return self.time_per_iteration * (self.length - self.pos)
- return 0.0
-
- def format_eta(self) -> str:
- if self.eta_known:
- t = int(self.eta)
- seconds = t % 60
- t //= 60
- minutes = t % 60
- t //= 60
- hours = t % 24
- t //= 24
- if t > 0:
- return f"{t}d {hours:02}:{minutes:02}:{seconds:02}"
- else:
- return f"{hours:02}:{minutes:02}:{seconds:02}"
- return ""
-
- def format_pos(self) -> str:
- pos = str(self.pos)
- if self.length is not None:
- pos += f"/{self.length}"
- return pos
-
- def format_pct(self) -> str:
- return f"{int(self.pct * 100): 4}%"[1:]
-
- def format_bar(self) -> str:
- if self.length is not None:
- bar_length = int(self.pct * self.width)
- bar = self.fill_char * bar_length
- bar += self.empty_char * (self.width - bar_length)
- elif self.finished:
- bar = self.fill_char * self.width
- else:
- chars = list(self.empty_char * (self.width or 1))
- if self.time_per_iteration != 0:
- chars[
- int(
- (math.cos(self.pos * self.time_per_iteration) / 2.0 + 0.5)
- * self.width
- )
- ] = self.fill_char
- bar = "".join(chars)
- return bar
-
- def format_progress_line(self) -> str:
- show_percent = self.show_percent
-
- info_bits = []
- if self.length is not None and show_percent is None:
- show_percent = not self.show_pos
-
- if self.show_pos:
- info_bits.append(self.format_pos())
- if show_percent:
- info_bits.append(self.format_pct())
- if self.show_eta and self.eta_known and not self.finished:
- info_bits.append(self.format_eta())
- if self.item_show_func is not None:
- item_info = self.item_show_func(self.current_item)
- if item_info is not None:
- info_bits.append(item_info)
-
- return (
- self.bar_template
- % {
- "label": self.label,
- "bar": self.format_bar(),
- "info": self.info_sep.join(info_bits),
- }
- ).rstrip()
-
- def render_progress(self) -> None:
- import shutil
-
- if self.is_hidden:
- # Only output the label as it changes if the output is not a
- # TTY. Use file=stderr if you expect to be piping stdout.
- if self._last_line != self.label:
- self._last_line = self.label
- echo(self.label, file=self.file, color=self.color)
-
- return
-
- buf = []
- # Update width in case the terminal has been resized
- if self.autowidth:
- old_width = self.width
- self.width = 0
- clutter_length = term_len(self.format_progress_line())
- new_width = max(0, shutil.get_terminal_size().columns - clutter_length)
- if new_width < old_width:
- buf.append(BEFORE_BAR)
- buf.append(" " * self.max_width) # type: ignore
- self.max_width = new_width
- self.width = new_width
-
- clear_width = self.width
- if self.max_width is not None:
- clear_width = self.max_width
-
- buf.append(BEFORE_BAR)
- line = self.format_progress_line()
- line_len = term_len(line)
- if self.max_width is None or self.max_width < line_len:
- self.max_width = line_len
-
- buf.append(line)
- buf.append(" " * (clear_width - line_len))
- line = "".join(buf)
- # Render the line only if it changed.
-
- if line != self._last_line:
- self._last_line = line
- echo(line, file=self.file, color=self.color, nl=False)
- self.file.flush()
-
- def make_step(self, n_steps: int) -> None:
- self.pos += n_steps
- if self.length is not None and self.pos >= self.length:
- self.finished = True
-
- if (time.time() - self.last_eta) < 1.0:
- return
-
- self.last_eta = time.time()
-
- # self.avg is a rolling list of length <= 7 of steps where steps are
- # defined as time elapsed divided by the total progress through
- # self.length.
- if self.pos:
- step = (time.time() - self.start) / self.pos
- else:
- step = time.time() - self.start
-
- self.avg = self.avg[-6:] + [step]
-
- self.eta_known = self.length is not None
-
- def update(self, n_steps: int, current_item: t.Optional[V] = None) -> None:
- """Update the progress bar by advancing a specified number of
- steps, and optionally set the ``current_item`` for this new
- position.
-
- :param n_steps: Number of steps to advance.
- :param current_item: Optional item to set as ``current_item``
- for the updated position.
-
- .. versionchanged:: 8.0
- Added the ``current_item`` optional parameter.
-
- .. versionchanged:: 8.0
- Only render when the number of steps meets the
- ``update_min_steps`` threshold.
- """
- if current_item is not None:
- self.current_item = current_item
-
- self._completed_intervals += n_steps
-
- if self._completed_intervals >= self.update_min_steps:
- self.make_step(self._completed_intervals)
- self.render_progress()
- self._completed_intervals = 0
-
- def finish(self) -> None:
- self.eta_known = False
- self.current_item = None
- self.finished = True
-
- def generator(self) -> t.Iterator[V]:
- """Return a generator which yields the items added to the bar
- during construction, and updates the progress bar *after* the
- yielded block returns.
- """
- # WARNING: the iterator interface for `ProgressBar` relies on
- # this and only works because this is a simple generator which
- # doesn't create or manage additional state. If this function
- # changes, the impact should be evaluated both against
- # `iter(bar)` and `next(bar)`. `next()` in particular may call
- # `self.generator()` repeatedly, and this must remain safe in
- # order for that interface to work.
- if not self.entered:
- raise RuntimeError("You need to use progress bars in a with block.")
-
- if self.is_hidden:
- yield from self.iter
- else:
- for rv in self.iter:
- self.current_item = rv
-
- # This allows show_item_func to be updated before the
- # item is processed. Only trigger at the beginning of
- # the update interval.
- if self._completed_intervals == 0:
- self.render_progress()
-
- yield rv
- self.update(1)
-
- self.finish()
- self.render_progress()
-
-
-def pager(generator: t.Iterable[str], color: t.Optional[bool] = None) -> None:
- """Decide what method to use for paging through text."""
- stdout = _default_text_stdout()
-
- # There are no standard streams attached to write to. For example,
- # pythonw on Windows.
- if stdout is None:
- stdout = StringIO()
-
- if not isatty(sys.stdin) or not isatty(stdout):
- return _nullpager(stdout, generator, color)
- pager_cmd = (os.environ.get("PAGER", None) or "").strip()
- if pager_cmd:
- if WIN:
- return _tempfilepager(generator, pager_cmd, color)
- return _pipepager(generator, pager_cmd, color)
- if os.environ.get("TERM") in ("dumb", "emacs"):
- return _nullpager(stdout, generator, color)
- if WIN or sys.platform.startswith("os2"):
- return _tempfilepager(generator, "more <", color)
- if hasattr(os, "system") and os.system("(less) 2>/dev/null") == 0:
- return _pipepager(generator, "less", color)
-
- import tempfile
-
- fd, filename = tempfile.mkstemp()
- os.close(fd)
- try:
- if hasattr(os, "system") and os.system(f'more "{filename}"') == 0:
- return _pipepager(generator, "more", color)
- return _nullpager(stdout, generator, color)
- finally:
- os.unlink(filename)
-
-
-def _pipepager(generator: t.Iterable[str], cmd: str, color: t.Optional[bool]) -> None:
- """Page through text by feeding it to another program. Invoking a
- pager through this might support colors.
- """
- import subprocess
-
- env = dict(os.environ)
-
- # If we're piping to less we might support colors under the
- # condition that
- cmd_detail = cmd.rsplit("/", 1)[-1].split()
- if color is None and cmd_detail[0] == "less":
- less_flags = f"{os.environ.get('LESS', '')}{' '.join(cmd_detail[1:])}"
- if not less_flags:
- env["LESS"] = "-R"
- color = True
- elif "r" in less_flags or "R" in less_flags:
- color = True
-
- c = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE, env=env)
- stdin = t.cast(t.BinaryIO, c.stdin)
- encoding = get_best_encoding(stdin)
- try:
- for text in generator:
- if not color:
- text = strip_ansi(text)
-
- stdin.write(text.encode(encoding, "replace"))
- except (OSError, KeyboardInterrupt):
- pass
- else:
- stdin.close()
-
- # Less doesn't respect ^C, but catches it for its own UI purposes (aborting
- # search or other commands inside less).
- #
- # That means when the user hits ^C, the parent process (click) terminates,
- # but less is still alive, paging the output and messing up the terminal.
- #
- # If the user wants to make the pager exit on ^C, they should set
- # `LESS='-K'`. It's not our decision to make.
- while True:
- try:
- c.wait()
- except KeyboardInterrupt:
- pass
- else:
- break
-
-
-def _tempfilepager(
- generator: t.Iterable[str], cmd: str, color: t.Optional[bool]
-) -> None:
- """Page through text by invoking a program on a temporary file."""
- import tempfile
-
- fd, filename = tempfile.mkstemp()
- # TODO: This never terminates if the passed generator never terminates.
- text = "".join(generator)
- if not color:
- text = strip_ansi(text)
- encoding = get_best_encoding(sys.stdout)
- with open_stream(filename, "wb")[0] as f:
- f.write(text.encode(encoding))
- try:
- os.system(f'{cmd} "{filename}"')
- finally:
- os.close(fd)
- os.unlink(filename)
-
-
-def _nullpager(
- stream: t.TextIO, generator: t.Iterable[str], color: t.Optional[bool]
-) -> None:
- """Simply print unformatted text. This is the ultimate fallback."""
- for text in generator:
- if not color:
- text = strip_ansi(text)
- stream.write(text)
-
-
-class Editor:
- def __init__(
- self,
- editor: t.Optional[str] = None,
- env: t.Optional[t.Mapping[str, str]] = None,
- require_save: bool = True,
- extension: str = ".txt",
- ) -> None:
- self.editor = editor
- self.env = env
- self.require_save = require_save
- self.extension = extension
-
- def get_editor(self) -> str:
- if self.editor is not None:
- return self.editor
- for key in "VISUAL", "EDITOR":
- rv = os.environ.get(key)
- if rv:
- return rv
- if WIN:
- return "notepad"
- for editor in "sensible-editor", "vim", "nano":
- if os.system(f"which {editor} >/dev/null 2>&1") == 0:
- return editor
- return "vi"
-
- def edit_file(self, filename: str) -> None:
- import subprocess
-
- editor = self.get_editor()
- environ: t.Optional[t.Dict[str, str]] = None
-
- if self.env:
- environ = os.environ.copy()
- environ.update(self.env)
-
- try:
- c = subprocess.Popen(f'{editor} "{filename}"', env=environ, shell=True)
- exit_code = c.wait()
- if exit_code != 0:
- raise ClickException(
- _("{editor}: Editing failed").format(editor=editor)
- )
- except OSError as e:
- raise ClickException(
- _("{editor}: Editing failed: {e}").format(editor=editor, e=e)
- ) from e
-
- def edit(self, text: t.Optional[t.AnyStr]) -> t.Optional[t.AnyStr]:
- import tempfile
-
- if not text:
- data = b""
- elif isinstance(text, (bytes, bytearray)):
- data = text
- else:
- if text and not text.endswith("\n"):
- text += "\n"
-
- if WIN:
- data = text.replace("\n", "\r\n").encode("utf-8-sig")
- else:
- data = text.encode("utf-8")
-
- fd, name = tempfile.mkstemp(prefix="editor-", suffix=self.extension)
- f: t.BinaryIO
-
- try:
- with os.fdopen(fd, "wb") as f:
- f.write(data)
-
- # If the filesystem resolution is 1 second, like Mac OS
- # 10.12 Extended, or 2 seconds, like FAT32, and the editor
- # closes very fast, require_save can fail. Set the modified
- # time to be 2 seconds in the past to work around this.
- os.utime(name, (os.path.getatime(name), os.path.getmtime(name) - 2))
- # Depending on the resolution, the exact value might not be
- # recorded, so get the new recorded value.
- timestamp = os.path.getmtime(name)
-
- self.edit_file(name)
-
- if self.require_save and os.path.getmtime(name) == timestamp:
- return None
-
- with open(name, "rb") as f:
- rv = f.read()
-
- if isinstance(text, (bytes, bytearray)):
- return rv
-
- return rv.decode("utf-8-sig").replace("\r\n", "\n") # type: ignore
- finally:
- os.unlink(name)
-
-
-def open_url(url: str, wait: bool = False, locate: bool = False) -> int:
- import subprocess
-
- def _unquote_file(url: str) -> str:
- from urllib.parse import unquote
-
- if url.startswith("file://"):
- url = unquote(url[7:])
-
- return url
-
- if sys.platform == "darwin":
- args = ["open"]
- if wait:
- args.append("-W")
- if locate:
- args.append("-R")
- args.append(_unquote_file(url))
- null = open("/dev/null", "w")
- try:
- return subprocess.Popen(args, stderr=null).wait()
- finally:
- null.close()
- elif WIN:
- if locate:
- url = _unquote_file(url.replace('"', ""))
- args = f'explorer /select,"{url}"'
- else:
- url = url.replace('"', "")
- wait_str = "/WAIT" if wait else ""
- args = f'start {wait_str} "" "{url}"'
- return os.system(args)
- elif CYGWIN:
- if locate:
- url = os.path.dirname(_unquote_file(url).replace('"', ""))
- args = f'cygstart "{url}"'
- else:
- url = url.replace('"', "")
- wait_str = "-w" if wait else ""
- args = f'cygstart {wait_str} "{url}"'
- return os.system(args)
-
- try:
- if locate:
- url = os.path.dirname(_unquote_file(url)) or "."
- else:
- url = _unquote_file(url)
- c = subprocess.Popen(["xdg-open", url])
- if wait:
- return c.wait()
- return 0
- except OSError:
- if url.startswith(("http://", "https://")) and not locate and not wait:
- import webbrowser
-
- webbrowser.open(url)
- return 0
- return 1
-
-
-def _translate_ch_to_exc(ch: str) -> t.Optional[BaseException]:
- if ch == "\x03":
- raise KeyboardInterrupt()
-
- if ch == "\x04" and not WIN: # Unix-like, Ctrl+D
- raise EOFError()
-
- if ch == "\x1a" and WIN: # Windows, Ctrl+Z
- raise EOFError()
-
- return None
-
-
-if WIN:
- import msvcrt
-
- @contextlib.contextmanager
- def raw_terminal() -> t.Iterator[int]:
- yield -1
-
- def getchar(echo: bool) -> str:
- # The function `getch` will return a bytes object corresponding to
- # the pressed character. Since Windows 10 build 1803, it will also
- # return \x00 when called a second time after pressing a regular key.
- #
- # `getwch` does not share this probably-bugged behavior. Moreover, it
- # returns a Unicode object by default, which is what we want.
- #
- # Either of these functions will return \x00 or \xe0 to indicate
- # a special key, and you need to call the same function again to get
- # the "rest" of the code. The fun part is that \u00e0 is
- # "latin small letter a with grave", so if you type that on a French
- # keyboard, you _also_ get a \xe0.
- # E.g., consider the Up arrow. This returns \xe0 and then \x48. The
- # resulting Unicode string reads as "a with grave" + "capital H".
- # This is indistinguishable from when the user actually types
- # "a with grave" and then "capital H".
- #
- # When \xe0 is returned, we assume it's part of a special-key sequence
- # and call `getwch` again, but that means that when the user types
- # the \u00e0 character, `getchar` doesn't return until a second
- # character is typed.
- # The alternative is returning immediately, but that would mess up
- # cross-platform handling of arrow keys and others that start with
- # \xe0. Another option is using `getch`, but then we can't reliably
- # read non-ASCII characters, because return values of `getch` are
- # limited to the current 8-bit codepage.
- #
- # Anyway, Click doesn't claim to do this Right(tm), and using `getwch`
- # is doing the right thing in more situations than with `getch`.
- func: t.Callable[[], str]
-
- if echo:
- func = msvcrt.getwche # type: ignore
- else:
- func = msvcrt.getwch # type: ignore
-
- rv = func()
-
- if rv in ("\x00", "\xe0"):
- # \x00 and \xe0 are control characters that indicate special key,
- # see above.
- rv += func()
-
- _translate_ch_to_exc(rv)
- return rv
-
-else:
- import tty
- import termios
-
- @contextlib.contextmanager
- def raw_terminal() -> t.Iterator[int]:
- f: t.Optional[t.TextIO]
- fd: int
-
- if not isatty(sys.stdin):
- f = open("/dev/tty")
- fd = f.fileno()
- else:
- fd = sys.stdin.fileno()
- f = None
-
- try:
- old_settings = termios.tcgetattr(fd)
-
- try:
- tty.setraw(fd)
- yield fd
- finally:
- termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
- sys.stdout.flush()
-
- if f is not None:
- f.close()
- except termios.error:
- pass
-
- def getchar(echo: bool) -> str:
- with raw_terminal() as fd:
- ch = os.read(fd, 32).decode(get_best_encoding(sys.stdin), "replace")
-
- if echo and isatty(sys.stdout):
- sys.stdout.write(ch)
-
- _translate_ch_to_exc(ch)
- return ch
diff --git a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/h11/_connection.py b/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/h11/_connection.py
deleted file mode 100644
index d1752707598154d190d69b2c26f3098b74656652..0000000000000000000000000000000000000000
--- a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/h11/_connection.py
+++ /dev/null
@@ -1,633 +0,0 @@
-# This contains the main Connection class. Everything in h11 revolves around
-# this.
-from typing import Any, Callable, cast, Dict, List, Optional, Tuple, Type, Union
-
-from ._events import (
- ConnectionClosed,
- Data,
- EndOfMessage,
- Event,
- InformationalResponse,
- Request,
- Response,
-)
-from ._headers import get_comma_header, has_expect_100_continue, set_comma_header
-from ._readers import READERS, ReadersType
-from ._receivebuffer import ReceiveBuffer
-from ._state import (
- _SWITCH_CONNECT,
- _SWITCH_UPGRADE,
- CLIENT,
- ConnectionState,
- DONE,
- ERROR,
- MIGHT_SWITCH_PROTOCOL,
- SEND_BODY,
- SERVER,
- SWITCHED_PROTOCOL,
-)
-from ._util import ( # Import the internal things we need
- LocalProtocolError,
- RemoteProtocolError,
- Sentinel,
-)
-from ._writers import WRITERS, WritersType
-
-# Everything in __all__ gets re-exported as part of the h11 public API.
-__all__ = ["Connection", "NEED_DATA", "PAUSED"]
-
-
-class NEED_DATA(Sentinel, metaclass=Sentinel):
- pass
-
-
-class PAUSED(Sentinel, metaclass=Sentinel):
- pass
-
-
-# If we ever have this much buffered without it making a complete parseable
-# event, we error out. The only time we really buffer is when reading the
-# request/response line + headers together, so this is effectively the limit on
-# the size of that.
-#
-# Some precedents for defaults:
-# - node.js: 80 * 1024
-# - tomcat: 8 * 1024
-# - IIS: 16 * 1024
-# - Apache: <8 KiB per line>
-DEFAULT_MAX_INCOMPLETE_EVENT_SIZE = 16 * 1024
-
-# RFC 7230's rules for connection lifecycles:
-# - If either side says they want to close the connection, then the connection
-# must close.
-# - HTTP/1.1 defaults to keep-alive unless someone says Connection: close
-# - HTTP/1.0 defaults to close unless both sides say Connection: keep-alive
-# (and even this is a mess -- e.g. if you're implementing a proxy then
-# sending Connection: keep-alive is forbidden).
-#
-# We simplify life by simply not supporting keep-alive with HTTP/1.0 peers. So
-# our rule is:
-# - If someone says Connection: close, we will close
-# - If someone uses HTTP/1.0, we will close.
-def _keep_alive(event: Union[Request, Response]) -> bool:
- connection = get_comma_header(event.headers, b"connection")
- if b"close" in connection:
- return False
- if getattr(event, "http_version", b"1.1") < b"1.1":
- return False
- return True
-
-
-def _body_framing(
- request_method: bytes, event: Union[Request, Response]
-) -> Tuple[str, Union[Tuple[()], Tuple[int]]]:
- # Called when we enter SEND_BODY to figure out framing information for
- # this body.
- #
- # These are the only two events that can trigger a SEND_BODY state:
- assert type(event) in (Request, Response)
- # Returns one of:
- #
- # ("content-length", count)
- # ("chunked", ())
- # ("http/1.0", ())
- #
- # which are (lookup key, *args) for constructing body reader/writer
- # objects.
- #
- # Reference: https://tools.ietf.org/html/rfc7230#section-3.3.3
- #
- # Step 1: some responses always have an empty body, regardless of what the
- # headers say.
- if type(event) is Response:
- if (
- event.status_code in (204, 304)
- or request_method == b"HEAD"
- or (request_method == b"CONNECT" and 200 <= event.status_code < 300)
- ):
- return ("content-length", (0,))
- # Section 3.3.3 also lists another case -- responses with status_code
- # < 200. For us these are InformationalResponses, not Responses, so
- # they can't get into this function in the first place.
- assert event.status_code >= 200
-
- # Step 2: check for Transfer-Encoding (T-E beats C-L):
- transfer_encodings = get_comma_header(event.headers, b"transfer-encoding")
- if transfer_encodings:
- assert transfer_encodings == [b"chunked"]
- return ("chunked", ())
-
- # Step 3: check for Content-Length
- content_lengths = get_comma_header(event.headers, b"content-length")
- if content_lengths:
- return ("content-length", (int(content_lengths[0]),))
-
- # Step 4: no applicable headers; fallback/default depends on type
- if type(event) is Request:
- return ("content-length", (0,))
- else:
- return ("http/1.0", ())
-
-
-################################################################
-#
-# The main Connection class
-#
-################################################################
-
-
-class Connection:
- """An object encapsulating the state of an HTTP connection.
-
- Args:
- our_role: If you're implementing a client, pass :data:`h11.CLIENT`. If
- you're implementing a server, pass :data:`h11.SERVER`.
-
- max_incomplete_event_size (int):
- The maximum number of bytes we're willing to buffer of an
- incomplete event. In practice this mostly sets a limit on the
- maximum size of the request/response line + headers. If this is
- exceeded, then :meth:`next_event` will raise
- :exc:`RemoteProtocolError`.
-
- """
-
- def __init__(
- self,
- our_role: Type[Sentinel],
- max_incomplete_event_size: int = DEFAULT_MAX_INCOMPLETE_EVENT_SIZE,
- ) -> None:
- self._max_incomplete_event_size = max_incomplete_event_size
- # State and role tracking
- if our_role not in (CLIENT, SERVER):
- raise ValueError("expected CLIENT or SERVER, not {!r}".format(our_role))
- self.our_role = our_role
- self.their_role: Type[Sentinel]
- if our_role is CLIENT:
- self.their_role = SERVER
- else:
- self.their_role = CLIENT
- self._cstate = ConnectionState()
-
- # Callables for converting data->events or vice-versa given the
- # current state
- self._writer = self._get_io_object(self.our_role, None, WRITERS)
- self._reader = self._get_io_object(self.their_role, None, READERS)
-
- # Holds any unprocessed received data
- self._receive_buffer = ReceiveBuffer()
- # If this is true, then it indicates that the incoming connection was
- # closed *after* the end of whatever's in self._receive_buffer:
- self._receive_buffer_closed = False
-
- # Extra bits of state that don't fit into the state machine.
- #
- # These two are only used to interpret framing headers for figuring
- # out how to read/write response bodies. their_http_version is also
- # made available as a convenient public API.
- self.their_http_version: Optional[bytes] = None
- self._request_method: Optional[bytes] = None
- # This is pure flow-control and doesn't at all affect the set of legal
- # transitions, so no need to bother ConnectionState with it:
- self.client_is_waiting_for_100_continue = False
-
- @property
- def states(self) -> Dict[Type[Sentinel], Type[Sentinel]]:
- """A dictionary like::
-
- {CLIENT: , SERVER: }
-
- See :ref:`state-machine` for details.
-
- """
- return dict(self._cstate.states)
-
- @property
- def our_state(self) -> Type[Sentinel]:
- """The current state of whichever role we are playing. See
- :ref:`state-machine` for details.
- """
- return self._cstate.states[self.our_role]
-
- @property
- def their_state(self) -> Type[Sentinel]:
- """The current state of whichever role we are NOT playing. See
- :ref:`state-machine` for details.
- """
- return self._cstate.states[self.their_role]
-
- @property
- def they_are_waiting_for_100_continue(self) -> bool:
- return self.their_role is CLIENT and self.client_is_waiting_for_100_continue
-
- def start_next_cycle(self) -> None:
- """Attempt to reset our connection state for a new request/response
- cycle.
-
- If both client and server are in :data:`DONE` state, then resets them
- both to :data:`IDLE` state in preparation for a new request/response
- cycle on this same connection. Otherwise, raises a
- :exc:`LocalProtocolError`.
-
- See :ref:`keepalive-and-pipelining`.
-
- """
- old_states = dict(self._cstate.states)
- self._cstate.start_next_cycle()
- self._request_method = None
- # self.their_http_version gets left alone, since it presumably lasts
- # beyond a single request/response cycle
- assert not self.client_is_waiting_for_100_continue
- self._respond_to_state_changes(old_states)
-
- def _process_error(self, role: Type[Sentinel]) -> None:
- old_states = dict(self._cstate.states)
- self._cstate.process_error(role)
- self._respond_to_state_changes(old_states)
-
- def _server_switch_event(self, event: Event) -> Optional[Type[Sentinel]]:
- if type(event) is InformationalResponse and event.status_code == 101:
- return _SWITCH_UPGRADE
- if type(event) is Response:
- if (
- _SWITCH_CONNECT in self._cstate.pending_switch_proposals
- and 200 <= event.status_code < 300
- ):
- return _SWITCH_CONNECT
- return None
-
- # All events go through here
- def _process_event(self, role: Type[Sentinel], event: Event) -> None:
- # First, pass the event through the state machine to make sure it
- # succeeds.
- old_states = dict(self._cstate.states)
- if role is CLIENT and type(event) is Request:
- if event.method == b"CONNECT":
- self._cstate.process_client_switch_proposal(_SWITCH_CONNECT)
- if get_comma_header(event.headers, b"upgrade"):
- self._cstate.process_client_switch_proposal(_SWITCH_UPGRADE)
- server_switch_event = None
- if role is SERVER:
- server_switch_event = self._server_switch_event(event)
- self._cstate.process_event(role, type(event), server_switch_event)
-
- # Then perform the updates triggered by it.
-
- if type(event) is Request:
- self._request_method = event.method
-
- if role is self.their_role and type(event) in (
- Request,
- Response,
- InformationalResponse,
- ):
- event = cast(Union[Request, Response, InformationalResponse], event)
- self.their_http_version = event.http_version
-
- # Keep alive handling
- #
- # RFC 7230 doesn't really say what one should do if Connection: close
- # shows up on a 1xx InformationalResponse. I think the idea is that
- # this is not supposed to happen. In any case, if it does happen, we
- # ignore it.
- if type(event) in (Request, Response) and not _keep_alive(
- cast(Union[Request, Response], event)
- ):
- self._cstate.process_keep_alive_disabled()
-
- # 100-continue
- if type(event) is Request and has_expect_100_continue(event):
- self.client_is_waiting_for_100_continue = True
- if type(event) in (InformationalResponse, Response):
- self.client_is_waiting_for_100_continue = False
- if role is CLIENT and type(event) in (Data, EndOfMessage):
- self.client_is_waiting_for_100_continue = False
-
- self._respond_to_state_changes(old_states, event)
-
- def _get_io_object(
- self,
- role: Type[Sentinel],
- event: Optional[Event],
- io_dict: Union[ReadersType, WritersType],
- ) -> Optional[Callable[..., Any]]:
- # event may be None; it's only used when entering SEND_BODY
- state = self._cstate.states[role]
- if state is SEND_BODY:
- # Special case: the io_dict has a dict of reader/writer factories
- # that depend on the request/response framing.
- framing_type, args = _body_framing(
- cast(bytes, self._request_method), cast(Union[Request, Response], event)
- )
- return io_dict[SEND_BODY][framing_type](*args) # type: ignore[index]
- else:
- # General case: the io_dict just has the appropriate reader/writer
- # for this state
- return io_dict.get((role, state)) # type: ignore[return-value]
-
- # This must be called after any action that might have caused
- # self._cstate.states to change.
- def _respond_to_state_changes(
- self,
- old_states: Dict[Type[Sentinel], Type[Sentinel]],
- event: Optional[Event] = None,
- ) -> None:
- # Update reader/writer
- if self.our_state != old_states[self.our_role]:
- self._writer = self._get_io_object(self.our_role, event, WRITERS)
- if self.their_state != old_states[self.their_role]:
- self._reader = self._get_io_object(self.their_role, event, READERS)
-
- @property
- def trailing_data(self) -> Tuple[bytes, bool]:
- """Data that has been received, but not yet processed, represented as
- a tuple with two elements, where the first is a byte-string containing
- the unprocessed data itself, and the second is a bool that is True if
- the receive connection was closed.
-
- See :ref:`switching-protocols` for discussion of why you'd want this.
- """
- return (bytes(self._receive_buffer), self._receive_buffer_closed)
-
- def receive_data(self, data: bytes) -> None:
- """Add data to our internal receive buffer.
-
- This does not actually do any processing on the data, just stores
- it. To trigger processing, you have to call :meth:`next_event`.
-
- Args:
- data (:term:`bytes-like object`):
- The new data that was just received.
-
- Special case: If *data* is an empty byte-string like ``b""``,
- then this indicates that the remote side has closed the
- connection (end of file). Normally this is convenient, because
- standard Python APIs like :meth:`file.read` or
- :meth:`socket.recv` use ``b""`` to indicate end-of-file, while
- other failures to read are indicated using other mechanisms
- like raising :exc:`TimeoutError`. When using such an API you
- can just blindly pass through whatever you get from ``read``
- to :meth:`receive_data`, and everything will work.
-
- But, if you have an API where reading an empty string is a
- valid non-EOF condition, then you need to be aware of this and
- make sure to check for such strings and avoid passing them to
- :meth:`receive_data`.
-
- Returns:
- Nothing, but after calling this you should call :meth:`next_event`
- to parse the newly received data.
-
- Raises:
- RuntimeError:
- Raised if you pass an empty *data*, indicating EOF, and then
- pass a non-empty *data*, indicating more data that somehow
- arrived after the EOF.
-
- (Calling ``receive_data(b"")`` multiple times is fine,
- and equivalent to calling it once.)
-
- """
- if data:
- if self._receive_buffer_closed:
- raise RuntimeError("received close, then received more data?")
- self._receive_buffer += data
- else:
- self._receive_buffer_closed = True
-
- def _extract_next_receive_event(
- self,
- ) -> Union[Event, Type[NEED_DATA], Type[PAUSED]]:
- state = self.their_state
- # We don't pause immediately when they enter DONE, because even in
- # DONE state we can still process a ConnectionClosed() event. But
- # if we have data in our buffer, then we definitely aren't getting
- # a ConnectionClosed() immediately and we need to pause.
- if state is DONE and self._receive_buffer:
- return PAUSED
- if state is MIGHT_SWITCH_PROTOCOL or state is SWITCHED_PROTOCOL:
- return PAUSED
- assert self._reader is not None
- event = self._reader(self._receive_buffer)
- if event is None:
- if not self._receive_buffer and self._receive_buffer_closed:
- # In some unusual cases (basically just HTTP/1.0 bodies), EOF
- # triggers an actual protocol event; in that case, we want to
- # return that event, and then the state will change and we'll
- # get called again to generate the actual ConnectionClosed().
- if hasattr(self._reader, "read_eof"):
- event = self._reader.read_eof() # type: ignore[attr-defined]
- else:
- event = ConnectionClosed()
- if event is None:
- event = NEED_DATA
- return event # type: ignore[no-any-return]
-
- def next_event(self) -> Union[Event, Type[NEED_DATA], Type[PAUSED]]:
- """Parse the next event out of our receive buffer, update our internal
- state, and return it.
-
- This is a mutating operation -- think of it like calling :func:`next`
- on an iterator.
-
- Returns:
- : One of three things:
-
- 1) An event object -- see :ref:`events`.
-
- 2) The special constant :data:`NEED_DATA`, which indicates that
- you need to read more data from your socket and pass it to
- :meth:`receive_data` before this method will be able to return
- any more events.
-
- 3) The special constant :data:`PAUSED`, which indicates that we
- are not in a state where we can process incoming data (usually
- because the peer has finished their part of the current
- request/response cycle, and you have not yet called
- :meth:`start_next_cycle`). See :ref:`flow-control` for details.
-
- Raises:
- RemoteProtocolError:
- The peer has misbehaved. You should close the connection
- (possibly after sending some kind of 4xx response).
-
- Once this method returns :class:`ConnectionClosed` once, then all
- subsequent calls will also return :class:`ConnectionClosed`.
-
- If this method raises any exception besides :exc:`RemoteProtocolError`
- then that's a bug -- if it happens please file a bug report!
-
- If this method raises any exception then it also sets
- :attr:`Connection.their_state` to :data:`ERROR` -- see
- :ref:`error-handling` for discussion.
-
- """
-
- if self.their_state is ERROR:
- raise RemoteProtocolError("Can't receive data when peer state is ERROR")
- try:
- event = self._extract_next_receive_event()
- if event not in [NEED_DATA, PAUSED]:
- self._process_event(self.their_role, cast(Event, event))
- if event is NEED_DATA:
- if len(self._receive_buffer) > self._max_incomplete_event_size:
- # 431 is "Request header fields too large" which is pretty
- # much the only situation where we can get here
- raise RemoteProtocolError(
- "Receive buffer too long", error_status_hint=431
- )
- if self._receive_buffer_closed:
- # We're still trying to complete some event, but that's
- # never going to happen because no more data is coming
- raise RemoteProtocolError("peer unexpectedly closed connection")
- return event
- except BaseException as exc:
- self._process_error(self.their_role)
- if isinstance(exc, LocalProtocolError):
- exc._reraise_as_remote_protocol_error()
- else:
- raise
-
- def send(self, event: Event) -> Optional[bytes]:
- """Convert a high-level event into bytes that can be sent to the peer,
- while updating our internal state machine.
-
- Args:
- event: The :ref:`event ` to send.
-
- Returns:
- If ``type(event) is ConnectionClosed``, then returns
- ``None``. Otherwise, returns a :term:`bytes-like object`.
-
- Raises:
- LocalProtocolError:
- Sending this event at this time would violate our
- understanding of the HTTP/1.1 protocol.
-
- If this method raises any exception then it also sets
- :attr:`Connection.our_state` to :data:`ERROR` -- see
- :ref:`error-handling` for discussion.
-
- """
- data_list = self.send_with_data_passthrough(event)
- if data_list is None:
- return None
- else:
- return b"".join(data_list)
-
- def send_with_data_passthrough(self, event: Event) -> Optional[List[bytes]]:
- """Identical to :meth:`send`, except that in situations where
- :meth:`send` returns a single :term:`bytes-like object`, this instead
- returns a list of them -- and when sending a :class:`Data` event, this
- list is guaranteed to contain the exact object you passed in as
- :attr:`Data.data`. See :ref:`sendfile` for discussion.
-
- """
- if self.our_state is ERROR:
- raise LocalProtocolError("Can't send data when our state is ERROR")
- try:
- if type(event) is Response:
- event = self._clean_up_response_headers_for_sending(event)
- # We want to call _process_event before calling the writer,
- # because if someone tries to do something invalid then this will
- # give a sensible error message, while our writers all just assume
- # they will only receive valid events. But, _process_event might
- # change self._writer. So we have to do a little dance:
- writer = self._writer
- self._process_event(self.our_role, event)
- if type(event) is ConnectionClosed:
- return None
- else:
- # In any situation where writer is None, process_event should
- # have raised ProtocolError
- assert writer is not None
- data_list: List[bytes] = []
- writer(event, data_list.append)
- return data_list
- except:
- self._process_error(self.our_role)
- raise
-
- def send_failed(self) -> None:
- """Notify the state machine that we failed to send the data it gave
- us.
-
- This causes :attr:`Connection.our_state` to immediately become
- :data:`ERROR` -- see :ref:`error-handling` for discussion.
-
- """
- self._process_error(self.our_role)
-
- # When sending a Response, we take responsibility for a few things:
- #
- # - Sometimes you MUST set Connection: close. We take care of those
- # times. (You can also set it yourself if you want, and if you do then
- # we'll respect that and close the connection at the right time. But you
- # don't have to worry about that unless you want to.)
- #
- # - The user has to set Content-Length if they want it. Otherwise, for
- # responses that have bodies (e.g. not HEAD), then we will automatically
- # select the right mechanism for streaming a body of unknown length,
- # which depends on depending on the peer's HTTP version.
- #
- # This function's *only* responsibility is making sure headers are set up
- # right -- everything downstream just looks at the headers. There are no
- # side channels.
- def _clean_up_response_headers_for_sending(self, response: Response) -> Response:
- assert type(response) is Response
-
- headers = response.headers
- need_close = False
-
- # HEAD requests need some special handling: they always act like they
- # have Content-Length: 0, and that's how _body_framing treats
- # them. But their headers are supposed to match what we would send if
- # the request was a GET. (Technically there is one deviation allowed:
- # we're allowed to leave out the framing headers -- see
- # https://tools.ietf.org/html/rfc7231#section-4.3.2 . But it's just as
- # easy to get them right.)
- method_for_choosing_headers = cast(bytes, self._request_method)
- if method_for_choosing_headers == b"HEAD":
- method_for_choosing_headers = b"GET"
- framing_type, _ = _body_framing(method_for_choosing_headers, response)
- if framing_type in ("chunked", "http/1.0"):
- # This response has a body of unknown length.
- # If our peer is HTTP/1.1, we use Transfer-Encoding: chunked
- # If our peer is HTTP/1.0, we use no framing headers, and close the
- # connection afterwards.
- #
- # Make sure to clear Content-Length (in principle user could have
- # set both and then we ignored Content-Length b/c
- # Transfer-Encoding overwrote it -- this would be naughty of them,
- # but the HTTP spec says that if our peer does this then we have
- # to fix it instead of erroring out, so we'll accord the user the
- # same respect).
- headers = set_comma_header(headers, b"content-length", [])
- if self.their_http_version is None or self.their_http_version < b"1.1":
- # Either we never got a valid request and are sending back an
- # error (their_http_version is None), so we assume the worst;
- # or else we did get a valid HTTP/1.0 request, so we know that
- # they don't understand chunked encoding.
- headers = set_comma_header(headers, b"transfer-encoding", [])
- # This is actually redundant ATM, since currently we
- # unconditionally disable keep-alive when talking to HTTP/1.0
- # peers. But let's be defensive just in case we add
- # Connection: keep-alive support later:
- if self._request_method != b"HEAD":
- need_close = True
- else:
- headers = set_comma_header(headers, b"transfer-encoding", [b"chunked"])
-
- if not self._cstate.keep_alive or need_close:
- # Make sure Connection: close is set
- connection = set(get_comma_header(headers, b"connection"))
- connection.discard(b"keep-alive")
- connection.add(b"close")
- headers = set_comma_header(headers, b"connection", sorted(connection))
-
- return Response(
- headers=headers,
- status_code=response.status_code,
- http_version=response.http_version,
- reason=response.reason,
- )
diff --git a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/jsonschema/benchmarks/json_schema_test_suite.py b/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/jsonschema/benchmarks/json_schema_test_suite.py
deleted file mode 100644
index 905fb6a3b88faf56e3288f7eb5053172f97abe8b..0000000000000000000000000000000000000000
--- a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/jsonschema/benchmarks/json_schema_test_suite.py
+++ /dev/null
@@ -1,12 +0,0 @@
-"""
-A performance benchmark using the official test suite.
-
-This benchmarks jsonschema using every valid example in the
-JSON-Schema-Test-Suite. It will take some time to complete.
-"""
-from pyperf import Runner
-
-from jsonschema.tests._suite import Suite
-
-if __name__ == "__main__":
- Suite().benchmark(runner=Runner())
diff --git a/spaces/deepwisdom/MetaGPT/tests/metagpt/actions/test_write_code.py b/spaces/deepwisdom/MetaGPT/tests/metagpt/actions/test_write_code.py
deleted file mode 100644
index d53e3724344ffdd3a8f91b8a9f427ed8c83ffcc4..0000000000000000000000000000000000000000
--- a/spaces/deepwisdom/MetaGPT/tests/metagpt/actions/test_write_code.py
+++ /dev/null
@@ -1,40 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""
-@Time : 2023/5/11 17:45
-@Author : alexanderwu
-@File : test_write_code.py
-@Modified By: mashenquan, 2023-8-1, fix-bug: `filename` of `write_code.run()` is missing.
-@Modified By: mashenquan, 2023/8/20. Remove global configuration `CONFIG`, enable configuration support for business isolation.
-"""
-import pytest
-
-from metagpt.config import Config
-from metagpt.provider.openai_api import OpenAIGPTAPI as LLM, CostManager
-from metagpt.actions.write_code import WriteCode
-from metagpt.logs import logger
-from tests.metagpt.actions.mock import TASKS_2, WRITE_CODE_PROMPT_SAMPLE
-
-
-@pytest.mark.asyncio
-async def test_write_code():
- api_design = "设计一个名为'add'的函数，该函数接受两个整数作为输入，并返回它们的和。"
- conf = Config()
- cost_manager = CostManager(**conf.runtime_options)
- llm = LLM(options=conf.runtime_options, cost_manager=cost_manager)
- write_code = WriteCode(options=conf.runtime_options, name="write_code", llm=llm)
- code = await write_code.run(context=api_design, filename="test")
- logger.info(code)
-
- # 我们不能精确地预测生成的代码，但我们可以检查某些关键字
- assert 'def add' in code
- assert 'return' in code
-
-
-@pytest.mark.asyncio
-async def test_write_code_directly():
- prompt = WRITE_CODE_PROMPT_SAMPLE + '\n' + TASKS_2[0]
- options = Config().runtime_options
- llm = LLM(options=options, cost_manager=CostManager(**options))
- rsp = await llm.aask(prompt)
- logger.info(rsp)
diff --git a/spaces/deppfellow/steam-recsys/func.py b/spaces/deppfellow/steam-recsys/func.py
deleted file mode 100644
index 25a1436d74873e3b828910ae663b0cd3a5d6e917..0000000000000000000000000000000000000000
--- a/spaces/deppfellow/steam-recsys/func.py
+++ /dev/null
@@ -1,74 +0,0 @@
-import pandas as pd
-import streamlit as st
-import requests
-
-from io import BytesIO
-from PIL import Image
-
-data_titles = pd.read_pickle("data/dict_of_all_titles.pkl")
-data_ids = pd.read_pickle("data/dict_of_all_ids.pkl")
-
-def ids_to_titles(ids_list):
- return [data_ids[title] for title in ids_list]
-
-def titles_to_ids(titles_list):
- return [data_titles[id] for id in titles_list]
-
-def generate_app_gamebox(titles):
- """
- Placeholder
- """
-
- titles_id = titles_to_ids(titles)
-
- for id in titles_id:
- url = f"https://cdn.cloudflare.steamstatic.com/steam/apps/{id}/header.jpg"
- resp = requests.get(url)
-
- if resp.status_code == 200:
- container = st.container()
- img_col, pref_col = container.columns([3, 2])
-
- img_col.image(BytesIO(resp.content))
- pref_col.selectbox(
- "Your rating:",
- options=["Positive", "Negative"],
- key=id,
- )
-
- return titles_id
-
-def generate_res_gamebox(ids):
- """
- Placeholder
- """
-
- for id in ids:
- url_page = f"https://store.steampowered.com/app/{id}/"
- url_img = f"https://cdn.cloudflare.steamstatic.com/steam/apps/{id}/header.jpg"
- resp = requests.get(url_img)
-
- if resp.status_code == 200:
- with st.container():
- st.image(BytesIO(resp.content))
- # st.caption(data_ids[id])
- st.caption(f"[{data_ids[id]}]({url_page})")
-
-
- st.divider()
-
-def combine_hybrid_result(res_ease, res_cbf):
- try:
- df = pd.concat([res_ease, res_cbf], axis=0)
-
- res_final = df.groupby("app_id").sum().sort_values(["predicted_score"], ascending=False)
-
- return res_final.head(10).index.tolist()
-
- except:
- st.error("Recommendation failed. Please select with at least 2 games title.")
-
- # for title in titles_list:
- # # url = f"https://store.steampowered.com/app/"
- # with st.container():
-
diff --git a/spaces/descript/vampnet/vampnet/modules/__init__.py b/spaces/descript/vampnet/vampnet/modules/__init__.py
deleted file mode 100644
index 3f4c8c226e42d022c60b620e8f21ccaf4e6a57bd..0000000000000000000000000000000000000000
--- a/spaces/descript/vampnet/vampnet/modules/__init__.py
+++ /dev/null
@@ -1,6 +0,0 @@
-import audiotools
-
-audiotools.ml.BaseModel.INTERN += ["vampnet.modules.**"]
-audiotools.ml.BaseModel.EXTERN += ["einops", "flash_attn.flash_attention", "loralib"]
-
-from .transformer import VampNet
\ No newline at end of file
diff --git a/spaces/diacanFperku/AutoGPT/Norton Ghost 8.0 Corporate Edition Full Version.md b/spaces/diacanFperku/AutoGPT/Norton Ghost 8.0 Corporate Edition Full Version.md
deleted file mode 100644
index 62558f5e7c84e60900b54f82caa7ee2edafadcaa..0000000000000000000000000000000000000000
--- a/spaces/diacanFperku/AutoGPT/Norton Ghost 8.0 Corporate Edition Full Version.md
+++ /dev/null
@@ -1,8 +0,0 @@
-
-
-Full System Backup - Protect your computer with advanced backup and restore. Windows - DownloadLatest versionDownloadCurrent version. 64KDownloads. System Backup - Protect Windows from crashes and make your system more resilient. Back up your PC files and protect your system from crashes, errors and other problems with an advanced security tool.
-System backup is one of the most requested features of Windows.
-Windows 7 Backup is a program for backing up Windows 7 systems. Download Free Contact Cracking Software 8a78ff9644
-
-
-
diff --git a/spaces/diacanFperku/AutoGPT/Portable Front Designer 3 _HOT_.md b/spaces/diacanFperku/AutoGPT/Portable Front Designer 3 _HOT_.md
deleted file mode 100644
index f84e8715ddd27edf524289282f5f03df42b30f12..0000000000000000000000000000000000000000
--- a/spaces/diacanFperku/AutoGPT/Portable Front Designer 3 _HOT_.md
+++ /dev/null
@@ -1,6 +0,0 @@
-
-
-Our free, specialized software for designing front panels, enclosures, and milled parts. DOWNLOAD. Front Panel Designer 6.3.3. Linux. 1fdad05405
-
-
-
diff --git a/spaces/diagaiwei/ir_chinese_medqa/colbert/modeling/tokenization/doc_tokenization.py b/spaces/diagaiwei/ir_chinese_medqa/colbert/modeling/tokenization/doc_tokenization.py
deleted file mode 100644
index 43d56c2b1e2dfd0f7c78672f47b95f8522438c0e..0000000000000000000000000000000000000000
--- a/spaces/diagaiwei/ir_chinese_medqa/colbert/modeling/tokenization/doc_tokenization.py
+++ /dev/null
@@ -1,71 +0,0 @@
-import torch
-
-
-# from transformers import BertTokenizerFast
-
-from colbert.modeling.hf_colbert import HF_ColBERT
-from colbert.infra import ColBERTConfig
-from colbert.modeling.tokenization.utils import _split_into_batches, _sort_by_length
-
-
-class DocTokenizer():
- def __init__(self, config: ColBERTConfig):
- self.tok = HF_ColBERT.raw_tokenizer_from_pretrained(config.checkpoint)
-
- self.config = config
- self.doc_maxlen = config.doc_maxlen
-
- self.D_marker_token, self.D_marker_token_id = '[D]', self.tok.convert_tokens_to_ids('[unused1]')
- self.cls_token, self.cls_token_id = self.tok.cls_token, self.tok.cls_token_id
- self.sep_token, self.sep_token_id = self.tok.sep_token, self.tok.sep_token_id
-
-
-
- # assert self.D_marker_token_id == 2
-
- def tokenize(self, batch_text, add_special_tokens=False):
- assert type(batch_text) in [list, tuple], (type(batch_text))
-
- tokens = [self.tok.tokenize(x, add_special_tokens=False) for x in batch_text]
-
- if not add_special_tokens:
- return tokens
-
- prefix, suffix = [self.cls_token, self.D_marker_token], [self.sep_token]
- tokens = [prefix + lst + suffix for lst in tokens]
-
- return tokens
-
- def encode(self, batch_text, add_special_tokens=False):
- assert type(batch_text) in [list, tuple], (type(batch_text))
-
- ids = self.tok(batch_text, add_special_tokens=False)['input_ids']
-
- if not add_special_tokens:
- return ids
-
- prefix, suffix = [self.cls_token_id, self.D_marker_token_id], [self.sep_token_id]
- ids = [prefix + lst + suffix for lst in ids]
-
- return ids
-
- def tensorize(self, batch_text, bsize=None):
- assert type(batch_text) in [list, tuple], (type(batch_text))
-
- # add placehold for the [D] marker
- batch_text = ['. ' + x for x in batch_text]
-
- obj = self.tok(batch_text, padding='longest', truncation='longest_first',
- return_tensors='pt', max_length=self.doc_maxlen)
-
- ids, mask = obj['input_ids'], obj['attention_mask']
-
- # postprocess for the [D] marker
- ids[:, 1] = self.D_marker_token_id
-
- if bsize:
- ids, mask, reverse_indices = _sort_by_length(ids, mask, bsize)
- batches = _split_into_batches(ids, mask, bsize)
- return batches, reverse_indices
-
- return ids, mask
diff --git a/spaces/dineshreddy/WALT/mmdet/models/detectors/mask_scoring_rcnn.py b/spaces/dineshreddy/WALT/mmdet/models/detectors/mask_scoring_rcnn.py
deleted file mode 100644
index b6252b6e1d234a201725342a5780fade7e21957c..0000000000000000000000000000000000000000
--- a/spaces/dineshreddy/WALT/mmdet/models/detectors/mask_scoring_rcnn.py
+++ /dev/null
@@ -1,27 +0,0 @@
-from ..builder import DETECTORS
-from .two_stage import TwoStageDetector
-
-
-@DETECTORS.register_module()
-class MaskScoringRCNN(TwoStageDetector):
- """Mask Scoring RCNN.
-
- https://arxiv.org/abs/1903.00241
- """
-
- def __init__(self,
- backbone,
- rpn_head,
- roi_head,
- train_cfg,
- test_cfg,
- neck=None,
- pretrained=None):
- super(MaskScoringRCNN, self).__init__(
- backbone=backbone,
- neck=neck,
- rpn_head=rpn_head,
- roi_head=roi_head,
- train_cfg=train_cfg,
- test_cfg=test_cfg,
- pretrained=pretrained)
diff --git a/spaces/dinhminh20521597/OCR_DEMO/configs/textrecog/nrtr/README.md b/spaces/dinhminh20521597/OCR_DEMO/configs/textrecog/nrtr/README.md
deleted file mode 100644
index f64af8923d9b81493478fc458f93a19786abd0f7..0000000000000000000000000000000000000000
--- a/spaces/dinhminh20521597/OCR_DEMO/configs/textrecog/nrtr/README.md
+++ /dev/null
@@ -1,66 +0,0 @@
-# NRTR
-
-> [NRTR: A No-Recurrence Sequence-to-Sequence Model For Scene Text Recognition](https://arxiv.org/abs/1806.00926)
-
-
-
-## Abstract
-
-Scene text recognition has attracted a great many researches due to its importance to various applications. Existing methods mainly adopt recurrence or convolution based networks. Though have obtained good performance, these methods still suffer from two limitations: slow training speed due to the internal recurrence of RNNs, and high complexity due to stacked convolutional layers for long-term feature extraction. This paper, for the first time, proposes a no-recurrence sequence-to-sequence text recognizer, named NRTR, that dispenses with recurrences and convolutions entirely. NRTR follows the encoder-decoder paradigm, where the encoder uses stacked self-attention to extract image features, and the decoder applies stacked self-attention to recognize texts based on encoder output. NRTR relies solely on self-attention mechanism thus could be trained with more parallelization and less complexity. Considering scene image has large variation in text and background, we further design a modality-transform block to effectively transform 2D input images to 1D sequences, combined with the encoder to extract more discriminative features. NRTR achieves state-of-the-art or highly competitive performance on both regular and irregular benchmarks, while requires only a small fraction of training time compared to the best model from the literature (at least 8 times faster).
-
-
-
-
-
-## Dataset
-
-### Train Dataset
-
-| trainset | instance_num | repeat_num | source |
-| :-------: | :----------: | :--------: | :----: |
-| SynthText | 7266686 | 1 | synth |
-| Syn90k | 8919273 | 1 | synth |
-
-### Test Dataset
-
-| testset | instance_num | type |
-| :-----: | :----------: | :-------: |
-| IIIT5K | 3000 | regular |
-| SVT | 647 | regular |
-| IC13 | 1015 | regular |
-| IC15 | 2077 | irregular |
-| SVTP | 645 | irregular |
-| CT80 | 288 | irregular |
-
-## Results and Models
-
-| Methods | Backbone | | Regular Text | | | | Irregular Text | | download |
-| :-------------------------------------------------------------: | :----------: | :----: | :----------: | :--: | :-: | :--: | :------------: | :--: | :----------------------------------------------------------------------------: |
-| | | IIIT5K | SVT | IC13 | | IC15 | SVTP | CT80 | |
-| [NRTR](/configs/textrecog/nrtr/nrtr_r31_1by16_1by8_academic.py) | R31-1/16-1/8 | 94.7 | 87.3 | 94.3 | | 73.5 | 78.9 | 85.1 | [model](https://download.openmmlab.com/mmocr/textrecog/nrtr/nrtr_r31_1by16_1by8_academic_20211124-f60cebf4.pth) \| [log](https://download.openmmlab.com/mmocr/textrecog/nrtr/20211124_002420.log.json) |
-| [NRTR](/configs/textrecog/nrtr/nrtr_r31_1by8_1by4_academic.py) | R31-1/8-1/4 | 95.2 | 90.0 | 94.0 | | 74.1 | 79.4 | 88.2 | [model](https://download.openmmlab.com/mmocr/textrecog/nrtr/nrtr_r31_1by8_1by4_academic_20211123-e1fdb322.pth) \| [log](https://download.openmmlab.com/mmocr/textrecog/nrtr/20211123_232151.log.json) |
-
-```{note}
-
-- For backbone `R31-1/16-1/8`:
- - The output consists of 92 classes, including 26 lowercase letters, 26 uppercase letters, 28 symbols, 10 digital numbers, 1 unknown token and 1 end-of-sequence token.
- - The encoder-block number is 6.
- - `1/16-1/8` means the height of feature from backbone is 1/16 of input image, where 1/8 for width.
-- For backbone `R31-1/8-1/4`:
- - The output consists of 92 classes, including 26 lowercase letters, 26 uppercase letters, 28 symbols, 10 digital numbers, 1 unknown token and 1 end-of-sequence token.
- - The encoder-block number is 6.
- - `1/8-1/4` means the height of feature from backbone is 1/8 of input image, where 1/4 for width.
-```
-
-## Citation
-
-```bibtex
-@inproceedings{sheng2019nrtr,
- title={NRTR: A no-recurrence sequence-to-sequence model for scene text recognition},
- author={Sheng, Fenfen and Chen, Zhineng and Xu, Bo},
- booktitle={2019 International Conference on Document Analysis and Recognition (ICDAR)},
- pages={781--786},
- year={2019},
- organization={IEEE}
-}
-```
diff --git a/spaces/dinhminh20521597/OCR_DEMO/configs/textrecog/satrn/satrn_small.py b/spaces/dinhminh20521597/OCR_DEMO/configs/textrecog/satrn/satrn_small.py
deleted file mode 100644
index 96f86797f4700fd6ab9590fa983323f3e22d15c2..0000000000000000000000000000000000000000
--- a/spaces/dinhminh20521597/OCR_DEMO/configs/textrecog/satrn/satrn_small.py
+++ /dev/null
@@ -1,68 +0,0 @@
-_base_ = [
- '../../_base_/default_runtime.py',
- '../../_base_/recog_pipelines/satrn_pipeline.py',
- '../../_base_/recog_datasets/ST_MJ_train.py',
- '../../_base_/recog_datasets/academic_test.py'
-]
-
-train_list = {{_base_.train_list}}
-test_list = {{_base_.test_list}}
-
-train_pipeline = {{_base_.train_pipeline}}
-test_pipeline = {{_base_.test_pipeline}}
-
-label_convertor = dict(
- type='AttnConvertor', dict_type='DICT90', with_unknown=True)
-
-model = dict(
- type='SATRN',
- backbone=dict(type='ShallowCNN', input_channels=3, hidden_dim=256),
- encoder=dict(
- type='SatrnEncoder',
- n_layers=6,
- n_head=8,
- d_k=256 // 8,
- d_v=256 // 8,
- d_model=256,
- n_position=100,
- d_inner=256 * 4,
- dropout=0.1),
- decoder=dict(
- type='NRTRDecoder',
- n_layers=6,
- d_embedding=256,
- n_head=8,
- d_model=256,
- d_inner=256 * 4,
- d_k=256 // 8,
- d_v=256 // 8),
- loss=dict(type='TFLoss'),
- label_convertor=label_convertor,
- max_seq_len=25)
-
-# optimizer
-optimizer = dict(type='Adam', lr=3e-4)
-optimizer_config = dict(grad_clip=None)
-# learning policy
-lr_config = dict(policy='step', step=[3, 4])
-total_epochs = 6
-
-data = dict(
- samples_per_gpu=64,
- workers_per_gpu=4,
- val_dataloader=dict(samples_per_gpu=1),
- test_dataloader=dict(samples_per_gpu=1),
- train=dict(
- type='UniformConcatDataset',
- datasets=train_list,
- pipeline=train_pipeline),
- val=dict(
- type='UniformConcatDataset',
- datasets=test_list,
- pipeline=test_pipeline),
- test=dict(
- type='UniformConcatDataset',
- datasets=test_list,
- pipeline=test_pipeline))
-
-evaluation = dict(interval=1, metric='acc')
diff --git a/spaces/ecker/vall-e/README.md b/spaces/ecker/vall-e/README.md
deleted file mode 100644
index 07ed940699db09444df2fceb43483295c3fd78e5..0000000000000000000000000000000000000000
--- a/spaces/ecker/vall-e/README.md
+++ /dev/null
@@ -1,39 +0,0 @@
----
-title: VALL-E
-emoji: 🐻❄️
-colorFrom: green
-colorTo: purple
-sdk: gradio
-sdk_version: 3.41.2
-app_file: app.py
-pinned: false
-license: agpl-3.0
----
-
-Recommended settings for stable speech:
-* `NAR levels`: 7; less NAR levels reduces the quality of the final waveform (this may also be strictly because, when EnCodec is fed a sequence with less RVQ bin levels than what it was initialized with, it'll sound worse).
-* `Temperature (AR)`: [0.85, 1.1]; It's ***really*** tough to find a one-size-fits-all value.
-* `Temperature (NAR)`: [0.15, 0.85]; This is even harder to nail decent values. Too high and you'll hear artifacts from the NAR, too low and you might not have acoustic detail recreated.
-* `Dynamic Temperature`: checked; Dynamic temperature seems to definitely help resolve issues with a model that is not strongly trained. Pairable with every other sampling technique.
-* `Top P`: [0.85, 0.95] || 1; I feel this is cope.
-* `Top K`: [768, 1024] || 0; I also feel this is cope.
-* `Beam Width`: 0 || 16; beam searching helps find potential best candidates, but I'm not sure how well it helps in the realm of audio. Incompatible with mirostat.
-* `Repetition Penalty`: 1.35; this and the length decay miraculously are what helps stabilize output; I have my theories.
-* `Repetition Penalty Length Decay`: 0.2; this helps not severly dampen the model's output when applying rep. pen.
-* `Length Penalty`: 0; this only be messed with if you're consistently having either too short output, or too long output. The AR is trained decently enough to know when to emit a STOP token.
-* `Mirostat (Tau)`: [2.0, 8.0]; The "surprise value" when performing mirostat sampling, which seems to be much more favorable in comparison to typical top-k/top-p or beam search sampling. The "best" values are still unknown.
-* `Mirostat (Eta)`: [0.05, 0.3]; The "learning rate" (decay value?) applied each step for mirostat sampling.
-
-This Space:
-* houses experimental models and the necessary inferencing code for my [VALL-E](https://git.ecker.tech/mrq/vall-e) implementation. I hope to gain some critical feedback with the outputs.
-* utilizes a T4 with a narcoleptic 5-minute sleep timer, as I do not have another system to (easily) host this myself with a 6800XT (or two) while I'm training off my 4070Ti and 7900XTX.
-
-The model is:
-* utilizing an RetNet for faster training/inferencing with conforming dimensionality (1024 dim, 4096 ffn dim, 16 heads, 12 layers) targetting the full eight RVQ-bins (albeit the model was originally trained at two then four).
-* trained on ~12.5K hour dataset composed of LibriTTS-R, LibriLight (`small`+`medium`+`duplicated`), generously donated audiobooks, and vidya voice clip rips (including some Japanese kusoge gacha clips).
-* a "monolothic" approach to sharing the retention-based transformer weights between AR and NAR tasks for no immediately discernable penalties (besides retraining).
-* utilizing DeepSpeed to inference using its int8 quantized inferencing (allegedly), and Vocos for better output quality.
- - I do need to add a toggle between different dtypes to gauge any perceptable quality/throughput gains/losses.
-* currently still being trained, and any updates to it will be pushed back to this repo.
-
-I am also currently training an experimental model with double the layers (24 layers instead) to gauge its performance. Depending on how well it performs, I may pivot to that too, but for now, I'm starting to doubt the time investment in training it.
diff --git a/spaces/elaldana/shouldidrive/app.py b/spaces/elaldana/shouldidrive/app.py
deleted file mode 100644
index 0d7638516bce47aeb557c9b27d35264cc1ffec13..0000000000000000000000000000000000000000
--- a/spaces/elaldana/shouldidrive/app.py
+++ /dev/null
@@ -1,128 +0,0 @@
-## ----------------------------- ###
-### libraries ###
-### ----------------------------- ###
-import gradio as gr
-import pandas as pd
-import numpy as np
-import os
-import warnings
-from sklearn.model_selection import train_test_split
-from sklearn.linear_model import LogisticRegression
-from sklearn import metrics
-from reader import get_article
-
-warnings.filterwarnings("ignore")
-
-
-### ------------------------------ ###
-### data transformation ###
-### ------------------------------ ###
-# load dataset
-uncleaned_data = pd.read_csv('data.csv')
-
-# remove timestamp from dataset (always first column)
-if uncleaned_data.columns[0].lower() == 'timestamp':
- uncleaned_data = uncleaned_data.iloc[: , 1:]
-data = pd.DataFrame()
-
-# keep track of which columns are categorical and what
-# those columns' value mappings are
-# structure: {colname1: {...}, colname2: {...} }
-cat_value_dicts = {}
-final_colname = uncleaned_data.columns[len(uncleaned_data.columns) - 1]
-
-# for each column...
-for (colname, colval) in uncleaned_data.iteritems():
- # check if col is already a number; if so, add col directly
- # to new dataframe and skip to next column
- if isinstance(colval.values[0], (np.integer, float)):
- data[colname] = uncleaned_data[colname].copy()
- continue
-
- # structure: {0: "lilac", 1: "blue", ...}
- new_dict = {}
- key = 0 # first index per column
- transformed_col_vals = [] # new numeric datapoints
-
- # if not, for each item in that column...
- for item in colval.values:
-
- # if item is not in this col's dict...
- if item not in new_dict:
- new_dict[item] = key
- key += 1
-
- # then add numerical value to transformed dataframe
- transformed_col_vals.append(new_dict[item])
-
- # reverse dictionary only for final col (0, 1) => (vals)
- if colname == final_colname:
- new_dict = {value : key for (key, value) in new_dict.items()}
- cat_value_dicts[colname] = new_dict
- data[colname] = transformed_col_vals
-
-
-### -------------------------------- ###
-### model training ###
-### -------------------------------- ###
-# select features and predicton; automatically selects last column as prediction
-num_features = len(data.columns) - 1
-x = data.iloc[: , :num_features]
-y = data.iloc[: , num_features:]
-
-# split data into training and testing sets
-x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.25)
-
-# instantiate the model (using default parameters)
-model = LogisticRegression(multi_class='multinomial', penalty='none', solver='newton-cg')
-model.fit(x_train, y_train.values.ravel())
-y_pred = model.predict(x_test)
-
-
-### -------------------------------- ###
-### file reading ###
-### -------------------------------- ###
-# borrow file reading function from reader.py
-info = get_article()
-
-
-### ------------------------------- ###
-### interface creation ###
-### ------------------------------- ###
-# predictor for generic number of features
-def general_predictor(*args):
- features = []
-
- # transform categorical input
- for colname, arg in zip(data.columns, args):
- if (colname in cat_value_dicts):
- features.append(cat_value_dicts[colname][arg])
- else:
- features.append(arg)
-
- # predict single datapoint
- new_input = [features]
- result = model.predict(new_input)
- return cat_value_dicts[final_colname][result[0]]
-
-# add data labels to replace those lost via star-args
-inputls = []
-for colname in data.columns:
- # skip last column
- if colname == final_colname:
- continue
-
- # access categories dict if data is categorical
- # otherwise, just use a number input
- if colname in cat_value_dicts:
- radio_options = list(cat_value_dicts[colname].keys())
- inputls.append(gr.inputs.Radio(choices=radio_options, type="value", label=colname))
- else:
- # add numerical input
- inputls.append(gr.inputs.Number(label=colname))
-
-# generate gradio interface
-interface = gr.Interface(general_predictor, inputs=inputls, outputs="text", article=info['article'], css=info['css'], theme='huggingface', title=info['title'], allow_flagging=False, description=info['description'])
-
-# show the interface
-interface.launch(share=True)
\ No newline at end of file
diff --git a/spaces/elun15/image-regression/utils.py b/spaces/elun15/image-regression/utils.py
deleted file mode 100644
index 8426b174adfaabd953b01da0f84544448dc0177a..0000000000000000000000000000000000000000
--- a/spaces/elun15/image-regression/utils.py
+++ /dev/null
@@ -1,64 +0,0 @@
-from enum import Enum
-
-import torch
-import torch.distributed as dist
-
-
-class Summary(Enum):
- NONE = 0
- AVERAGE = 1
- SUM = 2
- COUNT = 3
-
-
-class AverageMeter(object):
- """Computes and stores the average and current value"""
-
- def __init__(self, name, fmt=":f", summary_type=Summary.AVERAGE):
- self.name = name
- self.fmt = fmt
- self.summary_type = summary_type
- self.reset()
-
- def reset(self):
- self.val = 0
- self.avg = 0
- self.sum = 0
- self.count = 0
-
- def update(self, val, n=1):
- self.val = val
- self.sum += val * n
- self.count += n
- self.avg = self.sum / self.count
-
- def all_reduce(self):
- if torch.cuda.is_available():
- device = torch.device("cuda")
- elif torch.backends.mps.is_available():
- device = torch.device("mps")
- else:
- device = torch.device("cpu")
- total = torch.tensor([self.sum, self.count], dtype=torch.float32, device=device)
- dist.all_reduce(total, dist.ReduceOp.SUM, async_op=False)
- self.sum, self.count = total.tolist()
- self.avg = self.sum / self.count
-
- def __str__(self):
- fmtstr = "{name} {val" + self.fmt + "} ({avg" + self.fmt + "})"
- return fmtstr.format(**self.__dict__)
-
- def summary(self):
- fmtstr = ""
- if self.summary_type is Summary.NONE:
- fmtstr = ""
- elif self.summary_type is Summary.AVERAGE:
- fmtstr = "{name} {avg:.3f}"
- elif self.summary_type is Summary.SUM:
- fmtstr = "{name} {sum:.3f}"
- elif self.summary_type is Summary.COUNT:
- fmtstr = "{name} {count:.3f}"
- else:
- raise ValueError("invalid summary type %r" % self.summary_type)
-
- return fmtstr.format(**self.__dict__)
diff --git a/spaces/erbanku/gpt-academic/crazy_functions/test_project/cpp/libJPG/jpgd.h b/spaces/erbanku/gpt-academic/crazy_functions/test_project/cpp/libJPG/jpgd.h
deleted file mode 100644
index a1c0cac61839a6f66a42c341f50d5e36faad9a93..0000000000000000000000000000000000000000
--- a/spaces/erbanku/gpt-academic/crazy_functions/test_project/cpp/libJPG/jpgd.h
+++ /dev/null
@@ -1,316 +0,0 @@
-// jpgd.h - C++ class for JPEG decompression.
-// Public domain, Rich Geldreich
-#ifndef JPEG_DECODER_H
-#define JPEG_DECODER_H
-
-#include
-#include
-#include
-
-namespace jpgd
-{
- typedef unsigned char uint8;
- typedef signed short int16;
- typedef unsigned short uint16;
- typedef unsigned int uint;
- typedef signed int int32;
-
- // Loads a JPEG image from a memory buffer or a file.
- // req_comps can be 1 (grayscale), 3 (RGB), or 4 (RGBA).
- // On return, width/height will be set to the image's dimensions, and actual_comps will be set to the either 1 (grayscale) or 3 (RGB).
- // Notes: For more control over where and how the source data is read, see the decompress_jpeg_image_from_stream() function below, or call the jpeg_decoder class directly.
- // Requesting a 8 or 32bpp image is currently a little faster than 24bpp because the jpeg_decoder class itself currently always unpacks to either 8 or 32bpp.
-// BEGIN EPIC MOD
-//unsigned char *decompress_jpeg_image_from_memory(const unsigned char *pSrc_data, int src_data_size, int *width, int *height, int *actual_comps, int req_comps);
- unsigned char *decompress_jpeg_image_from_memory(const unsigned char *pSrc_data, int src_data_size, int *width, int *height, int *actual_comps, int req_comps, int format);
-// END EPIC MOD
- unsigned char *decompress_jpeg_image_from_file(const char *pSrc_filename, int *width, int *height, int *actual_comps, int req_comps);
-
- // Success/failure error codes.
- enum jpgd_status
- {
- JPGD_SUCCESS = 0, JPGD_FAILED = -1, JPGD_DONE = 1,
- JPGD_BAD_DHT_COUNTS = -256, JPGD_BAD_DHT_INDEX, JPGD_BAD_DHT_MARKER, JPGD_BAD_DQT_MARKER, JPGD_BAD_DQT_TABLE,
- JPGD_BAD_PRECISION, JPGD_BAD_HEIGHT, JPGD_BAD_WIDTH, JPGD_TOO_MANY_COMPONENTS,
- JPGD_BAD_SOF_LENGTH, JPGD_BAD_VARIABLE_MARKER, JPGD_BAD_DRI_LENGTH, JPGD_BAD_SOS_LENGTH,
- JPGD_BAD_SOS_COMP_ID, JPGD_W_EXTRA_BYTES_BEFORE_MARKER, JPGD_NO_ARITHMITIC_SUPPORT, JPGD_UNEXPECTED_MARKER,
- JPGD_NOT_JPEG, JPGD_UNSUPPORTED_MARKER, JPGD_BAD_DQT_LENGTH, JPGD_TOO_MANY_BLOCKS,
- JPGD_UNDEFINED_QUANT_TABLE, JPGD_UNDEFINED_HUFF_TABLE, JPGD_NOT_SINGLE_SCAN, JPGD_UNSUPPORTED_COLORSPACE,
- JPGD_UNSUPPORTED_SAMP_FACTORS, JPGD_DECODE_ERROR, JPGD_BAD_RESTART_MARKER, JPGD_ASSERTION_ERROR,
- JPGD_BAD_SOS_SPECTRAL, JPGD_BAD_SOS_SUCCESSIVE, JPGD_STREAM_READ, JPGD_NOTENOUGHMEM
- };
-
- // Input stream interface.
- // Derive from this class to read input data from sources other than files or memory. Set m_eof_flag to true when no more data is available.
- // The decoder is rather greedy: it will keep on calling this method until its internal input buffer is full, or until the EOF flag is set.
- // It the input stream contains data after the JPEG stream's EOI (end of image) marker it will probably be pulled into the internal buffer.
- // Call the get_total_bytes_read() method to determine the actual size of the JPEG stream after successful decoding.
- class jpeg_decoder_stream
- {
- public:
- jpeg_decoder_stream() { }
- virtual ~jpeg_decoder_stream() { }
-
- // The read() method is called when the internal input buffer is empty.
- // Parameters:
- // pBuf - input buffer
- // max_bytes_to_read - maximum bytes that can be written to pBuf
- // pEOF_flag - set this to true if at end of stream (no more bytes remaining)
- // Returns -1 on error, otherwise return the number of bytes actually written to the buffer (which may be 0).
- // Notes: This method will be called in a loop until you set *pEOF_flag to true or the internal buffer is full.
- virtual int read(uint8 *pBuf, int max_bytes_to_read, bool *pEOF_flag) = 0;
- };
-
- // stdio FILE stream class.
- class jpeg_decoder_file_stream : public jpeg_decoder_stream
- {
- jpeg_decoder_file_stream(const jpeg_decoder_file_stream &);
- jpeg_decoder_file_stream &operator =(const jpeg_decoder_file_stream &);
-
- FILE *m_pFile;
- bool m_eof_flag, m_error_flag;
-
- public:
- jpeg_decoder_file_stream();
- virtual ~jpeg_decoder_file_stream();
-
- bool open(const char *Pfilename);
- void close();
-
- virtual int read(uint8 *pBuf, int max_bytes_to_read, bool *pEOF_flag);
- };
-
- // Memory stream class.
- class jpeg_decoder_mem_stream : public jpeg_decoder_stream
- {
- const uint8 *m_pSrc_data;
- uint m_ofs, m_size;
-
- public:
- jpeg_decoder_mem_stream() : m_pSrc_data(NULL), m_ofs(0), m_size(0) { }
- jpeg_decoder_mem_stream(const uint8 *pSrc_data, uint size) : m_pSrc_data(pSrc_data), m_ofs(0), m_size(size) { }
-
- virtual ~jpeg_decoder_mem_stream() { }
-
- bool open(const uint8 *pSrc_data, uint size);
- void close() { m_pSrc_data = NULL; m_ofs = 0; m_size = 0; }
-
- virtual int read(uint8 *pBuf, int max_bytes_to_read, bool *pEOF_flag);
- };
-
- // Loads JPEG file from a jpeg_decoder_stream.
- unsigned char *decompress_jpeg_image_from_stream(jpeg_decoder_stream *pStream, int *width, int *height, int *actual_comps, int req_comps);
-
- enum
- {
- JPGD_IN_BUF_SIZE = 8192, JPGD_MAX_BLOCKS_PER_MCU = 10, JPGD_MAX_HUFF_TABLES = 8, JPGD_MAX_QUANT_TABLES = 4,
- JPGD_MAX_COMPONENTS = 4, JPGD_MAX_COMPS_IN_SCAN = 4, JPGD_MAX_BLOCKS_PER_ROW = 8192, JPGD_MAX_HEIGHT = 16384, JPGD_MAX_WIDTH = 16384
- };
-
- typedef int16 jpgd_quant_t;
- typedef int16 jpgd_block_t;
-
- class jpeg_decoder
- {
- public:
- // Call get_error_code() after constructing to determine if the stream is valid or not. You may call the get_width(), get_height(), etc.
- // methods after the constructor is called. You may then either destruct the object, or begin decoding the image by calling begin_decoding(), then decode() on each scanline.
- jpeg_decoder(jpeg_decoder_stream *pStream);
-
- ~jpeg_decoder();
-
- // Call this method after constructing the object to begin decompression.
- // If JPGD_SUCCESS is returned you may then call decode() on each scanline.
- int begin_decoding();
-
- // Returns the next scan line.
- // For grayscale images, pScan_line will point to a buffer containing 8-bit pixels (get_bytes_per_pixel() will return 1).
- // Otherwise, it will always point to a buffer containing 32-bit RGBA pixels (A will always be 255, and get_bytes_per_pixel() will return 4).
- // Returns JPGD_SUCCESS if a scan line has been returned.
- // Returns JPGD_DONE if all scan lines have been returned.
- // Returns JPGD_FAILED if an error occurred. Call get_error_code() for a more info.
- int decode(const void** pScan_line, uint* pScan_line_len);
-
- inline jpgd_status get_error_code() const { return m_error_code; }
-
- inline int get_width() const { return m_image_x_size; }
- inline int get_height() const { return m_image_y_size; }
-
- inline int get_num_components() const { return m_comps_in_frame; }
-
- inline int get_bytes_per_pixel() const { return m_dest_bytes_per_pixel; }
- inline int get_bytes_per_scan_line() const { return m_image_x_size * get_bytes_per_pixel(); }
-
- // Returns the total number of bytes actually consumed by the decoder (which should equal the actual size of the JPEG file).
- inline int get_total_bytes_read() const { return m_total_bytes_read; }
-
- private:
- jpeg_decoder(const jpeg_decoder &);
- jpeg_decoder &operator =(const jpeg_decoder &);
-
- typedef void (*pDecode_block_func)(jpeg_decoder *, int, int, int);
-
- struct huff_tables
- {
- bool ac_table;
- uint look_up[256];
- uint look_up2[256];
- uint8 code_size[256];
- uint tree[512];
- };
-
- struct coeff_buf
- {
- uint8 *pData;
- int block_num_x, block_num_y;
- int block_len_x, block_len_y;
- int block_size;
- };
-
- struct mem_block
- {
- mem_block *m_pNext;
- size_t m_used_count;
- size_t m_size;
- char m_data[1];
- };
-
- jmp_buf m_jmp_state;
- mem_block *m_pMem_blocks;
- int m_image_x_size;
- int m_image_y_size;
- jpeg_decoder_stream *m_pStream;
- int m_progressive_flag;
- uint8 m_huff_ac[JPGD_MAX_HUFF_TABLES];
- uint8* m_huff_num[JPGD_MAX_HUFF_TABLES]; // pointer to number of Huffman codes per bit size
- uint8* m_huff_val[JPGD_MAX_HUFF_TABLES]; // pointer to Huffman codes per bit size
- jpgd_quant_t* m_quant[JPGD_MAX_QUANT_TABLES]; // pointer to quantization tables
- int m_scan_type; // Gray, Yh1v1, Yh1v2, Yh2v1, Yh2v2 (CMYK111, CMYK4114 no longer supported)
- int m_comps_in_frame; // # of components in frame
- int m_comp_h_samp[JPGD_MAX_COMPONENTS]; // component's horizontal sampling factor
- int m_comp_v_samp[JPGD_MAX_COMPONENTS]; // component's vertical sampling factor
- int m_comp_quant[JPGD_MAX_COMPONENTS]; // component's quantization table selector
- int m_comp_ident[JPGD_MAX_COMPONENTS]; // component's ID
- int m_comp_h_blocks[JPGD_MAX_COMPONENTS];
- int m_comp_v_blocks[JPGD_MAX_COMPONENTS];
- int m_comps_in_scan; // # of components in scan
- int m_comp_list[JPGD_MAX_COMPS_IN_SCAN]; // components in this scan
- int m_comp_dc_tab[JPGD_MAX_COMPONENTS]; // component's DC Huffman coding table selector
- int m_comp_ac_tab[JPGD_MAX_COMPONENTS]; // component's AC Huffman coding table selector
- int m_spectral_start; // spectral selection start
- int m_spectral_end; // spectral selection end
- int m_successive_low; // successive approximation low
- int m_successive_high; // successive approximation high
- int m_max_mcu_x_size; // MCU's max. X size in pixels
- int m_max_mcu_y_size; // MCU's max. Y size in pixels
- int m_blocks_per_mcu;
- int m_max_blocks_per_row;
- int m_mcus_per_row, m_mcus_per_col;
- int m_mcu_org[JPGD_MAX_BLOCKS_PER_MCU];
- int m_total_lines_left; // total # lines left in image
- int m_mcu_lines_left; // total # lines left in this MCU
- int m_real_dest_bytes_per_scan_line;
- int m_dest_bytes_per_scan_line; // rounded up
- int m_dest_bytes_per_pixel; // 4 (RGB) or 1 (Y)
- huff_tables* m_pHuff_tabs[JPGD_MAX_HUFF_TABLES];
- coeff_buf* m_dc_coeffs[JPGD_MAX_COMPONENTS];
- coeff_buf* m_ac_coeffs[JPGD_MAX_COMPONENTS];
- int m_eob_run;
- int m_block_y_mcu[JPGD_MAX_COMPONENTS];
- uint8* m_pIn_buf_ofs;
- int m_in_buf_left;
- int m_tem_flag;
- bool m_eof_flag;
- uint8 m_in_buf_pad_start[128];
- uint8 m_in_buf[JPGD_IN_BUF_SIZE + 128];
- uint8 m_in_buf_pad_end[128];
- int m_bits_left;
- uint m_bit_buf;
- int m_restart_interval;
- int m_restarts_left;
- int m_next_restart_num;
- int m_max_mcus_per_row;
- int m_max_blocks_per_mcu;
- int m_expanded_blocks_per_mcu;
- int m_expanded_blocks_per_row;
- int m_expanded_blocks_per_component;
- bool m_freq_domain_chroma_upsample;
- int m_max_mcus_per_col;
- uint m_last_dc_val[JPGD_MAX_COMPONENTS];
- jpgd_block_t* m_pMCU_coefficients;
- int m_mcu_block_max_zag[JPGD_MAX_BLOCKS_PER_MCU];
- uint8* m_pSample_buf;
- int m_crr[256];
- int m_cbb[256];
- int m_crg[256];
- int m_cbg[256];
- uint8* m_pScan_line_0;
- uint8* m_pScan_line_1;
- jpgd_status m_error_code;
- bool m_ready_flag;
- int m_total_bytes_read;
-
- void free_all_blocks();
- // BEGIN EPIC MOD
- UE_NORETURN void stop_decoding(jpgd_status status);
- // END EPIC MOD
- void *alloc(size_t n, bool zero = false);
- void word_clear(void *p, uint16 c, uint n);
- void prep_in_buffer();
- void read_dht_marker();
- void read_dqt_marker();
- void read_sof_marker();
- void skip_variable_marker();
- void read_dri_marker();
- void read_sos_marker();
- int next_marker();
- int process_markers();
- void locate_soi_marker();
- void locate_sof_marker();
- int locate_sos_marker();
- void init(jpeg_decoder_stream * pStream);
- void create_look_ups();
- void fix_in_buffer();
- void transform_mcu(int mcu_row);
- void transform_mcu_expand(int mcu_row);
- coeff_buf* coeff_buf_open(int block_num_x, int block_num_y, int block_len_x, int block_len_y);
- inline jpgd_block_t *coeff_buf_getp(coeff_buf *cb, int block_x, int block_y);
- void load_next_row();
- void decode_next_row();
- void make_huff_table(int index, huff_tables *pH);
- void check_quant_tables();
- void check_huff_tables();
- void calc_mcu_block_order();
- int init_scan();
- void init_frame();
- void process_restart();
- void decode_scan(pDecode_block_func decode_block_func);
- void init_progressive();
- void init_sequential();
- void decode_start();
- void decode_init(jpeg_decoder_stream * pStream);
- void H2V2Convert();
- void H2V1Convert();
- void H1V2Convert();
- void H1V1Convert();
- void gray_convert();
- void expanded_convert();
- void find_eoi();
- inline uint get_char();
- inline uint get_char(bool *pPadding_flag);
- inline void stuff_char(uint8 q);
- inline uint8 get_octet();
- inline uint get_bits(int num_bits);
- inline uint get_bits_no_markers(int numbits);
- inline int huff_decode(huff_tables *pH);
- inline int huff_decode(huff_tables *pH, int& extrabits);
- static inline uint8 clamp(int i);
- static void decode_block_dc_first(jpeg_decoder *pD, int component_id, int block_x, int block_y);
- static void decode_block_dc_refine(jpeg_decoder *pD, int component_id, int block_x, int block_y);
- static void decode_block_ac_first(jpeg_decoder *pD, int component_id, int block_x, int block_y);
- static void decode_block_ac_refine(jpeg_decoder *pD, int component_id, int block_x, int block_y);
- };
-
-} // namespace jpgd
-
-#endif // JPEG_DECODER_H
diff --git a/spaces/evaluate-metric/mase/README.md b/spaces/evaluate-metric/mase/README.md
deleted file mode 100644
index bded6399cb98326bc04e85797f45a327e21333ea..0000000000000000000000000000000000000000
--- a/spaces/evaluate-metric/mase/README.md
+++ /dev/null
@@ -1,127 +0,0 @@
----
-title: MASE
-emoji: 🤗
-colorFrom: blue
-colorTo: red
-sdk: gradio
-sdk_version: 3.19.1
-app_file: app.py
-pinned: false
-tags:
-- evaluate
-- metric
-description: >-
- Mean Absolute Scaled Error (MASE) is the mean absolute error of the forecast values, divided by the mean absolute error of the in-sample one-step naive forecast on the training set.
----
-
-# Metric Card for MASE
-
-## Metric Description
-
-Mean Absolute Scaled Error (MASE) is the mean absolute error of the forecast values, divided by the mean absolute error of the in-sample one-step naive forecast. For prediction $x_i$ and corresponding ground truth $y_i$ as well as training data $z_t$ with seasonality $p$ the metric is given by:
-
-
-
-This metric is:
-* independent of the scale of the data;
-* has predictable behavior when predicted/ground-truth data is near zero;
-* symmetric;
-* interpretable, as values greater than one indicate that in-sample one-step forecasts from the naïve method perform better than the forecast values under consideration.
-
-
-## How to Use
-
-At minimum, this metric requires predictions, references and training data as inputs.
-
-```python
->>> mase_metric = evaluate.load("mase")
->>> predictions = [2.5, 0.0, 2, 8]
->>> references = [3, -0.5, 2, 7]
->>> training = [5, 0.5, 4, 6, 3, 5, 2]
->>> results = mase_metric.compute(predictions=predictions, references=references, training=training)
-```
-
-### Inputs
-
-Mandatory inputs:
-- `predictions`: numeric array-like of shape (`n_samples,`) or (`n_samples`, `n_outputs`), representing the estimated target values.
-- `references`: numeric array-like of shape (`n_samples,`) or (`n_samples`, `n_outputs`), representing the ground truth (correct) target values.
-- `training`: numeric array-like of shape (`n_train_samples,`) or (`n_train_samples`, `n_outputs`), representing the in sample training data.
-
-Optional arguments:
-- `periodicity`: the seasonal periodicity of training data. The default is 1.
-- `sample_weight`: numeric array-like of shape (`n_samples,`) representing sample weights. The default is `None`.
-- `multioutput`: `raw_values`, `uniform_average` or numeric array-like of shape (`n_outputs,`), which defines the aggregation of multiple output values. The default value is `uniform_average`.
- - `raw_values` returns a full set of errors in case of multioutput input.
- - `uniform_average` means that the errors of all outputs are averaged with uniform weight.
- - the array-like value defines weights used to average errors.
-
-### Output Values
-This metric outputs a dictionary, containing the mean absolute error score, which is of type:
-- `float`: if multioutput is `uniform_average` or an ndarray of weights, then the weighted average of all output errors is returned.
-- numeric array-like of shape (`n_outputs,`): if multioutput is `raw_values`, then the score is returned for each output separately.
-
-Each MASE `float` value ranges from `0.0` to `1.0`, with the best value being 0.0.
-
-Output Example(s):
-```python
-{'mase': 0.5}
-```
-
-If `multioutput="raw_values"`:
-```python
-{'mase': array([0.5, 1. ])}
-```
-
-#### Values from Popular Papers
-
-
-### Examples
-
-Example with the `uniform_average` config:
-```python
->>> mase_metric = evaluate.load("mase")
->>> predictions = [2.5, 0.0, 2, 8]
->>> references = [3, -0.5, 2, 7]
->>> training = [5, 0.5, 4, 6, 3, 5, 2]
->>> results = mase_metric.compute(predictions=predictions, references=references, training=training)
->>> print(results)
-{'mase': 0.1833...}
-```
-
-Example with multi-dimensional lists, and the `raw_values` config:
-```python
->>> mase_metric = evaluate.load("mase", "multilist")
->>> predictions = [[0.5, 1], [-1, 1], [7, -6]]
->>> references = [[0.1, 2], [-1, 2], [8, -5]]
->>> training = [[0.5, 1], [-1, 1], [7, -6]]
->>> results = mase_metric.compute(predictions=predictions, references=references, training=training)
->>> print(results)
-{'mase': 0.1818...}
->>> results = mase_metric.compute(predictions=predictions, references=references, training=training, multioutput='raw_values')
->>> print(results)
-{'mase': array([0.1052..., 0.2857...])}
-```
-
-## Limitations and Bias
-
-
-## Citation(s)
-
-```bibtex
-@article{HYNDMAN2006679,
- title = {Another look at measures of forecast accuracy},
- journal = {International Journal of Forecasting},
- volume = {22},
- number = {4},
- pages = {679--688},
- year = {2006},
- issn = {0169-2070},
- doi = {https://doi.org/10.1016/j.ijforecast.2006.03.001},
- url = {https://www.sciencedirect.com/science/article/pii/S0169207006000239},
- author = {Rob J. Hyndman and Anne B. Koehler},
-}
-```
-
-## Further References
-- [Mean absolute scaled error - Wikipedia](https://en.wikipedia.org/wiki/Mean_absolute_scaled_errorr)
diff --git a/spaces/facebook/MusicGen/audiocraft/grids/musicgen/musicgen_stereo_finetune_32khz.py b/spaces/facebook/MusicGen/audiocraft/grids/musicgen/musicgen_stereo_finetune_32khz.py
deleted file mode 100644
index 2904e73de08f1c9b844818558d739715776284d6..0000000000000000000000000000000000000000
--- a/spaces/facebook/MusicGen/audiocraft/grids/musicgen/musicgen_stereo_finetune_32khz.py
+++ /dev/null
@@ -1,57 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-from pathlib import Path
-from ._explorers import LMExplorer
-from ...environment import AudioCraftEnvironment
-
-
-@LMExplorer
-def explorer(launcher):
- partitions = AudioCraftEnvironment.get_slurm_partitions(['team', 'global'])
- launcher.slurm_(gpus=32, partition=partitions)
- launcher.bind_(solver='musicgen/musicgen_base_32khz')
- # replace this by the desired music dataset, which needs to be stereo
- launcher.bind_(dset='audio/example')
-
- fsdp = {'autocast': False, 'fsdp.use': True}
- medium = {'model/lm/model_scale': 'medium'}
- large = {'model/lm/model_scale': 'large'}
-
- cfg_low = {'classifier_free_guidance.training_dropout': 0.2}
- wd_low = {'conditioners.description.t5.word_dropout': 0.2}
-
- adam = {'optim.optimizer': 'adamw', 'optim.lr': 1e-4}
-
- stereo = {
- 'codebooks_pattern.delay.delays': [0, 0, 1, 1, 2, 2, 3, 3],
- 'transformer_lm.n_q': 8,
- 'interleave_stereo_codebooks.use': True,
- 'channels': 2,
- }
-
- # You must follow the instructions in docs/MUSICGEN.md about the creation
- # of the proper fine tuning checkpoints. We will assume they are stored under
- # ~/checkpoints/{mode_name}.
-
- checkpoints = Path.home() / 'checkpoints'
-
- launcher.bind_(fsdp, stereo, {'optim.epochs': 100})
-
- launcher.slurm_(gpus=32).bind_(label='32gpus')
- with launcher.job_array():
- sub = launcher.bind({'continue_from': str(checkpoints / 'stereo_finetune_musicgen-small.th')})
- sub()
-
- launcher.slurm_(gpus=64).bind_(label='64gpus')
- with launcher.job_array():
- sub = launcher.bind({'continue_from': str(checkpoints / 'stereo_finetune_musicgen-medium.th')})
- sub(medium, adam)
-
- launcher.slurm_(gpus=96).bind_(label='96gpus')
- with launcher.job_array():
- sub = launcher.bind({'continue_from': str(checkpoints / 'stereo_finetune_musicgen-large.th')})
- sub(large, cfg_low, wd_low, adam, {'optim.max_norm': 3})
diff --git a/spaces/facebook/MusicGen/audiocraft/models/musicgen.py b/spaces/facebook/MusicGen/audiocraft/models/musicgen.py
deleted file mode 100644
index 88ee13b6a5da2a54e580db7c39accb1acbade6b4..0000000000000000000000000000000000000000
--- a/spaces/facebook/MusicGen/audiocraft/models/musicgen.py
+++ /dev/null
@@ -1,422 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-"""
-Main model for using MusicGen. This will combine all the required components
-and provide easy access to the generation API.
-"""
-
-import typing as tp
-import warnings
-
-import omegaconf
-import torch
-
-from .encodec import CompressionModel
-from .lm import LMModel
-from .builders import get_debug_compression_model, get_debug_lm_model, get_wrapped_compression_model
-from .loaders import load_compression_model, load_lm_model
-from ..data.audio_utils import convert_audio
-from ..modules.conditioners import ConditioningAttributes, WavCondition
-from ..utils.autocast import TorchAutocast
-
-
-MelodyList = tp.List[tp.Optional[torch.Tensor]]
-MelodyType = tp.Union[torch.Tensor, MelodyList]
-
-
-# backward compatible names mapping
-_HF_MODEL_CHECKPOINTS_MAP = {
- "small": "facebook/musicgen-small",
- "medium": "facebook/musicgen-medium",
- "large": "facebook/musicgen-large",
- "melody": "facebook/musicgen-melody",
-}
-
-
-class MusicGen:
- """MusicGen main model with convenient generation API.
-
- Args:
- name (str): name of the model.
- compression_model (CompressionModel): Compression model
- used to map audio to invertible discrete representations.
- lm (LMModel): Language model over discrete representations.
- max_duration (float, optional): maximum duration the model can produce,
- otherwise, inferred from the training params.
- """
- def __init__(self, name: str, compression_model: CompressionModel, lm: LMModel,
- max_duration: tp.Optional[float] = None):
- self.name = name
- self.compression_model = compression_model
- self.lm = lm
- self.cfg: tp.Optional[omegaconf.DictConfig] = None
- # Just to be safe, let's put everything in eval mode.
- self.compression_model.eval()
- self.lm.eval()
-
- if hasattr(lm, 'cfg'):
- cfg = lm.cfg
- assert isinstance(cfg, omegaconf.DictConfig)
- self.cfg = cfg
-
- if self.cfg is not None:
- self.compression_model = get_wrapped_compression_model(self.compression_model, self.cfg)
-
- if max_duration is None:
- if self.cfg is not None:
- max_duration = lm.cfg.dataset.segment_duration # type: ignore
- else:
- raise ValueError("You must provide max_duration when building directly MusicGen")
- assert max_duration is not None
- self.max_duration: float = max_duration
- self.device = next(iter(lm.parameters())).device
-
- self.generation_params: dict = {}
- self.set_generation_params(duration=15) # 15 seconds by default
- self._progress_callback: tp.Optional[tp.Callable[[int, int], None]] = None
- if self.device.type == 'cpu':
- self.autocast = TorchAutocast(enabled=False)
- else:
- self.autocast = TorchAutocast(
- enabled=True, device_type=self.device.type, dtype=torch.float16)
-
- @property
- def frame_rate(self) -> float:
- """Roughly the number of AR steps per seconds."""
- return self.compression_model.frame_rate
-
- @property
- def sample_rate(self) -> int:
- """Sample rate of the generated audio."""
- return self.compression_model.sample_rate
-
- @property
- def audio_channels(self) -> int:
- """Audio channels of the generated audio."""
- return self.compression_model.channels
-
- @staticmethod
- def get_pretrained(name: str = 'facebook/musicgen-melody', device=None):
- """Return pretrained model, we provide four models:
- - facebook/musicgen-small (300M), text to music,
- # see: https://huggingface.co/facebook/musicgen-small
- - facebook/musicgen-medium (1.5B), text to music,
- # see: https://huggingface.co/facebook/musicgen-medium
- - facebook/musicgen-melody (1.5B) text to music and text+melody to music,
- # see: https://huggingface.co/facebook/musicgen-melody
- - facebook/musicgen-large (3.3B), text to music,
- # see: https://huggingface.co/facebook/musicgen-large
- """
- if device is None:
- if torch.cuda.device_count():
- device = 'cuda'
- else:
- device = 'cpu'
-
- if name == 'debug':
- # used only for unit tests
- compression_model = get_debug_compression_model(device)
- lm = get_debug_lm_model(device)
- return MusicGen(name, compression_model, lm, max_duration=30)
-
- if name in _HF_MODEL_CHECKPOINTS_MAP:
- warnings.warn(
- "MusicGen pretrained model relying on deprecated checkpoint mapping. " +
- f"Please use full pre-trained id instead: facebook/musicgen-{name}")
- name = _HF_MODEL_CHECKPOINTS_MAP[name]
-
- lm = load_lm_model(name, device=device)
- compression_model = load_compression_model(name, device=device)
- if 'self_wav' in lm.condition_provider.conditioners:
- lm.condition_provider.conditioners['self_wav'].match_len_on_eval = True
- lm.condition_provider.conditioners['self_wav']._use_masking = False
-
- return MusicGen(name, compression_model, lm)
-
- def set_generation_params(self, use_sampling: bool = True, top_k: int = 250,
- top_p: float = 0.0, temperature: float = 1.0,
- duration: float = 30.0, cfg_coef: float = 3.0,
- two_step_cfg: bool = False, extend_stride: float = 18):
- """Set the generation parameters for MusicGen.
-
- Args:
- use_sampling (bool, optional): Use sampling if True, else do argmax decoding. Defaults to True.
- top_k (int, optional): top_k used for sampling. Defaults to 250.
- top_p (float, optional): top_p used for sampling, when set to 0 top_k is used. Defaults to 0.0.
- temperature (float, optional): Softmax temperature parameter. Defaults to 1.0.
- duration (float, optional): Duration of the generated waveform. Defaults to 30.0.
- cfg_coef (float, optional): Coefficient used for classifier free guidance. Defaults to 3.0.
- two_step_cfg (bool, optional): If True, performs 2 forward for Classifier Free Guidance,
- instead of batching together the two. This has some impact on how things
- are padded but seems to have little impact in practice.
- extend_stride: when doing extended generation (i.e. more than 30 seconds), by how much
- should we extend the audio each time. Larger values will mean less context is
- preserved, and shorter value will require extra computations.
- """
- assert extend_stride < self.max_duration, "Cannot stride by more than max generation duration."
- self.extend_stride = extend_stride
- self.duration = duration
- self.generation_params = {
- 'use_sampling': use_sampling,
- 'temp': temperature,
- 'top_k': top_k,
- 'top_p': top_p,
- 'cfg_coef': cfg_coef,
- 'two_step_cfg': two_step_cfg,
- }
-
- def set_custom_progress_callback(self, progress_callback: tp.Optional[tp.Callable[[int, int], None]] = None):
- """Override the default progress callback."""
- self._progress_callback = progress_callback
-
- def generate_unconditional(self, num_samples: int, progress: bool = False,
- return_tokens: bool = False) -> tp.Union[torch.Tensor,
- tp.Tuple[torch.Tensor, torch.Tensor]]:
- """Generate samples in an unconditional manner.
-
- Args:
- num_samples (int): Number of samples to be generated.
- progress (bool, optional): Flag to display progress of the generation process. Defaults to False.
- """
- descriptions: tp.List[tp.Optional[str]] = [None] * num_samples
- attributes, prompt_tokens = self._prepare_tokens_and_attributes(descriptions, None)
- tokens = self._generate_tokens(attributes, prompt_tokens, progress)
- if return_tokens:
- return self.generate_audio(tokens), tokens
- return self.generate_audio(tokens)
-
- def generate(self, descriptions: tp.List[str], progress: bool = False, return_tokens: bool = False) \
- -> tp.Union[torch.Tensor, tp.Tuple[torch.Tensor, torch.Tensor]]:
- """Generate samples conditioned on text.
-
- Args:
- descriptions (list of str): A list of strings used as text conditioning.
- progress (bool, optional): Flag to display progress of the generation process. Defaults to False.
- """
- attributes, prompt_tokens = self._prepare_tokens_and_attributes(descriptions, None)
- assert prompt_tokens is None
- tokens = self._generate_tokens(attributes, prompt_tokens, progress)
- if return_tokens:
- return self.generate_audio(tokens), tokens
- return self.generate_audio(tokens)
-
- def generate_with_chroma(self, descriptions: tp.List[str], melody_wavs: MelodyType,
- melody_sample_rate: int, progress: bool = False,
- return_tokens: bool = False) -> tp.Union[torch.Tensor,
- tp.Tuple[torch.Tensor, torch.Tensor]]:
- """Generate samples conditioned on text and melody.
-
- Args:
- descriptions (list of str): A list of strings used as text conditioning.
- melody_wavs: (torch.Tensor or list of Tensor): A batch of waveforms used as
- melody conditioning. Should have shape [B, C, T] with B matching the description length,
- C=1 or 2. It can be [C, T] if there is a single description. It can also be
- a list of [C, T] tensors.
- melody_sample_rate: (int): Sample rate of the melody waveforms.
- progress (bool, optional): Flag to display progress of the generation process. Defaults to False.
- """
- if isinstance(melody_wavs, torch.Tensor):
- if melody_wavs.dim() == 2:
- melody_wavs = melody_wavs[None]
- if melody_wavs.dim() != 3:
- raise ValueError("Melody wavs should have a shape [B, C, T].")
- melody_wavs = list(melody_wavs)
- else:
- for melody in melody_wavs:
- if melody is not None:
- assert melody.dim() == 2, "One melody in the list has the wrong number of dims."
-
- melody_wavs = [
- convert_audio(wav, melody_sample_rate, self.sample_rate, self.audio_channels)
- if wav is not None else None
- for wav in melody_wavs]
- attributes, prompt_tokens = self._prepare_tokens_and_attributes(descriptions=descriptions, prompt=None,
- melody_wavs=melody_wavs)
- assert prompt_tokens is None
- tokens = self._generate_tokens(attributes, prompt_tokens, progress)
- if return_tokens:
- return self.generate_audio(tokens), tokens
- return self.generate_audio(tokens)
-
- def generate_continuation(self, prompt: torch.Tensor, prompt_sample_rate: int,
- descriptions: tp.Optional[tp.List[tp.Optional[str]]] = None,
- progress: bool = False, return_tokens: bool = False) \
- -> tp.Union[torch.Tensor, tp.Tuple[torch.Tensor, torch.Tensor]]:
- """Generate samples conditioned on audio prompts.
-
- Args:
- prompt (torch.Tensor): A batch of waveforms used for continuation.
- Prompt should be [B, C, T], or [C, T] if only one sample is generated.
- prompt_sample_rate (int): Sampling rate of the given audio waveforms.
- descriptions (list of str, optional): A list of strings used as text conditioning. Defaults to None.
- progress (bool, optional): Flag to display progress of the generation process. Defaults to False.
- """
- if prompt.dim() == 2:
- prompt = prompt[None]
- if prompt.dim() != 3:
- raise ValueError("prompt should have 3 dimensions: [B, C, T] (C = 1).")
- prompt = convert_audio(prompt, prompt_sample_rate, self.sample_rate, self.audio_channels)
- if descriptions is None:
- descriptions = [None] * len(prompt)
- attributes, prompt_tokens = self._prepare_tokens_and_attributes(descriptions, prompt)
- assert prompt_tokens is not None
- tokens = self._generate_tokens(attributes, prompt_tokens, progress)
- if return_tokens:
- return self.generate_audio(tokens), tokens
- return self.generate_audio(tokens)
-
- @torch.no_grad()
- def _prepare_tokens_and_attributes(
- self,
- descriptions: tp.Sequence[tp.Optional[str]],
- prompt: tp.Optional[torch.Tensor],
- melody_wavs: tp.Optional[MelodyList] = None,
- ) -> tp.Tuple[tp.List[ConditioningAttributes], tp.Optional[torch.Tensor]]:
- """Prepare model inputs.
-
- Args:
- descriptions (list of str): A list of strings used as text conditioning.
- prompt (torch.Tensor): A batch of waveforms used for continuation.
- melody_wavs (torch.Tensor, optional): A batch of waveforms
- used as melody conditioning. Defaults to None.
- """
- attributes = [
- ConditioningAttributes(text={'description': description})
- for description in descriptions]
-
- if melody_wavs is None:
- for attr in attributes:
- attr.wav['self_wav'] = WavCondition(
- torch.zeros((1, 1, 1), device=self.device),
- torch.tensor([0], device=self.device),
- sample_rate=[self.sample_rate],
- path=[None])
- else:
- if 'self_wav' not in self.lm.condition_provider.conditioners:
- raise RuntimeError("This model doesn't support melody conditioning. "
- "Use the `melody` model.")
- assert len(melody_wavs) == len(descriptions), \
- f"number of melody wavs must match number of descriptions! " \
- f"got melody len={len(melody_wavs)}, and descriptions len={len(descriptions)}"
- for attr, melody in zip(attributes, melody_wavs):
- if melody is None:
- attr.wav['self_wav'] = WavCondition(
- torch.zeros((1, 1, 1), device=self.device),
- torch.tensor([0], device=self.device),
- sample_rate=[self.sample_rate],
- path=[None])
- else:
- attr.wav['self_wav'] = WavCondition(
- melody[None].to(device=self.device),
- torch.tensor([melody.shape[-1]], device=self.device),
- sample_rate=[self.sample_rate],
- path=[None],
- )
-
- if prompt is not None:
- if descriptions is not None:
- assert len(descriptions) == len(prompt), "Prompt and nb. descriptions doesn't match"
- prompt = prompt.to(self.device)
- prompt_tokens, scale = self.compression_model.encode(prompt)
- assert scale is None
- else:
- prompt_tokens = None
- return attributes, prompt_tokens
-
- def _generate_tokens(self, attributes: tp.List[ConditioningAttributes],
- prompt_tokens: tp.Optional[torch.Tensor], progress: bool = False) -> torch.Tensor:
- """Generate discrete audio tokens given audio prompt and/or conditions.
-
- Args:
- attributes (list of ConditioningAttributes): Conditions used for generation (text/melody).
- prompt_tokens (torch.Tensor, optional): Audio prompt used for continuation.
- progress (bool, optional): Flag to display progress of the generation process. Defaults to False.
- Returns:
- torch.Tensor: Generated audio, of shape [B, C, T], T is defined by the generation params.
- """
- total_gen_len = int(self.duration * self.frame_rate)
- max_prompt_len = int(min(self.duration, self.max_duration) * self.frame_rate)
- current_gen_offset: int = 0
-
- def _progress_callback(generated_tokens: int, tokens_to_generate: int):
- generated_tokens += current_gen_offset
- if self._progress_callback is not None:
- # Note that total_gen_len might be quite wrong depending on the
- # codebook pattern used, but with delay it is almost accurate.
- self._progress_callback(generated_tokens, total_gen_len)
- else:
- print(f'{generated_tokens: 6d} / {total_gen_len: 6d}', end='\r')
-
- if prompt_tokens is not None:
- assert max_prompt_len >= prompt_tokens.shape[-1], \
- "Prompt is longer than audio to generate"
-
- callback = None
- if progress:
- callback = _progress_callback
-
- if self.duration <= self.max_duration:
- # generate by sampling from LM, simple case.
- with self.autocast:
- gen_tokens = self.lm.generate(
- prompt_tokens, attributes,
- callback=callback, max_gen_len=total_gen_len, **self.generation_params)
-
- else:
- # now this gets a bit messier, we need to handle prompts,
- # melody conditioning etc.
- ref_wavs = [attr.wav['self_wav'] for attr in attributes]
- all_tokens = []
- if prompt_tokens is None:
- prompt_length = 0
- else:
- all_tokens.append(prompt_tokens)
- prompt_length = prompt_tokens.shape[-1]
-
- stride_tokens = int(self.frame_rate * self.extend_stride)
-
- while current_gen_offset + prompt_length < total_gen_len:
- time_offset = current_gen_offset / self.frame_rate
- chunk_duration = min(self.duration - time_offset, self.max_duration)
- max_gen_len = int(chunk_duration * self.frame_rate)
- for attr, ref_wav in zip(attributes, ref_wavs):
- wav_length = ref_wav.length.item()
- if wav_length == 0:
- continue
- # We will extend the wav periodically if it not long enough.
- # we have to do it here rather than in conditioners.py as otherwise
- # we wouldn't have the full wav.
- initial_position = int(time_offset * self.sample_rate)
- wav_target_length = int(self.max_duration * self.sample_rate)
- positions = torch.arange(initial_position,
- initial_position + wav_target_length, device=self.device)
- attr.wav['self_wav'] = WavCondition(
- ref_wav[0][..., positions % wav_length],
- torch.full_like(ref_wav[1], wav_target_length),
- [self.sample_rate] * ref_wav[0].size(0),
- [None], [0.])
- with self.autocast:
- gen_tokens = self.lm.generate(
- prompt_tokens, attributes,
- callback=callback, max_gen_len=max_gen_len, **self.generation_params)
- if prompt_tokens is None:
- all_tokens.append(gen_tokens)
- else:
- all_tokens.append(gen_tokens[:, :, prompt_tokens.shape[-1]:])
- prompt_tokens = gen_tokens[:, :, stride_tokens:]
- prompt_length = prompt_tokens.shape[-1]
- current_gen_offset += stride_tokens
-
- gen_tokens = torch.cat(all_tokens, dim=-1)
- return gen_tokens
-
- def generate_audio(self, gen_tokens: torch.Tensor):
- """Generate Audio from tokens"""
- assert gen_tokens.dim() == 3
- with torch.no_grad():
- gen_audio = self.compression_model.decode(gen_tokens, None)
- return gen_audio
diff --git a/spaces/facebook/ov-seg/open_vocab_seg/test_time_augmentation.py b/spaces/facebook/ov-seg/open_vocab_seg/test_time_augmentation.py
deleted file mode 100644
index bb7a51f28419c59775013c74fdee49e5166bde51..0000000000000000000000000000000000000000
--- a/spaces/facebook/ov-seg/open_vocab_seg/test_time_augmentation.py
+++ /dev/null
@@ -1,217 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-# Copyright (c) Meta Platforms, Inc. All Rights Reserved
-
-import copy
-from itertools import count
-import math
-import numpy as np
-import torch
-from fvcore.transforms import HFlipTransform
-from torch import nn
-from torch.nn.parallel import DistributedDataParallel
-
-from detectron2.data.detection_utils import read_image
-from detectron2.modeling import DatasetMapperTTA
-from detectron2.modeling.postprocessing import sem_seg_postprocess
-import logging
-from detectron2.utils.logger import log_every_n, log_first_n
-
-__all__ = [
- "SemanticSegmentorWithTTA",
-]
-
-
-class SemanticSegmentorWithTTA(nn.Module):
- """
- A SemanticSegmentor with test-time augmentation enabled.
- Its :meth:`__call__` method has the same interface as :meth:`SemanticSegmentor.forward`.
- """
-
- def __init__(self, cfg, model, tta_mapper=None, batch_size=1):
- """
- Args:
- cfg (CfgNode):
- model (SemanticSegmentor): a SemanticSegmentor to apply TTA on.
- tta_mapper (callable): takes a dataset dict and returns a list of
- augmented versions of the dataset dict. Defaults to
- `DatasetMapperTTA(cfg)`.
- batch_size (int): batch the augmented images into this batch size for inference.
- """
- super().__init__()
- if isinstance(model, DistributedDataParallel):
- model = model.module
- self.cfg = cfg.clone()
-
- self.model = model
-
- if tta_mapper is None:
- tta_mapper = DatasetMapperTTA(cfg)
- self.tta_mapper = tta_mapper
- self.batch_size = batch_size
-
- def _inference_with_model(self, inputs):
- if self.cfg.TEST.SLIDING_WINDOW:
- log_first_n(logging.INFO, "Using sliding window to test")
-
- outputs = []
-
- for input in inputs:
- image_size = input["image"].shape[1:] # h,w
- if self.cfg.TEST.SLIDING_TILE_SIZE > 0:
- tile_size = (
- self.cfg.TEST.SLIDING_TILE_SIZE,
- self.cfg.TEST.SLIDING_TILE_SIZE,
- )
- else:
- selected_mapping = {256: 224, 512: 256, 768: 512, 896: 512}
- tile_size = min(image_size)
- tile_size = selected_mapping[tile_size]
- tile_size = (tile_size, tile_size)
- extra_info = {
- k: v
- for k, v in input.items()
- if k not in ["image", "height", "width"]
- }
- log_every_n(
- logging.INFO, "split {} to {}".format(image_size, tile_size)
- )
- overlap = self.cfg.TEST.SLIDING_OVERLAP
- stride = math.ceil(tile_size[0] * (1 - overlap))
- tile_rows = int(
- math.ceil((image_size[0] - tile_size[0]) / stride) + 1
- ) # strided convolution formula
- tile_cols = int(math.ceil((image_size[1] - tile_size[1]) / stride) + 1)
- full_probs = None
- count_predictions = None
- tile_counter = 0
-
- for row in range(tile_rows):
- for col in range(tile_cols):
- x1 = int(col * stride)
- y1 = int(row * stride)
- x2 = min(x1 + tile_size[1], image_size[1])
- y2 = min(y1 + tile_size[0], image_size[0])
- x1 = max(
- int(x2 - tile_size[1]), 0
- ) # for portrait images the x1 underflows sometimes
- y1 = max(
- int(y2 - tile_size[0]), 0
- ) # for very few rows y1 underflows
-
- img = input["image"][:, y1:y2, x1:x2]
- padded_img = nn.functional.pad(
- img,
- (
- 0,
- tile_size[1] - img.shape[-1],
- 0,
- tile_size[0] - img.shape[-2],
- ),
- )
- tile_counter += 1
- padded_input = {"image": padded_img}
- padded_input.update(extra_info)
- padded_prediction = self.model([padded_input])[0]["sem_seg"]
- prediction = padded_prediction[
- :, 0 : img.shape[1], 0 : img.shape[2]
- ]
- if full_probs is None:
- full_probs = prediction.new_zeros(
- prediction.shape[0], image_size[0], image_size[1]
- )
- if count_predictions is None:
- count_predictions = prediction.new_zeros(
- prediction.shape[0], image_size[0], image_size[1]
- )
- count_predictions[:, y1:y2, x1:x2] += 1
- full_probs[
- :, y1:y2, x1:x2
- ] += prediction # accumulate the predictions also in the overlapping regions
-
- full_probs /= count_predictions
- full_probs = sem_seg_postprocess(
- full_probs,
- image_size,
- input.get("height", image_size[0]),
- input.get("width", image_size[1]),
- )
- outputs.append({"sem_seg": full_probs})
-
- return outputs
- else:
- log_first_n(logging.INFO, "Using whole image to test")
- return self.model(inputs)
-
- def _batch_inference(self, batched_inputs):
- """
- Execute inference on a list of inputs,
- using batch size = self.batch_size, instead of the length of the list.
- Inputs & outputs have the same format as :meth:`SemanticSegmentor.forward`
- """
- outputs = []
- inputs = []
- for idx, input in zip(count(), batched_inputs):
- inputs.append(input)
- if len(inputs) == self.batch_size or idx == len(batched_inputs) - 1:
- with torch.no_grad():
- outputs.extend(self._inference_with_model(inputs))
- inputs = []
- return outputs
-
- def __call__(self, batched_inputs):
- """
- Same input/output format as :meth:`SemanticSegmentor.forward`
- """
-
- def _maybe_read_image(dataset_dict):
- ret = copy.copy(dataset_dict)
- if "image" not in ret:
- image = read_image(ret.pop("file_name"), self.model.input_format)
- image = torch.from_numpy(
- np.ascontiguousarray(image.transpose(2, 0, 1))
- ) # CHW
- ret["image"] = image
- if "height" not in ret and "width" not in ret:
- ret["height"] = image.shape[1]
- ret["width"] = image.shape[2]
- return ret
-
- return [self._inference_one_image(_maybe_read_image(x)) for x in batched_inputs]
-
- def _inference_one_image(self, input):
- """
- Args:
- input (dict): one dataset dict with "image" field being a CHW tensor
- Returns:
- dict: one output dict
- """
- augmented_inputs, tfms = self._get_augmented_inputs(input)
- # 1: forward with all augmented images
- outputs = self._batch_inference(augmented_inputs)
- # Delete now useless variables to avoid being out of memory
- del augmented_inputs
- # 2: merge the results
- # handle flip specially
- # outputs = [output.detach() for output in outputs]
- return self._merge_auged_output(outputs, tfms)
-
- def _merge_auged_output(self, outputs, tfms):
- new_outputs = []
- for output, tfm in zip(outputs, tfms):
- if any(isinstance(t, HFlipTransform) for t in tfm.transforms):
- new_outputs.append(output["sem_seg"].flip(dims=[2]))
- else:
- new_outputs.append(output["sem_seg"])
- del outputs
- # to avoid OOM with torch.stack
- final_predictions = new_outputs[0]
- for i in range(1, len(new_outputs)):
- final_predictions += new_outputs[i]
- final_predictions = final_predictions / len(new_outputs)
- del new_outputs
- return {"sem_seg": final_predictions}
-
- def _get_augmented_inputs(self, input):
- augmented_inputs = self.tta_mapper(input)
- tfms = [x.pop("transforms") for x in augmented_inputs]
- return augmented_inputs, tfms
diff --git a/spaces/falterWliame/Face_Mask_Detection/Apowersoft Screen Recorder Pro 2.4.0.16 Crack HOT!.md b/spaces/falterWliame/Face_Mask_Detection/Apowersoft Screen Recorder Pro 2.4.0.16 Crack HOT!.md
deleted file mode 100644
index 6ade531ce6c79775a18e3d9f23e8337c80d9298a..0000000000000000000000000000000000000000
--- a/spaces/falterWliame/Face_Mask_Detection/Apowersoft Screen Recorder Pro 2.4.0.16 Crack HOT!.md
+++ /dev/null
@@ -1,42 +0,0 @@
-
-
Apowersoft Screen Recorder Pro 2.4.0.16 Crack: A Review
-
If you are looking for a professional and easy-to-use tool to record your screen and audio activities, you may want to check out Apowersoft Screen Recorder Pro 2.4.0.16 Crack. This software allows you to capture any part of your screen, record webcam video streams, edit your recordings, and convert them to various formats without quality loss.
What Can Apowersoft Screen Recorder Pro 2.4.0.16 Crack Do?
-
Apowersoft Screen Recorder Pro 2.4.0.16 Crack has many features that make it a versatile and powerful screen recording software. Here are some of them:
-
-
Multiple Recording Modes: You can choose to record the full screen, a custom area, a specific window, or around the mouse cursor.
-
Record Screen with Audio Simultaneously: You can record the system sound, the microphone sound, or both at the same time.
-
Record Video from Webcam: You can also record video from your webcam and save it as a WMV file by default.
-
Record Live Streaming Video: You can capture any live streaming video from websites like Twitch TV, BBC, CNN, and Livestream.
-
Create Scheduled Task: You can set up a timer to start and stop the recording automatically.
-
Capture Screenshots: You can take screenshots of your screen and edit them with various tools like text, arrows, shapes, and more.
-
Professional Video Editor: You can trim, merge, crop, rotate, add effects, watermark, and subtitle your recorded videos.
-
Video Converter: You can convert your videos to MP4, AVI, FLV, SWF, MKV, MOV, MPEG, VOB, WEBM, and more formats.
-
Social Media Sharing: You can upload your videos to YouTube, Dropbox, Google Drive, or FTP server directly from the software.
-
-
How to Use Apowersoft Screen Recorder Pro 2.4.0.16 Crack?
-
Using Apowersoft Screen Recorder Pro 2.4.0.16 Crack is very simple and intuitive. Here are the basic steps to follow:
-
-
Download and install the software from the official website or from a trusted source.
-
Launch the software and choose the recording mode you want.
-
Adjust the settings like audio source, output format, hotkeys, etc.
-
Click the red REC button to start the recording.
-
Click the pause button to pause or resume the recording.
-
Click the stop button to finish the recording.
-
Edit your video with the built-in editor or convert it with the built-in converter.
-
Save your video to your local folder or share it online.
-
-
Why Choose Apowersoft Screen Recorder Pro 2.4.0.16 Crack?
-
There are many reasons why Apowersoft Screen Recorder Pro 2.4.0.16 Crack is a good choice for screen recording software. Here are some of them:
-
-
-
High Quality: The software can record your screen and audio with high quality and no lag.
-
Easy to Use: The software has a user-friendly interface and clear instructions that make it easy to use for anyone.
-
Versatile: The software can record any screen activity and any video format with various options and features.
-
Affordable: The software is free to download and use for a limited time with a watermark. You can also get a lifetime license for a reasonable price.
-
-
Conclusion
-
Apowersoft Screen Recorder Pro 2.4.0.16 Crack is a great software for anyone who wants to record their screen and audio activities with ease and quality. It has many features that make it a powerful and versatile tool for creating tutorials, gameplays, live streams, webinars, and more. You can download it from the official website or from a trusted source and enjoy its benefits.
3cee63e6c2
-
-
\ No newline at end of file
diff --git a/spaces/falterWliame/Face_Mask_Detection/Artlantis Studio 4 Free Download With Crack LINK.md b/spaces/falterWliame/Face_Mask_Detection/Artlantis Studio 4 Free Download With Crack LINK.md
deleted file mode 100644
index 5cf8cf038cd692073890b914860b3832d1685a1d..0000000000000000000000000000000000000000
--- a/spaces/falterWliame/Face_Mask_Detection/Artlantis Studio 4 Free Download With Crack LINK.md
+++ /dev/null
@@ -1,19 +0,0 @@
-
-
How to Download and Install Artlantis Studio 4 for Free with Crack
-
Artlantis Studio 4 is a powerful 3D rendering software that allows you to create realistic and stunning images and animations of your architectural projects. Whether you are a professional architect, designer, or student, Artlantis Studio 4 can help you showcase your work in the best possible way.
-
However, Artlantis Studio 4 is not a cheap software. It costs $995 for a single license, which may be too expensive for some users. That's why some people look for ways to download and install Artlantis Studio 4 for free with crack.
Crack is a term that refers to a modified version of a software that bypasses its security features and allows users to use it without paying for it. However, using crack is illegal and risky. It can expose your computer to viruses, malware, and other threats. It can also damage your files and system. Moreover, it can violate the intellectual property rights of the software developers and cause legal problems.
-
Therefore, we do not recommend using crack to download and install Artlantis Studio 4 for free. Instead, we suggest you to try the following alternatives:
-
-
Use the trial version of Artlantis Studio 4. You can download it from the official website and use it for 30 days without any limitations. This way, you can test the software and see if it meets your needs before buying it.
-
Use the educational version of Artlantis Studio 4. If you are a student or a teacher, you can apply for an educational license and use Artlantis Studio 4 for free for one year. You just need to provide proof of your academic status and agree to use the software only for educational purposes.
-
Use an alternative software to Artlantis Studio 4. There are many other 3D rendering software that you can use for free or at a lower cost. Some examples are Blender, SketchUp, Lumion, V-Ray, etc. They may have different features and interfaces than Artlantis Studio 4, but they can still help you create amazing 3D visuals.
-
-
We hope this article has helped you understand why you should not use crack to download and install Artlantis Studio 4 for free. Instead, we encourage you to use the legal and safe options that we have suggested. Thank you for reading!
-
-
If you have any questions or doubts about Artlantis Studio 4, you can visit the official website and check the FAQ section. You can also contact the customer support team and get assistance from the experts. They will be happy to help you with any issues or inquiries that you may have.
-
Artlantis Studio 4 is a great software that can enhance your 3D rendering skills and projects. However, it is not worth risking your computer and your reputation by using crack. Instead, you should respect the software developers and their work and use the software legally and ethically. By doing so, you will also support the innovation and improvement of Artlantis Studio 4 and other similar software.
-
We hope you have enjoyed this article and learned something new. If you did, please share it with your friends and colleagues who may be interested in Artlantis Studio 4. Also, feel free to leave a comment below and let us know what you think about Artlantis Studio 4 and its alternatives. We would love to hear from you!
d5da3c52bf
-
-
\ No newline at end of file
diff --git a/spaces/falterWliame/Face_Mask_Detection/Download Gta 4 Full Pc Game UPD.md b/spaces/falterWliame/Face_Mask_Detection/Download Gta 4 Full Pc Game UPD.md
deleted file mode 100644
index a6d42ace70754452a7ef55de3918b018a897258f..0000000000000000000000000000000000000000
--- a/spaces/falterWliame/Face_Mask_Detection/Download Gta 4 Full Pc Game UPD.md
+++ /dev/null
@@ -1,6 +0,0 @@
-
-
-Grand Theft Auto IV is a 2008 adventure game developed by Rockstar North and published by Rockstar Games. It is the sixth main entry in Grand. The PS3 version with enhanced graphics is one of the best versions of GTA4 released to date. As of 10th April 2012, the game has had over 30 million downloads, making it the best-selling video game in the US. The game has four main characters that lead the storyline. Each character can be identified as a second, third or fourth person character. The story begins with the protagonist Trevor on the run from law enforcement. 8a78ff9644
-
-
-
diff --git a/spaces/fatiXbelha/sd/Candy Crush Saga The Ultimate Sugar Wala Game Download for Your PC.md b/spaces/fatiXbelha/sd/Candy Crush Saga The Ultimate Sugar Wala Game Download for Your PC.md
deleted file mode 100644
index 4af401026a7f2842bc94180acf0d6a905bd0cc58..0000000000000000000000000000000000000000
--- a/spaces/fatiXbelha/sd/Candy Crush Saga The Ultimate Sugar Wala Game Download for Your PC.md
+++ /dev/null
@@ -1,180 +0,0 @@
-
-
Sugar Wala Game Download: How to Play the Sweetest Match 3 Puzzle Game
-
If you are looking for a fun and addictive puzzle game that will satisfy your sweet tooth, then you should try Sugar Wala Game. This game is a popular match 3 puzzle game that lets you match, pop, and blast candies in a tasty adventure. In this article, we will tell you everything you need to know about Sugar Wala Game, including how to download it, how to play it, why you should play it, and what are some alternatives if you want more variety.
-
What is Sugar Wala Game?
-
Sugar Wala Game is a simulation game created by Bonte Games. It is inspired by the famous Candy Crush Saga game, but with some unique twists and features. The game challenges you to solve puzzles by sifting the sugar into coffee cups. You have to draw bridges and well-placed lines to capture each grain of sugar. Every level has a new, sweet challenge, and the obstacles get harder as the game progresses.
Sugar Wala Game has many features that make it stand out from other match 3 puzzle games. Some of these features are:
-
-
Thousands of levels and puzzles in the Candy Kingdom, with new ones added every two weeks
-
Different ways to win rewards, such as spinning the Daily Booster Wheel, completing time-limited challenges, and collecting trinity gems
-
Variety of sugar-coated puzzle challenges, such as Target Score, Clear the Jelly, Collect the Ingredients, and Order Mode
-
Ability to blast candies with friends and compare scores on the leaderboard
-
Option to sync the game between devices and access full game features when connected to the internet
-
Free to play but with optional in-game items that require payment
-
-
How to Download Sugar Wala Game?
-
Sugar Wala Game is available on various platforms, such as Google Play Store, App Store, Microsoft Store, and Poki. Here are the step-by-step instructions for downloading the game on each platform:
-
Google Play Store
-
-
Open the Google Play Store app on your Android device
-
Search for "Sugar Wala Game" or use this link:
-
Tap on "Install" and wait for the download to finish
-
Tap on "Open" or find the game icon on your home screen or app drawer
-
Enjoy playing Sugar Wala Game!
-
-
App Store
-
-
Open the App Store app on your iPhone or iPad
-
Search for "Sugar Wala Game" or use this link:
-
Tap on "Get" and enter your Apple ID password if prompted
-
Wait for the download to finish and tap on "Open" or find the game icon on your home screen
-
Enjoy playing Sugar Wala Game!
-
-
Microsoft Store
-
-
Open the Microsoft Store app on your Windows PC or device
-
Search for "Sugar Wala Game" or use this link:
-
Click on "Get" and sign in with your Microsoft account if prompted
-
Wait for the download to finish and click on "Install" or find the game icon on your start menu or desktop
-
Enjoy playing Sugar Wala Game!
-
-
Poki
-
-
Open your web browser and go to this link:
-
Click on "Play" and wait for the game to load
-
Enjoy playing Sugar Wala Game!
-
-
How to Play Sugar Wala Game?
-
Sugar Wala Game is easy to play but hard to master. The basic gameplay mechanics are similar to other match 3 puzzle games, but with some twists and tricks. Here are some tips for playing the game:
-
Basic gameplay mechanics and tips for matching, popping, and blasting candies
-
-
The goal of each level is to complete the objective shown on the screen, such as reaching a target score, clearing the jelly, collecting the ingredients, or fulfilling the order
-
To do this, you have to match at least three candies of the same color by swiping them horizontally or vertically
-
Matching four or more candies will create special candies that have different effects, such as striped candies, wrapped candies, color bombs, and jelly fish
-
You can combine two special candies to create even more powerful effects, such as a striped candy and a wrapped candy will create a giant candy that clears three rows and three columns
-
You can also use boosters to help you in difficult levels, such as lollipop hammers, coconut wheels, free switches, and sweet teeth
-
You have a limited number of moves in each level, so use them wisely and plan ahead
-
You can earn up to three stars in each level depending on your score, and you can replay any level to improve your score
-
-
Game Modes and Challenges
-
Sugar Wala Game has different game modes and challenges that add variety and fun to the game. Some of these are:
-
-
Target Score: You have to reach a certain score within the given moves or time limit
-
Clear the Jelly: You have to clear all the jelly tiles by matching candies on them
-
Collect the Ingredients: You have to bring down all the ingredients (cherries or hazelnuts) to the bottom of the board
-
Order Mode: You have to collect a specific number and type of candies or special candies
-
Mixed Mode: You have to complete two or more objectives in one level
-
Candy Order: You have to collect a certain amount of sugar in each cup by drawing lines and bridges
-
Sugar Drop: You have to collect enough sugar drops by matching candies that have them
-
Dreamworld: You have to balance the moon scale by matching candies of the same color as the moonstruck candy
-
Episode Race: You have to compete with other players to finish an episode first and win prizes
-
Trinity Challenge: You have to complete three levels in a row without losing any lives and win trinity gems
-
-
Boosters and Rewards
-
Sugar Wala Game has many boosters and rewards that can help you in your sweet journey. Some of these are:
-
sugar wala game free download
-sugar wala game online play
-sugar wala game apk download
-sugar wala game for pc
-sugar wala game app
-sugar wala game install
-sugar wala game candy crush saga
-sugar wala game kaise khele
-sugar wala game video
-sugar wala game review
-sugar wala game hack
-sugar wala game mod apk
-sugar wala game cheats
-sugar wala game tips and tricks
-sugar wala game latest version
-sugar wala game update
-sugar wala game new levels
-sugar wala game features
-sugar wala game requirements
-sugar wala game size
-sugar wala game rating
-sugar wala game developer
-sugar wala game genre
-sugar wala game similar games
-sugar wala game alternatives
-sugar wala game best strategies
-sugar wala game walkthrough
-sugar wala game guide
-sugar wala game tutorial
-sugar wala game help
-sugar wala game support
-sugar wala game feedback
-sugar wala game forum
-sugar wala game community
-sugar wala game fan page
-sugar wala game blog
-sugar wala game news
-sugar wala game offers
-sugar wala game rewards
-sugar wala game spin wheel
-sugar wala game boosters
-sugar wala game combos
-sugar wala game puzzles
-sugar wala game challenges
-sugar wala game modes
-sugar wala game themes
-sugar wala game graphics
-sugar wala game sound effects
-sugar wala game music
-
-
Daily Booster Wheel: You can spin this wheel once a day for free and win a random booster, such as a striped candy, a wrapped candy, a color bomb, a jelly fish, a coconut wheel, a free switch, or a jackpot of all boosters
-
Trinity Gems: You can collect these gems by completing trinity challenges or buying them with real money. You can use them to buy more boosters, lives, moves, or tickets
-
Lives: You have five lives at the start of the game, and you lose one life every time you fail a level. You can regain one life every 30 minutes, or you can ask your friends for more lives, or you can buy more lives with trinity gems or real money
-
Moves: You have a limited number of moves in each level, but you can buy more moves with trinity gems or real money if you run out of them
Tickets: You need tickets to unlock new episodes after every 15 levels. You can get tickets by asking your friends for help, or by buying them with trinity gems or real money
-
Gold Bars: You can earn gold bars by completing certain achievements or buying them with real money. You can use gold bars to buy more boosters, lives, moves, or tickets
-
-
Friends and Leaderboards
Sugar Wala Game is more fun when you play with your friends. You can connect the game to your Facebook account and invite your friends to join you. You can also see how your friends are doing on the map and compare your scores with them on the leaderboard. You can also send and receive lives, moves, and tickets from your friends. Playing with friends can also unlock special events and rewards, such as the Friend Fiesta, the Team Challenge, and the Sugar Stars.
-
Why Play Sugar Wala Game?
-
Sugar Wala Game is not only a fun and addictive puzzle game, but also a game that has many benefits for your mind and mood. Here are some reasons why you should play Sugar Wala Game:
-
-
It stimulates your brain and improves your cognitive skills, such as memory, attention, logic, and problem-solving
-
It relaxes your mind and reduces stress, anxiety, and boredom
-
It boosts your mood and makes you happy, thanks to the colorful graphics, cheerful music, and sweet rewards
-
It challenges you and motivates you to achieve your goals, such as completing levels, earning stars, and unlocking new episodes
-
It entertains you and keeps you engaged, thanks to the variety of game modes, challenges, and features
-
It connects you with your friends and lets you share your progress, achievements, and fun moments
-
-
Sugar Wala Game Alternatives
-
If you love Sugar Wala Game, you may also enjoy other similar games that offer the same or different kinds of match 3 puzzle fun. Here are some of the best alternatives to Sugar Wala Game that you can try:
-
-
-
Game Name
-
Description
-
-
-
Candy Crush Saga
-
The original and most famous match 3 puzzle game that inspired Sugar Wala Game. Match candies in hundreds of levels and explore the sweet world of Candy Kingdom.
-
-
-
Candy Crush Soda Saga
-
The sequel to Candy Crush Saga that adds new elements, such as soda bottles, frosting, honey, and bubblegum. Match candies in over 3000 levels and pop the soda.
-
-
-
Candy Crush Jelly Saga
-
The third installment in the Candy Crush series that introduces new characters, such as the Jelly Queen and her minions. Match candies in over 2000 levels and spread the jelly.
-
-
Candy Crush Friends Saga
The latest addition to the Candy Crush family that features new 3D graphics, animations, and gameplay. Match candies in over 1000 levels and collect your candy friends.
Cookie Jam
A delicious match 3 puzzle game that lets you travel around the world and bake amazing desserts. Match cookies in over 6000 levels and satisfy your sweet tooth.
Toon Blast
A cartoon-themed match 3 puzzle game that lets you join a crazy adventure with funny characters. Match cubes in over 5000 levels and blast away the obstacles.
Gummy Drop!
A travel-themed match 3 puzzle game that lets you explore famous cities and landmarks. Match gummies in over 10000 levels and rebuild the world.
ConclusionSugar Wala Game is a simulation game that challenges you to sift sugar into coffee cups by drawing lines and bridges. It is also a match 3 puzzle game that lets you match, pop, and blast candies in a tasty adventure. It is a fun and addictive game that has many features, such as different game modes, challenges, boosters, rewards, friends, and leaderboards. It is also a game that has many benefits for your brain and mood, such as stimulating your cognitive skills, relaxing your mind, boosting your mood, challenging you to achieve your goals, entertaining you with variety, and connecting you with your friends. It is a game that you can download for free on various platforms, such as Google Play Store, App Store, Microsoft Store, and Poki.
-
If you are looking for a sweet treat for your senses, then you should download Sugar Wala Game today and enjoy the sugar-coated puzzle fun. You will not regret it!
-
Frequently Asked Questions (FAQs)
Here are some of the most common questions that people ask about Sugar Wala Game:
What is the highest level in Sugar Wala Game?
The highest level in Sugar Wala Game is currently level 5000, but the developers are constantly adding new levels and episodes every two weeks, so the number may change in the future.
-
How can I get more trinity gems in Sugar Wala Game?
-
There are several ways to get more trinity gems in Sugar Wala Game, such as:
-
-
Completing trinity challenges, which are three levels in a row that you have to complete without losing any lives
-
Spinning the trinity gem wheel, which is available once a day for free and gives you a chance to win up to 100 trinity gems
-
Buying them with real money, which is the fastest but most expensive way to get more trinity gems
-
-
How can I play Sugar Wala Game offline?
-
You can play Sugar Wala Game offline by downloading it on your device and launching it without an internet connection. However, you will not be able to access some of the game features, such as syncing your progress, sending and receiving lives, moves, and tickets from your friends, competing on the leaderboard, and participating in special events and rewards.
-
Is Sugar Wala Game safe for kids?
-
Sugar Wala Game is safe for kids as it does not contain any violence, gore, nudity, or profanity. However, it does have some in-game items that require real money to purchase, such as trinity gems, gold bars, boosters, lives, moves, and tickets. Therefore, parents should monitor their kids' spending habits and set parental controls if necessary.
-
How can I contact the developers of Sugar Wala Game?
-
You can contact the developers of Sugar Wala Game by sending them an email at support@bontegames.com or by visiting their website at . You can also follow them on Facebook, Twitter, Instagram, and YouTube for the latest news and updates about the game.
- 197e85843d
-
-
\ No newline at end of file
diff --git a/spaces/fatiXbelha/sd/Download TikTok Beats and Remixes How to Create Your Own Music with TikTok Sounds.md b/spaces/fatiXbelha/sd/Download TikTok Beats and Remixes How to Create Your Own Music with TikTok Sounds.md
deleted file mode 100644
index cefa8e339d7e714a3eb90a4d182ef14157cd16ad..0000000000000000000000000000000000000000
--- a/spaces/fatiXbelha/sd/Download TikTok Beats and Remixes How to Create Your Own Music with TikTok Sounds.md
+++ /dev/null
@@ -1,111 +0,0 @@
-
-
How to Download TikTok Beats for Free in 2021
-
TikTok is one of the most popular social media platforms in the world, with over 1 billion active users. It is also a great source of entertainment, creativity, and inspiration for many people. One of the main features of TikTok is its music and sound library, which allows users to add various songs and sounds to their videos.
But what if you want to download some of these songs and sounds for your own use? Maybe you want to use them in your own videos, or listen to them offline, or remix them with other tracks. How can you do that?
-
In this article, we will show you how to download TikTok beats for free in 2021. We will also explain what TikTok beats are, why you should download them, how to find the best ones, and how to use them in your own videos. Let's get started!
-
What are TikTok Beats and Why You Should Download Them
-
TikTok Beats are the viral songs and sounds from TikTok
-
TikTok beats are basically the songs and sounds that go viral on TikTok. They can be original tracks created by artists and producers on TikTok, or remixes of popular songs from other sources. They can also be snippets of dialogues, speeches, memes, or other audio clips that become trends on TikTok.
-
TikTok beats are usually catchy, upbeat, and fun. They often have a strong rhythm, melody, or hook that makes them easy to remember and sing along to. They also have a variety of genres, styles, and moods, ranging from hip hop, pop, rock, EDM, R&B, country, reggae, jazz, classical, and more.
-
TikTok Beats can help you create engaging and trendy videos
-
One of the reasons why you should download TikTok beats is that they can help you create engaging and trendy videos on TikTok. By using the same songs and sounds that other popular creators use, you can join in on the challenges, trends, dances, lip syncs, skits, pranks, tutorials, and other types of content that make TikTok so fun and diverse.
-
download tiktok instrumentals and free beats for your music 2023
-download tiktok mp3 online with free tik tok mp3 downloader
-download tiktok royalty-free audio tracks and instrumentals
-download tiktok music crdownload viewer
-download tiktok dangerous challenge song 2021 mp3
-download tiktok sounds and videos for free without watermark
-download tiktok to mp3 converter
-download tiktok audio downloader
-download tiktok no copyright song and mp3 free
-download tiktok future bass staircase
-download tiktok energetic tik tok
-download tiktok rap beats and hip hop instrumentals
-download tiktok dancehall and reggae riddims
-download tiktok pop and rock music
-download tiktok gospel and worship songs
-download tiktok afrobeat and highlife beats
-download tiktok bongo flava and east african music
-download tiktok trap and edm beats
-download tiktok r&b and soul music
-download tiktok jazz and blues instrumentals
-download tiktok comedy and prank sounds
-download tiktok remixes and mashups
-download tiktok viral and trending songs
-download tiktok lofi and chillhop beats
-download tiktok country and folk music
-download tiktok classical and orchestral music
-download tiktok metal and punk rock music
-download tiktok indie and alternative music
-download tiktok kpop and asian music
-download tiktok latin and reggaeton music
-download tiktok house and techno music
-download tiktok dubstep and drum and bass music
-download tiktok ambient and cinematic music
-download tiktok funk and disco music
-download tiktok celtic and medieval music
-download tiktok halloween and horror sounds
-download tiktok christmas and holiday songs
-download tiktok motivational and inspirational music
-download tiktok meditation and relaxation music
-download tiktok workout and fitness music
-download tiktok gaming and esports music
-download tiktok kids and nursery rhymes
-download tiktok anime and cartoon music
-download tiktok movie and tv show soundtracks
-download tiktok podcast and vlog music
-download tiktok wedding and romantic music
-download tiktok birthday and party music
-download tiktok karaoke and sing along songs
-
Using TikTok beats can also help you attract more viewers, followers, likes, comments, and shares on your videos. People are more likely to watch your videos if they recognize the song or sound that you use. They are also more likely to engage with your videos if they enjoy the song or sound that you use.
-
Moreover, using TikTok beats can help you express yourself creatively and authentically. You can choose the songs and sounds that match your personality, mood, style, message, or theme. You can also mix and match different songs and sounds to create your own unique mashups.
-
How to Find the Best TikTok Beats of 2021
-
Use hashtags and keywords to discover popular beats on TikTok
-
One of the easiest ways to find the best TikTok beats of 2021 is to use hashtags and keywords to discover popular beats on TikTok. You can search for hashtags like # tiktokbeats, #tiktoksongs, #tiktokmusic, #tiktokhits, #tiktoktunes, #tiktoksound, #tiktokaudio, or #tiktokchallenge. You can also search for keywords like "TikTok beats 2021", "TikTok songs 2021", "TikTok music 2021", "TikTok hits 2021", "TikTok tunes 2021", "TikTok sound 2021", "TikTok audio 2021", or "TikTok challenge 2021".
-
By using these hashtags and keywords, you can find the most popular and trending beats on TikTok. You can also see how other creators use them in their videos and get inspired by their ideas. You can also follow the hashtags and keywords to stay updated on the latest beats on TikTok.
-
Follow your favorite artists and producers on TikTok
-
Another way to find the best TikTok beats of 2021 is to follow your favorite artists and producers on TikTok. Many artists and producers upload their original tracks or remixes on TikTok, and some of them even create exclusive beats for TikTok users. You can follow them to get access to their music and see how they make their beats.
-
Some of the most popular artists and producers on TikTok are Doja Cat, Lil Nas X, Megan Thee Stallion, Olivia Rodrigo, Dua Lipa, Jason Derulo, BTS, The Weeknd, Drake, Justin Bieber, Ed Sheeran, Billie Eilish, Ariana Grande, Taylor Swift, Marshmello, Alan Walker, DJ Snake, Martin Garrix, Skrillex, Diplo, and more.
-
By following these artists and producers on TikTok, you can also interact with them and their fans. You can comment on their videos, like their posts, share their music, and even duet with them. You can also request them to make a beat for you or collaborate with them on a project.
-
Check out playlists and compilations of TikTok beats on Spotify and YouTube
-
A third way to find the best TikTok beats of 2021 is to check out playlists and compilations of TikTok beats on Spotify and YouTube. There are many playlists and compilations of TikTok beats on these platforms that are curated by experts, influencers, or fans. You can listen to these playlists and compilations to discover new beats or find your favorites.
-
Some of the most popular playlists and compilations of TikTok beats on Spotify are TikTok Viral Hits 2021, TikTok Songs 2021, TikTok Music 2021, TikTok Hits 2021, TikTok Tunes 2021, TikTok Sound 2021, TikTok Audio 2021, and TikTok Challenge 2021. Some of the most popular playlists and compilations of TikTok beats on YouTube are Top 50 Viral TikTok Songs & Music in 2021, Best Of Tik Tok Music 2021 - Top Trending Songs & Beats On Tik Tok Right Now, New Popular Songs & Beats On Tik Tok - Best Of Music & Sounds On Tik Tok Today, and Ultimate Tik Tok Songs & Beats Playlist - All Time Best Music & Sounds On Tik Tok Ever.
-
By checking out these playlists and compilations of TikTok beats on Spotify and YouTube, you can also enjoy high-quality audio and video. You can also download the playlists and compilations for offline listening or watching. You can also create your own playlists and compilations of your favorite beats on these platforms.
-
How to Download TikTok Beats for Free Using Online Tools
-
Copy the link of the TikTok video that contains the beat you want
-
The first step to download a TikTok beat for free is to copy the link of the TikTok video that contains the beat you want. To do this, you need to open the video on the TikTok app or website. Then, you need to tap or click on the share icon at the bottom right corner of the screen. Then, you need to tap or click on the copy link option from the menu that appears.
-
Alternatively, you can also copy the link of the video from the address bar of your browser if you are using a computer. You just need to select the link and press Ctrl+C (Windows) or Command+C (Mac) on your keyboard.
-
Go to a TikTok audio downloader platform
-
The second step to download a TikTok beat for free is to go to a TikTok audio downloader platform. A TikTok audio downloader platform is a website or app that allows you to download the audio from any TikTok video for free. There are many TikTok audio downloader platforms available online, but some of the most popular and reliable ones are: - TikTokToMP3: This is a simple and fast TikTok audio downloader platform that lets you download the MP3 file of any TikTok video in seconds. You just need to paste the video link and click on the download button. You can also choose the quality of the MP3 file from low, medium, or high. - MusicallyDown: This is another easy and quick TikTok audio downloader platform that allows you to download the MP3 file of any TikTok video in a few clicks. You just need to paste the video link and click on the download MP3 button. You can also download the video itself in MP4 format if you want. - SnapTik: This is a versatile and powerful TikTok audio downloader platform that enables you to download the MP3 file of any TikTok video in high quality. You just need to paste the video link and click on the download audio button. You can also download the video in HD quality, with or without watermark, and with or without subtitles.
Paste the video link and download the MP3 file
-
The third and final step to download a TikTok beat for free is to paste the video link and download the MP3 file. To do this, you need to go to the TikTok audio downloader platform of your choice and paste the video link in the input box. Then, you need to click on the download button or option that appears. The platform will then process your request and generate a download link for the MP3 file of the TikTok beat.
-
Once you have the download link, you need to click on it or right-click on it and choose save as or save link as from the menu that appears. Then, you need to choose a location on your device or cloud storage where you want to save the MP3 file. Then, you need to wait for the download to finish.
-
Congratulations! You have successfully downloaded a TikTok beat for free using an online tool. You can now enjoy listening to it offline, or use it in your own videos.
-
How to Use TikTok Beats in Your Own Videos
-
Upload the downloaded MP3 file to your device or cloud storage
-
The first step to use a TikTok beat in your own video is to upload the downloaded MP3 file to your device or cloud storage. To do this, you need to connect your device to your computer using a USB cable or Wi-Fi, or access your cloud storage using an app or browser. Then, you need to locate the MP3 file on your computer and drag and drop it or copy and paste it to your device or cloud storage.
-
Alternatively, you can also use an app like Dropbox, Google Drive, OneDrive, iCloud, or Amazon Drive to upload the MP3 file from your computer to your cloud storage directly. You just need to sign in to your account and select the upload option from the app.
-
Select the MP3 file as your sound when creating a new video on TikTok
-
The second step to use a TikTok beat in your own video is to select the MP3 file as your sound when creating a new video on TikTok. To do this, you need to open the TikTok app on your device and tap on the plus icon at the bottom center of the screen. Then, you need to tap on the sound icon at the top right corner of the screen.
-
Then, you need to tap on the my sound option at the bottom of the screen. This will open your device or cloud storage where you have uploaded the MP3 file. Then, you need to browse and select the MP3 file that you want to use as your sound. You will see a preview of the sound and its waveform on the screen.
-
Then, you need to tap on the confirm option at the bottom right corner of the screen. This will add the sound to your video and allow you to trim, adjust, or loop it as you wish. You can also add voice effects, filters, or stickers to your sound if you want.
-
Edit your video and add effects, filters, stickers, captions, etc.
-
The third and final step to use a TikTok beat in your own video is to edit your video and add effects, filters, stickers, captions, etc. To do this, you need to record your video using the red button at the bottom center of the screen. You can also upload a video from your device or cloud storage using the upload option at the bottom right corner of the screen.
-
Once you have recorded or uploaded your video, you can edit it using the tools at the bottom of the screen. You can add effects, filters, stickers, captions, hashtags, mentions, emojis, or other elements to your video. You can also trim, crop, rotate, speed up, slow down, reverse, or duplicate your video. You can also adjust the volume, pitch, or timing of your sound.
-
When you are done editing your video, you can tap on the next option at the bottom right corner of the screen. This will take you to the final page where you can add a title, description, cover image, and privacy settings to your video. You can also choose to save it as a draft or post it immediately.
-
Conclusion
-
TikTok beats are one of the best ways to spice up your videos and join in on the fun and trends on TikTok. They are also a great way to discover new music and artists that you might like. By following this guide, you can easily download TikTok beats for free in 2021 and use them in your own videos.
-
So what are you waiting for? Go ahead and download some TikTok beats today and unleash your creativity and personality on TikTok. You never know, you might become the next viral sensation on TikTok!
-
FAQs
-
Q: Can I download any TikTok beat for free?
-
A: Yes, you can download any TikTok beat for free using online tools like TikTokToMP3, MusicallyDown, or SnapTik. However, you should respect the rights and credits of the original creators and not use their beats for commercial purposes without their permission.
-
Q: How can I find out the name and artist of a TikTok beat?
-
A: You can find out the name and artist of a TikTok beat by tapping or clicking on the spinning disc icon at the bottom right corner of the video that contains the beat. This will show you the name and artist of the beat as well as other videos that use it.
-
Q: How can I make my own TikTok beat?
-
A: You can make your own TikTok beat by using apps like GarageBand, FL Studio Mobile, Music Maker Jam, or Beat Snap. These apps allow you to create your own tracks or remixes using various instruments, loops, samples, effects, and more.
-
Q: How can I share my TikTok beat with others?
-
A: You can share your TikTok beat with others by uploading it to your device or cloud storage and then copying its link. Then, you can paste the link in your bio, caption, comment, message, or any other platform where you want to share it. You can also tag or mention the original creators or artists of the beat if you have used their samples or tracks.
-
Q: How can I download TikTok beats on my iPhone or iPad?
-
A: You can download TikTok beats on your iPhone or iPad by using the same online tools as mentioned above. However, you may need to use a third-party app like Documents by Readdle, MyMedia, or FileMaster to save the MP3 file to your device. You can also use a cloud storage app like Dropbox, Google Drive, OneDrive, iCloud, or Amazon Drive to save the MP3 file to your cloud storage.
197e85843d
-
-
\ No newline at end of file
diff --git a/spaces/fatiXbelha/sd/Download and Install Lenovo G40-30 G50-30 Intel Graphics Driver for Windows 8.1 (64-bit).md b/spaces/fatiXbelha/sd/Download and Install Lenovo G40-30 G50-30 Intel Graphics Driver for Windows 8.1 (64-bit).md
deleted file mode 100644
index 1708ce1211693faee0eb78c3215d9cc8fdcecbab..0000000000000000000000000000000000000000
--- a/spaces/fatiXbelha/sd/Download and Install Lenovo G40-30 G50-30 Intel Graphics Driver for Windows 8.1 (64-bit).md
+++ /dev/null
@@ -1,137 +0,0 @@
-
-
How to Download and Install Drivers for Lenovo G40-30 Windows 8.1 64-bit
-
Drivers are software components that allow your computer and its devices to communicate with each other. They are essential for the proper functioning of your hardware, such as your network adapter, video card, sound card, printer, webcam, and more.
-
Updating drivers can improve the performance, stability, compatibility, and security of your computer. It can also enable new features and fix bugs in your devices. In this article, we will show you how to download and install drivers for your Lenovo G40-30 laptop running Windows 8.1 64-bit.
The Lenovo G40-30 is a laptop with a 14-inch display, powered by an Intel Celeron or Pentium processor, with up to 16 GB of RAM and up to 1 TB of hard disk space. It has various ports and features, such as USB 3.0, HDMI, VGA, Ethernet, audio combo jack, card reader, webcam, speakers, microphone, keyboard, touchpad, and more.
-
How to Download Drivers for Lenovo G40-30
-
To download drivers for your Lenovo G40-30 laptop, you will need to know the model and serial number of your device. You will also need to access the Lenovo support website and choose the right drivers for your operating system and hardware.
-
How to Find the Model and Serial Number of Your Laptop
-
The model and serial number of your laptop are usually printed on a sticker on the bottom of your device. You can also find them by following these steps:
-
-
Open the Start menu and type "cmd" in the search box.
-
Right-click on Command Prompt and select Run as administrator.
-
Type "wmic csproduct get name" and press Enter. This will show you the model name of your laptop.
-
Type "wmic bios get serialnumber" and press Enter. This will show you the serial number of your laptop.
-
-
How to Access the Lenovo Support Website and Download the Drivers
-
To access the Lenovo support website and download the drivers for your laptop, follow these steps:
Select Lenovo G Series laptops from the Series menu.
-
Select Lenovo G40-30 Laptop from the Subseries menu.
-
Type or paste your serial number in the Serial Number box and click Submit.
-
Select Drivers & Software from the left sidebar.
-
Select Windows 8.1 (64-bit) from the Operating System menu.
-
You will see a list of driver categories, such as Audio, BIOS/UEFI, Bluetooth and Modem, Camera and Card Reader, etc. Click on each category to expand it and see the available drivers.
-
Click on Download next to each driver that you want to download. You can also click on Details to see more information about each driver, such as its version number, release date, size, etc.
-
Save the driver files in a folder on your computer.
How to Choose the Right Drivers for Your Operating System and Hardware
-
It is important to choose the right drivers for your operating system and hardware, as installing the wrong drivers can cause problems or errors on your laptop. Here are some tips to help you choose the right drivers:
-
-
Make sure that the driver is compatible with your operating system version and architecture. For example, if you are using Windows 8.1 64-bit, you should download drivers that are designed for Windows 8.1 64-bit, not Windows 10 32-bit or Windows 7 64-bit.
-
Make sure that the driver is compatible with your hardware model and manufacturer. For example, if you have an Intel processor, you should download drivers that are made by Intel, not AMD or Nvidia.
-
Make sure that the driver is the latest version available. You can check the version number and release date of each driver on the Lenovo support website. You can also compare the version number with the one that is already installed on your laptop by using the Device Manager.
-
Make sure that the driver is not a beta or experimental version. Beta or experimental drivers are not fully tested and may contain bugs or errors. You should only download them if you are willing to take the risk of encountering problems or issues.
-
-
How to Install Drivers Manually on Windows 8.1
-
After downloading the drivers for your laptop, you will need to install them manually on your Windows 8.1 system. There are two main methods to do this: using the Device Manager or using the downloaded driver files.
-
How to Use the Device Manager to Update or Reinstall Drivers
-
The Device Manager is a tool that allows you to manage and update the devices and drivers on your computer. You can use it to update or reinstall drivers for your laptop by following these steps:
-
download intel graphics driver for lenovo g40-30 windows 8.1 64 bit
-download wlan driver for lenovo g40-30 windows 10 64 bit
-download intel chipset driver for lenovo g50-30 windows 8.1 64 bit
-download bluetooth driver for lenovo g40-30 windows 8.1 64 bit
-download audio driver for lenovo g50-30 windows 10 64 bit
-download touchpad driver for lenovo g40-30 windows 8.1 64 bit
-download camera driver for lenovo g50-30 windows 10 64 bit
-download bios update for lenovo g40-30 windows 8.1 64 bit
-download usb driver for lenovo g50-30 windows 10 64 bit
-download lan driver for lenovo g40-30 windows 8.1 64 bit
-download card reader driver for lenovo g50-30 windows 10 64 bit
-download energy manager for lenovo g40-30 windows 8.1 64 bit
-download veriface tools for lenovo g50-30 windows 10 64 bit
-download wireless display driver for lenovo g40-30 windows 8.1 64 bit
-download onekey optimizer for lenovo g50-30 windows 10 64 bit
-download keyboard driver for lenovo g40-30 windows 8.1 64 bit
-download power management driver for lenovo g50-30 windows 10 64 bit
-download storage driver for lenovo g40-30 windows 8.1 64 bit
-download shareit for lenovo g50-30 windows 10 64 bit
-download video driver for lenovo g40-30 windows 8.1 64 bit
-
-
Open the Start menu and type "device manager" in the search box.
-
Select Device Manager from the results.
-
You will see a list of device categories, such as Display adapters, Network adapters, Sound, video and game controllers, etc. Click on each category to expand it and see the devices under it.
-
Right-click on the device that you want to update or reinstall and select Update Driver Software or Uninstall.
-
If you select Update Driver Software, you will have two options: Search automatically for updated driver software or Browse my computer for driver software. If you choose the first option, Windows will search online for the latest driver for your device and install it automatically. If you choose the second option, you will need to browse to the folder where you saved the downloaded driver files and select them.
-
If you select Uninstall, you will be asked to confirm your action. Click OK to uninstall the driver from your device. Then, restart your laptop and Windows will try to reinstall the driver automatically. If Windows cannot find the driver, you will need to use the second option of Update Driver Software and browse to the folder where you saved the downloaded driver files.
-
-
How to Use the Downloaded Driver Files to Install Drivers
-
Another method to install drivers manually on your laptop is to use the downloaded driver files directly. These files usually have an .exe or .msi extension and can be run as executable programs. To use this method, follow these steps:
-
-
Locate the folder where you saved the downloaded driver files.
-
Double-click on each file to run it as an administrator.
-
You will see a setup wizard that will guide you through the installation process. Follow the instructions on the screen and accept any terms and conditions or license agreements.
-
Wait for the installation to complete and click Finish or Close when done.
-
-
How to Restart Your Laptop After Installing Drivers
-
After installing drivers manually on your laptop, it is recommended that you restart your device to apply the changes and ensure that everything works properly. To restart your laptop, follow these steps:
-
-
Open the Start menu and click on Power.
-
Select Restart from the options.
-
Your laptop will shut down and restart automatically.
-
-
Conclusion
-
In this article, we have shown you how to download and install drivers for your Lenovo G40-30 laptop running Windows 8.1 64-bit. We have explained what drivers are and why they are important, how to find the model and serial number of your laptop, how to access the Lenovo support website and download the drivers, how to choose the right drivers for your operating system and hardware, how to install drivers manually using the Device Manager or using the downloaded driver files, and how to restart your laptop after installing drivers. We hope that this article has been helpful and informative for you.
-
Updating drivers can enhance the performance, stability, compatibility, and security of your laptop and its devices. It can also enable new features and fix bugs in your hardware. However, updating drivers also involves some risks and challenges, such as installing the wrong drivers, encountering driver conflicts or errors, or losing your drivers due to system crashes or malware attacks. Therefore, you should always be careful and cautious when updating drivers and follow the instructions and tips that we have provided in this article.
-
If you have any feedback or questions about this article or about downloading and installing drivers for your Lenovo G40-30 laptop running Windows 8.1 64-bit, please feel free to leave a comment below or contact us through our website. We would love to hear from you and help you with any issues or problems that you may have.
-
FAQs
-
Here are some frequently asked questions and answers about downloading and installing drivers for your Lenovo G40-30 laptop running Windows 8.1 64-bit.
-
What are some common driver problems and how to fix them?
-
Some common driver problems that you may encounter on your laptop are:
-
-
Driver not found or missing: This means that Windows cannot detect or locate the driver for your device. This can happen if the driver is corrupted, outdated, incompatible, or deleted. To fix this problem, you can try to update or reinstall the driver using the methods that we have described in this article.
-
Driver not working or malfunctioning: This means that the driver is not functioning properly or causing errors on your device. This can happen if the driver is incompatible, conflicting, buggy, or infected. To fix this problem, you can try to update or reinstall the driver using the methods that we have described in this article. You can also try to uninstall the driver and use the default Windows driver instead.
-
Driver not compatible or supported: This means that the driver is not suitable or designed for your operating system or hardware. This can happen if the driver is outdated, incorrect, or mismatched. To fix this problem, you can try to download and install the correct and latest driver for your operating system and hardware from the Lenovo support website.
-
-
How to check if your drivers are up to date?
-
To check if your drivers are up to date on your laptop, you can use the Device Manager or a third-party tool. To use the Device Manager, follow these steps:
-
-
Open the Start menu and type "device manager" in the search box.
-
Select Device Manager from the results.
-
You will see a list of device categories, such as Display adapters, Network adapters, Sound, video and game controllers, etc. Click on each category to expand it and see the devices under it.
-
Right-click on each device and select Properties.
-
Select the Driver tab and check the Driver Version and Driver Date fields. Compare them with the version number and release date of the latest driver available on the Lenovo support website. If they are different, it means that your driver is outdated and needs to be updated.
-
-
To use a third-party tool, you can download and install a software program that can scan your laptop and detect any outdated or missing drivers. Some examples of such tools are Driver Booster, Driver Easy, Driver Genius, etc. These tools can also help you download and install the latest drivers automatically with one click.
-
How to backup and restore your drivers?
-
Backing up and restoring your drivers can help you prevent data loss or damage in case of system crashes or malware attacks. It can also help you revert to a previous driver version if you encounter any problems or issues with a new driver update. To backup and restore your drivers on your laptop, you can use a third-party tool or a built-in Windows feature. To use a third-party tool, you can download and install a software program that can backup and restore your drivers easily and quickly. Some examples of such tools are Driver Magician, Double Driver, DriverMax, etc. These tools can also help you backup and restore other important system files and settings.
-
To use a built-in Windows feature, you can use the System Restore function. System Restore is a feature that allows you to create restore points that contain snapshots of your system files and settings at a certain point in time. You can use these restore points to restore your system to a previous state if something goes wrong. To use System Restore, follow these steps:
-
-
Open the Start menu and type "system restore" in the search box.
-
Select Create a restore point from the results.
The System Properties window will open. Select the System Protection tab and click on System Restore.
-
The System Restore window will open. Click on Next to see the available restore points.
-
Select a restore point that was created before you updated or installed any drivers. You can also click on Show more restore points to see more options. Click on Next to proceed.
-
Review the details of the restore point and click on Finish to confirm your action.
-
Your laptop will restart and restore your system to the selected restore point. This may take some time, so be patient and do not interrupt the process.
-
-
How to uninstall drivers that are causing problems?
-
If you have installed a driver that is causing problems or errors on your laptop, you can uninstall it and use the default Windows driver or a previous driver version instead. To uninstall a driver on your laptop, follow these steps:
-
-
Open the Start menu and type "device manager" in the search box.
-
Select Device Manager from the results.
-
You will see a list of device categories, such as Display adapters, Network adapters, Sound, video and game controllers, etc. Click on each category to expand it and see the devices under it.
-
Right-click on the device that has the problematic driver and select Uninstall.
-
You will be asked to confirm your action. Check the box that says Delete the driver software for this device and click OK.
-
Restart your laptop and Windows will try to install the default or a previous driver for your device.
-
-
How to update drivers automatically using a third-party tool?
-
If you do not want to update drivers manually on your laptop, you can use a third-party tool that can scan your system and update all your drivers automatically with one click. This can save you time and hassle, as well as ensure that you have the latest and most compatible drivers for your devices. However, you should be careful when choosing a third-party tool, as some of them may contain malware or adware, or charge you for their services. To update drivers automatically using a third-party tool, follow these steps:
-
-
Download and install a reputable and reliable third-party tool that can update drivers automatically. Some examples of such tools are Driver Booster, Driver Easy, Driver Genius, etc. You can find them online or in software stores.
-
Run the tool and scan your system for any outdated or missing drivers. The tool will show you a list of drivers that need to be updated or installed.
-
Click on Update All or Install All to update or install all the drivers automatically. You may need to register or pay for the tool to use this feature.
-
Wait for the process to complete and restart your laptop when prompted.
-
197e85843d
-
-
\ No newline at end of file
diff --git a/spaces/fb700/chat3/crazy_functions/__init__.py b/spaces/fb700/chat3/crazy_functions/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/fb700/chatglm-fitness-RLHF/crazy_functions/test_project/cpp/libJPG/jpgd.h b/spaces/fb700/chatglm-fitness-RLHF/crazy_functions/test_project/cpp/libJPG/jpgd.h
deleted file mode 100644
index a1c0cac61839a6f66a42c341f50d5e36faad9a93..0000000000000000000000000000000000000000
--- a/spaces/fb700/chatglm-fitness-RLHF/crazy_functions/test_project/cpp/libJPG/jpgd.h
+++ /dev/null
@@ -1,316 +0,0 @@
-// jpgd.h - C++ class for JPEG decompression.
-// Public domain, Rich Geldreich
-#ifndef JPEG_DECODER_H
-#define JPEG_DECODER_H
-
-#include
-#include
-#include
-
-namespace jpgd
-{
- typedef unsigned char uint8;
- typedef signed short int16;
- typedef unsigned short uint16;
- typedef unsigned int uint;
- typedef signed int int32;
-
- // Loads a JPEG image from a memory buffer or a file.
- // req_comps can be 1 (grayscale), 3 (RGB), or 4 (RGBA).
- // On return, width/height will be set to the image's dimensions, and actual_comps will be set to the either 1 (grayscale) or 3 (RGB).
- // Notes: For more control over where and how the source data is read, see the decompress_jpeg_image_from_stream() function below, or call the jpeg_decoder class directly.
- // Requesting a 8 or 32bpp image is currently a little faster than 24bpp because the jpeg_decoder class itself currently always unpacks to either 8 or 32bpp.
-// BEGIN EPIC MOD
-//unsigned char *decompress_jpeg_image_from_memory(const unsigned char *pSrc_data, int src_data_size, int *width, int *height, int *actual_comps, int req_comps);
- unsigned char *decompress_jpeg_image_from_memory(const unsigned char *pSrc_data, int src_data_size, int *width, int *height, int *actual_comps, int req_comps, int format);
-// END EPIC MOD
- unsigned char *decompress_jpeg_image_from_file(const char *pSrc_filename, int *width, int *height, int *actual_comps, int req_comps);
-
- // Success/failure error codes.
- enum jpgd_status
- {
- JPGD_SUCCESS = 0, JPGD_FAILED = -1, JPGD_DONE = 1,
- JPGD_BAD_DHT_COUNTS = -256, JPGD_BAD_DHT_INDEX, JPGD_BAD_DHT_MARKER, JPGD_BAD_DQT_MARKER, JPGD_BAD_DQT_TABLE,
- JPGD_BAD_PRECISION, JPGD_BAD_HEIGHT, JPGD_BAD_WIDTH, JPGD_TOO_MANY_COMPONENTS,
- JPGD_BAD_SOF_LENGTH, JPGD_BAD_VARIABLE_MARKER, JPGD_BAD_DRI_LENGTH, JPGD_BAD_SOS_LENGTH,
- JPGD_BAD_SOS_COMP_ID, JPGD_W_EXTRA_BYTES_BEFORE_MARKER, JPGD_NO_ARITHMITIC_SUPPORT, JPGD_UNEXPECTED_MARKER,
- JPGD_NOT_JPEG, JPGD_UNSUPPORTED_MARKER, JPGD_BAD_DQT_LENGTH, JPGD_TOO_MANY_BLOCKS,
- JPGD_UNDEFINED_QUANT_TABLE, JPGD_UNDEFINED_HUFF_TABLE, JPGD_NOT_SINGLE_SCAN, JPGD_UNSUPPORTED_COLORSPACE,
- JPGD_UNSUPPORTED_SAMP_FACTORS, JPGD_DECODE_ERROR, JPGD_BAD_RESTART_MARKER, JPGD_ASSERTION_ERROR,
- JPGD_BAD_SOS_SPECTRAL, JPGD_BAD_SOS_SUCCESSIVE, JPGD_STREAM_READ, JPGD_NOTENOUGHMEM
- };
-
- // Input stream interface.
- // Derive from this class to read input data from sources other than files or memory. Set m_eof_flag to true when no more data is available.
- // The decoder is rather greedy: it will keep on calling this method until its internal input buffer is full, or until the EOF flag is set.
- // It the input stream contains data after the JPEG stream's EOI (end of image) marker it will probably be pulled into the internal buffer.
- // Call the get_total_bytes_read() method to determine the actual size of the JPEG stream after successful decoding.
- class jpeg_decoder_stream
- {
- public:
- jpeg_decoder_stream() { }
- virtual ~jpeg_decoder_stream() { }
-
- // The read() method is called when the internal input buffer is empty.
- // Parameters:
- // pBuf - input buffer
- // max_bytes_to_read - maximum bytes that can be written to pBuf
- // pEOF_flag - set this to true if at end of stream (no more bytes remaining)
- // Returns -1 on error, otherwise return the number of bytes actually written to the buffer (which may be 0).
- // Notes: This method will be called in a loop until you set *pEOF_flag to true or the internal buffer is full.
- virtual int read(uint8 *pBuf, int max_bytes_to_read, bool *pEOF_flag) = 0;
- };
-
- // stdio FILE stream class.
- class jpeg_decoder_file_stream : public jpeg_decoder_stream
- {
- jpeg_decoder_file_stream(const jpeg_decoder_file_stream &);
- jpeg_decoder_file_stream &operator =(const jpeg_decoder_file_stream &);
-
- FILE *m_pFile;
- bool m_eof_flag, m_error_flag;
-
- public:
- jpeg_decoder_file_stream();
- virtual ~jpeg_decoder_file_stream();
-
- bool open(const char *Pfilename);
- void close();
-
- virtual int read(uint8 *pBuf, int max_bytes_to_read, bool *pEOF_flag);
- };
-
- // Memory stream class.
- class jpeg_decoder_mem_stream : public jpeg_decoder_stream
- {
- const uint8 *m_pSrc_data;
- uint m_ofs, m_size;
-
- public:
- jpeg_decoder_mem_stream() : m_pSrc_data(NULL), m_ofs(0), m_size(0) { }
- jpeg_decoder_mem_stream(const uint8 *pSrc_data, uint size) : m_pSrc_data(pSrc_data), m_ofs(0), m_size(size) { }
-
- virtual ~jpeg_decoder_mem_stream() { }
-
- bool open(const uint8 *pSrc_data, uint size);
- void close() { m_pSrc_data = NULL; m_ofs = 0; m_size = 0; }
-
- virtual int read(uint8 *pBuf, int max_bytes_to_read, bool *pEOF_flag);
- };
-
- // Loads JPEG file from a jpeg_decoder_stream.
- unsigned char *decompress_jpeg_image_from_stream(jpeg_decoder_stream *pStream, int *width, int *height, int *actual_comps, int req_comps);
-
- enum
- {
- JPGD_IN_BUF_SIZE = 8192, JPGD_MAX_BLOCKS_PER_MCU = 10, JPGD_MAX_HUFF_TABLES = 8, JPGD_MAX_QUANT_TABLES = 4,
- JPGD_MAX_COMPONENTS = 4, JPGD_MAX_COMPS_IN_SCAN = 4, JPGD_MAX_BLOCKS_PER_ROW = 8192, JPGD_MAX_HEIGHT = 16384, JPGD_MAX_WIDTH = 16384
- };
-
- typedef int16 jpgd_quant_t;
- typedef int16 jpgd_block_t;
-
- class jpeg_decoder
- {
- public:
- // Call get_error_code() after constructing to determine if the stream is valid or not. You may call the get_width(), get_height(), etc.
- // methods after the constructor is called. You may then either destruct the object, or begin decoding the image by calling begin_decoding(), then decode() on each scanline.
- jpeg_decoder(jpeg_decoder_stream *pStream);
-
- ~jpeg_decoder();
-
- // Call this method after constructing the object to begin decompression.
- // If JPGD_SUCCESS is returned you may then call decode() on each scanline.
- int begin_decoding();
-
- // Returns the next scan line.
- // For grayscale images, pScan_line will point to a buffer containing 8-bit pixels (get_bytes_per_pixel() will return 1).
- // Otherwise, it will always point to a buffer containing 32-bit RGBA pixels (A will always be 255, and get_bytes_per_pixel() will return 4).
- // Returns JPGD_SUCCESS if a scan line has been returned.
- // Returns JPGD_DONE if all scan lines have been returned.
- // Returns JPGD_FAILED if an error occurred. Call get_error_code() for a more info.
- int decode(const void** pScan_line, uint* pScan_line_len);
-
- inline jpgd_status get_error_code() const { return m_error_code; }
-
- inline int get_width() const { return m_image_x_size; }
- inline int get_height() const { return m_image_y_size; }
-
- inline int get_num_components() const { return m_comps_in_frame; }
-
- inline int get_bytes_per_pixel() const { return m_dest_bytes_per_pixel; }
- inline int get_bytes_per_scan_line() const { return m_image_x_size * get_bytes_per_pixel(); }
-
- // Returns the total number of bytes actually consumed by the decoder (which should equal the actual size of the JPEG file).
- inline int get_total_bytes_read() const { return m_total_bytes_read; }
-
- private:
- jpeg_decoder(const jpeg_decoder &);
- jpeg_decoder &operator =(const jpeg_decoder &);
-
- typedef void (*pDecode_block_func)(jpeg_decoder *, int, int, int);
-
- struct huff_tables
- {
- bool ac_table;
- uint look_up[256];
- uint look_up2[256];
- uint8 code_size[256];
- uint tree[512];
- };
-
- struct coeff_buf
- {
- uint8 *pData;
- int block_num_x, block_num_y;
- int block_len_x, block_len_y;
- int block_size;
- };
-
- struct mem_block
- {
- mem_block *m_pNext;
- size_t m_used_count;
- size_t m_size;
- char m_data[1];
- };
-
- jmp_buf m_jmp_state;
- mem_block *m_pMem_blocks;
- int m_image_x_size;
- int m_image_y_size;
- jpeg_decoder_stream *m_pStream;
- int m_progressive_flag;
- uint8 m_huff_ac[JPGD_MAX_HUFF_TABLES];
- uint8* m_huff_num[JPGD_MAX_HUFF_TABLES]; // pointer to number of Huffman codes per bit size
- uint8* m_huff_val[JPGD_MAX_HUFF_TABLES]; // pointer to Huffman codes per bit size
- jpgd_quant_t* m_quant[JPGD_MAX_QUANT_TABLES]; // pointer to quantization tables
- int m_scan_type; // Gray, Yh1v1, Yh1v2, Yh2v1, Yh2v2 (CMYK111, CMYK4114 no longer supported)
- int m_comps_in_frame; // # of components in frame
- int m_comp_h_samp[JPGD_MAX_COMPONENTS]; // component's horizontal sampling factor
- int m_comp_v_samp[JPGD_MAX_COMPONENTS]; // component's vertical sampling factor
- int m_comp_quant[JPGD_MAX_COMPONENTS]; // component's quantization table selector
- int m_comp_ident[JPGD_MAX_COMPONENTS]; // component's ID
- int m_comp_h_blocks[JPGD_MAX_COMPONENTS];
- int m_comp_v_blocks[JPGD_MAX_COMPONENTS];
- int m_comps_in_scan; // # of components in scan
- int m_comp_list[JPGD_MAX_COMPS_IN_SCAN]; // components in this scan
- int m_comp_dc_tab[JPGD_MAX_COMPONENTS]; // component's DC Huffman coding table selector
- int m_comp_ac_tab[JPGD_MAX_COMPONENTS]; // component's AC Huffman coding table selector
- int m_spectral_start; // spectral selection start
- int m_spectral_end; // spectral selection end
- int m_successive_low; // successive approximation low
- int m_successive_high; // successive approximation high
- int m_max_mcu_x_size; // MCU's max. X size in pixels
- int m_max_mcu_y_size; // MCU's max. Y size in pixels
- int m_blocks_per_mcu;
- int m_max_blocks_per_row;
- int m_mcus_per_row, m_mcus_per_col;
- int m_mcu_org[JPGD_MAX_BLOCKS_PER_MCU];
- int m_total_lines_left; // total # lines left in image
- int m_mcu_lines_left; // total # lines left in this MCU
- int m_real_dest_bytes_per_scan_line;
- int m_dest_bytes_per_scan_line; // rounded up
- int m_dest_bytes_per_pixel; // 4 (RGB) or 1 (Y)
- huff_tables* m_pHuff_tabs[JPGD_MAX_HUFF_TABLES];
- coeff_buf* m_dc_coeffs[JPGD_MAX_COMPONENTS];
- coeff_buf* m_ac_coeffs[JPGD_MAX_COMPONENTS];
- int m_eob_run;
- int m_block_y_mcu[JPGD_MAX_COMPONENTS];
- uint8* m_pIn_buf_ofs;
- int m_in_buf_left;
- int m_tem_flag;
- bool m_eof_flag;
- uint8 m_in_buf_pad_start[128];
- uint8 m_in_buf[JPGD_IN_BUF_SIZE + 128];
- uint8 m_in_buf_pad_end[128];
- int m_bits_left;
- uint m_bit_buf;
- int m_restart_interval;
- int m_restarts_left;
- int m_next_restart_num;
- int m_max_mcus_per_row;
- int m_max_blocks_per_mcu;
- int m_expanded_blocks_per_mcu;
- int m_expanded_blocks_per_row;
- int m_expanded_blocks_per_component;
- bool m_freq_domain_chroma_upsample;
- int m_max_mcus_per_col;
- uint m_last_dc_val[JPGD_MAX_COMPONENTS];
- jpgd_block_t* m_pMCU_coefficients;
- int m_mcu_block_max_zag[JPGD_MAX_BLOCKS_PER_MCU];
- uint8* m_pSample_buf;
- int m_crr[256];
- int m_cbb[256];
- int m_crg[256];
- int m_cbg[256];
- uint8* m_pScan_line_0;
- uint8* m_pScan_line_1;
- jpgd_status m_error_code;
- bool m_ready_flag;
- int m_total_bytes_read;
-
- void free_all_blocks();
- // BEGIN EPIC MOD
- UE_NORETURN void stop_decoding(jpgd_status status);
- // END EPIC MOD
- void *alloc(size_t n, bool zero = false);
- void word_clear(void *p, uint16 c, uint n);
- void prep_in_buffer();
- void read_dht_marker();
- void read_dqt_marker();
- void read_sof_marker();
- void skip_variable_marker();
- void read_dri_marker();
- void read_sos_marker();
- int next_marker();
- int process_markers();
- void locate_soi_marker();
- void locate_sof_marker();
- int locate_sos_marker();
- void init(jpeg_decoder_stream * pStream);
- void create_look_ups();
- void fix_in_buffer();
- void transform_mcu(int mcu_row);
- void transform_mcu_expand(int mcu_row);
- coeff_buf* coeff_buf_open(int block_num_x, int block_num_y, int block_len_x, int block_len_y);
- inline jpgd_block_t *coeff_buf_getp(coeff_buf *cb, int block_x, int block_y);
- void load_next_row();
- void decode_next_row();
- void make_huff_table(int index, huff_tables *pH);
- void check_quant_tables();
- void check_huff_tables();
- void calc_mcu_block_order();
- int init_scan();
- void init_frame();
- void process_restart();
- void decode_scan(pDecode_block_func decode_block_func);
- void init_progressive();
- void init_sequential();
- void decode_start();
- void decode_init(jpeg_decoder_stream * pStream);
- void H2V2Convert();
- void H2V1Convert();
- void H1V2Convert();
- void H1V1Convert();
- void gray_convert();
- void expanded_convert();
- void find_eoi();
- inline uint get_char();
- inline uint get_char(bool *pPadding_flag);
- inline void stuff_char(uint8 q);
- inline uint8 get_octet();
- inline uint get_bits(int num_bits);
- inline uint get_bits_no_markers(int numbits);
- inline int huff_decode(huff_tables *pH);
- inline int huff_decode(huff_tables *pH, int& extrabits);
- static inline uint8 clamp(int i);
- static void decode_block_dc_first(jpeg_decoder *pD, int component_id, int block_x, int block_y);
- static void decode_block_dc_refine(jpeg_decoder *pD, int component_id, int block_x, int block_y);
- static void decode_block_ac_first(jpeg_decoder *pD, int component_id, int block_x, int block_y);
- static void decode_block_ac_refine(jpeg_decoder *pD, int component_id, int block_x, int block_y);
- };
-
-} // namespace jpgd
-
-#endif // JPEG_DECODER_H
diff --git a/spaces/fclong/summary/fengshen/models/roformer/modeling_roformer.py b/spaces/fclong/summary/fengshen/models/roformer/modeling_roformer.py
deleted file mode 100644
index 3f67d34c6484108890f21983a0924b3a748e97b4..0000000000000000000000000000000000000000
--- a/spaces/fclong/summary/fengshen/models/roformer/modeling_roformer.py
+++ /dev/null
@@ -1,1954 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The IDEA Authors. All rights reserved.
-
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-
-# http://www.apache.org/licenses/LICENSE-2.0
-
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-""" PyTorch RoFormer model. """
-
-import math
-import os
-import warnings
-from dataclasses import dataclass
-from typing import Optional, Tuple
-
-import torch
-import torch.utils.checkpoint
-from torch import nn
-from torch.nn import CrossEntropyLoss, MSELoss
-
-from transformers.activations import ACT2FN
-from transformers.file_utils import (
- ModelOutput,
- add_code_sample_docstrings,
- add_start_docstrings,
- add_start_docstrings_to_model_forward,
- replace_return_docstrings,
-)
-from transformers.modeling_outputs import (
- BaseModelOutputWithPastAndCrossAttentions,
- BaseModelOutputWithPoolingAndCrossAttentions,
- CausalLMOutputWithCrossAttentions,
- MaskedLMOutput,
- MultipleChoiceModelOutput,
- NextSentencePredictorOutput,
- QuestionAnsweringModelOutput,
- SequenceClassifierOutput,
- TokenClassifierOutput,
-)
-from transformers.modeling_utils import (
- PreTrainedModel,
- apply_chunking_to_forward,
- find_pruneable_heads_and_indices,
- prune_linear_layer,
-)
-from transformers.utils import logging
-from .configuration_roformer import RoFormerConfig
-
-
-logger = logging.get_logger(__name__)
-
-_CONFIG_FOR_DOC = "RoFormerConfig"
-_TOKENIZER_FOR_DOC = "BertTokenizer"
-_CHECKPOINT_FOR_DOC = "nvidia/megatron-bert-cased-345m"
-
-RoFormer_PRETRAINED_MODEL_ARCHIVE_LIST = [
- "nvidia/megatron-bert-cased-345m",
- # See all RoFormer models at https://huggingface.co/models?filter=RoFormer
-]
-
-
-def load_tf_weights_in_RoFormer(model, config, tf_checkpoint_path):
- """Load tf checkpoints in a pytorch model."""
- try:
- import re
-
- import numpy as np
- import tensorflow as tf
- except ImportError:
- logger.error(
- "Loading a TensorFlow model in PyTorch, requires TensorFlow to be installed. Please see "
- "https://www.tensorflow.org/install/ for installation instructions."
- )
- raise
- tf_path = os.path.abspath(tf_checkpoint_path)
- logger.info("Converting TensorFlow checkpoint from {}".format(tf_path))
- # Load weights from TF model
- init_vars = tf.train.list_variables(tf_path)
- names = []
- arrays = []
- for name, shape in init_vars:
- logger.info(f"Loading TF weight {name} with shape {shape}")
- array = tf.train.load_variable(tf_path, name)
- names.append(name)
- arrays.append(array)
-
- for name, array in zip(names, arrays):
- name = name.split("/")
- # adam_v and adam_m are variables used in AdamWeightDecayOptimizer to calculated m and v
- # which are not required for using pretrained model
- if any(
- n in ["adam_v", "adam_m", "AdamWeightDecayOptimizer",
- "AdamWeightDecayOptimizer_1", "global_step"]
- for n in name
- ):
- logger.info(f"Skipping {'/'.join(name)}")
- continue
- pointer = model
- for m_name in name:
- if re.fullmatch(r"[A-Za-z]+_\d+", m_name):
- scope_names = re.split(r"_(\d+)", m_name)
- else:
- scope_names = [m_name]
- if scope_names[0] == "kernel" or scope_names[0] == "gamma":
- pointer = getattr(pointer, "weight")
- elif scope_names[0] == "output_bias" or scope_names[0] == "beta":
- pointer = getattr(pointer, "bias")
- elif scope_names[0] == "output_weights":
- pointer = getattr(pointer, "weight")
- elif scope_names[0] == "squad":
- pointer = getattr(pointer, "classifier")
- else:
- try:
- pointer = getattr(pointer, scope_names[0])
- except AttributeError:
- logger.info(f"Skipping {'/'.join(name)}")
- continue
- if len(scope_names) >= 2:
- num = int(scope_names[1])
- pointer = pointer[num]
- if m_name[-11:] == "_embeddings":
- pointer = getattr(pointer, "weight")
- elif m_name == "kernel":
- array = np.transpose(array)
- try:
- assert (
- pointer.shape == array.shape
- ), f"Pointer shape {pointer.shape} and array shape {array.shape} mismatched"
- except AssertionError as e:
- e.args += (pointer.shape, array.shape)
- raise
- logger.info("Initialize PyTorch weight {}".format(name))
- pointer.data = torch.from_numpy(array)
- return model
-
-
-class RoFormerEmbeddings(nn.Module):
- """Construct the embeddings from word, position and token_type embeddings."""
-
- def __init__(self, config):
- super().__init__()
- self.word_embeddings = nn.Embedding(
- config.vocab_size, config.hidden_size, padding_idx=config.pad_token_id)
-
- # @IDEA modified -> roformer removed the position_embedding, and add the totary position embedding in the self_attention_layer
- # self.position_embeddings = nn.Embedding(config.max_position_embeddings, config.hidden_size)
-
- self.token_type_embeddings = nn.Embedding(
- config.type_vocab_size, config.hidden_size)
-
- # self.LayerNorm is not snake-cased to stick with TensorFlow model variable name and be able to load
- # any TensorFlow checkpoint file
-
- # In Megatron, layer-norm is applied after the 1st dropout.
- # self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
- self.dropout = nn.Dropout(config.hidden_dropout_prob)
-
- # position_ids (1, len position emb) is contiguous in memory and exported when serialized
- self.register_buffer("position_ids", torch.arange(
- config.max_position_embeddings).expand((1, -1)))
- self.position_embedding_type = getattr(
- config, "position_embedding_type", "absolute")
-
- def forward(
- self, input_ids=None, token_type_ids=None, position_ids=None, inputs_embeds=None, past_key_values_length=0
- ):
- if input_ids is not None:
- input_shape = input_ids.size()
- else:
- input_shape = inputs_embeds.size()[:-1]
-
- seq_length = input_shape[1]
-
- if position_ids is None:
- position_ids = self.position_ids[:,
- past_key_values_length: seq_length + past_key_values_length]
-
- if token_type_ids is None:
- token_type_ids = torch.zeros(
- input_shape, dtype=torch.long, device=self.position_ids.device)
-
- if inputs_embeds is None:
- inputs_embeds = self.word_embeddings(input_ids)
- token_type_embeddings = self.token_type_embeddings(token_type_ids)
-
- embeddings = inputs_embeds + token_type_embeddings
-
- # @IDEA modified -> roformer removed the position_embedding
- # if self.position_embedding_type == "absolute":
- # position_embeddings = self.position_embeddings(position_ids)
- # embeddings += position_embeddings
-
- # Megatron BERT moves that layer norm after the drop-out (and to each layer).
- # embeddings = self.LayerNorm(embeddings)
- embeddings = self.dropout(embeddings)
- return embeddings
-
-
-class RoPEmbedding(nn.Module):
- def __init__(self, d_model):
- super(RoPEmbedding, self).__init__()
- self.d_model = d_model
- div_term = torch.exp(torch.arange(
- 0, d_model, 2).float() * (-math.log(10000.0) / d_model))
- self.register_buffer('div_term', div_term)
-
- def forward(self, x, seq_dim=0):
- # x 是 [s, b, np, hn]，例如query和key
- x = x.permute(2, 1, 0, 3)
- t = torch.arange(x.size(seq_dim), device=x.device).type_as(
- self.div_term)
- sinusoid_inp = torch.outer(t, self.div_term)
- sin, cos = sinusoid_inp.sin(), sinusoid_inp.cos() # [s, hn]
- o_shape = (sin.size(0), 1, 1, sin.size(1))
- sin, cos = sin.view(*o_shape), cos.view(*o_shape) # [s, 1, 1, hn]
- sin = torch.repeat_interleave(sin, 2, dim=-1)
- cos = torch.repeat_interleave(cos, 2, dim=-1)
- x2 = torch.stack([-x[..., 1::2], x[..., ::2]], dim=-1).reshape_as(x)
- x = cos * x + sin * x2
- return x.permute(2, 1, 0, 3)
-
-
-# Copied from transformers.models.bert.modeling_bert.BertSelfAttention with Bert->RoFormer
-class RoFormerSelfAttention(nn.Module):
- def __init__(self, config):
- super().__init__()
- if config.hidden_size % config.num_attention_heads != 0 and not hasattr(config, "embedding_size"):
- raise ValueError(
- f"The hidden size ({config.hidden_size}) is not a multiple of the number of attention "
- f"heads ({config.num_attention_heads})"
- )
-
- self.num_attention_heads = config.num_attention_heads
- self.attention_head_size = int(
- config.hidden_size / config.num_attention_heads)
- self.all_head_size = self.num_attention_heads * self.attention_head_size
-
- self.query = nn.Linear(config.hidden_size, self.all_head_size)
- self.key = nn.Linear(config.hidden_size, self.all_head_size)
- self.value = nn.Linear(config.hidden_size, self.all_head_size)
-
- self.dropout = nn.Dropout(config.attention_probs_dropout_prob)
- self.position_embedding_type = getattr(
- config, "position_embedding_type", "absolute")
- if self.position_embedding_type == "relative_key" or self.position_embedding_type == "relative_key_query":
- self.max_position_embeddings = config.max_position_embeddings
- self.distance_embedding = nn.Embedding(
- 2 * config.max_position_embeddings - 1, self.attention_head_size)
- # @IDEA modified -> add rope positional embedding
- self.rope_emb = RoPEmbedding(self.attention_head_size)
-
- self.is_decoder = config.is_decoder
-
- def transpose_for_scores(self, x):
- new_x_shape = x.size()[
- :-1] + (self.num_attention_heads, self.attention_head_size)
- x = x.view(*new_x_shape)
- return x.permute(0, 2, 1, 3)
-
- def forward(
- self,
- hidden_states,
- attention_mask=None,
- head_mask=None,
- encoder_hidden_states=None,
- encoder_attention_mask=None,
- past_key_value=None,
- output_attentions=False,
- ):
- mixed_query_layer = self.query(hidden_states)
-
- # If this is instantiated as a cross-attention module, the keys
- # and values come from an encoder; the attention mask needs to be
- # such that the encoder's padding tokens are not attended to.
- is_cross_attention = encoder_hidden_states is not None
-
- if is_cross_attention and past_key_value is not None:
- # reuse k,v, cross_attentions
- key_layer = past_key_value[0]
- value_layer = past_key_value[1]
- attention_mask = encoder_attention_mask
- elif is_cross_attention:
- key_layer = self.transpose_for_scores(
- self.key(encoder_hidden_states))
- value_layer = self.transpose_for_scores(
- self.value(encoder_hidden_states))
- attention_mask = encoder_attention_mask
- elif past_key_value is not None:
- key_layer = self.transpose_for_scores(self.key(hidden_states))
- value_layer = self.transpose_for_scores(self.value(hidden_states))
- key_layer = torch.cat([past_key_value[0], key_layer], dim=2)
- value_layer = torch.cat([past_key_value[1], value_layer], dim=2)
- else:
- key_layer = self.transpose_for_scores(self.key(hidden_states))
- value_layer = self.transpose_for_scores(self.value(hidden_states))
- query_layer = self.transpose_for_scores(mixed_query_layer)
-
- if self.is_decoder:
- # if cross_attention save Tuple(torch.Tensor, torch.Tensor) of all cross attention key/value_states.
- # Further calls to cross_attention layer can then reuse all cross-attention
- # key/value_states (first "if" case)
- # if uni-directional self-attention (decoder) save Tuple(torch.Tensor, torch.Tensor) of
- # all previous decoder key/value_states. Further calls to uni-directional self-attention
- # can concat previous decoder key/value_states to current projected key/value_states (third "elif" case)
- # if encoder bi-directional self-attention `past_key_value` is always `None`
- past_key_value = (key_layer, value_layer)
-
- # Take the dot product between "query" and "key" to get the raw attention scores.
-
- # @IDEA modified -> add rope positional embedding
- # print('query_layer.shape')
- # print(query_layer.shape)
- # query_layer.hsape -> [batch_size,num_head,seq_len,per_head_hidden_size]
- query_layer = self.rope_emb(query_layer)
- key_layer = self.rope_emb(key_layer)
-
- attention_scores = torch.matmul(
- query_layer, key_layer.transpose(-1, -2))
-
- """ @IDEA modified -> removed the megatron positional
- if self.position_embedding_type == "relative_key" or self.position_embedding_type == "relative_key_query":
- seq_length = hidden_states.size()[1]
- position_ids_l = torch.arange(seq_length, dtype=torch.long, device=hidden_states.device).view(-1, 1)
- position_ids_r = torch.arange(seq_length, dtype=torch.long, device=hidden_states.device).view(1, -1)
- distance = position_ids_l - position_ids_r
- positional_embedding = self.distance_embedding(distance + self.max_position_embeddings - 1)
- positional_embedding = positional_embedding.to(dtype=query_layer.dtype) # fp16 compatibility
-
- if self.position_embedding_type == "relative_key":
- relative_position_scores = torch.einsum("bhld,lrd->bhlr", query_layer, positional_embedding)
- attention_scores = attention_scores + relative_position_scores
- elif self.position_embedding_type == "relative_key_query":
- relative_position_scores_query = torch.einsum("bhld,lrd->bhlr", query_layer, positional_embedding)
- relative_position_scores_key = torch.einsum("bhrd,lrd->bhlr", key_layer, positional_embedding)
- attention_scores = attention_scores + relative_position_scores_query + relative_position_scores_key
- """
-
- attention_scores = attention_scores / \
- math.sqrt(self.attention_head_size)
- if attention_mask is not None:
- # Apply the attention mask is (precomputed for all layers in RoFormerModel forward() function)
- attention_scores = attention_scores + attention_mask
-
- # Normalize the attention scores to probabilities.
- attention_probs = nn.Softmax(dim=-1)(attention_scores)
-
- # This is actually dropping out entire tokens to attend to, which might
- # seem a bit unusual, but is taken from the original Transformer paper.
- attention_probs = self.dropout(attention_probs)
-
- # Mask heads if we want to
- if head_mask is not None:
- attention_probs = attention_probs * head_mask
-
- context_layer = torch.matmul(attention_probs, value_layer)
-
- context_layer = context_layer.permute(0, 2, 1, 3).contiguous()
- new_context_layer_shape = context_layer.size()[
- :-2] + (self.all_head_size,)
- context_layer = context_layer.view(*new_context_layer_shape)
-
- outputs = (context_layer, attention_probs) if output_attentions else (
- context_layer,)
-
- if self.is_decoder:
- outputs = outputs + (past_key_value,)
- return outputs
-
-
-# Based transformers.models.bert.modeling_bert.BertSelfOutput. Moved LayerNorm to RoFormerAttention below.
-class RoFormerSelfOutput(nn.Module):
- def __init__(self, config):
- super().__init__()
- self.dense = nn.Linear(config.hidden_size, config.hidden_size)
- self.dropout = nn.Dropout(config.hidden_dropout_prob)
-
- def forward(self, hidden_states, residual):
- hidden_states = self.dense(hidden_states)
- hidden_states = self.dropout(hidden_states)
- return residual + hidden_states
-
-
-# Based transformers.models.bert.modeling_bert.BertAttention. Added LayerNorm.
-class RoFormerAttention(nn.Module):
- def __init__(self, config):
- super().__init__()
- self.ln = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
- self.self = RoFormerSelfAttention(config)
- self.output = RoFormerSelfOutput(config)
- self.pruned_heads = set()
-
- def prune_heads(self, heads):
- if len(heads) == 0:
- return
- heads, index = find_pruneable_heads_and_indices(
- heads, self.self.num_attention_heads, self.self.attention_head_size, self.pruned_heads
- )
-
- # Prune linear layers
- self.self.query = prune_linear_layer(self.self.query, index)
- self.self.key = prune_linear_layer(self.self.key, index)
- self.self.value = prune_linear_layer(self.self.value, index)
- self.output.dense = prune_linear_layer(self.output.dense, index, dim=1)
-
- # Update hyper params and store pruned heads
- self.self.num_attention_heads = self.self.num_attention_heads - \
- len(heads)
- self.self.all_head_size = self.self.attention_head_size * \
- self.self.num_attention_heads
- self.pruned_heads = self.pruned_heads.union(heads)
-
- def forward(
- self,
- hidden_states,
- attention_mask=None,
- head_mask=None,
- encoder_hidden_states=None,
- encoder_attention_mask=None,
- past_key_value=None,
- output_attentions=False,
- ):
- ln_outputs = self.ln(hidden_states)
- self_outputs = self.self(
- ln_outputs,
- attention_mask,
- head_mask,
- encoder_hidden_states,
- encoder_attention_mask,
- past_key_value,
- output_attentions,
- )
- attention_output = self.output(self_outputs[0], hidden_states)
- # add attentions if we output them
- outputs = (attention_output,) + self_outputs[1:]
- return outputs
-
-
-# Copied from transformers.models.bert.modeling_bert.BertIntermediate with Bert->RoFormer
-class RoFormerIntermediate(nn.Module):
- def __init__(self, config):
- super().__init__()
- self.dense = nn.Linear(config.hidden_size, config.intermediate_size)
- if isinstance(config.hidden_act, str):
- self.intermediate_act_fn = ACT2FN[config.hidden_act]
- else:
- self.intermediate_act_fn = config.hidden_act
-
- def forward(self, hidden_states):
- hidden_states = self.dense(hidden_states)
- hidden_states = self.intermediate_act_fn(hidden_states)
- return hidden_states
-
-
-# Based on transformers.models.bert.modeling_bert.BertOutput. Moved LayerNorm to RoFormerLayer below.
-class RoFormerOutput(nn.Module):
- def __init__(self, config):
- super().__init__()
- self.dense = nn.Linear(config.intermediate_size, config.hidden_size)
- self.dropout = nn.Dropout(config.hidden_dropout_prob)
-
- def forward(self, hidden_states, input_tensor):
- hidden_states = self.dense(hidden_states)
- hidden_states = self.dropout(hidden_states)
- return input_tensor + hidden_states
-
-
-# Based on transformers.models.bert.modeling_bert.BertLayer. Added LayerNorm.
-class RoFormerLayer(nn.Module):
- def __init__(self, config):
- super().__init__()
- self.chunk_size_feed_forward = config.chunk_size_feed_forward
- self.seq_len_dim = 1
- self.attention = RoFormerAttention(config)
- self.is_decoder = config.is_decoder
- self.add_cross_attention = config.add_cross_attention
- if self.add_cross_attention:
- assert self.is_decoder, f"{self} should be used as a decoder model if cross attention is added"
- self.crossattention = RoFormerAttention(config)
- self.ln = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
- self.intermediate = RoFormerIntermediate(config)
- self.output = RoFormerOutput(config)
-
- def forward(
- self,
- hidden_states,
- attention_mask=None,
- head_mask=None,
- encoder_hidden_states=None,
- encoder_attention_mask=None,
- past_key_value=None,
- output_attentions=False,
- ):
- # decoder uni-directional self-attention cached key/values tuple is at positions 1,2
- self_attn_past_key_value = past_key_value[:
- 2] if past_key_value is not None else None
- self_attention_outputs = self.attention(
- hidden_states,
- attention_mask,
- head_mask,
- output_attentions=output_attentions,
- past_key_value=self_attn_past_key_value,
- )
- attention_output = self_attention_outputs[0]
-
- # if decoder, the last output is tuple of self-attn cache
- if self.is_decoder:
- outputs = self_attention_outputs[1:-1]
- present_key_value = self_attention_outputs[-1]
- else:
- # add self attentions if we output attention weights
- outputs = self_attention_outputs[1:]
-
- cross_attn_present_key_value = None
- if self.is_decoder and encoder_hidden_states is not None:
- assert hasattr(
- self, "crossattention"
- ), f"If `encoder_hidden_states` are passed, {self} has to be instantiated with cross-attention layers by setting `config.add_cross_attention=True`"
-
- # cross_attn cached key/values tuple is at positions 3,4 of past_key_value tuple
- cross_attn_past_key_value = past_key_value[-2:
- ] if past_key_value is not None else None
- cross_attention_outputs = self.crossattention(
- attention_output,
- attention_mask,
- head_mask,
- encoder_hidden_states,
- encoder_attention_mask,
- cross_attn_past_key_value,
- output_attentions,
- )
- attention_output = cross_attention_outputs[0]
- # add cross attentions if we output attention weights
- outputs = outputs + cross_attention_outputs[1:-1]
-
- # add cross-attn cache to positions 3,4 of present_key_value tuple
- cross_attn_present_key_value = cross_attention_outputs[-1]
- present_key_value = present_key_value + cross_attn_present_key_value
-
- layer_output = apply_chunking_to_forward(
- self.feed_forward_chunk, self.chunk_size_feed_forward, self.seq_len_dim, attention_output
- )
- outputs = (layer_output,) + outputs
-
- # if decoder, return the attn key/values as the last output
- if self.is_decoder:
- outputs = outputs + (present_key_value,)
-
- return outputs
-
- def feed_forward_chunk(self, attention_output):
- ln_output = self.ln(attention_output)
- intermediate_output = self.intermediate(ln_output)
- layer_output = self.output(intermediate_output, attention_output)
- return layer_output
-
-
-def roformer_extended_attention_mask(attention_mask, tokentype_ids):
- # copy from bert_model.py and
- # https://github.com/bojone/bert4keras/blob/8836dc01fa99aa54947a15db5aa60a0ab6c0c036/bert4keras/models.py#L382
- # We create a 3D attention mask from a 2D tensor mask.
- # [b, 1, s]
- attention_mask_b1s = attention_mask.unsqueeze(1)
- # [b, s, 1]
- attention_mask_bs1 = attention_mask.unsqueeze(2)
- # [b, s, s]
- padding_mask_bss = attention_mask_b1s * attention_mask_bs1
-
- # Convert attention mask to binary:
- padding_mask_bss = (padding_mask_bss < 0.5)
-
- # 根据tokentype_ids来获取相应的双向或者单向mask，注意
- # 这里改变了原本实现中的小于等于号，因为megatron中的mask
- # 中非mask部分为0，mask部分为1
- idx = torch.cumsum(tokentype_ids, dim=1)
- causal_mask = idx[:, None, :] > idx[:, :, None]
- # 合并两个mask
- mask = torch.logical_or(causal_mask, padding_mask_bss)
- mask = mask.unsqueeze(1) # [b, 1, s, s]
- return mask
-
-
-class RoFormerEncoder(nn.Module):
- def __init__(self, config):
- super().__init__()
- self.config = config
- self.layer = nn.ModuleList([RoFormerLayer(config)
- for _ in range(config.num_hidden_layers)])
-
- # The final layer norm. We removed the 1st LN, moved LN to each hidden layer and this one
- # is simply the final LN (Transformer's BERT has it attached to each hidden layer).
- self.ln = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
-
- def forward(
- self,
- hidden_states,
- attention_mask=None,
- head_mask=None,
- encoder_hidden_states=None,
- encoder_attention_mask=None,
- past_key_values=None,
- use_cache=None,
- output_attentions=False,
- output_hidden_states=False,
- return_dict=True,
- ):
-
- all_hidden_states = () if output_hidden_states else None
- all_self_attentions = () if output_attentions else None
- all_cross_attentions = () if output_attentions and self.config.add_cross_attention else None
-
- next_decoder_cache = () if use_cache else None
- for i, layer_module in enumerate(self.layer):
- if output_hidden_states:
- all_hidden_states = all_hidden_states + (hidden_states,)
-
- layer_head_mask = head_mask[i] if head_mask is not None else None
- past_key_value = past_key_values[i] if past_key_values is not None else None
-
- if getattr(self.config, "gradient_checkpointing", False) and self.training:
-
- if use_cache:
- logger.warn(
- "`use_cache=True` is incompatible with `config.gradient_checkpointing=True`. Setting "
- "`use_cache=False`..."
- )
- use_cache = False
-
- def create_custom_forward(module):
- def custom_forward(*inputs):
- return module(*inputs, past_key_value, output_attentions)
-
- return custom_forward
-
- layer_outputs = torch.utils.checkpoint.checkpoint(
- create_custom_forward(layer_module),
- hidden_states,
- attention_mask,
- layer_head_mask,
- encoder_hidden_states,
- encoder_attention_mask,
- )
- else:
- layer_outputs = layer_module(
- hidden_states,
- attention_mask,
- layer_head_mask,
- encoder_hidden_states,
- encoder_attention_mask,
- past_key_value,
- output_attentions,
- )
-
- # Because we moved the layer-norm at the end of the hidden layer, we have non-normali-
- # zed data here. If that's really needed, we must apply LN to match Transformer's BERT.
-
- hidden_states = layer_outputs[0]
- if use_cache:
- next_decoder_cache += (layer_outputs[-1],)
- if output_attentions:
- all_self_attentions = all_self_attentions + (layer_outputs[1],)
- if self.config.add_cross_attention:
- all_cross_attentions = all_cross_attentions + \
- (layer_outputs[2],)
-
- # Finalize the hidden states.
- hidden_states = self.ln(hidden_states)
-
- if output_hidden_states:
- all_hidden_states = all_hidden_states + (hidden_states,)
-
- if not return_dict:
- return tuple(
- v
- for v in [
- hidden_states,
- next_decoder_cache,
- all_hidden_states,
- all_self_attentions,
- all_cross_attentions,
- ]
- if v is not None
- )
- return BaseModelOutputWithPastAndCrossAttentions(
- last_hidden_state=hidden_states,
- past_key_values=next_decoder_cache,
- hidden_states=all_hidden_states,
- attentions=all_self_attentions,
- cross_attentions=all_cross_attentions,
- )
-
-
-# Copied from transformers.models.bert.modeling_bert.BertPooler with Bert->RoFormer
-class RoFormerPooler(nn.Module):
- def __init__(self, config):
- super().__init__()
- self.dense = nn.Linear(config.hidden_size, config.hidden_size)
- self.activation = nn.Tanh()
-
- def forward(self, hidden_states):
- # We "pool" the model by simply taking the hidden state corresponding
- # to the first token.
- first_token_tensor = hidden_states[:, 0]
- pooled_output = self.dense(first_token_tensor)
- pooled_output = self.activation(pooled_output)
- return pooled_output
-
-
-# Copied from transformers.models.bert.modeling_bert.BertPredictionHeadTransform with Bert->RoFormer
-class RoFormerPredictionHeadTransform(nn.Module):
- def __init__(self, config):
- super().__init__()
- self.dense = nn.Linear(config.hidden_size, config.hidden_size)
- if isinstance(config.hidden_act, str):
- self.transform_act_fn = ACT2FN[config.hidden_act]
- else:
- self.transform_act_fn = config.hidden_act
- self.LayerNorm = nn.LayerNorm(
- config.hidden_size, eps=config.layer_norm_eps)
-
- def forward(self, hidden_states):
- hidden_states = self.dense(hidden_states)
- hidden_states = self.transform_act_fn(hidden_states)
- hidden_states = self.LayerNorm(hidden_states)
- return hidden_states
-
-
-# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead with Bert->RoFormer
-class RoFormerLMPredictionHead(nn.Module):
- def __init__(self, config):
- super().__init__()
- self.transform = RoFormerPredictionHeadTransform(config)
-
- # The output weights are the same as the input embeddings, but there is
- # an output-only bias for each token.
- self.decoder = nn.Linear(
- config.hidden_size, config.vocab_size, bias=False)
- self.bias = nn.Parameter(torch.zeros(config.vocab_size))
-
- # Need a link between the two variables so that the bias is correctly resized with `resize_token_embeddings`
- self.decoder.bias = self.bias
-
- def forward(self, hidden_states):
- hidden_states = self.transform(hidden_states)
- hidden_states = self.decoder(hidden_states)
- return hidden_states
-
-
-# Copied from transformers.models.bert.modeling_bert.BertOnlyMLMHead with Bert->RoFormer
-class RoFormerOnlyMLMHead(nn.Module):
- def __init__(self, config):
- super().__init__()
- self.predictions = RoFormerLMPredictionHead(config)
-
- def forward(self, sequence_output):
- prediction_scores = self.predictions(sequence_output)
- return prediction_scores
-
-
-# Copied from transformers.models.bert.modeling_bert.BertOnlyNSPHead with Bert->RoFormer
-class RoFormerOnlyNSPHead(nn.Module):
- def __init__(self, config):
- super().__init__()
- self.seq_relationship = nn.Linear(config.hidden_size, 2)
-
- def forward(self, pooled_output):
- seq_relationship_score = self.seq_relationship(pooled_output)
- return seq_relationship_score
-
-
-# Copied from transformers.models.bert.modeling_bert.BertPreTrainingHeads with Bert->RoFormer
-class RoFormerPreTrainingHeads(nn.Module):
- def __init__(self, config):
- super().__init__()
- self.predictions = RoFormerLMPredictionHead(config)
- self.seq_relationship = nn.Linear(config.hidden_size, 2)
-
- def forward(self, sequence_output, pooled_output):
- prediction_scores = self.predictions(sequence_output)
- seq_relationship_score = self.seq_relationship(pooled_output)
- return prediction_scores, seq_relationship_score
-
-
-class RoFormerPreTrainedModel(PreTrainedModel):
- """
- An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
- models.
- """
-
- config_class = RoFormerConfig
- load_tf_weights = load_tf_weights_in_RoFormer
- base_model_prefix = "bert"
- _keys_to_ignore_on_load_missing = [r"position_ids"]
-
- def _init_weights(self, module):
- """Initialize the weights"""
- if isinstance(module, (nn.Linear, nn.Embedding)):
- # Slightly different from the TF version which uses truncated_normal for initialization
- # cf https://github.com/pytorch/pytorch/pull/5617
- module.weight.data.normal_(
- mean=0.0, std=self.config.initializer_range)
- elif isinstance(module, nn.LayerNorm):
- module.bias.data.zero_()
- module.weight.data.fill_(1.0)
- if isinstance(module, nn.Linear) and module.bias is not None:
- module.bias.data.zero_()
-
-
-@dataclass
-# Copied from transformers.models.bert.modeling_bert.BertForPreTrainingOutput with Bert->RoFormer
-class RoFormerForPreTrainingOutput(ModelOutput):
- """
- Output type of :class:`~transformers.RoFormerForPreTraining`.
-
- Args:
- loss (`optional`, returned when ``labels`` is provided, ``torch.FloatTensor`` of shape :obj:`(1,)`):
- Total loss as the sum of the masked language modeling loss and the next sequence prediction
- (classification) loss.
- prediction_logits (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, config.vocab_size)`):
- Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).
- seq_relationship_logits (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, 2)`):
- Prediction scores of the next sequence prediction (classification) head (scores of True/False continuation
- before SoftMax).
- hidden_states (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``output_hidden_states=True`` is passed or when ``config.output_hidden_states=True``):
- Tuple of :obj:`torch.FloatTensor` (one for the output of the embeddings + one for the output of each layer)
- of shape :obj:`(batch_size, sequence_length, hidden_size)`.
-
- Hidden-states of the model at the output of each layer plus the initial embedding outputs.
- attentions (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``output_attentions=True`` is passed or when ``config.output_attentions=True``):
- Tuple of :obj:`torch.FloatTensor` (one for each layer) of shape :obj:`(batch_size, num_heads,
- sequence_length, sequence_length)`.
-
- Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
- heads.
- """
-
- loss: Optional[torch.FloatTensor] = None
- prediction_logits: torch.FloatTensor = None
- seq_relationship_logits: torch.FloatTensor = None
- hidden_states: Optional[Tuple[torch.FloatTensor]] = None
- attentions: Optional[Tuple[torch.FloatTensor]] = None
-
-
-RoFormer_START_DOCSTRING = r"""
-
- This model inherits from :class:`~transformers.PreTrainedModel`. Check the superclass documentation for the generic
- methods the library implements for all its model (such as downloading or saving, resizing the input embeddings,
- pruning heads etc.)
-
- This model is also a PyTorch `torch.nn.Module `__
- subclass. Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to
- general usage and behavior.
-
- Parameters:
- config (:class:`~transformers.RoFormerConfig`): Model configuration class with all the parameters of the model.
- Initializing with a config file does not load the weights associated with the model, only the
- configuration. Check out the :meth:`~transformers.PreTrainedModel.from_pretrained` method to load the model
- weights.
-"""
-
-RoFormer_INPUTS_DOCSTRING = r"""
- Args:
- input_ids (:obj:`torch.LongTensor` of shape :obj:`({0})`):
- Indices of input sequence tokens in the vocabulary.
-
- Indices can be obtained using :class:`~transformers.BertTokenizer`. See
- :meth:`transformers.PreTrainedTokenizer.encode` and :meth:`transformers.PreTrainedTokenizer.__call__` for
- details.
-
- `What are input IDs? <../glossary.html#input-ids>`__
- attention_mask (:obj:`torch.FloatTensor` of shape :obj:`({0})`, `optional`):
- Mask to avoid performing attention on padding token indices. Mask values selected in ``[0, 1]``:
-
- - 1 for tokens that are **not masked**,
- - 0 for tokens that are **masked**.
-
- `What are attention masks? <../glossary.html#attention-mask>`__
- token_type_ids (:obj:`torch.LongTensor` of shape :obj:`({0})`, `optional`):
- Segment token indices to indicate first and second portions of the inputs. Indices are selected in ``[0,
- 1]``:
-
- - 0 corresponds to a `sentence A` token,
- - 1 corresponds to a `sentence B` token.
-
- `What are token type IDs? <../glossary.html#token-type-ids>`_
- position_ids (:obj:`torch.LongTensor` of shape :obj:`({0})`, `optional`):
- Indices of positions of each input sequence tokens in the position embeddings. Selected in the range ``[0,
- config.max_position_embeddings - 1]``.
-
- `What are position IDs? <../glossary.html#position-ids>`_
- head_mask (:obj:`torch.FloatTensor` of shape :obj:`(num_heads,)` or :obj:`(num_layers, num_heads)`, `optional`):
- Mask to nullify selected heads of the self-attention modules. Mask values selected in ``[0, 1]``:
-
- - 1 indicates the head is **not masked**,
- - 0 indicates the head is **masked**.
-
- inputs_embeds (:obj:`torch.FloatTensor` of shape :obj:`({0}, hidden_size)`, `optional`):
- Optionally, instead of passing :obj:`input_ids` you can choose to directly pass an embedded representation.
- This is useful if you want more control over how to convert :obj:`input_ids` indices into associated
- vectors than the model's internal embedding lookup matrix.
- output_attentions (:obj:`bool`, `optional`):
- Whether or not to return the attentions tensors of all attention layers. See ``attentions`` under returned
- tensors for more detail.
- output_hidden_states (:obj:`bool`, `optional`):
- Whether or not to return the hidden states of all layers. See ``hidden_states`` under returned tensors for
- more detail.
- return_dict (:obj:`bool`, `optional`):
- Whether or not to return a :class:`~transformers.file_utils.ModelOutput` instead of a plain tuple.
-"""
-
-
-@add_start_docstrings(
- "The bare RoFormer Model transformer outputting raw hidden-states without any specific head on top.",
- RoFormer_START_DOCSTRING,
-)
-class RoFormerModel(RoFormerPreTrainedModel):
- """
-
- The model can behave as an encoder (with only self-attention) as well as a decoder, in which case a layer of
- cross-attention is added between the self-attention layers, following the architecture described in `Attention is
- all you need `__ by Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit,
- Llion Jones, Aidan N. Gomez, Lukasz Kaiser and Illia Polosukhin.
-
- To behave as an decoder the model needs to be initialized with the :obj:`is_decoder` argument of the configuration
- set to :obj:`True`. To be used in a Seq2Seq model, the model needs to initialized with both :obj:`is_decoder`
- argument and :obj:`add_cross_attention` set to :obj:`True`; an :obj:`encoder_hidden_states` is then expected as an
- input to the forward pass.
- """
-
- def __init__(self, config, add_pooling_layer=True):
- super().__init__(config)
- self.config = config
-
- self.embeddings = RoFormerEmbeddings(config)
- self.encoder = RoFormerEncoder(config)
-
- self.pooler = RoFormerPooler(config) if add_pooling_layer else None
-
- self.init_weights()
-
- def get_input_embeddings(self):
- return self.embeddings.word_embeddings
-
- def set_input_embeddings(self, value):
- self.embeddings.word_embeddings = value
-
- def _prune_heads(self, heads_to_prune):
- """
- Prunes heads of the model. heads_to_prune: dict of {layer_num: list of heads to prune in this layer} See base
- class PreTrainedModel
- """
- for layer, heads in heads_to_prune.items():
- self.encoder.layer[layer].attention.prune_heads(heads)
-
- @add_start_docstrings_to_model_forward(RoFormer_INPUTS_DOCSTRING.format("batch_size, sequence_length"))
- @add_code_sample_docstrings(
- processor_class=_TOKENIZER_FOR_DOC,
- checkpoint=_CHECKPOINT_FOR_DOC,
- output_type=BaseModelOutputWithPoolingAndCrossAttentions,
- config_class=_CONFIG_FOR_DOC,
- )
- def forward(
- self,
- input_ids=None,
- attention_mask=None,
- token_type_ids=None,
- position_ids=None,
- head_mask=None,
- inputs_embeds=None,
- encoder_hidden_states=None,
- encoder_attention_mask=None,
- past_key_values=None,
- use_cache=None,
- output_attentions=None,
- output_hidden_states=None,
- return_dict=None,
- ):
- r"""
- encoder_hidden_states (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`, `optional`):
- Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention if
- the model is configured as a decoder.
- encoder_attention_mask (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`):
- Mask to avoid performing attention on the padding token indices of the encoder input. This mask is used in
- the cross-attention if the model is configured as a decoder. Mask values selected in ``[0, 1]``:
-
- - 1 for tokens that are **not masked**,
- - 0 for tokens that are **masked**.
- past_key_values (:obj:`tuple(tuple(torch.FloatTensor))` of length :obj:`config.n_layers` with each tuple having 4 tensors of shape :obj:`(batch_size, num_heads, sequence_length - 1, embed_size_per_head)`):
- Contains precomputed key and value hidden states of the attention blocks. Can be used to speed up decoding.
-
- If :obj:`past_key_values` are used, the user can optionally input only the last :obj:`decoder_input_ids`
- (those that don't have their past key value states given to this model) of shape :obj:`(batch_size, 1)`
- instead of all :obj:`decoder_input_ids` of shape :obj:`(batch_size, sequence_length)`.
- use_cache (:obj:`bool`, `optional`):
- If set to :obj:`True`, :obj:`past_key_values` key value states are returned and can be used to speed up
- decoding (see :obj:`past_key_values`).
- """
- output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
- output_hidden_states = (
- output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
- )
- return_dict = return_dict if return_dict is not None else self.config.use_return_dict
-
- if self.config.is_decoder:
- use_cache = use_cache if use_cache is not None else self.config.use_cache
- else:
- use_cache = False
-
- if input_ids is not None and inputs_embeds is not None:
- raise ValueError(
- "You cannot specify both input_ids and inputs_embeds at the same time")
- elif input_ids is not None:
- input_shape = input_ids.size()
- batch_size, seq_length = input_shape
- elif inputs_embeds is not None:
- input_shape = inputs_embeds.size()[:-1]
- batch_size, seq_length = input_shape
- else:
- raise ValueError(
- "You have to specify either input_ids or inputs_embeds")
-
- device = input_ids.device if input_ids is not None else inputs_embeds.device
-
- # past_key_values_length
- past_key_values_length = past_key_values[0][0].shape[2] if past_key_values is not None else 0
-
- if attention_mask is None:
- attention_mask = torch.ones(
- ((batch_size, seq_length + past_key_values_length)), device=device)
- if token_type_ids is None:
- token_type_ids = torch.zeros(
- input_shape, dtype=torch.long, device=device)
-
- # @IDEA modified -> get_extended_attention_mask -> roformer_extended_attention_mask
- extended_attention_mask = roformer_extended_attention_mask(
- attention_mask, token_type_ids)
- """
- # We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length]
- # ourselves in which case we just need to make it broadcastable to all heads.
- extended_attention_mask: torch.Tensor = self.get_extended_attention_mask(attention_mask, input_shape, device)
- """
-
- # If a 2D or 3D attention mask is provided for the cross-attention
- # we need to make broadcastable to [batch_size, num_heads, seq_length, seq_length]
- if self.config.is_decoder and encoder_hidden_states is not None:
- encoder_batch_size, encoder_sequence_length, _ = encoder_hidden_states.size()
- encoder_hidden_shape = (
- encoder_batch_size, encoder_sequence_length)
- if encoder_attention_mask is None:
- encoder_attention_mask = torch.ones(
- encoder_hidden_shape, device=device)
- encoder_extended_attention_mask = self.invert_attention_mask(
- encoder_attention_mask)
- else:
- encoder_extended_attention_mask = None
-
- # Prepare head mask if needed
- # 1.0 in head_mask indicate we keep the head
- # attention_probs has shape bsz x n_heads x N x N
- # input head_mask has shape [num_heads] or [num_hidden_layers x num_heads]
- # and head_mask is converted to shape [num_hidden_layers x batch x num_heads x seq_length x seq_length]
- head_mask = self.get_head_mask(
- head_mask, self.config.num_hidden_layers)
-
- embedding_output = self.embeddings(
- input_ids=input_ids,
- position_ids=position_ids,
- token_type_ids=token_type_ids,
- inputs_embeds=inputs_embeds,
- past_key_values_length=past_key_values_length,
- )
- encoder_outputs = self.encoder(
- embedding_output,
- attention_mask=extended_attention_mask,
- head_mask=head_mask,
- encoder_hidden_states=encoder_hidden_states,
- encoder_attention_mask=encoder_extended_attention_mask,
- past_key_values=past_key_values,
- use_cache=use_cache,
- output_attentions=output_attentions,
- output_hidden_states=output_hidden_states,
- return_dict=return_dict,
- )
- sequence_output = encoder_outputs[0]
- pooled_output = self.pooler(
- sequence_output) if self.pooler is not None else None
-
- if not return_dict:
- return (sequence_output, pooled_output) + encoder_outputs[1:]
-
- return BaseModelOutputWithPoolingAndCrossAttentions(
- last_hidden_state=sequence_output,
- pooler_output=pooled_output,
- past_key_values=encoder_outputs.past_key_values,
- hidden_states=encoder_outputs.hidden_states,
- attentions=encoder_outputs.attentions,
- cross_attentions=encoder_outputs.cross_attentions,
- )
-
-
-@add_start_docstrings(
- """
- RoFormer Model with two heads on top as done during the pretraining: a `masked language modeling` head and a
- `next sentence prediction (classification)` head.
- """,
- RoFormer_START_DOCSTRING,
-)
-class RoFormerForPreTraining(RoFormerPreTrainedModel):
- def __init__(self, config, add_binary_head=True):
- super().__init__(config)
-
- self.bert = RoFormerModel(config)
- self.cls = RoFormerPreTrainingHeads(config)
-
- self.init_weights()
-
- def get_output_embeddings(self):
- return self.cls.predictions.decoder
-
- def set_output_embeddings(self, new_embeddings):
- self.cls.predictions.decoder = new_embeddings
-
- @add_start_docstrings_to_model_forward(RoFormer_INPUTS_DOCSTRING.format("batch_size, sequence_length"))
- @replace_return_docstrings(output_type=RoFormerForPreTrainingOutput, config_class=_CONFIG_FOR_DOC)
- def forward(
- self,
- input_ids=None,
- attention_mask=None,
- token_type_ids=None,
- position_ids=None,
- head_mask=None,
- inputs_embeds=None,
- labels=None,
- next_sentence_label=None,
- output_attentions=None,
- output_hidden_states=None,
- return_dict=None,
- ):
- r"""
- labels (:obj:`torch.LongTensor` of shape ``(batch_size, sequence_length)``, `optional`):
- Labels for computing the masked language modeling loss. Indices should be in ``[-100, 0, ...,
- config.vocab_size]`` (see ``input_ids`` docstring) Tokens with indices set to ``-100`` are ignored
- (masked), the loss is only computed for the tokens with labels in ``[0, ..., config.vocab_size]``
- next_sentence_label (``torch.LongTensor`` of shape ``(batch_size,)``, `optional`):
- Labels for computing the next sequence prediction (classification) loss. Input should be a sequence pair
- (see :obj:`input_ids` docstring) Indices should be in ``[0, 1]``:
-
- - 0 indicates sequence B is a continuation of sequence A,
- - 1 indicates sequence B is a random sequence.
- kwargs (:obj:`Dict[str, any]`, optional, defaults to `{}`):
- Used to hide legacy arguments that have been deprecated.
-
- Returns:
-
- Example::
-
- >>> from transformers import BertTokenizer, RoFormerForPreTraining
- >>> import torch
-
- >>> tokenizer = BertTokenizer.from_pretrained('nvidia/megatron-bert-cased-345m')
- >>> model = RoFormerForPreTraining.from_pretrained('nvidia/megatron-bert-cased-345m')
-
- >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
- >>> outputs = model(**inputs)
-
- >>> prediction_logits = outputs.prediction_logits
- >>> seq_relationship_logits = outputs.seq_relationship_logits
- """
- return_dict = return_dict if return_dict is not None else self.config.use_return_dict
-
- outputs = self.bert(
- input_ids,
- attention_mask=attention_mask,
- token_type_ids=token_type_ids,
- position_ids=position_ids,
- head_mask=head_mask,
- inputs_embeds=inputs_embeds,
- output_attentions=output_attentions,
- output_hidden_states=output_hidden_states,
- return_dict=return_dict,
- )
-
- sequence_output, pooled_output = outputs[:2]
- prediction_scores, seq_relationship_score = self.cls(
- sequence_output, pooled_output)
-
- total_loss = None
- if labels is not None and next_sentence_label is not None:
- loss_fct = CrossEntropyLoss()
- masked_lm_loss = loss_fct(
- prediction_scores.view(-1, self.config.vocab_size), labels.view(-1))
- next_sentence_loss = loss_fct(
- seq_relationship_score.view(-1, 2), next_sentence_label.view(-1))
- total_loss = masked_lm_loss + next_sentence_loss
-
- if not return_dict:
- output = (prediction_scores, seq_relationship_score) + outputs[2:]
- return ((total_loss,) + output) if total_loss is not None else output
-
- return RoFormerForPreTrainingOutput(
- loss=total_loss,
- prediction_logits=prediction_scores,
- seq_relationship_logits=seq_relationship_score,
- hidden_states=outputs.hidden_states,
- attentions=outputs.attentions,
- )
-
-
-@add_start_docstrings(
- """RoFormer Model with a `language modeling` head on top for CLM fine-tuning. """,
- RoFormer_START_DOCSTRING,
-)
-class RoFormerForCausalLM(RoFormerPreTrainedModel):
-
- _keys_to_ignore_on_load_unexpected = [r"pooler"]
- _keys_to_ignore_on_load_missing = [
- r"position_ids", r"predictions.decoder.bias"]
-
- def __init__(self, config):
- super().__init__(config)
-
- if not config.is_decoder:
- logger.warning(
- "If you want to use `RoFormerForCausalLM` as a standalone, add `is_decoder=True.`")
-
- self.bert = RoFormerModel(config, add_pooling_layer=False)
- self.cls = RoFormerOnlyMLMHead(config)
-
- self.init_weights()
-
- def get_output_embeddings(self):
- return self.cls.predictions.decoder
-
- def set_output_embeddings(self, new_embeddings):
- self.cls.predictions.decoder = new_embeddings
-
- @add_start_docstrings_to_model_forward(RoFormer_INPUTS_DOCSTRING.format("batch_size, sequence_length"))
- @replace_return_docstrings(output_type=CausalLMOutputWithCrossAttentions, config_class=_CONFIG_FOR_DOC)
- def forward(
- self,
- input_ids=None,
- attention_mask=None,
- token_type_ids=None,
- position_ids=None,
- head_mask=None,
- inputs_embeds=None,
- encoder_hidden_states=None,
- encoder_attention_mask=None,
- labels=None,
- past_key_values=None,
- use_cache=None,
- output_attentions=None,
- output_hidden_states=None,
- return_dict=None,
- ):
- r"""
- encoder_hidden_states (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`, `optional`):
- Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention if
- the model is configured as a decoder.
- encoder_attention_mask (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`):
- Mask to avoid performing attention on the padding token indices of the encoder input. This mask is used in
- the cross-attention if the model is configured as a decoder. Mask values selected in ``[0, 1]``:
-
- - 1 for tokens that are **not masked**,
- - 0 for tokens that are **masked**.
- labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`):
- Labels for computing the left-to-right language modeling loss (next word prediction). Indices should be in
- ``[-100, 0, ..., config.vocab_size]`` (see ``input_ids`` docstring) Tokens with indices set to ``-100`` are
- ignored (masked), the loss is only computed for the tokens with labels n ``[0, ..., config.vocab_size]``
- past_key_values (:obj:`tuple(tuple(torch.FloatTensor))` of length :obj:`config.n_layers` with each tuple having 4 tensors of shape :obj:`(batch_size, num_heads, sequence_length - 1, embed_size_per_head)`):
- Contains precomputed key and value hidden states of the attention blocks. Can be used to speed up decoding.
-
- If :obj:`past_key_values` are used, the user can optionally input only the last :obj:`decoder_input_ids`
- (those that don't have their past key value states given to this model) of shape :obj:`(batch_size, 1)`
- instead of all :obj:`decoder_input_ids` of shape :obj:`(batch_size, sequence_length)`.
- use_cache (:obj:`bool`, `optional`):
- If set to :obj:`True`, :obj:`past_key_values` key value states are returned and can be used to speed up
- decoding (see :obj:`past_key_values`).
-
- Returns:
-
- Example::
-
- >>> from transformers import BertTokenizer, RoFormerForCausalLM, RoFormerConfig
- >>> import torch
-
- >>> tokenizer = BertTokenizer.from_pretrained('nvidia/megatron-bert-cased-345m')
- >>> model = RoFormerLMHeadModel.from_pretrained('nvidia/megatron-bert-cased-345m', is_decoder=True)
-
- >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
- >>> outputs = model(**inputs)
-
- >>> prediction_logits = outputs.logits
- """
- return_dict = return_dict if return_dict is not None else self.config.use_return_dict
- if labels is not None:
- use_cache = False
-
- outputs = self.bert(
- input_ids,
- attention_mask=attention_mask,
- token_type_ids=token_type_ids,
- position_ids=position_ids,
- head_mask=head_mask,
- inputs_embeds=inputs_embeds,
- encoder_hidden_states=encoder_hidden_states,
- encoder_attention_mask=encoder_attention_mask,
- past_key_values=past_key_values,
- use_cache=use_cache,
- output_attentions=output_attentions,
- output_hidden_states=output_hidden_states,
- return_dict=return_dict,
- )
-
- sequence_output = outputs[0]
- prediction_scores = self.cls(sequence_output)
-
- lm_loss = None
- if labels is not None:
- # we are doing next-token prediction; shift prediction scores and input ids by one
- shifted_prediction_scores = prediction_scores[:,
- :-1, :].contiguous()
- labels = labels[:, 1:].contiguous()
- loss_fct = CrossEntropyLoss()
- lm_loss = loss_fct(
- shifted_prediction_scores.view(-1, self.config.vocab_size), labels.view(-1))
-
- if not return_dict:
- output = (prediction_scores,) + outputs[2:]
- return ((lm_loss,) + output) if lm_loss is not None else output
-
- return CausalLMOutputWithCrossAttentions(
- loss=lm_loss,
- logits=prediction_scores,
- past_key_values=outputs.past_key_values,
- hidden_states=outputs.hidden_states,
- attentions=outputs.attentions,
- cross_attentions=outputs.cross_attentions,
- )
-
- def prepare_inputs_for_generation(self, input_ids, past=None, attention_mask=None, **model_kwargs):
- input_shape = input_ids.shape
- # if model is used as a decoder in encoder-decoder model, the decoder attention mask is created on the fly
- if attention_mask is None:
- attention_mask = input_ids.new_ones(input_shape)
-
- # cut decoder_input_ids if past is used
- if past is not None:
- input_ids = input_ids[:, -1:]
-
- return {"input_ids": input_ids, "attention_mask": attention_mask, "past_key_values": past}
-
- def _reorder_cache(self, past, beam_idx):
- reordered_past = ()
- for layer_past in past:
- reordered_past += (tuple(past_state.index_select(0, beam_idx)
- for past_state in layer_past),)
- return reordered_past
-
-
-@add_start_docstrings("""RoFormer Model with a `language modeling` head on top. """, RoFormer_START_DOCSTRING)
-class RoFormerForMaskedLM(RoFormerPreTrainedModel):
-
- _keys_to_ignore_on_load_unexpected = [r"pooler", r"seq_relationship"]
- _keys_to_ignore_on_load_missing = [
- r"position_ids", r"predictions.decoder.bias"]
-
- def __init__(self, config):
- super().__init__(config)
-
- if config.is_decoder:
- logger.warning(
- "If you want to use `RoFormerForMaskedLM` make sure `config.is_decoder=False` for "
- "bi-directional self-attention."
- )
-
- self.bert = RoFormerModel(config, add_pooling_layer=False)
- self.cls = RoFormerOnlyMLMHead(config)
-
- self.init_weights()
-
- def get_output_embeddings(self):
- return self.cls.predictions.decoder
-
- def set_output_embeddings(self, new_embeddings):
- self.cls.predictions.decoder = new_embeddings
-
- @add_start_docstrings_to_model_forward(RoFormer_INPUTS_DOCSTRING.format("batch_size, sequence_length"))
- @add_code_sample_docstrings(
- processor_class=_TOKENIZER_FOR_DOC,
- checkpoint=_CHECKPOINT_FOR_DOC,
- output_type=MaskedLMOutput,
- config_class=_CONFIG_FOR_DOC,
- )
- def forward(
- self,
- input_ids=None,
- attention_mask=None,
- token_type_ids=None,
- position_ids=None,
- head_mask=None,
- inputs_embeds=None,
- encoder_hidden_states=None,
- encoder_attention_mask=None,
- labels=None,
- output_attentions=None,
- output_hidden_states=None,
- return_dict=None,
- ):
- r"""
- labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`):
- Labels for computing the masked language modeling loss. Indices should be in ``[-100, 0, ...,
- config.vocab_size]`` (see ``input_ids`` docstring) Tokens with indices set to ``-100`` are ignored
- (masked), the loss is only computed for the tokens with labels in ``[0, ..., config.vocab_size]``
- """
-
- return_dict = return_dict if return_dict is not None else self.config.use_return_dict
-
- outputs = self.bert(
- input_ids,
- attention_mask=attention_mask,
- token_type_ids=token_type_ids,
- position_ids=position_ids,
- head_mask=head_mask,
- inputs_embeds=inputs_embeds,
- encoder_hidden_states=encoder_hidden_states,
- encoder_attention_mask=encoder_attention_mask,
- output_attentions=output_attentions,
- output_hidden_states=output_hidden_states,
- return_dict=return_dict,
- )
-
- sequence_output = outputs[0]
- prediction_scores = self.cls(sequence_output)
-
- masked_lm_loss = None
- if labels is not None:
- loss_fct = CrossEntropyLoss() # -100 index = padding token
- masked_lm_loss = loss_fct(
- prediction_scores.view(-1, self.config.vocab_size), labels.view(-1))
-
- if not return_dict:
- output = (prediction_scores,) + outputs[2:]
- return ((masked_lm_loss,) + output) if masked_lm_loss is not None else output
-
- return MaskedLMOutput(
- loss=masked_lm_loss,
- logits=prediction_scores,
- hidden_states=outputs.hidden_states,
- attentions=outputs.attentions,
- )
-
- def prepare_inputs_for_generation(self, input_ids, attention_mask=None, **model_kwargs):
- input_shape = input_ids.shape
- effective_batch_size = input_shape[0]
-
- # add a dummy token
- assert self.config.pad_token_id is not None, "The PAD token should be defined for generation"
- attention_mask = torch.cat(
- [attention_mask, attention_mask.new_zeros((attention_mask.shape[0], 1))], dim=-1)
- dummy_token = torch.full(
- (effective_batch_size, 1), self.config.pad_token_id, dtype=torch.long, device=input_ids.device
- )
- input_ids = torch.cat([input_ids, dummy_token], dim=1)
-
- return {"input_ids": input_ids, "attention_mask": attention_mask}
-
-
-@add_start_docstrings(
- """RoFormer Model with a `next sentence prediction (classification)` head on top. """,
- RoFormer_START_DOCSTRING,
-)
-class RoFormerForNextSentencePrediction(RoFormerPreTrainedModel):
-
- _keys_to_ignore_on_load_unexpected = [r"predictions"]
-
- def __init__(self, config):
- super().__init__(config)
-
- self.bert = RoFormerModel(config)
- self.cls = RoFormerOnlyNSPHead(config)
-
- self.init_weights()
-
- @add_start_docstrings_to_model_forward(RoFormer_INPUTS_DOCSTRING.format("batch_size, sequence_length"))
- @replace_return_docstrings(output_type=NextSentencePredictorOutput, config_class=_CONFIG_FOR_DOC)
- def forward(
- self,
- input_ids=None,
- attention_mask=None,
- token_type_ids=None,
- position_ids=None,
- head_mask=None,
- inputs_embeds=None,
- labels=None,
- output_attentions=None,
- output_hidden_states=None,
- return_dict=None,
- **kwargs
- ):
- r"""
- labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size,)`, `optional`):
- Labels for computing the next sequence prediction (classification) loss. Input should be a sequence pair
- (see ``input_ids`` docstring). Indices should be in ``[0, 1]``:
-
- - 0 indicates sequence B is a continuation of sequence A,
- - 1 indicates sequence B is a random sequence.
-
- Returns:
-
- Example::
-
- >>> from transformers import BertTokenizer, RoFormerForNextSentencePrediction
- >>> import torch
-
- >>> tokenizer = BertTokenizer.from_pretrained('nvidia/megatron-bert-cased-345m')
- >>> model = RoFormerForNextSentencePrediction.from_pretrained('nvidia/megatron-bert-cased-345m')
-
- >>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
- >>> next_sentence = "The sky is blue due to the shorter wavelength of blue light."
- >>> encoding = tokenizer(prompt, next_sentence, return_tensors='pt')
-
- >>> outputs = model(**encoding, labels=torch.LongTensor([1]))
- >>> logits = outputs.logits
- >>> assert logits[0, 0] < logits[0, 1] # next sentence was random
- """
-
- if "next_sentence_label" in kwargs:
- warnings.warn(
- "The `next_sentence_label` argument is deprecated and will be removed in a future version, use `labels` instead.",
- FutureWarning,
- )
- labels = kwargs.pop("next_sentence_label")
-
- return_dict = return_dict if return_dict is not None else self.config.use_return_dict
-
- outputs = self.bert(
- input_ids,
- attention_mask=attention_mask,
- token_type_ids=token_type_ids,
- position_ids=position_ids,
- head_mask=head_mask,
- inputs_embeds=inputs_embeds,
- output_attentions=output_attentions,
- output_hidden_states=output_hidden_states,
- return_dict=return_dict,
- )
-
- pooled_output = outputs[1]
-
- seq_relationship_scores = self.cls(pooled_output)
-
- next_sentence_loss = None
- if labels is not None:
- loss_fct = CrossEntropyLoss()
- next_sentence_loss = loss_fct(
- seq_relationship_scores.view(-1, 2), labels.view(-1))
-
- if not return_dict:
- output = (seq_relationship_scores,) + outputs[2:]
- return ((next_sentence_loss,) + output) if next_sentence_loss is not None else output
-
- return NextSentencePredictorOutput(
- loss=next_sentence_loss,
- logits=seq_relationship_scores,
- hidden_states=outputs.hidden_states,
- attentions=outputs.attentions,
- )
-
-
-@add_start_docstrings(
- """
- RoFormer Model transformer with a sequence classification/regression head on top (a linear layer on top of the
- pooled output) e.g. for GLUE tasks.
- """,
- RoFormer_START_DOCSTRING,
-)
-class RoFormerForSequenceClassification(RoFormerPreTrainedModel):
- def __init__(self, config):
- super().__init__(config)
- self.num_labels = config.num_labels
-
- self.bert = RoFormerModel(config)
- self.dropout = nn.Dropout(config.hidden_dropout_prob)
- self.classifier = nn.Linear(config.hidden_size, config.num_labels)
-
- self.init_weights()
-
- @add_start_docstrings_to_model_forward(RoFormer_INPUTS_DOCSTRING.format("batch_size, sequence_length"))
- @add_code_sample_docstrings(
- processor_class=_TOKENIZER_FOR_DOC,
- checkpoint=_CHECKPOINT_FOR_DOC,
- output_type=SequenceClassifierOutput,
- config_class=_CONFIG_FOR_DOC,
- )
- def forward(
- self,
- input_ids=None,
- attention_mask=None,
- token_type_ids=None,
- position_ids=None,
- head_mask=None,
- inputs_embeds=None,
- labels=None,
- output_attentions=None,
- output_hidden_states=None,
- return_dict=None,
- ):
- r"""
- labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size,)`, `optional`):
- Labels for computing the sequence classification/regression loss. Indices should be in :obj:`[0, ...,
- config.num_labels - 1]`. If :obj:`config.num_labels == 1` a regression loss is computed (Mean-Square loss),
- If :obj:`config.num_labels > 1` a classification loss is computed (Cross-Entropy).
- """
- return_dict = return_dict if return_dict is not None else self.config.use_return_dict
-
- outputs = self.bert(
- input_ids,
- attention_mask=attention_mask,
- token_type_ids=token_type_ids,
- position_ids=position_ids,
- head_mask=head_mask,
- inputs_embeds=inputs_embeds,
- output_attentions=output_attentions,
- output_hidden_states=output_hidden_states,
- return_dict=return_dict,
- )
-
- pooled_output = outputs[1]
-
- pooled_output = self.dropout(pooled_output)
- logits = self.classifier(pooled_output)
-
- loss = None
- if labels is not None:
- if self.num_labels == 1:
- # We are doing regression
- loss_fct = MSELoss()
- loss = loss_fct(logits.view(-1), labels.view(-1))
- else:
- loss_fct = CrossEntropyLoss()
- loss = loss_fct(
- logits.view(-1, self.num_labels), labels.view(-1))
-
- if not return_dict:
- output = (logits,) + outputs[2:]
- return ((loss,) + output) if loss is not None else output
-
- return SequenceClassifierOutput(
- loss=loss,
- logits=logits,
- hidden_states=outputs.hidden_states,
- attentions=outputs.attentions,
- )
-
-
-@add_start_docstrings(
- """
- RoFormer Model with a multiple choice classification head on top (a linear layer on top of the pooled output
- and a softmax) e.g. for RocStories/SWAG tasks.
- """,
- RoFormer_START_DOCSTRING,
-)
-class RoFormerForMultipleChoice(RoFormerPreTrainedModel):
- def __init__(self, config):
- super().__init__(config)
-
- self.bert = RoFormerModel(config)
- self.dropout = nn.Dropout(config.hidden_dropout_prob)
- self.classifier = nn.Linear(config.hidden_size, 1)
-
- self.init_weights()
-
- @add_start_docstrings_to_model_forward(
- RoFormer_INPUTS_DOCSTRING.format(
- "batch_size, num_choices, sequence_length")
- )
- @add_code_sample_docstrings(
- processor_class=_TOKENIZER_FOR_DOC,
- checkpoint=_CHECKPOINT_FOR_DOC,
- output_type=MultipleChoiceModelOutput,
- config_class=_CONFIG_FOR_DOC,
- )
- def forward(
- self,
- input_ids=None,
- attention_mask=None,
- token_type_ids=None,
- position_ids=None,
- head_mask=None,
- inputs_embeds=None,
- labels=None,
- output_attentions=None,
- output_hidden_states=None,
- return_dict=None,
- ):
- r"""
- labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size,)`, `optional`):
- Labels for computing the multiple choice classification loss. Indices should be in ``[0, ...,
- num_choices-1]`` where :obj:`num_choices` is the size of the second dimension of the input tensors. (See
- :obj:`input_ids` above)
- """
- return_dict = return_dict if return_dict is not None else self.config.use_return_dict
- num_choices = input_ids.shape[1] if input_ids is not None else inputs_embeds.shape[1]
-
- input_ids = input_ids.view(-1, input_ids.size(-1)
- ) if input_ids is not None else None
- attention_mask = attention_mask.view(
- -1, attention_mask.size(-1)) if attention_mask is not None else None
- token_type_ids = token_type_ids.view(
- -1, token_type_ids.size(-1)) if token_type_ids is not None else None
- position_ids = position_ids.view(-1, position_ids.size(-1)
- ) if position_ids is not None else None
- inputs_embeds = (
- inputs_embeds.view(-1, inputs_embeds.size(-2),
- inputs_embeds.size(-1))
- if inputs_embeds is not None
- else None
- )
-
- outputs = self.bert(
- input_ids,
- attention_mask=attention_mask,
- token_type_ids=token_type_ids,
- position_ids=position_ids,
- head_mask=head_mask,
- inputs_embeds=inputs_embeds,
- output_attentions=output_attentions,
- output_hidden_states=output_hidden_states,
- return_dict=return_dict,
- )
-
- pooled_output = outputs[1]
-
- pooled_output = self.dropout(pooled_output)
- logits = self.classifier(pooled_output)
- reshaped_logits = logits.view(-1, num_choices)
-
- loss = None
- if labels is not None:
- loss_fct = CrossEntropyLoss()
- loss = loss_fct(reshaped_logits, labels)
-
- if not return_dict:
- output = (reshaped_logits,) + outputs[2:]
- return ((loss,) + output) if loss is not None else output
-
- return MultipleChoiceModelOutput(
- loss=loss,
- logits=reshaped_logits,
- hidden_states=outputs.hidden_states,
- attentions=outputs.attentions,
- )
-
-
-@add_start_docstrings(
- """
- RoFormer Model with a token classification head on top (a linear layer on top of the hidden-states output) e.g.
- for Named-Entity-Recognition (NER) tasks.
- """,
- RoFormer_START_DOCSTRING,
-)
-class RoFormerForTokenClassification(RoFormerPreTrainedModel):
-
- _keys_to_ignore_on_load_unexpected = [r"pooler"]
-
- def __init__(self, config):
- super().__init__(config)
- self.num_labels = config.num_labels
-
- self.bert = RoFormerModel(config, add_pooling_layer=False)
- self.dropout = nn.Dropout(config.hidden_dropout_prob)
- self.classifier = nn.Linear(config.hidden_size, config.num_labels)
-
- self.init_weights()
-
- @add_start_docstrings_to_model_forward(RoFormer_INPUTS_DOCSTRING.format("batch_size, sequence_length"))
- @add_code_sample_docstrings(
- processor_class=_TOKENIZER_FOR_DOC,
- checkpoint=_CHECKPOINT_FOR_DOC,
- output_type=TokenClassifierOutput,
- config_class=_CONFIG_FOR_DOC,
- )
- def forward(
- self,
- input_ids=None,
- attention_mask=None,
- token_type_ids=None,
- position_ids=None,
- head_mask=None,
- inputs_embeds=None,
- labels=None,
- output_attentions=None,
- output_hidden_states=None,
- return_dict=None,
- ):
- r"""
- labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`):
- Labels for computing the token classification loss. Indices should be in ``[0, ..., config.num_labels -
- 1]``.
- """
- return_dict = return_dict if return_dict is not None else self.config.use_return_dict
-
- outputs = self.bert(
- input_ids,
- attention_mask=attention_mask,
- token_type_ids=token_type_ids,
- position_ids=position_ids,
- head_mask=head_mask,
- inputs_embeds=inputs_embeds,
- output_attentions=output_attentions,
- output_hidden_states=output_hidden_states,
- return_dict=return_dict,
- )
-
- sequence_output = outputs[0]
-
- sequence_output = self.dropout(sequence_output)
- logits = self.classifier(sequence_output)
-
- loss = None
- if labels is not None:
- loss_fct = CrossEntropyLoss()
- # Only keep active parts of the loss
- if attention_mask is not None:
- active_loss = attention_mask.view(-1) == 1
- active_logits = logits.view(-1, self.num_labels)
- active_labels = torch.where(
- active_loss, labels.view(-1), torch.tensor(
- loss_fct.ignore_index).type_as(labels)
- )
- loss = loss_fct(active_logits, active_labels)
- else:
- loss = loss_fct(
- logits.view(-1, self.num_labels), labels.view(-1))
-
- if not return_dict:
- output = (logits,) + outputs[2:]
- return ((loss,) + output) if loss is not None else output
-
- return TokenClassifierOutput(
- loss=loss,
- logits=logits,
- hidden_states=outputs.hidden_states,
- attentions=outputs.attentions,
- )
-
-
-@add_start_docstrings(
- """
- RoFormer Model with a span classification head on top for extractive question-answering tasks like SQuAD (a
- linear layers on top of the hidden-states output to compute `span start logits` and `span end logits`).
- """,
- RoFormer_START_DOCSTRING,
-)
-class RoFormerForQuestionAnswering(RoFormerPreTrainedModel):
-
- _keys_to_ignore_on_load_unexpected = [r"pooler"]
-
- def __init__(self, config):
- super().__init__(config)
- self.num_labels = config.num_labels
-
- self.bert = RoFormerModel(config, add_pooling_layer=False)
- self.qa_outputs = nn.Linear(config.hidden_size, config.num_labels)
-
- self.init_weights()
-
- @add_start_docstrings_to_model_forward(RoFormer_INPUTS_DOCSTRING.format("batch_size, sequence_length"))
- @add_code_sample_docstrings(
- processor_class=_TOKENIZER_FOR_DOC,
- checkpoint=_CHECKPOINT_FOR_DOC,
- output_type=QuestionAnsweringModelOutput,
- config_class=_CONFIG_FOR_DOC,
- )
- def forward(
- self,
- input_ids=None,
- attention_mask=None,
- token_type_ids=None,
- position_ids=None,
- head_mask=None,
- inputs_embeds=None,
- start_positions=None,
- end_positions=None,
- output_attentions=None,
- output_hidden_states=None,
- return_dict=None,
- ):
- r"""
- start_positions (:obj:`torch.LongTensor` of shape :obj:`(batch_size,)`, `optional`):
- Labels for position (index) of the start of the labelled span for computing the token classification loss.
- Positions are clamped to the length of the sequence (:obj:`sequence_length`). Position outside of the
- sequence are not taken into account for computing the loss.
- end_positions (:obj:`torch.LongTensor` of shape :obj:`(batch_size,)`, `optional`):
- Labels for position (index) of the end of the labelled span for computing the token classification loss.
- Positions are clamped to the length of the sequence (:obj:`sequence_length`). Position outside of the
- sequence are not taken into account for computing the loss.
- """
- return_dict = return_dict if return_dict is not None else self.config.use_return_dict
-
- outputs = self.bert(
- input_ids,
- attention_mask=attention_mask,
- token_type_ids=token_type_ids,
- position_ids=position_ids,
- head_mask=head_mask,
- inputs_embeds=inputs_embeds,
- output_attentions=output_attentions,
- output_hidden_states=output_hidden_states,
- return_dict=return_dict,
- )
-
- sequence_output = outputs[0]
-
- logits = self.qa_outputs(sequence_output)
- start_logits, end_logits = logits.split(1, dim=-1)
- start_logits = start_logits.squeeze(-1).contiguous()
- end_logits = end_logits.squeeze(-1).contiguous()
-
- total_loss = None
- if start_positions is not None and end_positions is not None:
- # If we are on multi-GPU, split add a dimension
- if len(start_positions.size()) > 1:
- start_positions = start_positions.squeeze(-1)
- if len(end_positions.size()) > 1:
- end_positions = end_positions.squeeze(-1)
- # sometimes the start/end positions are outside our model inputs, we ignore these terms
- ignored_index = start_logits.size(1)
- start_positions = start_positions.clamp(0, ignored_index)
- end_positions = end_positions.clamp(0, ignored_index)
-
- loss_fct = CrossEntropyLoss(ignore_index=ignored_index)
- start_loss = loss_fct(start_logits, start_positions)
- end_loss = loss_fct(end_logits, end_positions)
- total_loss = (start_loss + end_loss) / 2
-
- if not return_dict:
- output = (start_logits, end_logits) + outputs[2:]
- return ((total_loss,) + output) if total_loss is not None else output
-
- return QuestionAnsweringModelOutput(
- loss=total_loss,
- start_logits=start_logits,
- end_logits=end_logits,
- hidden_states=outputs.hidden_states,
- attentions=outputs.attentions,
- )
diff --git a/spaces/feregVcuzo/sanity-test-midi/checkpoint/Best Real Project Playtime Mobile APK The Ultimate Guide to Download and Install the Game.md b/spaces/feregVcuzo/sanity-test-midi/checkpoint/Best Real Project Playtime Mobile APK The Ultimate Guide to Download and Install the Game.md
deleted file mode 100644
index fd5056fa7a96bd8a5747c9acced8c31871c7f510..0000000000000000000000000000000000000000
--- a/spaces/feregVcuzo/sanity-test-midi/checkpoint/Best Real Project Playtime Mobile APK The Ultimate Guide to Download and Install the Game.md
+++ /dev/null
@@ -1,186 +0,0 @@
-
-
Best Real Project Playtime Mobile APK: A Guide for Horror Fans
-
If you are looking for a thrilling and fun multiplayer horror game, you might want to check out Project Playtime Mobile APK. This is a fan-made port of the popular PC game Project Playtime, which is available on Steam. In this game, you can either play as a survivor who tries to escape from a toy factory, or as a monster who hunts down the survivors. This guide will tell you everything you need to know about Project Playtime Mobile APK, including how to download and install it, how to use it effectively, what are the reviews and ratings of it, what are the alternatives and competitors of it, and what are the common problems and solutions for it.
Project Playtime is a free-to-play multiplayer horror game developed by Mob Entertainment. It was released on Steam in December 2022 as an early access game. The game is inspired by the popular horror franchise Five Nights at Freddy's, as well as other horror games like Dead by Daylight and Among Us.
-
The game is set in a toy factory where six players have to work together to create one giant toy while avoiding a terrifying monster that roams the factory. The monster is controlled by a seventh player who has only one goal: find and kill everyone. The game has two maps: Poppy's Factory, where the monster is a giant rabbit named Huggy Wuggy, and Destroy-a-Toy, where the monster is a giant bear named Killy Willy. The game also has different modes, such as Classic Mode, where the survivors have to collect parts and assemble them in a machine, Sabotage Mode, where the survivors can buy items to hinder the monster or help themselves, and Story Mode, where the survivors can learn more about the backstory of the game.
-
The main features and benefits of playing Project Playtime
-
Project Playtime is a game that offers many features and benefits for horror fans, such as:
-
best real project playtime horror game apk
-download best real project playtime mobile app
-best real project playtime android apk free
-best real project playtime mobile mod apk
-best real project playtime apk for ios
-best real project playtime mobile online multiplayer
-best real project playtime mobile apk latest version
-best real project playtime mobile apk no ads
-best real project playtime mobile apk unlimited money
-best real project playtime mobile apk offline mode
-best real project playtime mobile apk review
-best real project playtime mobile apk gameplay
-best real project playtime mobile apk cheats
-best real project playtime mobile apk hack
-best real project playtime mobile apk tips and tricks
-best real project playtime mobile apk walkthrough
-best real project playtime mobile apk guide
-best real project playtime mobile apk tutorial
-best real project playtime mobile apk features
-best real project playtime mobile apk requirements
-best real project playtime mobile apk size
-best real project playtime mobile apk download link
-best real project playtime mobile apk update
-best real project playtime mobile apk new version
-best real project playtime mobile apk old version
-best real project playtime mobile apk beta version
-best real project playtime mobile apk full version
-best real project playtime mobile apk pro version
-best real project playtime mobile apk premium version
-best real project playtime mobile apk cracked version
-best real project playtime mobile apk original version
-best real project playtime mobile apk alternative version
-best real project playtime mobile apk fan made version
-best real project playtime mobile apk custom version
-best real project playtime mobile apk unofficial version
-best real project playtime mobile apk comparison with other games
-best real project playtime mobile apk ratings and reviews
-best real project playtime mobile apk feedback and suggestions
-best real project playtime mobile apk problems and solutions
-best real project playtime mobile apk bugs and fixes
-best real project playtime mobile apk support and contact information
-best real project playtime mobile apk developer and publisher information
-best real project playtime mobile apk genre and category information
-best real project playtime mobile apk release date and availability information
-best real project playtime mobile apk price and purchase information
-best real project playtime mobile apk refund and cancellation information
-best real project playtime mobile apk privacy policy and terms of service information
-
-
It has a unique gameplay that combines stealth, teamwork, puzzle-solving, and survival elements.
-
It has a variety of characters, monsters, perks, sabotages, cosmetics, and achievements that add replay value and customization options.
-
It has a rich lore and story that create an immersive and creepy atmosphere.
-
It has a friendly and active community that supports the game's development and provides feedback.
-
It has regular updates that add new content, features, bug fixes, and improvements.
-
-
How to download and install Project Playtime Mobile APK
-
The steps to find and get the APK file from a reliable source
-
Since Project Playtime is not officially available on mobile devices, you will need to download an APK file from a third-party source. An APK file is an Android application package that contains the app's code and resources. You can use an APK file to install an app that is not available on the Google Play Store. However, you need to be careful about the source of the APK file, as some of them may contain malware or viruses that can harm your device. Only download APK files from trusted and reputable websites, such as APK Mirror. To find and get the Project Playtime Mobile APK file from a reliable source, you can follow these steps: - Go to your web browser and search for "Project Playtime Mobile APK" on Google or any other search engine. - Look for a website that offers the latest version of the APK file and has positive reviews and ratings from other users. For example, you can use APK Combo, which is a website that hosts Android apps and games for free download. - Tap on the website link and scroll down to the download section. You should see a button that says "Download APK" or something similar. Tap on it and wait for the download to start. - You may see a warning message that says "This type of file can harm your device". Tap on OK to proceed with the download. Only do this if you trust the source of the APK file. - Once the download is complete, you should see a notification on your device that says "Download complete" or something similar. Tap on it to open the APK file.
The instructions to install and run the APK file on your Android device
-
After you have downloaded the Project Playtime Mobile APK file, you need to install and run it on your Android device. To do this, you need to follow these instructions:
- - If you have not done so already, enable the installation of unknown apps on your device. To do this, go to your device settings and tap on Apps & Notifications (or Apps in older versions of Android). Tap on the three dots in the upper-right corner and tap on Special access. Tap on Install unknown apps and select your web browser or file manager app. Move the slider to allow from this source. - Locate the Project Playtime Mobile APK file on your device using your web browser or file manager app. Tap on it to open it. - You should see a screen that says "Do you want to install this application?" Tap on Install at the bottom of the screen and wait for the installation to finish. - Once the installation is done, you should see a screen that says "App installed". Tap on Open to launch the app or Done to exit the screen. - You may need to grant some permissions to the app, such as access to your storage, microphone, camera, etc. Tap on Allow or Deny as per your preference. - You should now be able to enjoy playing Project Playtime Mobile APK on your Android device.
How to use Project Playtime Mobile APK effectively
-
The tips and tricks to survive and win as a survivor or a monster
-
Project Playtime Mobile APK is a game that requires skill, strategy, and teamwork to survive and win as either a survivor or a monster. Here are some tips and tricks that can help you improve your gameplay:
- - As a survivor, you need to work together with your teammates to collect parts and assemble them in a machine. You can communicate with them using voice chat or text chat. You can also use items such as flashlights, radios, keys, etc. to help you find parts or escape routes. - As a monster, you need to hunt down and kill all the survivors before they complete their task. You can use your abilities such as roar, sprint, jump, etc. to chase and catch them. You can also use sabotages such as traps, doors, vents, etc. to hinder their progress or lure them into danger. - As either role, you need to be aware of your surroundings and use them to your advantage. You can hide behind objects, crouch under tables, climb ladders, etc. to avoid detection or ambush your enemies. You can also use sound cues such as footsteps, screams, alarms, etc. to locate or distract them. - As either role, you need to be careful of your stamina and health bars. Your stamina determines how fast you can run or use abilities. Your health determines how much damage you can take before dying. You can replenish your stamina by resting or using items such as energy drinks. You can replenish your health by using items such as bandages or medkits.
The best strategies and tactics to play on different maps and modes
-
Project Playtime Mobile APK has two maps and three modes that offer different challenges and opportunities for both survivors and monsters. Here are some of the best strategies and tactics to play on each map and mode:
- - Poppy's Factory: This is the first map of the game where the monster is Huggy Wuggy, a giant rabbit with long arms and legs. - As a survivor, you need to avoid Huggy Wuggy's long reach and speed. You can use items such as scissors, glue, or magnets to cut, stick, or slow him down. You can also use vents to escape from him or surprise him from behind. - As Huggy Wuggy, you need to use your long reach and speed to catch the survivors. You can use your roar to stun them or your sprint to chase them. You can also use vents to travel faster or ambush them from above. - Classic Mode: This is the default mode of the game where the survivors have to collect parts and assemble them in a machine. The machine has four slots that require different types of parts: head, body, arms, and legs. The survivors have to find the matching parts and bring them to the machine. The monster has to stop them by killing them or sabotaging the machine. - As a survivor, you need to coordinate with your teammates to find and deliver the parts. You can use radios to communicate with them or flashlights to see in the dark. You can also use keys to unlock doors or chests that may contain parts or items. - As a monster, you need to patrol the factory and find the survivors. You can use traps to slow them down or doors to block their way. You can also use vents to move around or sabotage the machine to make it malfunction. - Sabotage Mode: This is a mode where the survivors can buy items using coins that they find in the factory. The items can be used to hinder the monster or help themselves. The monster can also buy sabotages using coins that they get from killing survivors. The sabotages can be used to hinder the survivors or help themselves. - As a survivor, you need to collect coins and buy items that suit your playstyle. You can buy items such as grenades, bear traps, stun guns, etc. that can damage or disable the monster. You can also buy items such as medkits, energy drinks, shields, etc. that can heal or boost yourself. - As a monster, you need to collect coins and buy sabotages that suit your playstyle. You can buy sabotages such as fire, gas, blackout, etc. that can harm or confuse the survivors. You can also buy sabotages such as rage, stealth, regeneration, etc. that can enhance or heal yourself. - Story Mode: This is a mode where the survivors can learn more about the backstory of the game and the characters. The mode has different chapters that reveal different aspects of the game's lore and story. The mode also has different objectives and challenges that test the survivors' skills and knowledge. - As a survivor, you need to follow the instructions and complete the objectives of each chapter. You can also explore the factory and find clues and secrets that reveal more information about the game's lore and story. - As a monster, you need to prevent the survivors from completing their objectives and learning more about the game's lore and story. You can also find clues and secrets that reveal more information about your own origin and motivation.
Reviews and ratings of Project Playtime Mobile APK
-
The positive and negative feedback from other players
-
Project Playtime Mobile APK is a game that has received mixed reviews and ratings from other players who have tried it. Here are some of the positive and negative feedback from other players:
-
-
-
Positive Feedback
-
Negative Feedback
-
-
-
- The game is very fun and exciting to play with friends or strangers.
-
- The game is very buggy and glitchy on some devices.
-
-
-
- The game has a lot of content and variety to keep players entertained.
-
- The game is very hard and unfair for some players.
-
-
-
- The game has a great atmosphere and graphics that create a scary and immersive experience.
-
- The game has a lot of ads and pop-ups that interrupt the gameplay.
-
-
-
- The game has a good community and support that listen to feedback and suggestions.
-
- The game has a lot of hackers and cheaters that ruin the game for others.
-
-
-
The pros and cons of playing Project Playtime Mobile APK
-
Based on the reviews and ratings of other players, here are some of the pros and cons of playing Project Playtime Mobile APK:
-
-
Pros:
-
It is a free-to-play game that does not require any purchase or subscription.
-
It is a multiplayer game that allows you to play with up to six other players online.
-
It is a horror game that offers a unique gameplay that combines stealth, teamwork, puzzle-solving, and survival elements.
-
It has a lot of features and benefits that add replay value and customization options.
-
It has a rich lore and story that create an immersive and creepy atmosphere.
-
It has regular updates that add new content, features, bug fixes, and improvements.
-
-
-
Cons:
-
It is not an official port of the PC game and may have compatibility issues with some devices.
-
It is a horror game that may not be suitable for some players who are sensitive to gore, violence, or jump scares.
-
It is a multiplayer game that requires a stable internet connection and may have lag or connection problems.
-
It has a lot of ads and pop-ups that may interrupt the gameplay or affect the performance.
-
It has a lot of hackers and cheaters that may ruin the game for others or give unfair advantages.
-
-
-
-
Alternatives and competitors of Project Playtime Mobile APK
-
The other similar games that you can try if you like Project Playtime
-
If you enjoy playing Project Playtime Mobile APK, you may also like some of the other similar games that are available on mobile devices. Here are some of the other games that you can try if you like Project Playtime:
- - Five Nights at Freddy's AR: Special Delivery: This is a game based on the popular horror franchise Five Nights at Freddy's, where you have to survive against animatronic characters that come to your real-world location using augmented reality. You can collect and customize your own animatronics, as well as send them to your friends or enemies. - Dead by Daylight Mobile: This is a game based on the popular horror game Dead by Daylight, where four survivors have to escape from a killer who has supernatural abilities. You can play as either a survivor or a killer, and choose from different characters, maps, modes, and items. - Among Us: This is a game where you have to work together with other players to complete tasks on a spaceship, while one or more impostors try to kill everyone. You can play as either a crewmate or an impostor, and use deception, deduction, and communication to win. - Granny: This is a game where you have to escape from a house where a creepy old lady named Granny keeps you locked up. You have to find items and clues to unlock doors and windows, while avoiding Granny's traps and attacks.
The differences and similarities between Project Playtime and its alternatives
-
Project Playtime and its alternatives have some differences and similarities that make them appealing to different types of players. Here are some of the differences and similarities between Project Playtime and its alternatives:
-
-
-
Differences
-
Similarities
-
-
-
- Project Playtime is not officially available on mobile devices, while its alternatives are.
-
- Project Playtime and its alternatives are all multiplayer horror games that require teamwork and strategy.
-
-
-
- Project Playtime has a unique gameplay that combines stealth, teamwork, puzzle-solving, and survival elements, while its alternatives have more straightforward gameplay mechanics.
-
- Project Playtime and its alternatives have different characters, maps, modes, items, and cosmetics that add variety and customization options.
-
-
- Project Playtime has a rich lore and story that create an immersive and creepy atmosphere, while its alternatives have more simple or vague stories.
-
- Project Playtime and its alternatives have a friendly and active community that supports the game's development and provides feedback.
-
-
-
- Project Playtime has regular updates that add new content, features, bug fixes, and improvements, while its alternatives have less frequent or inconsistent updates.
-
- Project Playtime and its alternatives have a lot of ads and pop-ups that may interrupt the gameplay or affect the performance.
-
-
-
- Project Playtime has a lot of hackers and cheaters that may ruin the game for others or give unfair advantages, while its alternatives have more security and anti-cheat measures.
-
- Project Playtime and its alternatives have a lot of features and benefits that make them fun and exciting to play with friends or strangers.
-
-
-
Common problems and solutions for Project Playtime Mobile APK
-
The most frequent issues and errors that players encounter
-
Project Playtime Mobile APK is a game that may have some problems and errors that can affect the gameplay or performance. Here are some of the most frequent issues and errors that players encounter:
- - The game crashes or freezes during loading or gameplay. - The game does not start or launch properly. - The game does not connect or sync with the server or other players. - The game does not recognize or respond to the touch screen or other inputs. - The game has low graphics quality or frame rate. - The game has missing or corrupted files or data.
The possible fixes and workarounds for these problems
-
Project Playtime Mobile APK is a game that may have some possible fixes and workarounds for these problems. Here are some of the possible fixes and workarounds for these problems:
- - The game crashes or freezes during loading or gameplay: You can try to clear the cache and data of the app, restart your device, update the app to the latest version, uninstall and reinstall the app, or use a different device. - The game does not start or launch properly: You can try to check the compatibility of your device, enable the installation of unknown apps, allow the permissions of the app, disable any antivirus or firewall software, or use a VPN service. - The game does not connect or sync with the server or other players: You can try to check your internet connection, switch to a different network, restart your router or modem, change your region or server, or contact the support team. - The game does not recognize or respond to the touch screen or other inputs: You can try to calibrate your touch screen, clean your screen, adjust your sensitivity settings, use a stylus pen, or use an external controller. - The game has low graphics quality or frame rate: You can try to lower your graphics settings, close any background apps, free up some storage space, use a booster app, or use a different device. - The game has missing or corrupted files or data: You can try to verify the integrity of the files, download the files again, restore your backup data, use a file manager app, or contact the support team.
Conclusion
-
A summary of the main points and a call to action
-
Project Playtime Mobile APK is a fan-made port of the popular PC game Project Playtime, which is a multiplayer horror game where you can either play as a survivor who tries to escape from a toy factory, or as a monster who hunts down the survivors. In this guide, we have covered everything you need to know about Project Playtime Mobile APK, including how to download and install it, how to use it effectively, what are the reviews and ratings of it, what are the alternatives and competitors of it, and what are the common problems and solutions for it.
-
If you are looking for a thrilling and fun multiplayer horror game, you should definitely give Project Playtime Mobile APK a try. You can download it from a reliable source such as APK Combo, install it on your Android device using our instructions, and enjoy playing it with your friends or strangers online. You can also join the community and support the development of the game by providing feedback and suggestions. Project Playtime Mobile APK is a game that will keep you on the edge of your seat and make you scream with fear and joy.
-
So what are you waiting for? Download Project Playtime Mobile APK now and experience the horror of being hunted by a giant toy!
-
FAQs
-
What are some of the FAQs about Project Playtime Mobile APK?
-
Here are some of the FAQs about Project Playtime Mobile APK:
-
-
Q: Is Project Playtime Mobile A: Project Playtime Mobile APK is a fan-made port of the popular PC game Project Playtime, which is a multiplayer horror game where you can either play as a survivor who tries to escape from a toy factory, or as a monster who hunts down the survivors. The game is not officially available on mobile devices, but you can download and install it using an APK file from a third-party source.
-
Q: How do I download and install Project Playtime Mobile APK?
-A: To download and install Project Playtime Mobile APK, you need to follow these steps: - Go to your web browser and search for "Project Playtime Mobile APK" on Google or any other search engine. - Look for a website that offers the latest version of the APK file and has positive reviews and ratings from other users. For example, you can use APK Combo, which is a website that hosts Android apps and games for free download. - Tap on the website link and scroll down to the download section. You should see a button that says "Download APK" or something similar. Tap on it and wait for the download to start. - You may see a warning message that says "This type of file can harm your device". Tap on OK to proceed with the download. Only do this if you trust the source of the APK file. - Once the download is complete, you should see a notification on your device that says "Download complete" or something similar. Tap on it to open the APK file. - If you have not done so already, enable the installation of unknown apps on your device. To do this, go to your device settings and tap on Apps & Notifications (or Apps in older versions of Android). Tap on the three dots in the upper-right corner and tap on Special access. Tap on Install unknown apps and select your web browser or file manager app. Move the slider to allow from this source. - Locate the Project Playtime Mobile APK file on your device using your web browser or file manager app. Tap on it to open it. - You should see a screen that says "Do you want to install this application?" Tap on Install at the bottom of the screen and wait for the installation to finish. - Once the installation is done, you should see a screen that says "App installed". Tap on Open to launch the app or Done to exit the screen. - You may need to grant some permissions to the app, such as access to your storage, microphone, camera, etc. Tap on Allow or Deny as per your preference. - You should now be able to enjoy playing Project Playtime Mobile APK on your Android device.
-
Q: How do I use Project Playtime Mobile APK effectively?
-A: To use Project Playtime Mobile APK effectively, you need to follow these tips and tricks: - As a survivor, you need to work together with your teammates to collect parts and assemble them in a machine. You can communicate with them using voice chat or text chat. You can also use items such as flashlights, radios, keys, etc. to help you find parts or escape routes. - As a monster, you need to hunt down and kill all the survivors before they complete their task. You can use your abilities such as roar, sprint, jump, etc. to chase and catch them. You can also use sabotages such as traps, doors, vents, etc. to hinder their progress or lure them into danger. - As either role, you need to be aware of your surroundings and use them to your advantage. You can hide behind objects, crouch under tables, climb ladders, etc. to avoid detection or ambush your enemies. You can also use sound cues such as footsteps, screams, alarms, etc. to locate or distract them. - As either role, you need to be careful of your stamina and health bars. Your stamina determines how fast you can run or use abilities. Your health determines how much damage you can take before dying. You can replenish your stamina by resting or using items such as energy drinks. You can replenish your health by using items such as bandages or medkits.
-
Q: What are some of the reviews and ratings of Project Playtime Mobile APK?
-A: Project Playtime Mobile APK is a game that has received mixed reviews and ratings from other players who have tried it. Here are some of the reviews and ratings of Project Playtime Mobile APK:
-
-
"This game is amazing! It's so scary and fun at the same time! I love playing with my friends online and trying different characters and modes. The graphics are great and the sounds are creepy. The only problem is that sometimes it crashes or lags on my phone."
-
"This game is terrible! It's so buggy and glitchy on my device! I can't even start or join a game without getting an error message or a black screen. The game is also full of ads and hackers that make it impossible to play. The game is a waste of time and space."
-
"This game is okay. It's not the best or the worst game I've ever played. It has some good and bad aspects. The game is fun and exciting when it works, but it also has a lot of problems and errors that need to be fixed. The game is decent but not amazing."
-
-
Q: What are some of the alternatives and competitors of Project Playtime Mobile APK?
-A: Project Playtime Mobile APK is a game that has some alternatives and competitors that are similar to it. Here are some of the alternatives and competitors of Project Playtime Mobile APK:
-
-
Five Nights at Freddy's AR: Special Delivery: This is a game based on the popular horror franchise Five Nights at Freddy's, where you have to survive against animatronic characters that come to your real-world location using augmented reality. You can collect and customize your own animatronics, as well as send them to your friends or enemies.
-
Dead by Daylight Mobile: This is a game based on the popular horror game Dead by Daylight, where four survivors have to escape from a killer who has supernatural abilities. You can play as either a survivor or a killer, and choose from different characters, maps, modes, and items.
-
Among Us: This is a game where you have to work together with other players to complete tasks on a spaceship, while one or more impostors try to kill everyone. You can play as either a crewmate or an impostor, and use deception, deduction, and communication to win.
-
Granny: This is a game where you have to escape from a house where a creepy old lady named Granny keeps you locked up. You have to find items and clues to unlock doors and windows, while avoiding Granny's traps and attacks.
-
-
197e85843d
-
-
\ No newline at end of file
diff --git a/spaces/feregVcuzo/sanity-test-midi/checkpoint/Cmo conseguir el apk de Arena of Valor con trucos mapas y vista amplia.md b/spaces/feregVcuzo/sanity-test-midi/checkpoint/Cmo conseguir el apk de Arena of Valor con trucos mapas y vista amplia.md
deleted file mode 100644
index 2c50de0014838b6306c132aabd06a432095efcca..0000000000000000000000000000000000000000
--- a/spaces/feregVcuzo/sanity-test-midi/checkpoint/Cmo conseguir el apk de Arena of Valor con trucos mapas y vista amplia.md
+++ /dev/null
@@ -1,98 +0,0 @@
-
-
Descargar Arena of Valor Hack Apk: How to Get Unlimited Money and Gems
-
Are you a fan of Arena of Valor, the epic 5v5 MOBA game that has taken the world by storm? Do you want to enjoy the game without any limitations or restrictions? If so, you might be interested in descargar Arena of Valor hack apk, a modified version of the game that gives you unlimited money and gems. In this article, we will tell you everything you need to know about Arena of Valor hack apk, including what it is, why you need it, and how to get it. Let's get started!
A popular 5v5 MOBA game with over 100 million players worldwide
-
Arena of Valor is a multiplayer online battle arena (MOBA) game developed by TiMi Studios and published by Tencent Games. It is one of the most popular games in the world, with over 100 million active players across various platforms. The game is inspired by the Warcraft III mod Defense of the Ancients (DotA) and features similar gameplay elements.
-
Features of Arena of Valor
-
Choose from over 100 heroes with different roles and abilities
-
In Arena of Valor, you can choose from over 100 heroes, each with their own unique skills, attributes, and playstyles. There are five main roles in the game: tank, warrior, assassin, mage, and support. You can also customize your hero with different skins, items, and talents.
-
Team up with friends or random players in various modes and maps
-
Arena of Valor offers various modes and maps for you to enjoy. You can play the classic 5v5 mode, where you have to destroy the enemy's base while defending your own. You can also try other modes, such as 3v3, 10v10, Abyssal Clash, Valley Skirmish, Hook Wars, and more. You can also join ranked matches, tournaments, events, and seasonal activities.
-
Enjoy stunning graphics, smooth controls, and immersive sound effects
-
Arena of Valor boasts impressive graphics that bring the game to life. The game also has smooth controls that are easy to learn and master. You can also enjoy the immersive sound effects that enhance your gameplay experience. You can also chat with your teammates using voice or text messages.
-
Why do you need Arena of Valor hack apk?
-
The benefits of using Arena of Valor mod apk
-
Get unlimited money and gems to buy items, skins, and heroes
-
One of the main reasons why you might want to descargar Arena of Valor hack apk is to get unlimited money and gems. Money and gems are the main currencies in the game that you can use to buy items, skins, and heroes. However, earning money and gems can be time-consuming and tedious. You might also have to spend real money to get them. With Arena of Valor hack apk , you can get unlimited money and gems for free. You can use them to buy any item, skin, or hero you want. You can also upgrade your items and heroes to make them more powerful.
-
Unlock all heroes and modes without spending real money
-
Another benefit of using Arena of Valor hack apk is that you can unlock all heroes and modes without spending real money. Normally, some heroes and modes are locked behind a paywall or require a certain level or rank to access. With Arena of Valor mod apk, you can unlock all heroes and modes instantly. You can play with any hero you like and try any mode you want.
-
descargar arena of valor mod menu apk
-descargar arena of valor hackeado apk 2023
-descargar arena of valor trucos apk
-descargar arena of valor mapa hack apk
-descargar arena of valor vision amplia apk
-descargar arena of valor hack apk ultima version
-descargar arena of valor hack apk sin root
-descargar arena of valor hack apk mega
-descargar arena of valor hack apk mediafire
-descargar arena of valor hack apk android
-descargar arena of valor hack apk ios
-descargar arena of valor hack apk gratis
-descargar arena of valor hack apk full
-descargar arena of valor hack apk no ban
-descargar arena of valor hack apk online
-descargar arena of valor hack apk offline
-descargar arena of valor hack apk diamantes infinitos
-descargar arena of valor hack apk oro ilimitado
-descargar arena of valor hack apk gemas gratis
-descargar arena of valor hack apk skins desbloqueados
-descargar arena of valor hack apk vip
-descargar arena of valor hack apk anti ban
-descargar arena of valor hack apk actualizado
-descargar arena of valor hack apk 2023 mega
-descargar arena of valor hack apk 2023 mediafire
-descargar arena of valor mod menu 2023 apk
-descargar arena of valor mod menu 2023 mediafire
-descargar arena of valor mod menu 2023 mega
-descargar arena of valor mod menu 2023 android
-descargar arena of valor mod menu 2023 ios
-descargar arena of valor mod menu 2023 gratis
-descargar arena of valor mod menu 2023 full
-descargar arena of valor mod menu 2023 no ban
-descargar arena of valor mod menu 2023 online
-descargar arena of valor mod menu 2023 offline
-descargar arena of valor mod menu 2023 diamantes infinitos
-descargar arena of valor mod menu 2023 oro ilimitado
-descargar arena of valor mod menu 2023 gemas gratis
-descargar arena of valor mod menu 2023 skins desbloqueados
-descargar arena of valor mod menu 2023 vip
-descargar arena of valor mod menu 2023 anti ban
-descargar arena of valor mod menu 2023 actualizado
-como descargar arena of valor hack apk
-como instalar arena of valor hack apk
-como usar arena of valor hack apk
-como actualizar arena of valor hack apk
-como jugar con amigos en arena of valor hack apk
-
Enhance your gameplay experience and have more fun
-
The last benefit of using Arena of Valor hack apk is that you can enhance your gameplay experience and have more fun. With unlimited money and gems, you can buy any item, skin, or hero you want. You can also upgrade your items and heroes to make them more powerful. You can also unlock all heroes and modes without spending real money. You can play with any hero you like and try any mode you want. You can also enjoy the stunning graphics, smooth controls, and immersive sound effects. You can also chat with your teammates using voice or text messages. You can also join ranked matches, tournaments, events, and seasonal activities. You can also customize your hero with different skins, items, and talents. You can also have more fun with Arena of Valor hack apk.
-
How to descargar Arena of Valor hack apk?
-
The steps to download and install Arena of Valor mod apk on your device
-
If you are interested in descargar Arena of Valor hack apk, you might be wondering how to do it. Here are the steps to download and install Arena of Valor mod apk on your device:
-
Find a reliable source for Arena of Valor hack apk online (such as )
-
The first step is to find a reliable source for Arena of Valor hack apk online. There are many websites that claim to offer Arena of Valor mod apk, but not all of them are trustworthy. Some of them might contain viruses, malware, or spyware that can harm your device or steal your personal information. Some of them might also have outdated or fake versions of the game that do not work properly. Therefore, you need to be careful when choosing a source for Arena of Valor hack apk online. One of the best sources for Arena of Valor mod apk online is . This website offers the latest and working version of Arena of Valor hack apk that gives you unlimited money and gems. It also has a user-friendly interface and a fast download speed. It also has a high rating and positive feedback from other users.
-
Download the apk file and allow unknown sources in your settings
-
The next step is to download the apk file from the source you have chosen. To do this, you need to click on the download button on the website and wait for the file to be downloaded on your device. Once the file is downloaded, you need to allow unknown sources in your settings. This is because Arena of Valor hack apk is not available on the official app store and is considered an unknown source by your device. To allow unknown sources in your settings, you need to go to your device's settings, then security, then unknown sources, then enable it.
-
Install the apk file and launch the game
-
The final step is to install the apk file and launch the game. To do this, you need to locate the downloaded file on your device and tap on it. Then, follow the instructions on the screen to install the game. Once the game is installed, you can launch it from your home screen or app drawer. You will see that you have unlimited money and gems in the game. You will also see that all heroes and modes are unlocked for you. You can now enjoy the game with Arena of Valor hack apk.
-
Conclusion
-
Arena of Valor is a popular 5v5 MOBA game with over 100 million players worldwide. It has many features that make it fun and exciting, such as over 100 heroes, various modes and maps, stunning graphics, smooth controls, and immersive sound effects. However, some players might want to descargar Arena of Valor hack apk, a modified version of the game that gives them unlimited money and gems. This way, they can buy any item, skin, or hero they want, unlock all heroes and modes without spending real money, and enhance their gameplay experience and have more fun.
-
If you are one of those players who want to descargar Arena of Valor hack apk , you can follow the steps we have provided in this article. You can find a reliable source for Arena of Valor hack apk online, such as . You can download the apk file and allow unknown sources in your settings. You can install the apk file and launch the game. You can enjoy the game with unlimited money and gems, and all heroes and modes unlocked.
-
We hope you found this article helpful and informative. If you have any questions or feedback, please feel free to leave a comment below. Thank you for reading and happy gaming!
-
FAQs
-
Here are some frequently asked questions about Arena of Valor hack apk:
-
-
Is Arena of Valor hack apk safe to use?
-
Arena of Valor hack apk is safe to use as long as you download it from a reliable source, such as . However, you should always be careful when downloading and installing any apk file from unknown sources, as they might contain viruses, malware, or spyware that can harm your device or steal your personal information. You should also scan the apk file with an antivirus program before installing it.
-
Will I get banned for using Arena of Valor hack apk?
-
There is a possibility that you might get banned for using Arena of Valor hack apk, as it violates the terms of service of the game. However, this is unlikely to happen if you use the hack apk discreetly and moderately. You should not abuse the unlimited money and gems, or use them to buy items, skins, or heroes that are not available in your region or server. You should also not brag about using the hack apk or insult other players who do not use it. You should also avoid playing ranked matches or tournaments with the hack apk, as they might detect it and ban you.
-
Can I update Arena of Valor hack apk?
-
Arena of Valor hack apk might not work properly if the game updates to a new version. Therefore, you might need to update the hack apk as well. To do this, you need to visit the source where you downloaded the hack apk from, such as , and check if they have an updated version of the hack apk. If they do, you can download and install it following the same steps as before. If they do not, you might have to wait until they release an updated version of the hack apk.
-
Can I play Arena of Valor hack apk with my friends?
-
Arena of Valor hack apk allows you to play with your friends or random players in various modes and maps. However, you should be careful when playing with your friends who do not use the hack apk, as they might notice that you have unlimited money and gems, or that you have unlocked all heroes and modes. They might report you or unfriend you for using the hack apk. Therefore, you should only play with your friends who also use the hack apk, or who do not mind that you use it.
-
Can I uninstall Arena of Valor hack apk?
-
If you want to uninstall Arena of Valor hack apk for any reason, you can do so easily. To do this, you need to go to your device's settings, then apps, then Arena of Valor, then uninstall. You can also delete the downloaded apk file from your device's storage. This will remove the game and all its data from your device.
")
-
-demo.launch()
\ No newline at end of file
diff --git a/spaces/Deep1994/t5-paraphrase/app.py b/spaces/Deep1994/t5-paraphrase/app.py
deleted file mode 100644
index 7391702429d98d41c66d45a14e25b2045ff6238a..0000000000000000000000000000000000000000
--- a/spaces/Deep1994/t5-paraphrase/app.py
+++ /dev/null
@@ -1,71 +0,0 @@
-import streamlit as st
-from transformers import T5ForConditionalGeneration, T5Tokenizer
-import torch
-
-def set_seed(seed):
- torch.manual_seed(seed)
- if torch.cuda.is_available():
- torch.cuda.manual_seed_all(seed)
-
-tokenizer = T5Tokenizer.from_pretrained('Deep1994/t5-paraphrase-quora')
-
-@st.cache(allow_output_mutation=True)
-def load_model():
- model = T5ForConditionalGeneration.from_pretrained('Deep1994/t5-paraphrase-quora')
-
- return model
-
-model = load_model()
-
-st.sidebar.subheader('Select decoding strategy below.')
-decoding_strategy = st.sidebar.selectbox("decoding_strategy", ['Top k/p sampling', 'Beam Search'])
-
-st.title('Paraphrase a question in English.')
-
-st.write('This is a fine-tuned t5 model that will paraphrase\
- your English input text into another English output\
- by leveraging a pre-trained [Text-To-Text Transfer Tranformers](https://arxiv.org/abs/1910.10683) model.')
-
-
-st.subheader('Input Text')
-text = st.text_area(' ', height=100)
-
-if text != '':
- set_seed(1234) # for reproducibility
- prefix = 'paraphrase: '
- encoding = tokenizer.encode_plus(prefix + text, padding=True, return_tensors="pt")
- input_ids, attention_masks = encoding["input_ids"], encoding["attention_mask"]
-
- if str(decoding_strategy) == 'Top k/p sampling':
- beam_outputs = model.generate(
- input_ids=input_ids, attention_mask=attention_masks,
- do_sample=True,
- max_length=20,
- top_k=50,
- top_p=0.95,
- early_stopping=True,
- num_return_sequences=10
- )
- elif str(decoding_strategy) == 'Beam Search':
- beam_outputs = model.generate(
- input_ids=input_ids,
- attention_mask=attention_masks,
- max_length=20,
- num_beams=10,
- no_repeat_ngram_size=2,
- num_return_sequences=10,
- early_stopping=True
- )
-
- final_outputs =[]
- for beam_output in beam_outputs:
- sent = tokenizer.decode(beam_output, skip_special_tokens=True, clean_up_tokenization_spaces=True)
- if sent.lower() != text.lower() and sent not in final_outputs:
- final_outputs.append(sent)
- if len(final_outputs) == 5:
- break
- # final_outputs.append(sent)
-
- st.subheader('Paraphrased Text')
- for i, final_output in enumerate(final_outputs):
- st.write(final_output + '\n')
\ No newline at end of file
diff --git a/spaces/Detomo/ai-comic-generation/src/components/ui/accordion.tsx b/spaces/Detomo/ai-comic-generation/src/components/ui/accordion.tsx
deleted file mode 100644
index 937620af27e5d8ef577f0baca229a9b753ebd017..0000000000000000000000000000000000000000
--- a/spaces/Detomo/ai-comic-generation/src/components/ui/accordion.tsx
+++ /dev/null
@@ -1,60 +0,0 @@
-"use client"
-
-import * as React from "react"
-import * as AccordionPrimitive from "@radix-ui/react-accordion"
-import { ChevronDown } from "lucide-react"
-
-import { cn } from "@/lib/utils"
-
-const Accordion = AccordionPrimitive.Root
-
-const AccordionItem = React.forwardRef<
- React.ElementRef
-
-
-Detectron2 is Facebook AI Research's next generation software system
-that implements state-of-the-art object detection algorithms.
-It is a ground-up rewrite of the previous version,
-[Detectron](https://github.com/facebookresearch/Detectron/),
-and it originates from [maskrcnn-benchmark](https://github.com/facebookresearch/maskrcnn-benchmark/).
-
-
-